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[] = "avconv";
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 qp_hist = 0;
157 static char *vfilters = NULL;
160 static int intra_only = 0;
161 static int audio_sample_rate = 0;
162 #define QSCALE_NONE -99999
163 static float audio_qscale = QSCALE_NONE;
164 static int audio_disable = 0;
165 static int audio_channels = 0;
166 static unsigned int audio_codec_tag = 0;
167 static char *audio_language = NULL;
169 static int subtitle_disable = 0;
170 static char *subtitle_language = NULL;
171 static unsigned int subtitle_codec_tag = 0;
173 static int data_disable = 0;
174 static unsigned int data_codec_tag = 0;
176 static float mux_preload= 0.5;
177 static float mux_max_delay= 0.7;
179 static int64_t recording_time = INT64_MAX;
180 static int64_t start_time = 0;
181 static int64_t input_ts_offset = 0;
182 static int file_overwrite = 0;
183 static AVDictionary *metadata;
184 static int do_benchmark = 0;
185 static int do_hex_dump = 0;
186 static int do_pkt_dump = 0;
187 static int do_psnr = 0;
188 static int do_pass = 0;
189 static const char *pass_logfilename_prefix;
190 static int video_sync_method= -1;
191 static int audio_sync_method= 0;
192 static float audio_drift_threshold= 0.1;
193 static int copy_ts= 0;
194 static int copy_tb= 0;
195 static int opt_shortest = 0;
196 static char *vstats_filename;
197 static FILE *vstats_file;
198 static int opt_programid = 0;
199 static int copy_initial_nonkeyframes = 0;
201 static int rate_emu = 0;
203 static int audio_volume = 256;
205 static int exit_on_error = 0;
206 static int using_stdin = 0;
207 static int verbose = 1;
208 static int run_as_daemon = 0;
209 static int thread_count= 1;
210 static int q_pressed = 0;
211 static int64_t video_size = 0;
212 static int64_t audio_size = 0;
213 static int64_t extra_size = 0;
214 static int nb_frames_dup = 0;
215 static int nb_frames_drop = 0;
216 static int input_sync;
217 static uint64_t limit_filesize = 0;
218 static int force_fps = 0;
219 static char *forced_key_frames = NULL;
221 static float dts_delta_threshold = 10;
223 static int64_t timer_start;
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 "av2pass"
239 typedef struct OutputStream {
240 int file_index; /* file index */
241 int index; /* stream index in the output file */
242 int source_index; /* InputStream index */
243 AVStream *st; /* stream in the output file */
244 int encoding_needed; /* true if encoding needed for this stream */
246 /* input pts and corresponding output pts
248 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
249 struct InputStream *sync_ist; /* input stream to sync against */
250 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
251 AVBitStreamFilterContext *bitstream_filters;
256 AVFrame resample_frame; /* temporary frame for image resampling */
257 struct SwsContext *img_resample_ctx; /* for image resampling */
260 int resample_pix_fmt;
261 AVRational frame_rate;
263 float frame_aspect_ratio;
265 /* forced key frames */
266 int64_t *forced_kf_pts;
272 ReSampleContext *resample; /* for audio resampling */
273 int resample_sample_fmt;
274 int resample_channels;
275 int resample_sample_rate;
277 AVAudioConvert *reformat_ctx;
278 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
282 AVFilterContext *output_video_filter;
283 AVFilterContext *input_video_filter;
284 AVFilterBufferRef *picref;
286 AVFilterGraph *graph;
291 int is_past_recording_time;
294 typedef struct InputStream {
297 int discard; /* true if stream data should be discarded */
298 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
301 int64_t start; /* time when read started */
302 int64_t next_pts; /* synthetic pts for cases where pkt.pts
304 int64_t pts; /* current pts */
306 int is_start; /* is 1 at the start and after a discontinuity */
307 int showed_multi_packet_warning;
311 typedef struct InputFile {
312 AVFormatContext *ctx;
313 int eof_reached; /* true if eof reached */
314 int ist_index; /* index of first stream in ist_table */
315 int buffer_size; /* current total buffer size */
322 /* init terminal so that we can grab keys */
323 static struct termios oldtty;
326 typedef struct OutputFile {
327 AVFormatContext *ctx;
329 int ost_index; /* index of the first stream in output_streams */
330 int64_t recording_time; /* desired length of the resulting file in microseconds */
331 int64_t start_time; /* start time in microseconds */
334 static InputStream *input_streams = NULL;
335 static int nb_input_streams = 0;
336 static InputFile *input_files = NULL;
337 static int nb_input_files = 0;
339 static OutputStream *output_streams = NULL;
340 static int nb_output_streams = 0;
341 static OutputFile *output_files = NULL;
342 static int nb_output_files = 0;
346 static int configure_video_filters(InputStream *ist, OutputStream *ost)
348 AVFilterContext *last_filter, *filter;
349 /** filter graph containing all filters including input & output */
350 AVCodecContext *codec = ost->st->codec;
351 AVCodecContext *icodec = ist->st->codec;
352 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
353 AVRational sample_aspect_ratio;
357 ost->graph = avfilter_graph_alloc();
359 if (ist->st->sample_aspect_ratio.num){
360 sample_aspect_ratio = ist->st->sample_aspect_ratio;
362 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
364 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
365 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
366 sample_aspect_ratio.num, sample_aspect_ratio.den);
368 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
369 "src", args, NULL, ost->graph);
372 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
373 "out", NULL, pix_fmts, ost->graph);
376 last_filter = ost->input_video_filter;
378 if (codec->width != icodec->width || codec->height != icodec->height) {
379 snprintf(args, 255, "%d:%d:flags=0x%X",
383 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
384 NULL, args, NULL, ost->graph)) < 0)
386 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
388 last_filter = filter;
391 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
392 ost->graph->scale_sws_opts = av_strdup(args);
395 AVFilterInOut *outputs = avfilter_inout_alloc();
396 AVFilterInOut *inputs = avfilter_inout_alloc();
398 outputs->name = av_strdup("in");
399 outputs->filter_ctx = last_filter;
400 outputs->pad_idx = 0;
401 outputs->next = NULL;
403 inputs->name = av_strdup("out");
404 inputs->filter_ctx = ost->output_video_filter;
408 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
410 av_freep(&ost->avfilter);
412 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
416 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
419 codec->width = ost->output_video_filter->inputs[0]->w;
420 codec->height = ost->output_video_filter->inputs[0]->h;
421 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
422 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
423 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
424 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
428 #endif /* CONFIG_AVFILTER */
430 static void term_exit(void)
432 av_log(NULL, AV_LOG_QUIET, "%s", "");
435 tcsetattr (0, TCSANOW, &oldtty);
439 static volatile int received_sigterm = 0;
442 sigterm_handler(int sig)
444 received_sigterm = sig;
449 static void term_init(void)
459 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
460 |INLCR|IGNCR|ICRNL|IXON);
461 tty.c_oflag |= OPOST;
462 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
463 tty.c_cflag &= ~(CSIZE|PARENB);
468 tcsetattr (0, TCSANOW, &tty);
469 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
473 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
474 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
476 signal(SIGXCPU, sigterm_handler);
480 /* read a key without blocking */
481 static int read_key(void)
496 n = select(1, &rfds, NULL, NULL, &tv);
511 static int decode_interrupt_cb(void)
513 q_pressed += read_key() == 'q';
514 return q_pressed > 1;
517 static int exit_program(int ret)
522 for(i=0;i<nb_output_files;i++) {
523 AVFormatContext *s = output_files[i].ctx;
524 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
526 avformat_free_context(s);
527 av_dict_free(&output_files[i].opts);
529 for(i=0;i<nb_input_files;i++) {
530 av_close_input_file(input_files[i].ctx);
532 for (i = 0; i < nb_input_streams; i++)
533 av_dict_free(&input_streams[i].opts);
535 av_free(intra_matrix);
536 av_free(inter_matrix);
540 av_free(vstats_filename);
542 av_free(streamid_map);
543 av_free(meta_data_maps);
545 av_freep(&input_streams);
546 av_freep(&input_files);
547 av_freep(&output_streams);
548 av_freep(&output_files);
553 allocated_audio_buf_size= allocated_audio_out_size= 0;
560 if (received_sigterm) {
562 "Received signal %d: terminating.\n",
563 (int) received_sigterm);
567 exit(ret); /* not all OS-es handle main() return value */
571 static void assert_avoptions(AVDictionary *m)
573 AVDictionaryEntry *t;
574 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
575 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
580 static void assert_codec_experimental(AVCodecContext *c, int encoder)
582 const char *codec_string = encoder ? "encoder" : "decoder";
584 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
585 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
586 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
587 "results.\nAdd '-strict experimental' if you want to use it.\n",
588 codec_string, c->codec->name);
589 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
590 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
591 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
592 codec_string, codec->name);
597 /* similar to ff_dynarray_add() and av_fast_realloc() */
598 static void *grow_array(void *array, int elem_size, int *size, int new_size)
600 if (new_size >= INT_MAX / elem_size) {
601 fprintf(stderr, "Array too big.\n");
604 if (*size < new_size) {
605 uint8_t *tmp = av_realloc(array, new_size*elem_size);
607 fprintf(stderr, "Could not alloc buffer.\n");
610 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
617 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
619 if(codec && codec->sample_fmts){
620 const enum AVSampleFormat *p= codec->sample_fmts;
622 if(*p == st->codec->sample_fmt)
626 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
627 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
628 if(av_get_sample_fmt_name(st->codec->sample_fmt))
629 av_log(NULL, AV_LOG_WARNING,
630 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
631 av_get_sample_fmt_name(st->codec->sample_fmt),
633 av_get_sample_fmt_name(codec->sample_fmts[0]));
634 st->codec->sample_fmt = codec->sample_fmts[0];
639 static void choose_sample_rate(AVStream *st, AVCodec *codec)
641 if(codec && codec->supported_samplerates){
642 const int *p= codec->supported_samplerates;
644 int best_dist=INT_MAX;
646 int dist= abs(st->codec->sample_rate - *p);
647 if(dist < best_dist){
653 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
655 st->codec->sample_rate= best;
659 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
661 if(codec && codec->pix_fmts){
662 const enum PixelFormat *p= codec->pix_fmts;
663 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
664 if(st->codec->codec_id==CODEC_ID_MJPEG){
665 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
666 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
667 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};
671 if(*p == st->codec->pix_fmt)
675 if(st->codec->pix_fmt != PIX_FMT_NONE)
676 av_log(NULL, AV_LOG_WARNING,
677 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
678 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
680 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
681 st->codec->pix_fmt = codec->pix_fmts[0];
687 get_sync_ipts(const OutputStream *ost)
689 const InputStream *ist = ost->sync_ist;
690 OutputFile *of = &output_files[ost->file_index];
691 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
694 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
698 AVPacket new_pkt= *pkt;
699 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
700 &new_pkt.data, &new_pkt.size,
701 pkt->data, pkt->size,
702 pkt->flags & AV_PKT_FLAG_KEY);
705 new_pkt.destruct= av_destruct_packet;
707 fprintf(stderr, "%s failed for stream %d, codec %s",
708 bsfc->filter->name, pkt->stream_index,
709 avctx->codec ? avctx->codec->name : "copy");
719 ret= av_interleaved_write_frame(s, pkt);
721 print_error("av_interleaved_write_frame()", ret);
726 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
728 static void do_audio_out(AVFormatContext *s,
731 unsigned char *buf, int size)
734 int64_t audio_out_size, audio_buf_size;
735 int64_t allocated_for_size= size;
737 int size_out, frame_bytes, ret, resample_changed;
738 AVCodecContext *enc= ost->st->codec;
739 AVCodecContext *dec= ist->st->codec;
740 int osize = av_get_bytes_per_sample(enc->sample_fmt);
741 int isize = av_get_bytes_per_sample(dec->sample_fmt);
742 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
745 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
746 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
747 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
748 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
749 audio_buf_size*= osize*enc->channels;
751 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
752 if(coded_bps > 8*osize)
753 audio_out_size= audio_out_size * coded_bps / (8*osize);
754 audio_out_size += FF_MIN_BUFFER_SIZE;
756 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
757 fprintf(stderr, "Buffer sizes too large\n");
761 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
762 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
763 if (!audio_buf || !audio_out){
764 fprintf(stderr, "Out of memory in do_audio_out\n");
768 if (enc->channels != dec->channels)
769 ost->audio_resample = 1;
771 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
772 ost->resample_channels != dec->channels ||
773 ost->resample_sample_rate != dec->sample_rate;
775 if ((ost->audio_resample && !ost->resample) || resample_changed) {
776 if (resample_changed) {
777 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",
778 ist->file_index, ist->st->index,
779 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
780 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
781 ost->resample_sample_fmt = dec->sample_fmt;
782 ost->resample_channels = dec->channels;
783 ost->resample_sample_rate = dec->sample_rate;
785 audio_resample_close(ost->resample);
787 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
788 if (audio_sync_method <= 1 &&
789 ost->resample_sample_fmt == enc->sample_fmt &&
790 ost->resample_channels == enc->channels &&
791 ost->resample_sample_rate == enc->sample_rate) {
792 ost->resample = NULL;
793 ost->audio_resample = 0;
795 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
796 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
797 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
798 enc->sample_rate, dec->sample_rate,
799 enc->sample_fmt, dec->sample_fmt,
801 if (!ost->resample) {
802 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
803 dec->channels, dec->sample_rate,
804 enc->channels, enc->sample_rate);
810 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
811 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
812 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
813 if (ost->reformat_ctx)
814 av_audio_convert_free(ost->reformat_ctx);
815 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
816 dec->sample_fmt, 1, NULL, 0);
817 if (!ost->reformat_ctx) {
818 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
819 av_get_sample_fmt_name(dec->sample_fmt),
820 av_get_sample_fmt_name(enc->sample_fmt));
823 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
826 if(audio_sync_method){
827 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
828 - av_fifo_size(ost->fifo)/(enc->channels * 2);
829 double idelta= delta*dec->sample_rate / enc->sample_rate;
830 int byte_delta= ((int)idelta)*2*dec->channels;
832 //FIXME resample delay
833 if(fabs(delta) > 50){
834 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
836 byte_delta= FFMAX(byte_delta, -size);
840 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
845 static uint8_t *input_tmp= NULL;
846 input_tmp= av_realloc(input_tmp, byte_delta + size);
848 if(byte_delta > allocated_for_size - size){
849 allocated_for_size= byte_delta + (int64_t)size;
854 memset(input_tmp, 0, byte_delta);
855 memcpy(input_tmp + byte_delta, buf, size);
859 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
861 }else if(audio_sync_method>1){
862 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
863 av_assert0(ost->audio_resample);
865 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
866 // 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));
867 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
871 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
872 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
874 if (ost->audio_resample) {
876 size_out = audio_resample(ost->resample,
877 (short *)buftmp, (short *)buf,
878 size / (dec->channels * isize));
879 size_out = size_out * enc->channels * osize;
885 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
886 const void *ibuf[6]= {buftmp};
887 void *obuf[6]= {audio_buf};
888 int istride[6]= {isize};
889 int ostride[6]= {osize};
890 int len= size_out/istride[0];
891 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
892 printf("av_audio_convert() failed\n");
898 size_out = len*osize;
901 /* now encode as many frames as possible */
902 if (enc->frame_size > 1) {
903 /* output resampled raw samples */
904 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
905 fprintf(stderr, "av_fifo_realloc2() failed\n");
908 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
910 frame_bytes = enc->frame_size * osize * enc->channels;
912 while (av_fifo_size(ost->fifo) >= frame_bytes) {
914 av_init_packet(&pkt);
916 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
918 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
920 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
923 fprintf(stderr, "Audio encoding failed\n");
927 pkt.stream_index= ost->index;
930 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
931 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
932 pkt.flags |= AV_PKT_FLAG_KEY;
933 write_frame(s, &pkt, enc, ost->bitstream_filters);
935 ost->sync_opts += enc->frame_size;
939 av_init_packet(&pkt);
941 ost->sync_opts += size_out / (osize * enc->channels);
943 /* output a pcm frame */
944 /* determine the size of the coded buffer */
947 size_out = size_out*coded_bps/8;
949 if(size_out > audio_out_size){
950 fprintf(stderr, "Internal error, buffer size too small\n");
954 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
955 ret = avcodec_encode_audio(enc, audio_out, size_out,
958 fprintf(stderr, "Audio encoding failed\n");
962 pkt.stream_index= ost->index;
965 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
966 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
967 pkt.flags |= AV_PKT_FLAG_KEY;
968 write_frame(s, &pkt, enc, ost->bitstream_filters);
972 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
976 AVPicture picture_tmp;
979 dec = ist->st->codec;
981 /* deinterlace : must be done before any resize */
982 if (do_deinterlace) {
985 /* create temporary picture */
986 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
987 buf = av_malloc(size);
991 picture2 = &picture_tmp;
992 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
994 if(avpicture_deinterlace(picture2, picture,
995 dec->pix_fmt, dec->width, dec->height) < 0) {
996 /* if error, do not deinterlace */
997 fprintf(stderr, "Deinterlacing failed\n");
1006 if (picture != picture2)
1007 *picture = *picture2;
1011 /* we begin to correct av delay at this threshold */
1012 #define AV_DELAY_MAX 0.100
1014 static void do_subtitle_out(AVFormatContext *s,
1020 static uint8_t *subtitle_out = NULL;
1021 int subtitle_out_max_size = 1024 * 1024;
1022 int subtitle_out_size, nb, i;
1023 AVCodecContext *enc;
1026 if (pts == AV_NOPTS_VALUE) {
1027 fprintf(stderr, "Subtitle packets must have a pts\n");
1033 enc = ost->st->codec;
1035 if (!subtitle_out) {
1036 subtitle_out = av_malloc(subtitle_out_max_size);
1039 /* Note: DVB subtitle need one packet to draw them and one other
1040 packet to clear them */
1041 /* XXX: signal it in the codec context ? */
1042 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1047 for(i = 0; i < nb; i++) {
1048 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1049 // start_display_time is required to be 0
1050 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1051 sub->end_display_time -= sub->start_display_time;
1052 sub->start_display_time = 0;
1053 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1054 subtitle_out_max_size, sub);
1055 if (subtitle_out_size < 0) {
1056 fprintf(stderr, "Subtitle encoding failed\n");
1060 av_init_packet(&pkt);
1061 pkt.stream_index = ost->index;
1062 pkt.data = subtitle_out;
1063 pkt.size = subtitle_out_size;
1064 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1065 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1066 /* XXX: the pts correction is handled here. Maybe handling
1067 it in the codec would be better */
1069 pkt.pts += 90 * sub->start_display_time;
1071 pkt.pts += 90 * sub->end_display_time;
1073 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1077 static int bit_buffer_size= 1024*256;
1078 static uint8_t *bit_buffer= NULL;
1080 static void do_video_resample(OutputStream *ost,
1082 AVFrame *in_picture,
1083 AVFrame **out_picture)
1085 int resample_changed = 0;
1086 AVCodecContext *dec = ist->st->codec;
1087 *out_picture = in_picture;
1089 resample_changed = ost->resample_width != dec->width ||
1090 ost->resample_height != dec->height ||
1091 ost->resample_pix_fmt != dec->pix_fmt;
1093 #if !CONFIG_AVFILTER
1094 if (resample_changed) {
1095 av_log(NULL, AV_LOG_INFO,
1096 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1097 ist->file_index, ist->st->index,
1098 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1099 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1100 ost->resample_width = dec->width;
1101 ost->resample_height = dec->height;
1102 ost->resample_pix_fmt = dec->pix_fmt;
1105 ost->video_resample = dec->width != enc->width ||
1106 dec->height != enc->height ||
1107 dec->pix_fmt != enc->pix_fmt;
1109 if (ost->video_resample) {
1110 *out_picture = &ost->resample_frame;
1111 if (!ost->img_resample_ctx || resample_changed) {
1112 /* initialize the destination picture */
1113 if (!ost->resample_frame.data[0]) {
1114 avcodec_get_frame_defaults(&ost->resample_frame);
1115 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1116 enc->width, enc->height)) {
1117 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1121 /* initialize a new scaler context */
1122 sws_freeContext(ost->img_resample_ctx);
1123 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1124 enc->width, enc->height, enc->pix_fmt,
1125 ost->sws_flags, NULL, NULL, NULL);
1126 if (ost->img_resample_ctx == NULL) {
1127 fprintf(stderr, "Cannot get resampling context\n");
1131 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1132 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1135 if (resample_changed) {
1136 avfilter_graph_free(&ost->graph);
1137 if (configure_video_filters(ist, ost)) {
1138 fprintf(stderr, "Error reinitialising filters!\n");
1143 if (resample_changed) {
1144 ost->resample_width = dec->width;
1145 ost->resample_height = dec->height;
1146 ost->resample_pix_fmt = dec->pix_fmt;
1151 static void do_video_out(AVFormatContext *s,
1154 AVFrame *in_picture,
1155 int *frame_size, float quality)
1157 int nb_frames, i, ret, format_video_sync;
1158 AVFrame *final_picture;
1159 AVCodecContext *enc, *dec;
1162 enc = ost->st->codec;
1163 dec = ist->st->codec;
1165 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1167 /* by default, we output a single frame */
1172 format_video_sync = video_sync_method;
1173 if (format_video_sync < 0)
1174 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1176 if (format_video_sync) {
1177 double vdelta = sync_ipts - ost->sync_opts;
1178 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1181 else if (format_video_sync == 2) {
1184 }else if(vdelta>0.6)
1185 ost->sync_opts= lrintf(sync_ipts);
1186 }else if (vdelta > 1.1)
1187 nb_frames = lrintf(vdelta);
1188 //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);
1189 if (nb_frames == 0){
1192 fprintf(stderr, "*** drop!\n");
1193 }else if (nb_frames > 1) {
1194 nb_frames_dup += nb_frames - 1;
1196 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1199 ost->sync_opts= lrintf(sync_ipts);
1201 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1205 do_video_resample(ost, ist, in_picture, &final_picture);
1207 /* duplicates frame if needed */
1208 for(i=0;i<nb_frames;i++) {
1210 av_init_packet(&pkt);
1211 pkt.stream_index= ost->index;
1213 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1214 /* raw pictures are written as AVPicture structure to
1215 avoid any copies. We support temorarily the older
1217 AVFrame* old_frame = enc->coded_frame;
1218 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1219 pkt.data= (uint8_t *)final_picture;
1220 pkt.size= sizeof(AVPicture);
1221 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1222 pkt.flags |= AV_PKT_FLAG_KEY;
1224 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1225 enc->coded_frame = old_frame;
1227 AVFrame big_picture;
1229 big_picture= *final_picture;
1230 /* better than nothing: use input picture interlaced
1232 big_picture.interlaced_frame = in_picture->interlaced_frame;
1233 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1234 if(top_field_first == -1)
1235 big_picture.top_field_first = in_picture->top_field_first;
1237 big_picture.top_field_first = top_field_first;
1240 /* handles same_quant here. This is not correct because it may
1241 not be a global option */
1242 big_picture.quality = quality;
1244 big_picture.pict_type = 0;
1245 // big_picture.pts = AV_NOPTS_VALUE;
1246 big_picture.pts= ost->sync_opts;
1247 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1248 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1249 if (ost->forced_kf_index < ost->forced_kf_count &&
1250 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1251 big_picture.pict_type = AV_PICTURE_TYPE_I;
1252 ost->forced_kf_index++;
1254 ret = avcodec_encode_video(enc,
1255 bit_buffer, bit_buffer_size,
1258 fprintf(stderr, "Video encoding failed\n");
1263 pkt.data= bit_buffer;
1265 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1266 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1267 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1268 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1269 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1271 if(enc->coded_frame->key_frame)
1272 pkt.flags |= AV_PKT_FLAG_KEY;
1273 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1276 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1277 // enc->frame_number-1, ret, enc->pict_type);
1278 /* if two pass, output log */
1279 if (ost->logfile && enc->stats_out) {
1280 fprintf(ost->logfile, "%s", enc->stats_out);
1285 ost->frame_number++;
1289 static double psnr(double d){
1290 return -10.0*log(d)/log(10.0);
1293 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1296 AVCodecContext *enc;
1298 double ti1, bitrate, avg_bitrate;
1300 /* this is executed just the first time do_video_stats is called */
1302 vstats_file = fopen(vstats_filename, "w");
1309 enc = ost->st->codec;
1310 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1311 frame_number = ost->frame_number;
1312 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1313 if (enc->flags&CODEC_FLAG_PSNR)
1314 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1316 fprintf(vstats_file,"f_size= %6d ", frame_size);
1317 /* compute pts value */
1318 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1322 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1323 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1324 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1325 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1326 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1330 static void print_report(OutputFile *output_files,
1331 OutputStream *ost_table, int nb_ostreams,
1336 AVFormatContext *oc;
1338 AVCodecContext *enc;
1339 int frame_number, vid, i;
1341 int64_t pts = INT64_MAX;
1342 static int64_t last_time = -1;
1343 static int qp_histogram[52];
1345 if (!is_last_report) {
1347 /* display the report every 0.5 seconds */
1348 cur_time = av_gettime();
1349 if (last_time == -1) {
1350 last_time = cur_time;
1353 if ((cur_time - last_time) < 500000)
1355 last_time = cur_time;
1359 oc = output_files[0].ctx;
1361 total_size = avio_size(oc->pb);
1362 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1363 total_size= avio_tell(oc->pb);
1367 for(i=0;i<nb_ostreams;i++) {
1369 ost = &ost_table[i];
1370 enc = ost->st->codec;
1371 if (!ost->st->stream_copy && enc->coded_frame)
1372 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1373 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1374 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1376 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1377 float t = (av_gettime()-timer_start) / 1000000.0;
1379 frame_number = ost->frame_number;
1380 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1381 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1383 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1387 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1392 if (enc->flags&CODEC_FLAG_PSNR){
1394 double error, error_sum=0;
1395 double scale, scale_sum=0;
1396 char type[3]= {'Y','U','V'};
1397 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1400 error= enc->error[j];
1401 scale= enc->width*enc->height*255.0*255.0*frame_number;
1403 error= enc->coded_frame->error[j];
1404 scale= enc->width*enc->height*255.0*255.0;
1409 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1411 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1415 /* compute min output value */
1416 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1417 ost->st->time_base, AV_TIME_BASE_Q));
1420 if (verbose > 0 || is_last_report) {
1421 int hours, mins, secs, us;
1422 secs = pts / AV_TIME_BASE;
1423 us = pts % AV_TIME_BASE;
1429 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1431 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1432 "size=%8.0fkB time=", total_size / 1024.0);
1433 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1434 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1435 (100 * us) / AV_TIME_BASE);
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1437 "bitrate=%6.1fkbits/s", bitrate);
1439 if (nb_frames_dup || nb_frames_drop)
1440 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1441 nb_frames_dup, nb_frames_drop);
1444 fprintf(stderr, "%s \r", buf);
1449 if (is_last_report && verbose >= 0){
1450 int64_t raw= audio_size + video_size + extra_size;
1451 fprintf(stderr, "\n");
1452 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1456 100.0*(total_size - raw)/raw
1461 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1463 int fill_char = 0x00;
1464 if (sample_fmt == AV_SAMPLE_FMT_U8)
1466 memset(buf, fill_char, size);
1469 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1470 static int output_packet(InputStream *ist, int ist_index,
1471 OutputStream *ost_table, int nb_ostreams,
1472 const AVPacket *pkt)
1474 AVFormatContext *os;
1479 void *buffer_to_free = NULL;
1480 static unsigned int samples_size= 0;
1481 AVSubtitle subtitle, *subtitle_to_free;
1482 int64_t pkt_pts = AV_NOPTS_VALUE;
1484 int frame_available;
1489 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1491 if(ist->next_pts == AV_NOPTS_VALUE)
1492 ist->next_pts= ist->pts;
1496 av_init_packet(&avpkt);
1504 if(pkt->dts != AV_NOPTS_VALUE)
1505 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1506 if(pkt->pts != AV_NOPTS_VALUE)
1507 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1509 //while we have more to decode or while the decoder did output something on EOF
1510 while (avpkt.size > 0 || (!pkt && got_output)) {
1511 uint8_t *data_buf, *decoded_data_buf;
1512 int data_size, decoded_data_size;
1514 ist->pts= ist->next_pts;
1516 if(avpkt.size && avpkt.size != pkt->size &&
1517 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1518 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1519 ist->showed_multi_packet_warning=1;
1522 /* decode the packet if needed */
1523 decoded_data_buf = NULL; /* fail safe */
1524 decoded_data_size= 0;
1525 data_buf = avpkt.data;
1526 data_size = avpkt.size;
1527 subtitle_to_free = NULL;
1528 if (ist->decoding_needed) {
1529 switch(ist->st->codec->codec_type) {
1530 case AVMEDIA_TYPE_AUDIO:{
1531 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1532 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1534 samples= av_malloc(samples_size);
1536 decoded_data_size= samples_size;
1537 /* XXX: could avoid copy if PCM 16 bits with same
1538 endianness as CPU */
1539 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1546 got_output = decoded_data_size > 0;
1547 /* Some bug in mpeg audio decoder gives */
1548 /* decoded_data_size < 0, it seems they are overflows */
1550 /* no audio frame */
1553 decoded_data_buf = (uint8_t *)samples;
1554 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1555 (ist->st->codec->sample_rate * ist->st->codec->channels);
1557 case AVMEDIA_TYPE_VIDEO:
1558 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1559 /* XXX: allocate picture correctly */
1560 avcodec_get_frame_defaults(&picture);
1561 avpkt.pts = pkt_pts;
1562 avpkt.dts = ist->pts;
1563 pkt_pts = AV_NOPTS_VALUE;
1565 ret = avcodec_decode_video2(ist->st->codec,
1566 &picture, &got_output, &avpkt);
1567 quality = same_quant ? picture.quality : 0;
1571 /* no picture yet */
1572 goto discard_packet;
1574 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1575 if (ist->st->codec->time_base.num != 0) {
1576 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1577 ist->next_pts += ((int64_t)AV_TIME_BASE *
1578 ist->st->codec->time_base.num * ticks) /
1579 ist->st->codec->time_base.den;
1582 buffer_to_free = NULL;
1583 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1585 case AVMEDIA_TYPE_SUBTITLE:
1586 ret = avcodec_decode_subtitle2(ist->st->codec,
1587 &subtitle, &got_output, &avpkt);
1591 goto discard_packet;
1593 subtitle_to_free = &subtitle;
1600 switch(ist->st->codec->codec_type) {
1601 case AVMEDIA_TYPE_AUDIO:
1602 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1603 ist->st->codec->sample_rate;
1605 case AVMEDIA_TYPE_VIDEO:
1606 if (ist->st->codec->time_base.num != 0) {
1607 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1608 ist->next_pts += ((int64_t)AV_TIME_BASE *
1609 ist->st->codec->time_base.num * ticks) /
1610 ist->st->codec->time_base.den;
1618 // preprocess audio (volume)
1619 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1620 if (audio_volume != 256) {
1623 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1624 int v = ((*volp) * audio_volume + 128) >> 8;
1625 if (v < -32768) v = -32768;
1626 if (v > 32767) v = 32767;
1632 /* frame rate emulation */
1634 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1635 int64_t now = av_gettime() - ist->start;
1639 /* if output time reached then transcode raw format,
1640 encode packets and output them */
1641 for (i = 0; i < nb_ostreams; i++) {
1642 OutputFile *of = &output_files[ost_table[i].file_index];
1645 ost = &ost_table[i];
1646 if (ost->source_index != ist_index)
1649 if (of->start_time && ist->pts < of->start_time)
1652 if (of->recording_time != INT64_MAX &&
1653 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1654 (AVRational){1, 1000000}) >= 0) {
1655 ost->is_past_recording_time = 1;
1660 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1661 ost->input_video_filter) {
1662 if (!picture.sample_aspect_ratio.num)
1663 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1664 picture.pts = ist->pts;
1666 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1668 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1669 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1670 while (frame_available) {
1671 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1672 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1673 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1676 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1677 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1681 os = output_files[ost->file_index].ctx;
1683 /* set the input output pts pairs */
1684 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1686 if (ost->encoding_needed) {
1687 av_assert0(ist->decoding_needed);
1688 switch(ost->st->codec->codec_type) {
1689 case AVMEDIA_TYPE_AUDIO:
1690 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1692 case AVMEDIA_TYPE_VIDEO:
1694 if (ost->picref->video && !ost->frame_aspect_ratio)
1695 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1697 do_video_out(os, ost, ist, &picture, &frame_size,
1698 same_quant ? quality : ost->st->codec->global_quality);
1699 if (vstats_filename && frame_size)
1700 do_video_stats(os, ost, frame_size);
1702 case AVMEDIA_TYPE_SUBTITLE:
1703 do_subtitle_out(os, ost, ist, &subtitle,
1710 AVFrame avframe; //FIXME/XXX remove this
1713 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1714 av_init_packet(&opkt);
1716 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1717 #if !CONFIG_AVFILTER
1723 /* no reencoding needed : output the packet directly */
1724 /* force the input stream PTS */
1726 avcodec_get_frame_defaults(&avframe);
1727 ost->st->codec->coded_frame= &avframe;
1728 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1730 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1731 audio_size += data_size;
1732 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1733 video_size += data_size;
1737 opkt.stream_index= ost->index;
1738 if(pkt->pts != AV_NOPTS_VALUE)
1739 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1741 opkt.pts= AV_NOPTS_VALUE;
1743 if (pkt->dts == AV_NOPTS_VALUE)
1744 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1746 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1747 opkt.dts -= ost_tb_start_time;
1749 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1750 opkt.flags= pkt->flags;
1752 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1753 if( ost->st->codec->codec_id != CODEC_ID_H264
1754 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1755 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1757 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1758 opkt.destruct= av_destruct_packet;
1760 opkt.data = data_buf;
1761 opkt.size = data_size;
1764 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1765 /* store AVPicture in AVPacket, as expected by the output format */
1766 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1767 opkt.data = (uint8_t *)&pict;
1768 opkt.size = sizeof(AVPicture);
1769 opkt.flags |= AV_PKT_FLAG_KEY;
1771 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1772 ost->st->codec->frame_number++;
1773 ost->frame_number++;
1774 av_free_packet(&opkt);
1778 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1779 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1781 avfilter_unref_buffer(ost->picref);
1786 av_free(buffer_to_free);
1787 /* XXX: allocate the subtitles in the codec ? */
1788 if (subtitle_to_free) {
1789 avsubtitle_free(subtitle_to_free);
1790 subtitle_to_free = NULL;
1797 for(i=0;i<nb_ostreams;i++) {
1798 ost = &ost_table[i];
1799 if (ost->source_index == ist_index) {
1800 AVCodecContext *enc= ost->st->codec;
1801 os = output_files[ost->file_index].ctx;
1803 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1805 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1808 if (ost->encoding_needed) {
1812 av_init_packet(&pkt);
1813 pkt.stream_index= ost->index;
1815 switch(ost->st->codec->codec_type) {
1816 case AVMEDIA_TYPE_AUDIO:
1817 fifo_bytes = av_fifo_size(ost->fifo);
1819 /* encode any samples remaining in fifo */
1820 if (fifo_bytes > 0) {
1821 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1822 int fs_tmp = enc->frame_size;
1824 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1825 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1826 enc->frame_size = fifo_bytes / (osize * enc->channels);
1828 int frame_bytes = enc->frame_size*osize*enc->channels;
1829 if (allocated_audio_buf_size < frame_bytes)
1831 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1834 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1835 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1836 ost->st->time_base.num, enc->sample_rate);
1837 enc->frame_size = fs_tmp;
1840 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1843 fprintf(stderr, "Audio encoding failed\n");
1847 pkt.flags |= AV_PKT_FLAG_KEY;
1849 case AVMEDIA_TYPE_VIDEO:
1850 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1852 fprintf(stderr, "Video encoding failed\n");
1856 if(enc->coded_frame && enc->coded_frame->key_frame)
1857 pkt.flags |= AV_PKT_FLAG_KEY;
1858 if (ost->logfile && enc->stats_out) {
1859 fprintf(ost->logfile, "%s", enc->stats_out);
1868 pkt.data= bit_buffer;
1870 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1871 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1872 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1882 static void print_sdp(OutputFile *output_files, int n)
1886 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1890 for (i = 0; i < n; i++)
1891 avc[i] = output_files[i].ctx;
1893 av_sdp_create(avc, n, sdp, sizeof(sdp));
1894 printf("SDP:\n%s\n", sdp);
1900 * The following code is the main loop of the file converter
1902 static int transcode(OutputFile *output_files,
1903 int nb_output_files,
1904 InputFile *input_files,
1907 int ret = 0, i, j, step;
1908 AVFormatContext *is, *os;
1909 AVCodecContext *codec, *icodec;
1916 int no_packet_count=0;
1917 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1918 int nb_streams[AVMEDIA_TYPE_NB]={0};
1920 if (!(no_packet = av_mallocz(nb_input_files)))
1924 for (i = 0; i < nb_input_streams; i++)
1925 input_streams[i].start = av_gettime();
1927 /* output stream init */
1928 for(i=0;i<nb_output_files;i++) {
1929 os = output_files[i].ctx;
1930 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1931 av_dump_format(os, i, os->filename, 1);
1932 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1933 ret = AVERROR(EINVAL);
1938 /* for each output stream, we compute the right encoding parameters */
1939 for (i = 0; i < nb_output_streams; i++) {
1940 ost = &output_streams[i];
1941 os = output_files[ost->file_index].ctx;
1942 ist = &input_streams[ost->source_index];
1944 codec = ost->st->codec;
1945 icodec = ist->st->codec;
1947 ost->st->disposition = ist->st->disposition;
1948 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1949 codec->chroma_sample_location = icodec->chroma_sample_location;
1951 if (ost->st->stream_copy) {
1952 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1954 if (extra_size > INT_MAX)
1957 /* if stream_copy is selected, no need to decode or encode */
1958 codec->codec_id = icodec->codec_id;
1959 codec->codec_type = icodec->codec_type;
1961 if(!codec->codec_tag){
1962 if( !os->oformat->codec_tag
1963 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1964 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1965 codec->codec_tag = icodec->codec_tag;
1968 codec->bit_rate = icodec->bit_rate;
1969 codec->rc_max_rate = icodec->rc_max_rate;
1970 codec->rc_buffer_size = icodec->rc_buffer_size;
1971 codec->extradata= av_mallocz(extra_size);
1972 if (!codec->extradata)
1974 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1975 codec->extradata_size= icodec->extradata_size;
1977 codec->time_base = ist->st->time_base;
1978 if(!strcmp(os->oformat->name, "avi")) {
1979 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){
1980 codec->time_base = icodec->time_base;
1981 codec->time_base.num *= icodec->ticks_per_frame;
1982 codec->time_base.den *= 2;
1984 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
1985 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){
1986 codec->time_base = icodec->time_base;
1987 codec->time_base.num *= icodec->ticks_per_frame;
1990 av_reduce(&codec->time_base.num, &codec->time_base.den,
1991 codec->time_base.num, codec->time_base.den, INT_MAX);
1993 switch(codec->codec_type) {
1994 case AVMEDIA_TYPE_AUDIO:
1995 if(audio_volume != 256) {
1996 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1999 codec->channel_layout = icodec->channel_layout;
2000 codec->sample_rate = icodec->sample_rate;
2001 codec->channels = icodec->channels;
2002 codec->frame_size = icodec->frame_size;
2003 codec->audio_service_type = icodec->audio_service_type;
2004 codec->block_align= icodec->block_align;
2005 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2006 codec->block_align= 0;
2007 if(codec->codec_id == CODEC_ID_AC3)
2008 codec->block_align= 0;
2010 case AVMEDIA_TYPE_VIDEO:
2011 codec->pix_fmt = icodec->pix_fmt;
2012 codec->width = icodec->width;
2013 codec->height = icodec->height;
2014 codec->has_b_frames = icodec->has_b_frames;
2015 if (!codec->sample_aspect_ratio.num) {
2016 codec->sample_aspect_ratio =
2017 ost->st->sample_aspect_ratio =
2018 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2019 ist->st->codec->sample_aspect_ratio.num ?
2020 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2023 case AVMEDIA_TYPE_SUBTITLE:
2024 codec->width = icodec->width;
2025 codec->height = icodec->height;
2027 case AVMEDIA_TYPE_DATA:
2034 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2035 switch(codec->codec_type) {
2036 case AVMEDIA_TYPE_AUDIO:
2037 ost->fifo= av_fifo_alloc(1024);
2040 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2041 if (!codec->sample_rate) {
2042 codec->sample_rate = icodec->sample_rate;
2044 choose_sample_rate(ost->st, ost->enc);
2045 codec->time_base = (AVRational){1, codec->sample_rate};
2046 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2047 codec->sample_fmt = icodec->sample_fmt;
2048 choose_sample_fmt(ost->st, ost->enc);
2049 if (!codec->channels) {
2050 codec->channels = icodec->channels;
2051 codec->channel_layout = icodec->channel_layout;
2053 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2054 codec->channel_layout = 0;
2055 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2056 icodec->request_channels = codec->channels;
2057 ist->decoding_needed = 1;
2058 ost->encoding_needed = 1;
2059 ost->resample_sample_fmt = icodec->sample_fmt;
2060 ost->resample_sample_rate = icodec->sample_rate;
2061 ost->resample_channels = icodec->channels;
2063 case AVMEDIA_TYPE_VIDEO:
2064 if (codec->pix_fmt == PIX_FMT_NONE)
2065 codec->pix_fmt = icodec->pix_fmt;
2066 choose_pixel_fmt(ost->st, ost->enc);
2068 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2069 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2073 if (!codec->width || !codec->height) {
2074 codec->width = icodec->width;
2075 codec->height = icodec->height;
2078 ost->video_resample = codec->width != icodec->width ||
2079 codec->height != icodec->height ||
2080 codec->pix_fmt != icodec->pix_fmt;
2081 if (ost->video_resample) {
2082 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2085 ost->resample_height = icodec->height;
2086 ost->resample_width = icodec->width;
2087 ost->resample_pix_fmt= icodec->pix_fmt;
2088 ost->encoding_needed = 1;
2089 ist->decoding_needed = 1;
2091 if (!ost->frame_rate.num)
2092 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2093 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2094 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2095 ost->frame_rate = ost->enc->supported_framerates[idx];
2097 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2098 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2099 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2100 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2101 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2105 if (configure_video_filters(ist, ost)) {
2106 fprintf(stderr, "Error opening filters!\n");
2111 case AVMEDIA_TYPE_SUBTITLE:
2112 ost->encoding_needed = 1;
2113 ist->decoding_needed = 1;
2120 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2121 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2122 char logfilename[1024];
2125 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2126 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2128 if (codec->flags & CODEC_FLAG_PASS1) {
2129 f = fopen(logfilename, "wb");
2131 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2137 size_t logbuffer_size;
2138 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2139 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2142 codec->stats_in = logbuffer;
2146 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2147 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2148 int size= codec->width * codec->height;
2149 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2154 bit_buffer = av_malloc(bit_buffer_size);
2156 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2158 ret = AVERROR(ENOMEM);
2162 /* open each encoder */
2163 for (i = 0; i < nb_output_streams; i++) {
2164 ost = &output_streams[i];
2165 if (ost->encoding_needed) {
2166 AVCodec *codec = ost->enc;
2167 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2169 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2170 ost->st->codec->codec_id, ost->file_index, ost->index);
2171 ret = AVERROR(EINVAL);
2174 if (dec->subtitle_header) {
2175 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2176 if (!ost->st->codec->subtitle_header) {
2177 ret = AVERROR(ENOMEM);
2180 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2181 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2183 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2184 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2185 ost->file_index, ost->index);
2186 ret = AVERROR(EINVAL);
2189 assert_codec_experimental(ost->st->codec, 1);
2190 assert_avoptions(ost->opts);
2191 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2192 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2193 "It takes bits/s as argument, not kbits/s\n");
2194 extra_size += ost->st->codec->extradata_size;
2198 /* open each decoder */
2199 for (i = 0; i < nb_input_streams; i++) {
2200 ist = &input_streams[i];
2201 if (ist->decoding_needed) {
2202 AVCodec *codec = ist->dec;
2204 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2206 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2207 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2208 ret = AVERROR(EINVAL);
2212 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2213 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2214 ist->file_index, ist->st->index);
2215 ret = AVERROR(EINVAL);
2218 assert_codec_experimental(ist->st->codec, 0);
2219 assert_avoptions(ost->opts);
2224 for (i = 0; i < nb_input_streams; i++) {
2226 ist = &input_streams[i];
2228 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2229 ist->next_pts = AV_NOPTS_VALUE;
2233 /* open files and write file headers */
2234 for (i = 0; i < nb_output_files; i++) {
2235 os = output_files[i].ctx;
2236 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2237 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2238 ret = AVERROR(EINVAL);
2241 // assert_avoptions(output_files[i].opts);
2242 if (strcmp(os->oformat->name, "rtp")) {
2248 /* dump the file output parameters - cannot be done before in case
2250 for(i=0;i<nb_output_files;i++) {
2251 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2254 /* dump the stream mapping */
2256 fprintf(stderr, "Stream mapping:\n");
2257 for (i = 0; i < nb_output_streams;i ++) {
2258 ost = &output_streams[i];
2259 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2260 input_streams[ost->source_index].file_index,
2261 input_streams[ost->source_index].st->index,
2264 if (ost->sync_ist != &input_streams[ost->source_index])
2265 fprintf(stderr, " [sync #%d.%d]",
2266 ost->sync_ist->file_index,
2267 ost->sync_ist->st->index);
2268 if (ost->st->stream_copy)
2269 fprintf(stderr, " (copy)");
2270 fprintf(stderr, "\n");
2275 fprintf(stderr, "%s\n", error);
2280 print_sdp(output_files, nb_output_files);
2285 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2286 avio_set_interrupt_cb(decode_interrupt_cb);
2290 timer_start = av_gettime();
2292 for(; received_sigterm == 0;) {
2293 int file_index, ist_index;
2299 ipts_min = INT64_MAX;
2301 /* if 'q' pressed, exits */
2305 /* read_key() returns 0 on EOF */
2309 if (key == '+') verbose++;
2310 if (key == '-') verbose--;
2311 if (key == 's') qp_hist ^= 1;
2314 do_hex_dump = do_pkt_dump = 0;
2315 } else if(do_pkt_dump){
2319 av_log_set_level(AV_LOG_DEBUG);
2321 if (key == 'd' || key == 'D'){
2324 debug = input_streams[0].st->codec->debug<<1;
2325 if(!debug) debug = 1;
2326 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2329 scanf("%d", &debug);
2330 for(i=0;i<nb_input_streams;i++) {
2331 input_streams[i].st->codec->debug = debug;
2333 for(i=0;i<nb_output_streams;i++) {
2334 ost = &output_streams[i];
2335 ost->st->codec->debug = debug;
2337 if(debug) av_log_set_level(AV_LOG_DEBUG);
2338 fprintf(stderr,"debug=%d\n", debug);
2341 fprintf(stderr, "key function\n"
2342 "? show this help\n"
2343 "+ increase verbosity\n"
2344 "- decrease verbosity\n"
2345 "D cycle through available debug modes\n"
2346 "h dump packets/hex press to cycle through the 3 states\n"
2348 "s Show QP histogram\n"
2353 /* select the stream that we must read now by looking at the
2354 smallest output pts */
2356 for (i = 0; i < nb_output_streams; i++) {
2359 ost = &output_streams[i];
2360 os = output_files[ost->file_index].ctx;
2361 ist = &input_streams[ost->source_index];
2362 if(ost->is_past_recording_time || no_packet[ist->file_index])
2364 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2366 if (!input_files[ist->file_index].eof_reached){
2367 if(ipts < ipts_min) {
2369 if(input_sync ) file_index = ist->file_index;
2371 if(opts < opts_min) {
2373 if(!input_sync) file_index = ist->file_index;
2376 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2381 /* if none, if is finished */
2382 if (file_index < 0) {
2383 if(no_packet_count){
2385 memset(no_packet, 0, nb_input_files);
2392 /* finish if limit size exhausted */
2393 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0].ctx->pb))
2396 /* read a frame from it and output it in the fifo */
2397 is = input_files[file_index].ctx;
2398 ret= av_read_frame(is, &pkt);
2399 if(ret == AVERROR(EAGAIN)){
2400 no_packet[file_index]=1;
2405 input_files[file_index].eof_reached = 1;
2413 memset(no_packet, 0, nb_input_files);
2416 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2417 is->streams[pkt.stream_index]);
2419 /* the following test is needed in case new streams appear
2420 dynamically in stream : we ignore them */
2421 if (pkt.stream_index >= input_files[file_index].nb_streams)
2422 goto discard_packet;
2423 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2424 ist = &input_streams[ist_index];
2426 goto discard_packet;
2428 if (pkt.dts != AV_NOPTS_VALUE)
2429 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2430 if (pkt.pts != AV_NOPTS_VALUE)
2431 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2433 if (ist->ts_scale) {
2434 if(pkt.pts != AV_NOPTS_VALUE)
2435 pkt.pts *= ist->ts_scale;
2436 if(pkt.dts != AV_NOPTS_VALUE)
2437 pkt.dts *= ist->ts_scale;
2440 // 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);
2441 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2442 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2443 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2444 int64_t delta= pkt_dts - ist->next_pts;
2445 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2446 input_files[ist->file_index].ts_offset -= delta;
2448 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2449 delta, input_files[ist->file_index].ts_offset);
2450 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2451 if(pkt.pts != AV_NOPTS_VALUE)
2452 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2456 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2457 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2460 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2461 ist->file_index, ist->st->index);
2464 av_free_packet(&pkt);
2469 av_free_packet(&pkt);
2471 /* dump report by using the output first video and audio streams */
2472 print_report(output_files, output_streams, nb_output_streams, 0);
2475 /* at the end of stream, we must flush the decoder buffers */
2476 for (i = 0; i < nb_input_streams; i++) {
2477 ist = &input_streams[i];
2478 if (ist->decoding_needed) {
2479 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2485 /* write the trailer if needed and close file */
2486 for(i=0;i<nb_output_files;i++) {
2487 os = output_files[i].ctx;
2488 av_write_trailer(os);
2491 /* dump report by using the first video and audio streams */
2492 print_report(output_files, output_streams, nb_output_streams, 1);
2494 /* close each encoder */
2495 for (i = 0; i < nb_output_streams; i++) {
2496 ost = &output_streams[i];
2497 if (ost->encoding_needed) {
2498 av_freep(&ost->st->codec->stats_in);
2499 avcodec_close(ost->st->codec);
2502 avfilter_graph_free(&ost->graph);
2506 /* close each decoder */
2507 for (i = 0; i < nb_input_streams; i++) {
2508 ist = &input_streams[i];
2509 if (ist->decoding_needed) {
2510 avcodec_close(ist->st->codec);
2518 av_freep(&bit_buffer);
2519 av_freep(&no_packet);
2521 if (output_streams) {
2522 for (i = 0; i < nb_output_streams; i++) {
2523 ost = &output_streams[i];
2525 if (ost->st->stream_copy)
2526 av_freep(&ost->st->codec->extradata);
2528 fclose(ost->logfile);
2529 ost->logfile = NULL;
2531 av_fifo_free(ost->fifo); /* works even if fifo is not
2532 initialized but set to zero */
2533 av_freep(&ost->st->codec->subtitle_header);
2534 av_free(ost->resample_frame.data[0]);
2535 av_free(ost->forced_kf_pts);
2536 if (ost->video_resample)
2537 sws_freeContext(ost->img_resample_ctx);
2539 audio_resample_close(ost->resample);
2540 if (ost->reformat_ctx)
2541 av_audio_convert_free(ost->reformat_ctx);
2542 av_dict_free(&ost->opts);
2549 static int opt_format(const char *opt, const char *arg)
2551 last_asked_format = arg;
2555 static int opt_video_rc_override_string(const char *opt, const char *arg)
2557 video_rc_override_string = arg;
2561 static int opt_me_threshold(const char *opt, const char *arg)
2563 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2567 static int opt_verbose(const char *opt, const char *arg)
2569 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2573 static int opt_frame_rate(const char *opt, const char *arg)
2575 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2576 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2582 static int opt_frame_crop(const char *opt, const char *arg)
2584 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2585 return AVERROR(EINVAL);
2588 static int opt_frame_size(const char *opt, const char *arg)
2590 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2591 fprintf(stderr, "Incorrect frame size\n");
2592 return AVERROR(EINVAL);
2597 static int opt_pad(const char *opt, const char *arg) {
2598 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2602 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2604 if (strcmp(arg, "list")) {
2605 frame_pix_fmt = av_get_pix_fmt(arg);
2606 if (frame_pix_fmt == PIX_FMT_NONE) {
2607 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2608 return AVERROR(EINVAL);
2611 opt_pix_fmts(NULL, NULL);
2617 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2624 p = strchr(arg, ':');
2626 x = strtol(arg, &end, 10);
2628 y = strtol(end+1, &end, 10);
2630 ar = (double)x / (double)y;
2632 ar = strtod(arg, NULL);
2635 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2636 return AVERROR(EINVAL);
2638 frame_aspect_ratio = ar;
2642 static int opt_metadata(const char *opt, const char *arg)
2644 char *mid= strchr(arg, '=');
2647 fprintf(stderr, "Missing =\n");
2652 av_dict_set(&metadata, arg, mid, 0);
2657 static int opt_qscale(const char *opt, const char *arg)
2659 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2660 if (video_qscale <= 0 || video_qscale > 255) {
2661 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2662 return AVERROR(EINVAL);
2667 static int opt_top_field_first(const char *opt, const char *arg)
2669 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2670 return opt_default(opt, arg);
2673 static int opt_thread_count(const char *opt, const char *arg)
2675 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2678 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2683 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2685 if (strcmp(arg, "list")) {
2686 audio_sample_fmt = av_get_sample_fmt(arg);
2687 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2688 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2689 return AVERROR(EINVAL);
2694 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2695 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2701 static int opt_audio_rate(const char *opt, const char *arg)
2703 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2707 static int opt_audio_channels(const char *opt, const char *arg)
2709 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2713 static int opt_codec(const char *opt, const char *arg)
2715 return av_dict_set(&codec_names, opt, arg, 0);
2718 static int opt_audio_codec(const char *opt, const char *arg)
2720 return opt_codec("codec:a", arg);
2723 static int opt_video_codec(const char *opt, const char *arg)
2725 return opt_codec("codec:v", arg);
2728 static int opt_subtitle_codec(const char *opt, const char *arg)
2730 return opt_codec("codec:s", arg);
2733 static int opt_data_codec(const char *opt, const char *arg)
2735 return opt_codec("codec:d", arg);
2738 static int opt_codec_tag(const char *opt, const char *arg)
2741 uint32_t *codec_tag;
2743 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2744 !strcmp(opt, "vtag") ? &video_codec_tag :
2745 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2749 *codec_tag = strtol(arg, &tail, 0);
2751 *codec_tag = AV_RL32(arg);
2756 static int opt_map(const char *opt, const char *arg)
2758 StreamMap *m = NULL;
2759 int i, negative = 0, file_idx;
2760 int sync_file_idx = -1, sync_stream_idx;
2768 map = av_strdup(arg);
2770 /* parse sync stream first, just pick first matching stream */
2771 if (sync = strchr(map, ',')) {
2773 sync_file_idx = strtol(sync + 1, &sync, 0);
2774 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2775 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2780 for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2781 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2782 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2783 sync_stream_idx = i;
2786 if (i == input_files[sync_file_idx].ctx->nb_streams) {
2787 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2788 "match any streams.\n", arg);
2794 file_idx = strtol(map, &p, 0);
2795 if (file_idx >= nb_input_files || file_idx < 0) {
2796 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2800 /* disable some already defined maps */
2801 for (i = 0; i < nb_stream_maps; i++) {
2802 m = &stream_maps[i];
2803 if (check_stream_specifier(input_files[m->file_index].ctx,
2804 input_files[m->file_index].ctx->streams[m->stream_index],
2805 *p == ':' ? p + 1 : p) > 0)
2809 for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2810 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2811 *p == ':' ? p + 1 : p) <= 0)
2813 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2814 m = &stream_maps[nb_stream_maps - 1];
2816 m->file_index = file_idx;
2817 m->stream_index = i;
2819 if (sync_file_idx >= 0) {
2820 m->sync_file_index = sync_file_idx;
2821 m->sync_stream_index = sync_stream_idx;
2823 m->sync_file_index = file_idx;
2824 m->sync_stream_index = i;
2829 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2837 static void parse_meta_type(char *arg, char *type, int *index)
2847 if (*(++arg) == ':')
2848 *index = strtol(++arg, NULL, 0);
2851 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2858 static int opt_map_metadata(const char *opt, const char *arg)
2860 MetadataMap *m, *m1;
2863 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2864 &nb_meta_data_maps, nb_meta_data_maps + 1);
2866 m = &meta_data_maps[nb_meta_data_maps - 1][1];
2867 m->file = strtol(arg, &p, 0);
2868 parse_meta_type(p, &m->type, &m->index);
2870 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2871 if (p = strchr(opt, ':'))
2872 parse_meta_type(p, &m1->type, &m1->index);
2876 if (m->type == 'g' || m1->type == 'g')
2877 metadata_global_autocopy = 0;
2878 if (m->type == 's' || m1->type == 's')
2879 metadata_streams_autocopy = 0;
2880 if (m->type == 'c' || m1->type == 'c')
2881 metadata_chapters_autocopy = 0;
2886 static int opt_input_ts_scale(const char *opt, const char *arg)
2888 return av_dict_set(&ts_scale, opt, arg, 0);
2891 static int opt_recording_time(const char *opt, const char *arg)
2893 recording_time = parse_time_or_die(opt, arg, 1);
2897 static int opt_start_time(const char *opt, const char *arg)
2899 start_time = parse_time_or_die(opt, arg, 1);
2903 static int opt_input_ts_offset(const char *opt, const char *arg)
2905 input_ts_offset = parse_time_or_die(opt, arg, 1);
2909 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2911 const char *codec_string = encoder ? "encoder" : "decoder";
2915 return CODEC_ID_NONE;
2917 avcodec_find_encoder_by_name(name) :
2918 avcodec_find_decoder_by_name(name);
2920 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2923 if(codec->type != type) {
2924 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2930 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2932 AVDictionaryEntry *e = NULL;
2933 char *codec_name = NULL;
2936 while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2937 char *p = strchr(e->key, ':');
2939 if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2940 codec_name = e->value;
2947 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2948 return avcodec_find_encoder(st->codec->codec_id);
2950 } else if (!strcmp(codec_name, "copy"))
2951 st->stream_copy = 1;
2953 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2954 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2955 avcodec_find_decoder_by_name(codec_name);
2962 * Add all the streams from the given input file to the global
2963 * list of input streams.
2965 static void add_input_streams(AVFormatContext *ic)
2967 int i, rfps, rfps_base, ret;
2969 for (i = 0; i < ic->nb_streams; i++) {
2970 AVStream *st = ic->streams[i];
2971 AVCodecContext *dec = st->codec;
2972 AVDictionaryEntry *e = NULL;
2976 dec->thread_count = thread_count;
2978 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2979 ist = &input_streams[nb_input_streams - 1];
2981 ist->file_index = nb_input_files;
2983 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2985 while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
2986 char *p = strchr(e->key, ':');
2988 if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
2994 ist->ts_scale = strtod(scale, NULL);
2996 ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
2998 switch (dec->codec_type) {
2999 case AVMEDIA_TYPE_AUDIO:
3001 ist->dec = avcodec_find_decoder(dec->codec_id);
3003 st->discard= AVDISCARD_ALL;
3005 case AVMEDIA_TYPE_VIDEO:
3007 ist->dec = avcodec_find_decoder(dec->codec_id);
3008 rfps = ic->streams[i]->r_frame_rate.num;
3009 rfps_base = ic->streams[i]->r_frame_rate.den;
3011 dec->flags |= CODEC_FLAG_EMU_EDGE;
3014 dec->debug |= FF_DEBUG_MV;
3016 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3019 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3020 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3022 (float)rfps / rfps_base, rfps, rfps_base);
3026 st->discard= AVDISCARD_ALL;
3027 else if(video_discard)
3028 st->discard= video_discard;
3030 case AVMEDIA_TYPE_DATA:
3032 case AVMEDIA_TYPE_SUBTITLE:
3034 ist->dec = avcodec_find_decoder(dec->codec_id);
3035 if(subtitle_disable)
3036 st->discard = AVDISCARD_ALL;
3038 case AVMEDIA_TYPE_ATTACHMENT:
3039 case AVMEDIA_TYPE_UNKNOWN:
3047 static int opt_input_file(const char *opt, const char *filename)
3049 AVFormatContext *ic;
3050 AVInputFormat *file_iformat = NULL;
3054 AVDictionary **opts;
3055 int orig_nb_streams; // number of streams before avformat_find_stream_info
3057 if (last_asked_format) {
3058 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3059 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3062 last_asked_format = NULL;
3065 if (!strcmp(filename, "-"))
3068 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3069 !strcmp(filename, "/dev/stdin");
3071 /* get default parameters from command line */
3072 ic = avformat_alloc_context();
3074 print_error(filename, AVERROR(ENOMEM));
3077 if (audio_sample_rate) {
3078 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3079 av_dict_set(&format_opts, "sample_rate", buf, 0);
3081 if (audio_channels) {
3082 snprintf(buf, sizeof(buf), "%d", audio_channels);
3083 av_dict_set(&format_opts, "channels", buf, 0);
3085 if (frame_rate.num) {
3086 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3087 av_dict_set(&format_opts, "framerate", buf, 0);
3089 if (frame_width && frame_height) {
3090 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3091 av_dict_set(&format_opts, "video_size", buf, 0);
3093 if (frame_pix_fmt != PIX_FMT_NONE)
3094 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3096 ic->flags |= AVFMT_FLAG_NONBLOCK;
3098 /* open the input file with generic libav function */
3099 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3101 print_error(filename, err);
3104 assert_avoptions(format_opts);
3109 for(i=0; i<ic->nb_streams; i++){
3110 ic->streams[i]->discard= AVDISCARD_ALL;
3112 for(i=0; i<ic->nb_programs; i++){
3113 AVProgram *p= ic->programs[i];
3114 if(p->id != opt_programid){
3115 p->discard = AVDISCARD_ALL;
3118 for(j=0; j<p->nb_stream_indexes; j++){
3119 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3124 fprintf(stderr, "Specified program id not found\n");
3130 /* apply forced codec ids */
3131 for (i = 0; i < ic->nb_streams; i++)
3132 choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3134 /* Set AVCodecContext options for avformat_find_stream_info */
3135 opts = setup_find_stream_info_opts(ic, codec_opts);
3136 orig_nb_streams = ic->nb_streams;
3138 /* If not enough info to get the stream parameters, we decode the
3139 first frames to get it. (used in mpeg case for example) */
3140 ret = avformat_find_stream_info(ic, opts);
3141 if (ret < 0 && verbose >= 0) {
3142 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3143 av_close_input_file(ic);
3147 timestamp = start_time;
3148 /* add the stream start time */
3149 if (ic->start_time != AV_NOPTS_VALUE)
3150 timestamp += ic->start_time;
3152 /* if seeking requested, we execute it */
3153 if (start_time != 0) {
3154 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3156 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3157 filename, (double)timestamp / AV_TIME_BASE);
3159 /* reset seek info */
3163 /* update the current parameters so that they match the one of the input stream */
3164 add_input_streams(ic);
3166 /* dump the file content */
3168 av_dump_format(ic, nb_input_files, filename, 0);
3170 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3171 input_files[nb_input_files - 1].ctx = ic;
3172 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3173 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3174 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3176 top_field_first = -1;
3177 frame_rate = (AVRational){0, 0};
3178 frame_pix_fmt = PIX_FMT_NONE;
3181 audio_sample_rate = 0;
3183 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3184 av_dict_free(&ts_scale);
3186 for (i = 0; i < orig_nb_streams; i++)
3187 av_dict_free(&opts[i]);
3189 av_dict_free(&codec_names);
3195 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3196 AVCodecContext *avctx)
3202 for (p = kf; *p; p++)
3205 ost->forced_kf_count = n;
3206 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3207 if (!ost->forced_kf_pts) {
3208 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3211 for (i = 0; i < n; i++) {
3212 p = i ? strchr(p, ',') + 1 : kf;
3213 t = parse_time_or_die("force_key_frames", p, 1);
3214 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3218 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3221 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3222 int idx = oc->nb_streams - 1;
3225 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3229 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3230 nb_output_streams + 1);
3231 ost = &output_streams[nb_output_streams - 1];
3232 ost->file_index = nb_output_files;
3235 st->codec->codec_type = type;
3236 ost->enc = choose_codec(oc, st, type, codec_names);
3238 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3241 avcodec_get_context_defaults3(st->codec, ost->enc);
3242 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3244 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3248 static OutputStream *new_video_stream(AVFormatContext *oc)
3252 AVCodecContext *video_enc;
3254 ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3256 if (!st->stream_copy) {
3257 ost->frame_aspect_ratio = frame_aspect_ratio;
3258 frame_aspect_ratio = 0;
3260 ost->avfilter = vfilters;
3265 ost->bitstream_filters = video_bitstream_filters;
3266 video_bitstream_filters= NULL;
3268 st->codec->thread_count= thread_count;
3270 video_enc = st->codec;
3273 video_enc->codec_tag= video_codec_tag;
3275 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3276 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3279 if (st->stream_copy) {
3280 video_enc->sample_aspect_ratio =
3281 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3287 ost->frame_rate = frame_rate;
3289 video_enc->width = frame_width;
3290 video_enc->height = frame_height;
3291 video_enc->pix_fmt = frame_pix_fmt;
3292 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3293 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3296 video_enc->gop_size = 0;
3297 if (video_qscale || same_quant) {
3298 video_enc->flags |= CODEC_FLAG_QSCALE;
3299 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3303 video_enc->intra_matrix = intra_matrix;
3305 video_enc->inter_matrix = inter_matrix;
3307 p= video_rc_override_string;
3310 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3312 fprintf(stderr, "error parsing rc_override\n");
3315 video_enc->rc_override=
3316 av_realloc(video_enc->rc_override,
3317 sizeof(RcOverride)*(i+1));
3318 video_enc->rc_override[i].start_frame= start;
3319 video_enc->rc_override[i].end_frame = end;
3321 video_enc->rc_override[i].qscale= q;
3322 video_enc->rc_override[i].quality_factor= 1.0;
3325 video_enc->rc_override[i].qscale= 0;
3326 video_enc->rc_override[i].quality_factor= -q/100.0;
3331 video_enc->rc_override_count=i;
3332 if (!video_enc->rc_initial_buffer_occupancy)
3333 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3334 video_enc->me_threshold= me_threshold;
3335 video_enc->intra_dc_precision= intra_dc_precision - 8;
3338 video_enc->flags|= CODEC_FLAG_PSNR;
3343 video_enc->flags |= CODEC_FLAG_PASS1;
3345 video_enc->flags |= CODEC_FLAG_PASS2;
3349 if (forced_key_frames)
3350 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3352 if (video_language) {
3353 av_dict_set(&st->metadata, "language", video_language, 0);
3354 av_freep(&video_language);
3357 /* reset some key parameters */
3359 av_freep(&forced_key_frames);
3360 frame_pix_fmt = PIX_FMT_NONE;
3364 static OutputStream *new_audio_stream(AVFormatContext *oc)
3368 AVCodecContext *audio_enc;
3370 ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3373 ost->bitstream_filters = audio_bitstream_filters;
3374 audio_bitstream_filters= NULL;
3376 st->codec->thread_count= thread_count;
3378 audio_enc = st->codec;
3379 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3382 audio_enc->codec_tag= audio_codec_tag;
3384 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3385 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3387 if (!st->stream_copy) {
3388 if (audio_qscale > QSCALE_NONE) {
3389 audio_enc->flags |= CODEC_FLAG_QSCALE;
3390 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3393 audio_enc->channels = audio_channels;
3394 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3395 audio_enc->sample_fmt = audio_sample_fmt;
3396 if (audio_sample_rate)
3397 audio_enc->sample_rate = audio_sample_rate;
3399 if (audio_language) {
3400 av_dict_set(&st->metadata, "language", audio_language, 0);
3401 av_freep(&audio_language);
3404 /* reset some key parameters */
3410 static OutputStream *new_data_stream(AVFormatContext *oc)
3414 AVCodecContext *data_enc;
3416 ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3418 data_enc = st->codec;
3419 if (!st->stream_copy) {
3420 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3425 data_enc->codec_tag= data_codec_tag;
3427 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3428 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3435 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3439 AVCodecContext *subtitle_enc;
3441 ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3443 subtitle_enc = st->codec;
3445 ost->bitstream_filters = subtitle_bitstream_filters;
3446 subtitle_bitstream_filters= NULL;
3448 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3450 if(subtitle_codec_tag)
3451 subtitle_enc->codec_tag= subtitle_codec_tag;
3453 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3454 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3457 if (subtitle_language) {
3458 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3459 av_freep(&subtitle_language);
3462 subtitle_disable = 0;
3466 /* arg format is "output-stream-index:streamid-value". */
3467 static int opt_streamid(const char *opt, const char *arg)
3473 av_strlcpy(idx_str, arg, sizeof(idx_str));
3474 p = strchr(idx_str, ':');
3477 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3482 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3483 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3484 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3488 static int copy_chapters(int infile, int outfile)
3490 AVFormatContext *is = input_files[infile].ctx;
3491 AVFormatContext *os = output_files[outfile].ctx;
3494 for (i = 0; i < is->nb_chapters; i++) {
3495 AVChapter *in_ch = is->chapters[i], *out_ch;
3496 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
3497 AV_TIME_BASE_Q, in_ch->time_base);
3498 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
3499 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3502 if (in_ch->end < ts_off)
3504 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3507 out_ch = av_mallocz(sizeof(AVChapter));
3509 return AVERROR(ENOMEM);
3511 out_ch->id = in_ch->id;
3512 out_ch->time_base = in_ch->time_base;
3513 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3514 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3516 if (metadata_chapters_autocopy)
3517 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3520 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3522 return AVERROR(ENOMEM);
3523 os->chapters[os->nb_chapters - 1] = out_ch;
3528 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
3531 AVFormatContext *ic = NULL;
3533 err = avformat_open_input(&ic, filename, NULL, NULL);
3536 /* copy stream format */
3537 for(i=0;i<ic->nb_streams;i++) {
3542 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3543 ost = new_output_stream(s, codec->type);
3546 // FIXME: a more elegant solution is needed
3547 memcpy(st, ic->streams[i], sizeof(AVStream));
3548 st->info = av_malloc(sizeof(*st->info));
3549 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3550 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3552 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3553 choose_sample_fmt(st, codec);
3554 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3555 choose_pixel_fmt(st, codec);
3558 av_close_input_file(ic);
3562 static int opt_output_file(const char *opt, const char *filename)
3564 AVFormatContext *oc;
3566 AVOutputFormat *file_oformat;
3570 if (!strcmp(filename, "-"))
3573 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3574 last_asked_format = NULL;
3576 print_error(filename, err);
3580 file_oformat= oc->oformat;
3582 if (!strcmp(file_oformat->name, "ffm") &&
3583 av_strstart(filename, "http:", NULL)) {
3584 /* special case for files sent to ffserver: we get the stream
3585 parameters from ffserver */
3586 int err = read_ffserver_streams(oc, filename);
3588 print_error(filename, err);
3591 } else if (!nb_stream_maps) {
3592 /* pick the "best" stream of each type */
3593 #define NEW_STREAM(type, index)\
3595 ost = new_ ## type ## _stream(oc);\
3596 ost->source_index = index;\
3597 ost->sync_ist = &input_streams[index];\
3598 input_streams[index].discard = 0;\
3601 /* video: highest resolution */
3602 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3603 int area = 0, idx = -1;
3604 for (i = 0; i < nb_input_streams; i++) {
3605 ist = &input_streams[i];
3606 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3607 ist->st->codec->width * ist->st->codec->height > area) {
3608 area = ist->st->codec->width * ist->st->codec->height;
3612 NEW_STREAM(video, idx);
3615 /* audio: most channels */
3616 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3617 int channels = 0, idx = -1;
3618 for (i = 0; i < nb_input_streams; i++) {
3619 ist = &input_streams[i];
3620 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3621 ist->st->codec->channels > channels) {
3622 channels = ist->st->codec->channels;
3626 NEW_STREAM(audio, idx);
3629 /* subtitles: pick first */
3630 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3631 for (i = 0; i < nb_input_streams; i++)
3632 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3633 NEW_STREAM(subtitle, i);
3637 /* do something with data? */
3639 for (i = 0; i < nb_stream_maps; i++) {
3640 StreamMap *map = &stream_maps[i];
3645 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3646 switch (ist->st->codec->codec_type) {
3647 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
3648 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
3649 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3650 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
3652 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3653 map->file_index, map->stream_index);
3657 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3658 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3659 map->sync_stream_index];
3664 av_dict_copy(&oc->metadata, metadata, 0);
3665 av_dict_free(&metadata);
3668 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3669 output_files[nb_output_files - 1].ctx = oc;
3670 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3671 output_files[nb_output_files - 1].recording_time = recording_time;
3672 output_files[nb_output_files - 1].start_time = start_time;
3673 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3675 /* check filename in case of an image number is expected */
3676 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3677 if (!av_filename_number_test(oc->filename)) {
3678 print_error(oc->filename, AVERROR(EINVAL));
3683 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3684 /* test if it already exists to avoid loosing precious files */
3685 if (!file_overwrite &&
3686 (strchr(filename, ':') == NULL ||
3687 filename[1] == ':' ||
3688 av_strstart(filename, "file:", NULL))) {
3689 if (avio_check(filename, 0) == 0) {
3691 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3693 if (!read_yesno()) {
3694 fprintf(stderr, "Not overwriting - exiting\n");
3699 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3706 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3707 print_error(filename, err);
3712 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3713 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3716 if (chapters_input_file >= nb_input_files) {
3717 if (chapters_input_file == INT_MAX) {
3718 /* copy chapters from the first input file that has them*/
3719 chapters_input_file = -1;
3720 for (i = 0; i < nb_input_files; i++)
3721 if (input_files[i].ctx->nb_chapters) {
3722 chapters_input_file = i;
3726 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3727 chapters_input_file);
3731 if (chapters_input_file >= 0)
3732 copy_chapters(chapters_input_file, nb_output_files - 1);
3735 for (i = 0; i < nb_meta_data_maps; i++) {
3736 AVFormatContext *files[2];
3737 AVDictionary **meta[2];
3740 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3741 if ((index) < 0 || (index) >= (nb_elems)) {\
3742 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3747 int in_file_index = meta_data_maps[i][1].file;
3748 if (in_file_index < 0)
3750 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3753 files[1] = input_files[in_file_index].ctx;
3755 for (j = 0; j < 2; j++) {
3756 MetadataMap *map = &meta_data_maps[i][j];
3758 switch (map->type) {
3760 meta[j] = &files[j]->metadata;
3763 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3764 meta[j] = &files[j]->streams[map->index]->metadata;
3767 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3768 meta[j] = &files[j]->chapters[map->index]->metadata;
3771 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3772 meta[j] = &files[j]->programs[map->index]->metadata;
3777 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3780 /* copy global metadata by default */
3781 if (metadata_global_autocopy && nb_input_files)
3782 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3783 AV_DICT_DONT_OVERWRITE);
3784 if (metadata_streams_autocopy)
3785 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3786 InputStream *ist = &input_streams[output_streams[i].source_index];
3787 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3790 frame_rate = (AVRational){0, 0};
3793 audio_sample_rate = 0;
3795 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3796 chapters_input_file = INT_MAX;
3797 recording_time = INT64_MAX;
3800 av_freep(&meta_data_maps);
3801 nb_meta_data_maps = 0;
3802 metadata_global_autocopy = 1;
3803 metadata_streams_autocopy = 1;
3804 metadata_chapters_autocopy = 1;
3805 av_freep(&stream_maps);
3808 av_dict_free(&codec_names);
3810 av_freep(&forced_key_frames);
3816 /* same option as mencoder */
3817 static int opt_pass(const char *opt, const char *arg)
3819 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3823 static int64_t getutime(void)
3826 struct rusage rusage;
3828 getrusage(RUSAGE_SELF, &rusage);
3829 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3830 #elif HAVE_GETPROCESSTIMES
3832 FILETIME c, e, k, u;
3833 proc = GetCurrentProcess();
3834 GetProcessTimes(proc, &c, &e, &k, &u);
3835 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3837 return av_gettime();
3841 static int64_t getmaxrss(void)
3843 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3844 struct rusage rusage;
3845 getrusage(RUSAGE_SELF, &rusage);
3846 return (int64_t)rusage.ru_maxrss * 1024;
3847 #elif HAVE_GETPROCESSMEMORYINFO
3849 PROCESS_MEMORY_COUNTERS memcounters;
3850 proc = GetCurrentProcess();
3851 memcounters.cb = sizeof(memcounters);
3852 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3853 return memcounters.PeakPagefileUsage;
3859 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3862 const char *p = str;
3869 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3876 static int opt_inter_matrix(const char *opt, const char *arg)
3878 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3879 parse_matrix_coeffs(inter_matrix, arg);
3883 static int opt_intra_matrix(const char *opt, const char *arg)
3885 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3886 parse_matrix_coeffs(intra_matrix, arg);
3890 static void show_usage(void)
3892 printf("Hyper fast Audio and Video encoder\n");
3893 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3897 static int opt_help(const char *opt, const char *arg)
3900 AVOutputFormat *oformat = NULL;
3901 AVInputFormat *iformat = NULL;
3903 av_log_set_callback(log_callback_help);
3905 show_help_options(options, "Main options:\n",
3906 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3907 show_help_options(options, "\nAdvanced options:\n",
3908 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3910 show_help_options(options, "\nVideo options:\n",
3911 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3913 show_help_options(options, "\nAdvanced Video options:\n",
3914 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3915 OPT_VIDEO | OPT_EXPERT);
3916 show_help_options(options, "\nAudio options:\n",
3917 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3919 show_help_options(options, "\nAdvanced Audio options:\n",
3920 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3921 OPT_AUDIO | OPT_EXPERT);
3922 show_help_options(options, "\nSubtitle options:\n",
3923 OPT_SUBTITLE | OPT_GRAB,
3925 show_help_options(options, "\nAudio/Video grab options:\n",
3929 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3932 /* individual codec options */
3934 while ((c = av_codec_next(c))) {
3935 if (c->priv_class) {
3936 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3941 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3944 /* individual muxer options */
3945 while ((oformat = av_oformat_next(oformat))) {
3946 if (oformat->priv_class) {
3947 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3952 /* individual demuxer options */
3953 while ((iformat = av_iformat_next(iformat))) {
3954 if (iformat->priv_class) {
3955 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3960 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3964 static int opt_target(const char *opt, const char *arg)
3966 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3967 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3969 if(!strncmp(arg, "pal-", 4)) {
3972 } else if(!strncmp(arg, "ntsc-", 5)) {
3975 } else if(!strncmp(arg, "film-", 5)) {
3980 /* Calculate FR via float to avoid int overflow */
3981 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3984 } else if((fr == 29970) || (fr == 23976)) {
3987 /* Try to determine PAL/NTSC by peeking in the input files */
3988 if(nb_input_files) {
3990 for (j = 0; j < nb_input_files; j++) {
3991 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3992 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3993 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3995 fr = c->time_base.den * 1000 / c->time_base.num;
3999 } else if((fr == 29970) || (fr == 23976)) {
4009 if(verbose > 0 && norm != UNKNOWN)
4010 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4013 if(norm == UNKNOWN) {
4014 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4015 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4016 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4020 if(!strcmp(arg, "vcd")) {
4021 opt_codec("c:v", "mpeg1video");
4022 opt_codec("c:a", "mp2");
4023 opt_format("f", "vcd");
4025 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4026 opt_frame_rate("r", frame_rates[norm]);
4027 opt_default("g", norm == PAL ? "15" : "18");
4029 opt_default("b", "1150000");
4030 opt_default("maxrate", "1150000");
4031 opt_default("minrate", "1150000");
4032 opt_default("bufsize", "327680"); // 40*1024*8;
4034 opt_default("b:a", "224000");
4035 audio_sample_rate = 44100;
4038 opt_default("packetsize", "2324");
4039 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4041 /* We have to offset the PTS, so that it is consistent with the SCR.
4042 SCR starts at 36000, but the first two packs contain only padding
4043 and the first pack from the other stream, respectively, may also have
4044 been written before.
4045 So the real data starts at SCR 36000+3*1200. */
4046 mux_preload= (36000+3*1200) / 90000.0; //0.44
4047 } else if(!strcmp(arg, "svcd")) {
4049 opt_codec("c:v", "mpeg2video");
4050 opt_codec("c:a", "mp2");
4051 opt_format("f", "svcd");
4053 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4054 opt_frame_rate("r", frame_rates[norm]);
4055 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4056 opt_default("g", norm == PAL ? "15" : "18");
4058 opt_default("b", "2040000");
4059 opt_default("maxrate", "2516000");
4060 opt_default("minrate", "0"); //1145000;
4061 opt_default("bufsize", "1835008"); //224*1024*8;
4062 opt_default("flags", "+scan_offset");
4065 opt_default("b:a", "224000");
4066 audio_sample_rate = 44100;
4068 opt_default("packetsize", "2324");
4070 } else if(!strcmp(arg, "dvd")) {
4072 opt_codec("c:v", "mpeg2video");
4073 opt_codec("c:a", "ac3");
4074 opt_format("f", "dvd");
4076 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4077 opt_frame_rate("r", frame_rates[norm]);
4078 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4079 opt_default("g", norm == PAL ? "15" : "18");
4081 opt_default("b", "6000000");
4082 opt_default("maxrate", "9000000");
4083 opt_default("minrate", "0"); //1500000;
4084 opt_default("bufsize", "1835008"); //224*1024*8;
4086 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4087 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4089 opt_default("b:a", "448000");
4090 audio_sample_rate = 48000;
4092 } else if(!strncmp(arg, "dv", 2)) {
4094 opt_format("f", "dv");
4096 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4097 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4098 norm == PAL ? "yuv420p" : "yuv411p");
4099 opt_frame_rate("r", frame_rates[norm]);
4101 audio_sample_rate = 48000;
4105 fprintf(stderr, "Unknown target: %s\n", arg);
4106 return AVERROR(EINVAL);
4111 static int opt_vstats_file(const char *opt, const char *arg)
4113 av_free (vstats_filename);
4114 vstats_filename=av_strdup (arg);
4118 static int opt_vstats(const char *opt, const char *arg)
4121 time_t today2 = time(NULL);
4122 struct tm *today = localtime(&today2);
4124 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4126 return opt_vstats_file(opt, filename);
4129 static int opt_bsf(const char *opt, const char *arg)
4131 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4132 AVBitStreamFilterContext **bsfp;
4135 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4139 bsfp= *opt == 'v' ? &video_bitstream_filters :
4140 *opt == 'a' ? &audio_bitstream_filters :
4141 &subtitle_bitstream_filters;
4143 bsfp= &(*bsfp)->next;
4150 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4154 static int opt_passlogfile(const char *opt, const char *arg)
4156 pass_logfilename_prefix = arg;
4157 #if CONFIG_LIBX264_ENCODER
4158 return opt_default("passlogfile", arg);
4164 static const OptionDef options[] = {
4166 #include "cmdutils_common_opts.h"
4167 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4168 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4169 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4170 { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4171 { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4172 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4173 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4174 "outfile[,metadata]:infile[,metadata]" },
4175 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
4176 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4177 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4178 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4179 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4180 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4181 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4182 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4183 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4184 "add timings for benchmarking" },
4185 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4186 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4187 "dump each input packet" },
4188 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4189 "when dumping packets, also dump the payload" },
4190 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4191 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4192 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4193 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4194 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4195 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4196 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4197 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4198 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4199 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4200 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4201 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4202 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4203 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4206 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4207 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4208 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4209 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4210 { "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" },
4211 { "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" },
4212 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4213 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4214 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4215 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4216 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4217 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4218 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4219 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4220 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4221 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4222 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4223 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4224 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4225 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4226 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4227 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4228 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4229 "use same quantizer as source (implies VBR)" },
4230 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4231 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4232 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4233 "deinterlace pictures" },
4234 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4235 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4236 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4238 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4240 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4241 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4242 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4243 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4244 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4245 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4246 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4247 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4248 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4249 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4252 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4253 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4254 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4255 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4256 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4257 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4258 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4259 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4260 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4261 { "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" },
4263 /* subtitle options */
4264 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4265 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4266 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4267 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4270 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4273 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4274 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4276 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4277 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4278 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4280 /* data codec support */
4281 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4283 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4287 int main(int argc, char **argv)
4291 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4293 if(argc>1 && !strcmp(argv[1], "-d")){
4296 av_log_set_callback(log_callback_null);
4301 avcodec_register_all();
4303 avdevice_register_all();
4306 avfilter_register_all();
4311 if(isatty(STDIN_FILENO))
4312 avio_set_interrupt_cb(decode_interrupt_cb);
4321 parse_options(argc, argv, options, opt_output_file);
4323 if(nb_output_files <= 0 && nb_input_files == 0) {
4325 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4329 /* file converter / grab */
4330 if (nb_output_files <= 0) {
4331 fprintf(stderr, "At least one output file must be specified\n");
4335 if (nb_input_files == 0) {
4336 fprintf(stderr, "At least one input file must be specified\n");
4341 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4343 ti = getutime() - ti;
4345 int maxrss = getmaxrss() / 1024;
4346 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4349 return exit_program(0);