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/pixdesc.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/libm.h"
45 #include "libavformat/os_support.h"
47 #include "libavformat/ffm.h" // not public API
50 # include "libavfilter/avcodec.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
74 #include <sys/ioctl.h>
84 #include "libavutil/avassert.h"
86 const char program_name[] = "ffmpeg";
87 const int program_birth_year = 2000;
89 /* select an input stream for an output stream */
90 typedef struct AVStreamMap {
94 int sync_stream_index;
98 * select an input file for an output file
100 typedef struct AVMetaDataMap {
101 int file; //< file index
102 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103 int index; //< stream/chapter/program number
106 typedef struct AVChapterMap {
111 static const OptionDef options[];
113 #define MAX_FILES 100
114 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
116 static const char *last_asked_format = NULL;
117 static AVFormatContext *input_files[MAX_FILES];
118 static int64_t input_files_ts_offset[MAX_FILES];
119 static double *input_files_ts_scale[MAX_FILES] = {NULL};
120 static AVCodec **input_codecs = NULL;
121 static int nb_input_files = 0;
122 static int nb_input_codecs = 0;
123 static int nb_input_files_ts_scale[MAX_FILES] = {0};
125 static AVFormatContext *output_files[MAX_FILES];
126 static AVCodec **output_codecs = NULL;
127 static int nb_output_files = 0;
128 static int nb_output_codecs = 0;
130 static AVStreamMap *stream_maps = NULL;
131 static int nb_stream_maps;
133 /* first item specifies output metadata, second is input */
134 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
135 static int nb_meta_data_maps;
136 static int metadata_global_autocopy = 1;
137 static int metadata_streams_autocopy = 1;
138 static int metadata_chapters_autocopy = 1;
140 static AVChapterMap *chapter_maps = NULL;
141 static int nb_chapter_maps;
143 /* indexed by output file stream index */
144 static int *streamid_map = NULL;
145 static int nb_streamid_map = 0;
147 static int frame_width = 0;
148 static int frame_height = 0;
149 static float frame_aspect_ratio = 0;
150 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
151 static int frame_bits_per_raw_sample = 0;
152 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
153 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
154 static AVRational frame_rate;
155 static float video_qscale = 0;
156 static uint16_t *intra_matrix = NULL;
157 static uint16_t *inter_matrix = NULL;
158 static const char *video_rc_override_string=NULL;
159 static int video_disable = 0;
160 static int video_discard = 0;
161 static char *video_codec_name = NULL;
162 static unsigned int video_codec_tag = 0;
163 static char *video_language = NULL;
164 static int same_quality = 0;
165 static int do_deinterlace = 0;
166 static int top_field_first = -1;
167 static int me_threshold = 0;
168 static int intra_dc_precision = 8;
169 static int loop_input = 0;
170 static int loop_output = AVFMT_NOOUTPUTLOOP;
171 static int qp_hist = 0;
173 static char *vfilters = NULL;
176 static int intra_only = 0;
177 static int audio_sample_rate = 44100;
178 static int64_t channel_layout = 0;
179 #define QSCALE_NONE -99999
180 static float audio_qscale = QSCALE_NONE;
181 static int audio_disable = 0;
182 static int audio_channels = 1;
183 static char *audio_codec_name = NULL;
184 static unsigned int audio_codec_tag = 0;
185 static char *audio_language = NULL;
187 static int subtitle_disable = 0;
188 static char *subtitle_codec_name = NULL;
189 static char *subtitle_language = NULL;
190 static unsigned int subtitle_codec_tag = 0;
192 static int data_disable = 0;
193 static char *data_codec_name = NULL;
194 static unsigned int data_codec_tag = 0;
196 static float mux_preload= 0.5;
197 static float mux_max_delay= 0.7;
199 static int64_t recording_time = INT64_MAX;
200 static int64_t start_time = 0;
201 static int64_t recording_timestamp = 0;
202 static int64_t input_ts_offset = 0;
203 static int file_overwrite = 0;
204 static AVMetadata *metadata;
205 static int do_benchmark = 0;
206 static int do_hex_dump = 0;
207 static int do_pkt_dump = 0;
208 static int do_psnr = 0;
209 static int do_pass = 0;
210 static const char *pass_logfilename_prefix;
211 static int audio_stream_copy = 0;
212 static int video_stream_copy = 0;
213 static int subtitle_stream_copy = 0;
214 static int data_stream_copy = 0;
215 static int video_sync_method= -1;
216 static int audio_sync_method= 0;
217 static float audio_drift_threshold= 0.1;
218 static int copy_ts= 0;
219 static int copy_tb= 0;
220 static int opt_shortest = 0;
221 static int video_global_header = 0;
222 static char *vstats_filename;
223 static FILE *vstats_file;
224 static int opt_programid = 0;
225 static int copy_initial_nonkeyframes = 0;
227 static int rate_emu = 0;
229 static int video_channel = 0;
230 static char *video_standard;
232 static int audio_volume = 256;
234 static int exit_on_error = 0;
235 static int using_stdin = 0;
236 static int verbose = 1;
237 static int run_as_daemon = 0;
238 static int thread_count= 1;
239 static int q_pressed = 0;
240 static int64_t video_size = 0;
241 static int64_t audio_size = 0;
242 static int64_t extra_size = 0;
243 static int nb_frames_dup = 0;
244 static int nb_frames_drop = 0;
245 static int input_sync;
246 static uint64_t limit_filesize = 0;
247 static int force_fps = 0;
248 static char *forced_key_frames = NULL;
250 static float dts_delta_threshold = 10;
252 static int64_t timer_start;
254 static uint8_t *audio_buf;
255 static uint8_t *audio_out;
256 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
258 static short *samples;
260 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
261 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
262 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
264 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
266 struct AVInputStream;
268 typedef struct AVOutputStream {
269 int file_index; /* file index */
270 int index; /* stream index in the output file */
271 int source_index; /* AVInputStream index */
272 AVStream *st; /* stream in the output file */
273 int encoding_needed; /* true if encoding needed for this stream */
275 /* input pts and corresponding output pts
277 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
278 struct AVInputStream *sync_ist; /* input stream to sync against */
279 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
280 AVBitStreamFilterContext *bitstream_filters;
283 AVFrame resample_frame; /* temporary frame for image resampling */
284 struct SwsContext *img_resample_ctx; /* for image resampling */
287 int resample_pix_fmt;
289 float frame_aspect_ratio;
291 /* forced key frames */
292 int64_t *forced_kf_pts;
298 ReSampleContext *resample; /* for audio resampling */
299 int resample_sample_fmt;
300 int resample_channels;
301 int resample_sample_rate;
303 AVAudioConvert *reformat_ctx;
304 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
308 AVFilterContext *output_video_filter;
309 AVFilterContext *input_video_filter;
310 AVFilterBufferRef *picref;
312 AVFilterGraph *graph;
318 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
319 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
321 typedef struct AVInputStream {
325 int discard; /* true if stream data should be discarded */
326 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
327 int64_t sample_index; /* current sample */
329 int64_t start; /* time when read started */
330 int64_t next_pts; /* synthetic pts for cases where pkt.pts
332 int64_t pts; /* current pts */
333 int is_start; /* is 1 at the start and after a discontinuity */
334 int showed_multi_packet_warning;
335 int is_past_recording_time;
337 AVFrame *filter_frame;
338 int has_filter_frame;
342 typedef struct AVInputFile {
343 int eof_reached; /* true if eof reached */
344 int ist_index; /* index of first stream in ist_table */
345 int buffer_size; /* current total buffer size */
346 int nb_streams; /* nb streams we are aware of */
351 /* init terminal so that we can grab keys */
352 static struct termios oldtty;
357 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
359 AVFilterContext *last_filter, *filter;
360 /** filter graph containing all filters including input & output */
361 AVCodecContext *codec = ost->st->codec;
362 AVCodecContext *icodec = ist->st->codec;
363 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
364 AVRational sample_aspect_ratio;
368 ost->graph = avfilter_graph_alloc();
370 if (ist->st->sample_aspect_ratio.num){
371 sample_aspect_ratio = ist->st->sample_aspect_ratio;
373 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
375 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
376 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
377 sample_aspect_ratio.num, sample_aspect_ratio.den);
379 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
380 "src", args, NULL, ost->graph);
383 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
384 "out", NULL, &ffsink_ctx, ost->graph);
387 last_filter = ost->input_video_filter;
389 if (codec->width != icodec->width || codec->height != icodec->height) {
390 snprintf(args, 255, "%d:%d:flags=0x%X",
394 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
395 NULL, args, NULL, ost->graph)) < 0)
397 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
399 last_filter = filter;
402 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
403 ost->graph->scale_sws_opts = av_strdup(args);
406 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
407 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
409 outputs->name = av_strdup("in");
410 outputs->filter_ctx = last_filter;
411 outputs->pad_idx = 0;
412 outputs->next = NULL;
414 inputs->name = av_strdup("out");
415 inputs->filter_ctx = ost->output_video_filter;
419 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
421 av_freep(&ost->avfilter);
423 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
427 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
430 codec->width = ost->output_video_filter->inputs[0]->w;
431 codec->height = ost->output_video_filter->inputs[0]->h;
432 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
433 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
434 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
435 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
439 #endif /* CONFIG_AVFILTER */
441 static void term_exit(void)
443 av_log(NULL, AV_LOG_QUIET, "");
446 tcsetattr (0, TCSANOW, &oldtty);
450 static volatile int received_sigterm = 0;
453 sigterm_handler(int sig)
455 received_sigterm = sig;
460 static void term_init(void)
470 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
471 |INLCR|IGNCR|ICRNL|IXON);
472 tty.c_oflag |= OPOST;
473 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
474 tty.c_cflag &= ~(CSIZE|PARENB);
479 tcsetattr (0, TCSANOW, &tty);
480 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
484 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
485 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
487 signal(SIGXCPU, sigterm_handler);
491 /* read a key without blocking */
492 static int read_key(void)
507 n = select(1, &rfds, NULL, NULL, &tv);
522 static int decode_interrupt_cb(void)
524 q_pressed += read_key() == 'q';
525 return q_pressed > 1;
528 static int ffmpeg_exit(int ret)
533 for(i=0;i<nb_output_files;i++) {
534 AVFormatContext *s = output_files[i];
535 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
537 avformat_free_context(s);
538 av_free(output_streams_for_file[i]);
540 for(i=0;i<nb_input_files;i++) {
541 av_close_input_file(input_files[i]);
542 av_free(input_files_ts_scale[i]);
545 av_free(intra_matrix);
546 av_free(inter_matrix);
550 av_free(vstats_filename);
552 av_free(streamid_map);
553 av_free(input_codecs);
554 av_free(output_codecs);
555 av_free(stream_maps);
556 av_free(meta_data_maps);
558 av_free(video_codec_name);
559 av_free(audio_codec_name);
560 av_free(subtitle_codec_name);
561 av_free(data_codec_name);
563 av_free(video_standard);
568 allocated_audio_buf_size= allocated_audio_out_size= 0;
575 if (received_sigterm) {
577 "Received signal %d: terminating.\n",
578 (int) received_sigterm);
582 exit(ret); /* not all OS-es handle main() return value */
586 /* similar to ff_dynarray_add() and av_fast_realloc() */
587 static void *grow_array(void *array, int elem_size, int *size, int new_size)
589 if (new_size >= INT_MAX / elem_size) {
590 fprintf(stderr, "Array too big.\n");
593 if (*size < new_size) {
594 uint8_t *tmp = av_realloc(array, new_size*elem_size);
596 fprintf(stderr, "Could not alloc buffer.\n");
599 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
606 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
608 if(codec && codec->sample_fmts){
609 const enum AVSampleFormat *p= codec->sample_fmts;
611 if(*p == st->codec->sample_fmt)
615 av_log(NULL, AV_LOG_WARNING,
616 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
617 av_get_sample_fmt_name(st->codec->sample_fmt),
619 av_get_sample_fmt_name(codec->sample_fmts[0]));
620 st->codec->sample_fmt = codec->sample_fmts[0];
625 static void choose_sample_rate(AVStream *st, AVCodec *codec)
627 if(codec && codec->supported_samplerates){
628 const int *p= codec->supported_samplerates;
630 int best_dist=INT_MAX;
632 int dist= abs(st->codec->sample_rate - *p);
633 if(dist < best_dist){
639 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
641 st->codec->sample_rate= best;
645 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
647 if(codec && codec->pix_fmts){
648 const enum PixelFormat *p= codec->pix_fmts;
649 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
650 if(st->codec->codec_id==CODEC_ID_MJPEG){
651 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
652 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
653 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};
657 if(*p == st->codec->pix_fmt)
661 if(st->codec->pix_fmt != PIX_FMT_NONE)
662 av_log(NULL, AV_LOG_WARNING,
663 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
664 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
666 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
667 st->codec->pix_fmt = codec->pix_fmts[0];
672 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
674 int idx = oc->nb_streams - 1;
677 output_streams_for_file[file_idx] =
678 grow_array(output_streams_for_file[file_idx],
679 sizeof(*output_streams_for_file[file_idx]),
680 &nb_output_streams_for_file[file_idx],
682 ost = output_streams_for_file[file_idx][idx] =
683 av_mallocz(sizeof(AVOutputStream));
685 fprintf(stderr, "Could not alloc output stream\n");
688 ost->file_index = file_idx;
691 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
695 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
701 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
704 /* copy stream format */
706 for(i=0;i<ic->nb_streams;i++) {
712 // FIXME: a more elegant solution is needed
713 st = av_mallocz(sizeof(AVStream));
714 memcpy(st, ic->streams[i], sizeof(AVStream));
715 st->codec = avcodec_alloc_context();
717 print_error(filename, AVERROR(ENOMEM));
720 avcodec_copy_context(st->codec, ic->streams[i]->codec);
723 codec = avcodec_find_encoder(st->codec->codec_id);
724 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
725 if (audio_stream_copy) {
728 choose_sample_fmt(st, codec);
729 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
730 if (video_stream_copy) {
733 choose_pixel_fmt(st, codec);
736 if(st->codec->flags & CODEC_FLAG_BITEXACT)
739 new_output_stream(s, nb_output_files);
743 s->timestamp = av_gettime();
745 av_close_input_file(ic);
750 get_sync_ipts(const AVOutputStream *ost)
752 const AVInputStream *ist = ost->sync_ist;
753 return (double)(ist->pts - start_time)/AV_TIME_BASE;
756 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
760 AVPacket new_pkt= *pkt;
761 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
762 &new_pkt.data, &new_pkt.size,
763 pkt->data, pkt->size,
764 pkt->flags & AV_PKT_FLAG_KEY);
767 new_pkt.destruct= av_destruct_packet;
769 fprintf(stderr, "%s failed for stream %d, codec %s",
770 bsfc->filter->name, pkt->stream_index,
771 avctx->codec ? avctx->codec->name : "copy");
781 ret= av_interleaved_write_frame(s, pkt);
783 print_error("av_interleaved_write_frame()", ret);
788 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
790 static void do_audio_out(AVFormatContext *s,
793 unsigned char *buf, int size)
796 int64_t audio_out_size, audio_buf_size;
797 int64_t allocated_for_size= size;
799 int size_out, frame_bytes, ret, resample_changed;
800 AVCodecContext *enc= ost->st->codec;
801 AVCodecContext *dec= ist->st->codec;
802 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
803 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
804 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
807 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
808 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
809 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
810 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
811 audio_buf_size*= osize*enc->channels;
813 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
814 if(coded_bps > 8*osize)
815 audio_out_size= audio_out_size * coded_bps / (8*osize);
816 audio_out_size += FF_MIN_BUFFER_SIZE;
818 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
819 fprintf(stderr, "Buffer sizes too large\n");
823 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
824 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
825 if (!audio_buf || !audio_out){
826 fprintf(stderr, "Out of memory in do_audio_out\n");
830 if (enc->channels != dec->channels)
831 ost->audio_resample = 1;
833 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
834 ost->resample_channels != dec->channels ||
835 ost->resample_sample_rate != dec->sample_rate;
837 if ((ost->audio_resample && !ost->resample) || resample_changed) {
838 if (resample_changed) {
839 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",
840 ist->file_index, ist->index,
841 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
842 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
843 ost->resample_sample_fmt = dec->sample_fmt;
844 ost->resample_channels = dec->channels;
845 ost->resample_sample_rate = dec->sample_rate;
847 audio_resample_close(ost->resample);
849 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
850 if (audio_sync_method <= 1 &&
851 ost->resample_sample_fmt == enc->sample_fmt &&
852 ost->resample_channels == enc->channels &&
853 ost->resample_sample_rate == enc->sample_rate) {
854 ost->resample = NULL;
855 ost->audio_resample = 0;
857 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
858 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
859 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
860 enc->sample_rate, dec->sample_rate,
861 enc->sample_fmt, dec->sample_fmt,
863 if (!ost->resample) {
864 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
865 dec->channels, dec->sample_rate,
866 enc->channels, enc->sample_rate);
872 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
873 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
874 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
875 if (ost->reformat_ctx)
876 av_audio_convert_free(ost->reformat_ctx);
877 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
878 dec->sample_fmt, 1, NULL, 0);
879 if (!ost->reformat_ctx) {
880 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
881 av_get_sample_fmt_name(dec->sample_fmt),
882 av_get_sample_fmt_name(enc->sample_fmt));
885 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
888 if(audio_sync_method){
889 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
890 - av_fifo_size(ost->fifo)/(enc->channels * 2);
891 double idelta= delta*dec->sample_rate / enc->sample_rate;
892 int byte_delta= ((int)idelta)*2*dec->channels;
894 //FIXME resample delay
895 if(fabs(delta) > 50){
896 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
898 byte_delta= FFMAX(byte_delta, -size);
902 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
907 static uint8_t *input_tmp= NULL;
908 input_tmp= av_realloc(input_tmp, byte_delta + size);
910 if(byte_delta > allocated_for_size - size){
911 allocated_for_size= byte_delta + (int64_t)size;
916 memset(input_tmp, 0, byte_delta);
917 memcpy(input_tmp + byte_delta, buf, size);
921 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
923 }else if(audio_sync_method>1){
924 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
925 av_assert0(ost->audio_resample);
927 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
928 // 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));
929 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
933 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
934 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
936 if (ost->audio_resample) {
938 size_out = audio_resample(ost->resample,
939 (short *)buftmp, (short *)buf,
940 size / (dec->channels * isize));
941 size_out = size_out * enc->channels * osize;
947 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
948 const void *ibuf[6]= {buftmp};
949 void *obuf[6]= {audio_buf};
950 int istride[6]= {isize};
951 int ostride[6]= {osize};
952 int len= size_out/istride[0];
953 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
954 printf("av_audio_convert() failed\n");
960 size_out = len*osize;
963 /* now encode as many frames as possible */
964 if (enc->frame_size > 1) {
965 /* output resampled raw samples */
966 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
967 fprintf(stderr, "av_fifo_realloc2() failed\n");
970 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
972 frame_bytes = enc->frame_size * osize * enc->channels;
974 while (av_fifo_size(ost->fifo) >= frame_bytes) {
976 av_init_packet(&pkt);
978 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
980 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
982 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
985 fprintf(stderr, "Audio encoding failed\n");
989 pkt.stream_index= ost->index;
992 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
993 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
994 pkt.flags |= AV_PKT_FLAG_KEY;
995 write_frame(s, &pkt, enc, ost->bitstream_filters);
997 ost->sync_opts += enc->frame_size;
1001 av_init_packet(&pkt);
1003 ost->sync_opts += size_out / (osize * enc->channels);
1005 /* output a pcm frame */
1006 /* determine the size of the coded buffer */
1009 size_out = size_out*coded_bps/8;
1011 if(size_out > audio_out_size){
1012 fprintf(stderr, "Internal error, buffer size too small\n");
1016 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1017 ret = avcodec_encode_audio(enc, audio_out, size_out,
1020 fprintf(stderr, "Audio encoding failed\n");
1024 pkt.stream_index= ost->index;
1025 pkt.data= audio_out;
1027 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1028 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1029 pkt.flags |= AV_PKT_FLAG_KEY;
1030 write_frame(s, &pkt, enc, ost->bitstream_filters);
1034 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1036 AVCodecContext *dec;
1037 AVPicture *picture2;
1038 AVPicture picture_tmp;
1041 dec = ist->st->codec;
1043 /* deinterlace : must be done before any resize */
1044 if (do_deinterlace) {
1047 /* create temporary picture */
1048 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1049 buf = av_malloc(size);
1053 picture2 = &picture_tmp;
1054 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1056 if(avpicture_deinterlace(picture2, picture,
1057 dec->pix_fmt, dec->width, dec->height) < 0) {
1058 /* if error, do not deinterlace */
1059 fprintf(stderr, "Deinterlacing failed\n");
1068 if (picture != picture2)
1069 *picture = *picture2;
1073 /* we begin to correct av delay at this threshold */
1074 #define AV_DELAY_MAX 0.100
1076 static void do_subtitle_out(AVFormatContext *s,
1077 AVOutputStream *ost,
1082 static uint8_t *subtitle_out = NULL;
1083 int subtitle_out_max_size = 1024 * 1024;
1084 int subtitle_out_size, nb, i;
1085 AVCodecContext *enc;
1088 if (pts == AV_NOPTS_VALUE) {
1089 fprintf(stderr, "Subtitle packets must have a pts\n");
1095 enc = ost->st->codec;
1097 if (!subtitle_out) {
1098 subtitle_out = av_malloc(subtitle_out_max_size);
1101 /* Note: DVB subtitle need one packet to draw them and one other
1102 packet to clear them */
1103 /* XXX: signal it in the codec context ? */
1104 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1109 for(i = 0; i < nb; i++) {
1110 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1111 // start_display_time is required to be 0
1112 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1113 sub->end_display_time -= sub->start_display_time;
1114 sub->start_display_time = 0;
1115 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1116 subtitle_out_max_size, sub);
1117 if (subtitle_out_size < 0) {
1118 fprintf(stderr, "Subtitle encoding failed\n");
1122 av_init_packet(&pkt);
1123 pkt.stream_index = ost->index;
1124 pkt.data = subtitle_out;
1125 pkt.size = subtitle_out_size;
1126 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1127 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1128 /* XXX: the pts correction is handled here. Maybe handling
1129 it in the codec would be better */
1131 pkt.pts += 90 * sub->start_display_time;
1133 pkt.pts += 90 * sub->end_display_time;
1135 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1139 static int bit_buffer_size= 1024*256;
1140 static uint8_t *bit_buffer= NULL;
1142 static void do_video_out(AVFormatContext *s,
1143 AVOutputStream *ost,
1145 AVFrame *in_picture,
1148 int nb_frames, i, ret, av_unused resample_changed;
1149 AVFrame *final_picture, *formatted_picture;
1150 AVCodecContext *enc, *dec;
1153 enc = ost->st->codec;
1154 dec = ist->st->codec;
1156 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1158 /* by default, we output a single frame */
1163 if(video_sync_method){
1164 double vdelta = sync_ipts - ost->sync_opts;
1165 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1168 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1171 }else if(vdelta>0.6)
1172 ost->sync_opts= lrintf(sync_ipts);
1173 }else if (vdelta > 1.1)
1174 nb_frames = lrintf(vdelta);
1175 //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);
1176 if (nb_frames == 0){
1179 fprintf(stderr, "*** drop!\n");
1180 }else if (nb_frames > 1) {
1181 nb_frames_dup += nb_frames - 1;
1183 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1186 ost->sync_opts= lrintf(sync_ipts);
1188 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1192 formatted_picture = in_picture;
1193 final_picture = formatted_picture;
1195 #if !CONFIG_AVFILTER
1196 resample_changed = ost->resample_width != dec->width ||
1197 ost->resample_height != dec->height ||
1198 ost->resample_pix_fmt != dec->pix_fmt;
1200 if (resample_changed) {
1201 av_log(NULL, AV_LOG_INFO,
1202 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1203 ist->file_index, ist->index,
1204 ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1205 dec->width , dec->height , avcodec_get_pix_fmt_name(dec->pix_fmt));
1206 ost->resample_width = dec->width;
1207 ost->resample_height = dec->height;
1208 ost->resample_pix_fmt = dec->pix_fmt;
1211 ost->video_resample = dec->width != enc->width ||
1212 dec->height != enc->height ||
1213 dec->pix_fmt != enc->pix_fmt;
1215 if (ost->video_resample) {
1216 final_picture = &ost->resample_frame;
1217 if (!ost->img_resample_ctx || resample_changed) {
1218 /* initialize the destination picture */
1219 if (!ost->resample_frame.data[0]) {
1220 avcodec_get_frame_defaults(&ost->resample_frame);
1221 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1222 enc->width, enc->height)) {
1223 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1227 /* initialize a new scaler context */
1228 sws_freeContext(ost->img_resample_ctx);
1229 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1230 enc->width, enc->height, enc->pix_fmt,
1231 ost->sws_flags, NULL, NULL, NULL);
1232 if (ost->img_resample_ctx == NULL) {
1233 fprintf(stderr, "Cannot get resampling context\n");
1237 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1238 0, ost->resample_height, ost->resample_frame.data, ost->resample_frame.linesize);
1242 /* duplicates frame if needed */
1243 for(i=0;i<nb_frames;i++) {
1245 av_init_packet(&pkt);
1246 pkt.stream_index= ost->index;
1248 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1249 /* raw pictures are written as AVPicture structure to
1250 avoid any copies. We support temorarily the older
1252 AVFrame* old_frame = enc->coded_frame;
1253 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1254 pkt.data= (uint8_t *)final_picture;
1255 pkt.size= sizeof(AVPicture);
1256 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1257 pkt.flags |= AV_PKT_FLAG_KEY;
1259 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1260 enc->coded_frame = old_frame;
1262 AVFrame big_picture;
1264 big_picture= *final_picture;
1265 /* better than nothing: use input picture interlaced
1267 big_picture.interlaced_frame = in_picture->interlaced_frame;
1268 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1269 if(top_field_first == -1)
1270 big_picture.top_field_first = in_picture->top_field_first;
1272 big_picture.top_field_first = top_field_first;
1275 /* handles sameq here. This is not correct because it may
1276 not be a global option */
1277 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1279 big_picture.pict_type = 0;
1280 // big_picture.pts = AV_NOPTS_VALUE;
1281 big_picture.pts= ost->sync_opts;
1282 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1283 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1284 if (ost->forced_kf_index < ost->forced_kf_count &&
1285 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1286 big_picture.pict_type = AV_PICTURE_TYPE_I;
1287 ost->forced_kf_index++;
1289 ret = avcodec_encode_video(enc,
1290 bit_buffer, bit_buffer_size,
1293 fprintf(stderr, "Video encoding failed\n");
1298 pkt.data= bit_buffer;
1300 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1301 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1302 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1303 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1304 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1306 if(enc->coded_frame->key_frame)
1307 pkt.flags |= AV_PKT_FLAG_KEY;
1308 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1311 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1312 // enc->frame_number-1, ret, enc->pict_type);
1313 /* if two pass, output log */
1314 if (ost->logfile && enc->stats_out) {
1315 fprintf(ost->logfile, "%s", enc->stats_out);
1320 ost->frame_number++;
1324 static double psnr(double d){
1325 return -10.0*log(d)/log(10.0);
1328 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1331 AVCodecContext *enc;
1333 double ti1, bitrate, avg_bitrate;
1335 /* this is executed just the first time do_video_stats is called */
1337 vstats_file = fopen(vstats_filename, "w");
1344 enc = ost->st->codec;
1345 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346 frame_number = ost->frame_number;
1347 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1348 if (enc->flags&CODEC_FLAG_PSNR)
1349 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1351 fprintf(vstats_file,"f_size= %6d ", frame_size);
1352 /* compute pts value */
1353 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1357 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1358 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1359 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1360 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1361 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1365 static void print_report(AVFormatContext **output_files,
1366 AVOutputStream **ost_table, int nb_ostreams,
1370 AVOutputStream *ost;
1371 AVFormatContext *oc;
1373 AVCodecContext *enc;
1374 int frame_number, vid, i;
1375 double bitrate, ti1, pts;
1376 static int64_t last_time = -1;
1377 static int qp_histogram[52];
1379 if (!is_last_report) {
1381 /* display the report every 0.5 seconds */
1382 cur_time = av_gettime();
1383 if (last_time == -1) {
1384 last_time = cur_time;
1387 if ((cur_time - last_time) < 500000)
1389 last_time = cur_time;
1393 oc = output_files[0];
1395 total_size = avio_size(oc->pb);
1396 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1397 total_size= avio_tell(oc->pb);
1402 for(i=0;i<nb_ostreams;i++) {
1405 enc = ost->st->codec;
1406 if (!ost->st->stream_copy && enc->coded_frame)
1407 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1408 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1409 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1411 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1412 float t = (av_gettime()-timer_start) / 1000000.0;
1414 frame_number = ost->frame_number;
1415 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1416 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1422 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1425 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1427 if (enc->flags&CODEC_FLAG_PSNR){
1429 double error, error_sum=0;
1430 double scale, scale_sum=0;
1431 char type[3]= {'Y','U','V'};
1432 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1435 error= enc->error[j];
1436 scale= enc->width*enc->height*255.0*255.0*frame_number;
1438 error= enc->coded_frame->error[j];
1439 scale= enc->width*enc->height*255.0*255.0;
1444 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1446 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1450 /* compute min output value */
1451 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1452 if ((pts < ti1) && (pts > 0))
1458 if (verbose > 0 || is_last_report) {
1459 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1461 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1462 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1463 (double)total_size / 1024, ti1, bitrate);
1465 if (nb_frames_dup || nb_frames_drop)
1466 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1467 nb_frames_dup, nb_frames_drop);
1470 fprintf(stderr, "%s \r", buf);
1475 if (is_last_report && verbose >= 0){
1476 int64_t raw= audio_size + video_size + extra_size;
1477 fprintf(stderr, "\n");
1478 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1482 100.0*(total_size - raw)/raw
1487 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1489 int fill_char = 0x00;
1490 if (sample_fmt == AV_SAMPLE_FMT_U8)
1492 memset(buf, fill_char, size);
1495 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1496 static int output_packet(AVInputStream *ist, int ist_index,
1497 AVOutputStream **ost_table, int nb_ostreams,
1498 const AVPacket *pkt)
1500 AVFormatContext *os;
1501 AVOutputStream *ost;
1505 void *buffer_to_free = NULL;
1506 static unsigned int samples_size= 0;
1507 AVSubtitle subtitle, *subtitle_to_free;
1508 int64_t pkt_pts = AV_NOPTS_VALUE;
1510 int frame_available;
1514 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1516 if(ist->next_pts == AV_NOPTS_VALUE)
1517 ist->next_pts= ist->pts;
1521 av_init_packet(&avpkt);
1529 if(pkt->dts != AV_NOPTS_VALUE)
1530 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1531 if(pkt->pts != AV_NOPTS_VALUE)
1532 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1534 //while we have more to decode or while the decoder did output something on EOF
1535 while (avpkt.size > 0 || (!pkt && got_output)) {
1536 uint8_t *data_buf, *decoded_data_buf;
1537 int data_size, decoded_data_size;
1539 ist->pts= ist->next_pts;
1541 if(avpkt.size && avpkt.size != pkt->size &&
1542 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1543 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1544 ist->showed_multi_packet_warning=1;
1547 /* decode the packet if needed */
1548 decoded_data_buf = NULL; /* fail safe */
1549 decoded_data_size= 0;
1550 data_buf = avpkt.data;
1551 data_size = avpkt.size;
1552 subtitle_to_free = NULL;
1553 if (ist->decoding_needed) {
1554 switch(ist->st->codec->codec_type) {
1555 case AVMEDIA_TYPE_AUDIO:{
1556 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1557 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1559 samples= av_malloc(samples_size);
1561 decoded_data_size= samples_size;
1562 /* XXX: could avoid copy if PCM 16 bits with same
1563 endianness as CPU */
1564 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1571 got_output = decoded_data_size > 0;
1572 /* Some bug in mpeg audio decoder gives */
1573 /* decoded_data_size < 0, it seems they are overflows */
1575 /* no audio frame */
1578 decoded_data_buf = (uint8_t *)samples;
1579 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1580 (ist->st->codec->sample_rate * ist->st->codec->channels);
1582 case AVMEDIA_TYPE_VIDEO:
1583 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1584 /* XXX: allocate picture correctly */
1585 avcodec_get_frame_defaults(&picture);
1586 avpkt.pts = pkt_pts;
1587 avpkt.dts = ist->pts;
1588 pkt_pts = AV_NOPTS_VALUE;
1590 ret = avcodec_decode_video2(ist->st->codec,
1591 &picture, &got_output, &avpkt);
1592 ist->st->quality= picture.quality;
1596 /* no picture yet */
1597 goto discard_packet;
1599 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1600 if (ist->st->codec->time_base.num != 0) {
1601 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1602 ist->next_pts += ((int64_t)AV_TIME_BASE *
1603 ist->st->codec->time_base.num * ticks) /
1604 ist->st->codec->time_base.den;
1607 buffer_to_free = NULL;
1608 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1610 case AVMEDIA_TYPE_SUBTITLE:
1611 ret = avcodec_decode_subtitle2(ist->st->codec,
1612 &subtitle, &got_output, &avpkt);
1616 goto discard_packet;
1618 subtitle_to_free = &subtitle;
1625 switch(ist->st->codec->codec_type) {
1626 case AVMEDIA_TYPE_AUDIO:
1627 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1628 ist->st->codec->sample_rate;
1630 case AVMEDIA_TYPE_VIDEO:
1631 if (ist->st->codec->time_base.num != 0) {
1632 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1633 ist->next_pts += ((int64_t)AV_TIME_BASE *
1634 ist->st->codec->time_base.num * ticks) /
1635 ist->st->codec->time_base.den;
1644 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1645 for(i=0;i<nb_ostreams;i++) {
1647 if (ost->input_video_filter && ost->source_index == ist_index) {
1648 if (!picture.sample_aspect_ratio.num)
1649 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1650 picture.pts = ist->pts;
1651 // add it to be filtered
1652 av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture, ""); //TODO user setable params
1658 // preprocess audio (volume)
1659 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1660 if (audio_volume != 256) {
1663 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1664 int v = ((*volp) * audio_volume + 128) >> 8;
1665 if (v < -32768) v = -32768;
1666 if (v > 32767) v = 32767;
1672 /* frame rate emulation */
1674 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1675 int64_t now = av_gettime() - ist->start;
1679 /* if output time reached then transcode raw format,
1680 encode packets and output them */
1681 if (start_time == 0 || ist->pts >= start_time)
1682 for(i=0;i<nb_ostreams;i++) {
1686 if (ost->source_index == ist_index) {
1688 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1689 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1690 while (frame_available) {
1691 AVRational ist_pts_tb;
1692 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1693 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1695 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1697 os = output_files[ost->file_index];
1699 /* set the input output pts pairs */
1700 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1702 if (ost->encoding_needed) {
1703 av_assert0(ist->decoding_needed);
1704 switch(ost->st->codec->codec_type) {
1705 case AVMEDIA_TYPE_AUDIO:
1706 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1708 case AVMEDIA_TYPE_VIDEO:
1710 if (ost->picref->video && !ost->frame_aspect_ratio)
1711 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1713 do_video_out(os, ost, ist, &picture, &frame_size);
1714 if (vstats_filename && frame_size)
1715 do_video_stats(os, ost, frame_size);
1717 case AVMEDIA_TYPE_SUBTITLE:
1718 do_subtitle_out(os, ost, ist, &subtitle,
1725 AVFrame avframe; //FIXME/XXX remove this
1727 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1729 av_init_packet(&opkt);
1731 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1732 #if !CONFIG_AVFILTER
1738 /* no reencoding needed : output the packet directly */
1739 /* force the input stream PTS */
1741 avcodec_get_frame_defaults(&avframe);
1742 ost->st->codec->coded_frame= &avframe;
1743 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1745 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1746 audio_size += data_size;
1747 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1748 video_size += data_size;
1752 opkt.stream_index= ost->index;
1753 if(pkt->pts != AV_NOPTS_VALUE)
1754 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1756 opkt.pts= AV_NOPTS_VALUE;
1758 if (pkt->dts == AV_NOPTS_VALUE)
1759 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1761 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1762 opkt.dts -= ost_tb_start_time;
1764 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1765 opkt.flags= pkt->flags;
1767 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1768 if( ost->st->codec->codec_id != CODEC_ID_H264
1769 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1770 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1772 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1773 opkt.destruct= av_destruct_packet;
1775 opkt.data = data_buf;
1776 opkt.size = data_size;
1779 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1780 ost->st->codec->frame_number++;
1781 ost->frame_number++;
1782 av_free_packet(&opkt);
1786 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1787 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1789 avfilter_unref_buffer(ost->picref);
1795 av_free(buffer_to_free);
1796 /* XXX: allocate the subtitles in the codec ? */
1797 if (subtitle_to_free) {
1798 avsubtitle_free(subtitle_to_free);
1799 subtitle_to_free = NULL;
1806 for(i=0;i<nb_ostreams;i++) {
1808 if (ost->source_index == ist_index) {
1809 AVCodecContext *enc= ost->st->codec;
1810 os = output_files[ost->file_index];
1812 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1814 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1817 if (ost->encoding_needed) {
1821 av_init_packet(&pkt);
1822 pkt.stream_index= ost->index;
1824 switch(ost->st->codec->codec_type) {
1825 case AVMEDIA_TYPE_AUDIO:
1826 fifo_bytes = av_fifo_size(ost->fifo);
1828 /* encode any samples remaining in fifo */
1829 if (fifo_bytes > 0) {
1830 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1831 int fs_tmp = enc->frame_size;
1833 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1834 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1835 enc->frame_size = fifo_bytes / (osize * enc->channels);
1837 int frame_bytes = enc->frame_size*osize*enc->channels;
1838 if (allocated_audio_buf_size < frame_bytes)
1840 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1843 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1844 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1845 ost->st->time_base.num, enc->sample_rate);
1846 enc->frame_size = fs_tmp;
1849 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1852 fprintf(stderr, "Audio encoding failed\n");
1856 pkt.flags |= AV_PKT_FLAG_KEY;
1858 case AVMEDIA_TYPE_VIDEO:
1859 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1861 fprintf(stderr, "Video encoding failed\n");
1865 if(enc->coded_frame && enc->coded_frame->key_frame)
1866 pkt.flags |= AV_PKT_FLAG_KEY;
1867 if (ost->logfile && enc->stats_out) {
1868 fprintf(ost->logfile, "%s", enc->stats_out);
1877 pkt.data= bit_buffer;
1879 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1880 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1881 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1893 static void print_sdp(AVFormatContext **avc, int n)
1897 av_sdp_create(avc, n, sdp, sizeof(sdp));
1898 printf("SDP:\n%s\n", sdp);
1902 static int copy_chapters(int infile, int outfile)
1904 AVFormatContext *is = input_files[infile];
1905 AVFormatContext *os = output_files[outfile];
1908 for (i = 0; i < is->nb_chapters; i++) {
1909 AVChapter *in_ch = is->chapters[i], *out_ch;
1910 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1911 AV_TIME_BASE_Q, in_ch->time_base);
1912 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1913 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1916 if (in_ch->end < ts_off)
1918 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1921 out_ch = av_mallocz(sizeof(AVChapter));
1923 return AVERROR(ENOMEM);
1925 out_ch->id = in_ch->id;
1926 out_ch->time_base = in_ch->time_base;
1927 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1928 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1930 if (metadata_chapters_autocopy)
1931 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1934 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1936 return AVERROR(ENOMEM);
1937 os->chapters[os->nb_chapters - 1] = out_ch;
1942 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1943 AVCodecContext *avctx)
1949 for (p = kf; *p; p++)
1952 ost->forced_kf_count = n;
1953 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1954 if (!ost->forced_kf_pts) {
1955 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1958 for (i = 0; i < n; i++) {
1959 p = i ? strchr(p, ',') + 1 : kf;
1960 t = parse_time_or_die("force_key_frames", p, 1);
1961 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1966 * The following code is the main loop of the file converter
1968 static int transcode(AVFormatContext **output_files,
1969 int nb_output_files,
1970 AVFormatContext **input_files,
1972 AVStreamMap *stream_maps, int nb_stream_maps)
1974 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1975 AVFormatContext *is, *os;
1976 AVCodecContext *codec, *icodec;
1977 AVOutputStream *ost, **ost_table = NULL;
1978 AVInputStream *ist, **ist_table = NULL;
1979 AVInputFile *file_table;
1983 uint8_t no_packet[MAX_FILES]={0};
1984 int no_packet_count=0;
1985 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1986 int nb_streams[AVMEDIA_TYPE_NB]={0};
1988 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1992 /* input stream init */
1994 for(i=0;i<nb_input_files;i++) {
1995 is = input_files[i];
1996 file_table[i].ist_index = j;
1997 file_table[i].nb_streams = is->nb_streams;
1998 j += is->nb_streams;
2002 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
2006 for(i=0;i<nb_istreams;i++) {
2007 ist = av_mallocz(sizeof(AVInputStream));
2013 for(i=0;i<nb_input_files;i++) {
2014 is = input_files[i];
2015 for(k=0;k<is->nb_streams;k++) {
2016 ist = ist_table[j++];
2017 ist->st = is->streams[k];
2018 ist->file_index = i;
2020 ist->discard = 1; /* the stream is discarded by default
2024 ist->start = av_gettime();
2029 /* output stream init */
2031 for(i=0;i<nb_output_files;i++) {
2032 os = output_files[i];
2033 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2034 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2035 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2036 ret = AVERROR(EINVAL);
2039 nb_ostreams += os->nb_streams;
2041 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2042 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2043 ret = AVERROR(EINVAL);
2047 /* Sanity check the mapping args -- do the input files & streams exist? */
2048 for(i=0;i<nb_stream_maps;i++) {
2049 int fi = stream_maps[i].file_index;
2050 int si = stream_maps[i].stream_index;
2052 if (fi < 0 || fi > nb_input_files - 1 ||
2053 si < 0 || si > file_table[fi].nb_streams - 1) {
2054 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2055 ret = AVERROR(EINVAL);
2058 fi = stream_maps[i].sync_file_index;
2059 si = stream_maps[i].sync_stream_index;
2060 if (fi < 0 || fi > nb_input_files - 1 ||
2061 si < 0 || si > file_table[fi].nb_streams - 1) {
2062 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2063 ret = AVERROR(EINVAL);
2068 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2072 for(k=0;k<nb_output_files;k++) {
2073 os = output_files[k];
2074 for(i=0;i<os->nb_streams;i++,n++) {
2075 nb_streams[os->streams[i]->codec->codec_type]++;
2078 for(step=1<<30; step; step>>=1){
2079 int found_streams[AVMEDIA_TYPE_NB]={0};
2080 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2081 nb_frame_threshold[j] += step;
2083 for(j=0; j<nb_istreams; j++) {
2088 AVFormatContext *f= input_files[ ist->file_index ];
2090 for(pi=0; pi<f->nb_programs; pi++){
2091 AVProgram *p= f->programs[pi];
2092 if(p->id == opt_programid)
2093 for(si=0; si<p->nb_stream_indexes; si++){
2094 if(f->streams[ p->stream_index[si] ] == ist->st)
2099 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2100 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2101 found_streams[ist->st->codec->codec_type]++;
2104 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2105 if(found_streams[j] < nb_streams[j])
2106 nb_frame_threshold[j] -= step;
2109 for(k=0;k<nb_output_files;k++) {
2110 os = output_files[k];
2111 for(i=0;i<os->nb_streams;i++,n++) {
2113 ost = ost_table[n] = output_streams_for_file[k][i];
2114 ost->st = os->streams[i];
2115 if (nb_stream_maps > 0) {
2116 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2117 stream_maps[n].stream_index;
2119 /* Sanity check that the stream types match */
2120 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2121 int i= ost->file_index;
2122 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2123 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2124 stream_maps[n].file_index, stream_maps[n].stream_index,
2125 ost->file_index, ost->index);
2130 /* get corresponding input stream index : we select the first one with the right type */
2132 for(j=0;j<nb_istreams;j++) {
2137 AVFormatContext *f= input_files[ ist->file_index ];
2139 for(pi=0; pi<f->nb_programs; pi++){
2140 AVProgram *p= f->programs[pi];
2141 if(p->id == opt_programid)
2142 for(si=0; si<p->nb_stream_indexes; si++){
2143 if(f->streams[ p->stream_index[si] ] == ist->st)
2148 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2149 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2150 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2151 ost->source_index = j;
2158 if(! opt_programid) {
2159 /* try again and reuse existing stream */
2160 for(j=0;j<nb_istreams;j++) {
2162 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2163 && ist->st->discard != AVDISCARD_ALL) {
2164 ost->source_index = j;
2170 int i= ost->file_index;
2171 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2172 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2173 ost->file_index, ost->index);
2178 ist = ist_table[ost->source_index];
2180 ost->sync_ist = (nb_stream_maps > 0) ?
2181 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2182 stream_maps[n].sync_stream_index] : ist;
2186 /* for each output stream, we compute the right encoding parameters */
2187 for(i=0;i<nb_ostreams;i++) {
2189 os = output_files[ost->file_index];
2190 ist = ist_table[ost->source_index];
2192 codec = ost->st->codec;
2193 icodec = ist->st->codec;
2195 if (metadata_streams_autocopy)
2196 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2197 AV_METADATA_DONT_OVERWRITE);
2199 ost->st->disposition = ist->st->disposition;
2200 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2201 codec->chroma_sample_location = icodec->chroma_sample_location;
2203 if (ost->st->stream_copy) {
2204 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2206 if (extra_size > INT_MAX)
2209 /* if stream_copy is selected, no need to decode or encode */
2210 codec->codec_id = icodec->codec_id;
2211 codec->codec_type = icodec->codec_type;
2213 if(!codec->codec_tag){
2214 if( !os->oformat->codec_tag
2215 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2216 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2217 codec->codec_tag = icodec->codec_tag;
2220 codec->bit_rate = icodec->bit_rate;
2221 codec->rc_max_rate = icodec->rc_max_rate;
2222 codec->rc_buffer_size = icodec->rc_buffer_size;
2223 codec->extradata= av_mallocz(extra_size);
2224 if (!codec->extradata)
2226 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2227 codec->extradata_size= icodec->extradata_size;
2228 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){
2229 codec->time_base = icodec->time_base;
2230 codec->time_base.num *= icodec->ticks_per_frame;
2231 av_reduce(&codec->time_base.num, &codec->time_base.den,
2232 codec->time_base.num, codec->time_base.den, INT_MAX);
2234 codec->time_base = ist->st->time_base;
2235 switch(codec->codec_type) {
2236 case AVMEDIA_TYPE_AUDIO:
2237 if(audio_volume != 256) {
2238 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2241 codec->channel_layout = icodec->channel_layout;
2242 codec->sample_rate = icodec->sample_rate;
2243 codec->channels = icodec->channels;
2244 codec->frame_size = icodec->frame_size;
2245 codec->audio_service_type = icodec->audio_service_type;
2246 codec->block_align= icodec->block_align;
2247 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2248 codec->block_align= 0;
2249 if(codec->codec_id == CODEC_ID_AC3)
2250 codec->block_align= 0;
2252 case AVMEDIA_TYPE_VIDEO:
2253 codec->pix_fmt = icodec->pix_fmt;
2254 codec->width = icodec->width;
2255 codec->height = icodec->height;
2256 codec->has_b_frames = icodec->has_b_frames;
2257 if (!codec->sample_aspect_ratio.num) {
2258 codec->sample_aspect_ratio =
2259 ost->st->sample_aspect_ratio =
2260 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2261 ist->st->codec->sample_aspect_ratio.num ?
2262 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2265 case AVMEDIA_TYPE_SUBTITLE:
2266 codec->width = icodec->width;
2267 codec->height = icodec->height;
2269 case AVMEDIA_TYPE_DATA:
2275 switch(codec->codec_type) {
2276 case AVMEDIA_TYPE_AUDIO:
2277 ost->fifo= av_fifo_alloc(1024);
2280 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2281 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2282 icodec->request_channels = codec->channels;
2283 ist->decoding_needed = 1;
2284 ost->encoding_needed = 1;
2285 ost->resample_sample_fmt = icodec->sample_fmt;
2286 ost->resample_sample_rate = icodec->sample_rate;
2287 ost->resample_channels = icodec->channels;
2289 case AVMEDIA_TYPE_VIDEO:
2290 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2291 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2294 ost->video_resample = codec->width != icodec->width ||
2295 codec->height != icodec->height ||
2296 codec->pix_fmt != icodec->pix_fmt;
2297 if (ost->video_resample) {
2298 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2300 ost->resample_height = icodec->height;
2301 ost->resample_width = icodec->width;
2302 ost->resample_pix_fmt= icodec->pix_fmt;
2303 ost->encoding_needed = 1;
2304 ist->decoding_needed = 1;
2307 if (configure_video_filters(ist, ost)) {
2308 fprintf(stderr, "Error opening filters!\n");
2313 case AVMEDIA_TYPE_SUBTITLE:
2314 ost->encoding_needed = 1;
2315 ist->decoding_needed = 1;
2322 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2323 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2324 char logfilename[1024];
2327 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2328 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2330 if (codec->flags & CODEC_FLAG_PASS1) {
2331 f = fopen(logfilename, "wb");
2333 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2339 size_t logbuffer_size;
2340 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2341 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2344 codec->stats_in = logbuffer;
2348 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2349 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2350 int size= codec->width * codec->height;
2351 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2356 bit_buffer = av_malloc(bit_buffer_size);
2358 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2360 ret = AVERROR(ENOMEM);
2364 /* open each encoder */
2365 for(i=0;i<nb_ostreams;i++) {
2367 if (ost->encoding_needed) {
2368 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2369 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2371 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2373 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2374 ost->st->codec->codec_id, ost->file_index, ost->index);
2375 ret = AVERROR(EINVAL);
2378 if (dec->subtitle_header) {
2379 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2380 if (!ost->st->codec->subtitle_header) {
2381 ret = AVERROR(ENOMEM);
2384 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2385 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2387 if (avcodec_open(ost->st->codec, codec) < 0) {
2388 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2389 ost->file_index, ost->index);
2390 ret = AVERROR(EINVAL);
2393 extra_size += ost->st->codec->extradata_size;
2397 /* open each decoder */
2398 for(i=0;i<nb_istreams;i++) {
2400 if (ist->decoding_needed) {
2401 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2403 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2405 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2406 ist->st->codec->codec_id, ist->file_index, ist->index);
2407 ret = AVERROR(EINVAL);
2410 if (avcodec_open(ist->st->codec, codec) < 0) {
2411 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2412 ist->file_index, ist->index);
2413 ret = AVERROR(EINVAL);
2416 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2417 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2422 for(i=0;i<nb_istreams;i++) {
2426 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2427 ist->next_pts = AV_NOPTS_VALUE;
2431 /* set meta data information from input file if required */
2432 for (i=0;i<nb_meta_data_maps;i++) {
2433 AVFormatContext *files[2];
2434 AVMetadata **meta[2];
2437 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2438 if ((index) < 0 || (index) >= (nb_elems)) {\
2439 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2441 ret = AVERROR(EINVAL);\
2445 int out_file_index = meta_data_maps[i][0].file;
2446 int in_file_index = meta_data_maps[i][1].file;
2447 if (in_file_index < 0 || out_file_index < 0)
2449 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2450 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2452 files[0] = output_files[out_file_index];
2453 files[1] = input_files[in_file_index];
2455 for (j = 0; j < 2; j++) {
2456 AVMetaDataMap *map = &meta_data_maps[i][j];
2458 switch (map->type) {
2460 meta[j] = &files[j]->metadata;
2463 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2464 meta[j] = &files[j]->streams[map->index]->metadata;
2467 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2468 meta[j] = &files[j]->chapters[map->index]->metadata;
2471 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2472 meta[j] = &files[j]->programs[map->index]->metadata;
2477 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2480 /* copy global metadata by default */
2481 if (metadata_global_autocopy) {
2483 for (i = 0; i < nb_output_files; i++)
2484 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2485 AV_METADATA_DONT_OVERWRITE);
2488 /* copy chapters according to chapter maps */
2489 for (i = 0; i < nb_chapter_maps; i++) {
2490 int infile = chapter_maps[i].in_file;
2491 int outfile = chapter_maps[i].out_file;
2493 if (infile < 0 || outfile < 0)
2495 if (infile >= nb_input_files) {
2496 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2497 ret = AVERROR(EINVAL);
2500 if (outfile >= nb_output_files) {
2501 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2502 ret = AVERROR(EINVAL);
2505 copy_chapters(infile, outfile);
2508 /* copy chapters from the first input file that has them*/
2509 if (!nb_chapter_maps)
2510 for (i = 0; i < nb_input_files; i++) {
2511 if (!input_files[i]->nb_chapters)
2514 for (j = 0; j < nb_output_files; j++)
2515 if ((ret = copy_chapters(i, j)) < 0)
2520 /* open files and write file headers */
2521 for(i=0;i<nb_output_files;i++) {
2522 os = output_files[i];
2523 if (av_write_header(os) < 0) {
2524 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2525 ret = AVERROR(EINVAL);
2528 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2534 /* dump the file output parameters - cannot be done before in case
2536 for(i=0;i<nb_output_files;i++) {
2537 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2540 /* dump the stream mapping */
2542 fprintf(stderr, "Stream mapping:\n");
2543 for(i=0;i<nb_ostreams;i++) {
2545 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2546 ist_table[ost->source_index]->file_index,
2547 ist_table[ost->source_index]->index,
2550 if (ost->sync_ist != ist_table[ost->source_index])
2551 fprintf(stderr, " [sync #%d.%d]",
2552 ost->sync_ist->file_index,
2553 ost->sync_ist->index);
2554 fprintf(stderr, "\n");
2559 fprintf(stderr, "%s\n", error);
2564 print_sdp(output_files, nb_output_files);
2569 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2570 avio_set_interrupt_cb(decode_interrupt_cb);
2574 timer_start = av_gettime();
2576 for(; received_sigterm == 0;) {
2577 int file_index, ist_index;
2585 /* if 'q' pressed, exits */
2589 /* read_key() returns 0 on EOF */
2593 if (key == '+') verbose++;
2594 if (key == '-') verbose--;
2595 if (key == 's') qp_hist ^= 1;
2598 do_hex_dump = do_pkt_dump = 0;
2599 } else if(do_pkt_dump){
2603 av_log_set_level(AV_LOG_DEBUG);
2605 if (key == 'd' || key == 'D'){
2609 debug = ist->st->codec->debug<<1;
2610 if(!debug) debug = 1;
2611 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2614 scanf("%d", &debug);
2615 for(i=0;i<nb_istreams;i++) {
2617 ist->st->codec->debug = debug;
2619 for(i=0;i<nb_ostreams;i++) {
2621 ost->st->codec->debug = debug;
2623 if(debug) av_log_set_level(AV_LOG_DEBUG);
2624 fprintf(stderr,"debug=%d\n", debug);
2627 fprintf(stderr, "key function\n"
2628 "? show this help\n"
2629 "+ increase verbosity\n"
2630 "- decrease verbosity\n"
2631 "D cycle through available debug modes\n"
2632 "h dump packets/hex press to cycle through the 3 states\n"
2634 "s Show QP histogram\n"
2639 /* select the stream that we must read now by looking at the
2640 smallest output pts */
2642 for(i=0;i<nb_ostreams;i++) {
2645 os = output_files[ost->file_index];
2646 ist = ist_table[ost->source_index];
2647 if(ist->is_past_recording_time || no_packet[ist->file_index])
2649 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2650 ipts = (double)ist->pts;
2651 if (!file_table[ist->file_index].eof_reached){
2652 if(ipts < ipts_min) {
2654 if(input_sync ) file_index = ist->file_index;
2656 if(opts < opts_min) {
2658 if(!input_sync) file_index = ist->file_index;
2661 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2666 /* if none, if is finished */
2667 if (file_index < 0) {
2668 if(no_packet_count){
2670 memset(no_packet, 0, sizeof(no_packet));
2677 /* finish if limit size exhausted */
2678 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2681 /* read a frame from it and output it in the fifo */
2682 is = input_files[file_index];
2683 ret= av_read_frame(is, &pkt);
2684 if(ret == AVERROR(EAGAIN)){
2685 no_packet[file_index]=1;
2690 file_table[file_index].eof_reached = 1;
2698 memset(no_packet, 0, sizeof(no_packet));
2701 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2702 is->streams[pkt.stream_index]);
2704 /* the following test is needed in case new streams appear
2705 dynamically in stream : we ignore them */
2706 if (pkt.stream_index >= file_table[file_index].nb_streams)
2707 goto discard_packet;
2708 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2709 ist = ist_table[ist_index];
2711 goto discard_packet;
2713 if (pkt.dts != AV_NOPTS_VALUE)
2714 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2715 if (pkt.pts != AV_NOPTS_VALUE)
2716 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2718 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2719 && input_files_ts_scale[file_index][pkt.stream_index]){
2720 if(pkt.pts != AV_NOPTS_VALUE)
2721 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2722 if(pkt.dts != AV_NOPTS_VALUE)
2723 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2726 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2727 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2728 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2729 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2730 int64_t delta= pkt_dts - ist->next_pts;
2731 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2732 input_files_ts_offset[ist->file_index]-= delta;
2734 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2735 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2736 if(pkt.pts != AV_NOPTS_VALUE)
2737 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2741 /* finish if recording time exhausted */
2742 if (recording_time != INT64_MAX &&
2743 (pkt.pts != AV_NOPTS_VALUE || pkt.dts != AV_NOPTS_VALUE ?
2744 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2746 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2748 ist->is_past_recording_time = 1;
2749 goto discard_packet;
2752 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2753 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2756 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2757 ist->file_index, ist->index);
2760 av_free_packet(&pkt);
2765 av_free_packet(&pkt);
2767 /* dump report by using the output first video and audio streams */
2768 print_report(output_files, ost_table, nb_ostreams, 0);
2771 /* at the end of stream, we must flush the decoder buffers */
2772 for(i=0;i<nb_istreams;i++) {
2774 if (ist->decoding_needed) {
2775 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2781 /* write the trailer if needed and close file */
2782 for(i=0;i<nb_output_files;i++) {
2783 os = output_files[i];
2784 av_write_trailer(os);
2787 /* dump report by using the first video and audio streams */
2788 print_report(output_files, ost_table, nb_ostreams, 1);
2790 /* close each encoder */
2791 for(i=0;i<nb_ostreams;i++) {
2793 if (ost->encoding_needed) {
2794 av_freep(&ost->st->codec->stats_in);
2795 avcodec_close(ost->st->codec);
2798 avfilter_graph_free(&ost->graph);
2802 /* close each decoder */
2803 for(i=0;i<nb_istreams;i++) {
2805 if (ist->decoding_needed) {
2806 avcodec_close(ist->st->codec);
2814 av_freep(&bit_buffer);
2815 av_free(file_table);
2818 for(i=0;i<nb_istreams;i++) {
2825 for(i=0;i<nb_ostreams;i++) {
2828 if (ost->st->stream_copy)
2829 av_freep(&ost->st->codec->extradata);
2831 fclose(ost->logfile);
2832 ost->logfile = NULL;
2834 av_fifo_free(ost->fifo); /* works even if fifo is not
2835 initialized but set to zero */
2836 av_freep(&ost->st->codec->subtitle_header);
2837 av_free(ost->resample_frame.data[0]);
2838 av_free(ost->forced_kf_pts);
2839 if (ost->video_resample)
2840 sws_freeContext(ost->img_resample_ctx);
2842 audio_resample_close(ost->resample);
2843 if (ost->reformat_ctx)
2844 av_audio_convert_free(ost->reformat_ctx);
2853 static void opt_format(const char *arg)
2855 last_asked_format = arg;
2858 static void opt_video_rc_override_string(const char *arg)
2860 video_rc_override_string = arg;
2863 static int opt_me_threshold(const char *opt, const char *arg)
2865 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2869 static int opt_verbose(const char *opt, const char *arg)
2871 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2875 static int opt_frame_rate(const char *opt, const char *arg)
2877 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2878 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2884 static int opt_bitrate(const char *opt, const char *arg)
2886 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2888 opt_default(opt, arg);
2890 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2891 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2896 static int opt_frame_crop(const char *opt, const char *arg)
2898 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2899 return AVERROR(EINVAL);
2902 static void opt_frame_size(const char *arg)
2904 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2905 fprintf(stderr, "Incorrect frame size\n");
2910 static int opt_pad(const char *opt, const char *arg) {
2911 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2915 static void opt_frame_pix_fmt(const char *arg)
2917 if (strcmp(arg, "list")) {
2918 frame_pix_fmt = av_get_pix_fmt(arg);
2919 if (frame_pix_fmt == PIX_FMT_NONE) {
2920 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2929 static void opt_frame_aspect_ratio(const char *arg)
2936 p = strchr(arg, ':');
2938 x = strtol(arg, &end, 10);
2940 y = strtol(end+1, &end, 10);
2942 ar = (double)x / (double)y;
2944 ar = strtod(arg, NULL);
2947 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2950 frame_aspect_ratio = ar;
2953 static int opt_metadata(const char *opt, const char *arg)
2955 char *mid= strchr(arg, '=');
2958 fprintf(stderr, "Missing =\n");
2963 av_metadata_set2(&metadata, arg, mid, 0);
2968 static int opt_qscale(const char *opt, const char *arg)
2970 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2971 if (video_qscale <= 0 || video_qscale > 255) {
2972 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2973 return AVERROR(EINVAL);
2978 static int opt_top_field_first(const char *opt, const char *arg)
2980 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2981 opt_default(opt, arg);
2985 static int opt_thread_count(const char *opt, const char *arg)
2987 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2990 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2995 static void opt_audio_sample_fmt(const char *arg)
2997 if (strcmp(arg, "list")) {
2998 audio_sample_fmt = av_get_sample_fmt(arg);
2999 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3000 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3006 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3007 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3012 static int opt_audio_rate(const char *opt, const char *arg)
3014 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3018 static int opt_audio_channels(const char *opt, const char *arg)
3020 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3024 static int opt_video_channel(const char *opt, const char *arg)
3026 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3030 static void opt_video_standard(const char *arg)
3032 video_standard = av_strdup(arg);
3035 static void opt_codec(int *pstream_copy, char **pcodec_name,
3036 int codec_type, const char *arg)
3038 av_freep(pcodec_name);
3039 if (!strcmp(arg, "copy")) {
3042 *pcodec_name = av_strdup(arg);
3046 static void opt_audio_codec(const char *arg)
3048 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3051 static void opt_video_codec(const char *arg)
3053 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3056 static void opt_subtitle_codec(const char *arg)
3058 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3061 static void opt_data_codec(const char *arg)
3063 opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
3066 static int opt_codec_tag(const char *opt, const char *arg)
3069 uint32_t *codec_tag;
3071 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3072 !strcmp(opt, "vtag") ? &video_codec_tag :
3073 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3077 *codec_tag = strtol(arg, &tail, 0);
3079 *codec_tag = AV_RL32(arg);
3084 static void opt_map(const char *arg)
3089 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3090 m = &stream_maps[nb_stream_maps-1];
3092 m->file_index = strtol(arg, &p, 0);
3096 m->stream_index = strtol(p, &p, 0);
3099 m->sync_file_index = strtol(p, &p, 0);
3102 m->sync_stream_index = strtol(p, &p, 0);
3104 m->sync_file_index = m->file_index;
3105 m->sync_stream_index = m->stream_index;
3109 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3120 *index = strtol(++arg, endptr, 0);
3123 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3130 static void opt_map_metadata(const char *arg)
3132 AVMetaDataMap *m, *m1;
3135 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3136 &nb_meta_data_maps, nb_meta_data_maps + 1);
3138 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3139 m->file = strtol(arg, &p, 0);
3140 parse_meta_type(p, &m->type, &m->index, &p);
3144 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3145 m1->file = strtol(p, &p, 0);
3146 parse_meta_type(p, &m1->type, &m1->index, &p);
3148 if (m->type == 'g' || m1->type == 'g')
3149 metadata_global_autocopy = 0;
3150 if (m->type == 's' || m1->type == 's')
3151 metadata_streams_autocopy = 0;
3152 if (m->type == 'c' || m1->type == 'c')
3153 metadata_chapters_autocopy = 0;
3156 static void opt_map_meta_data(const char *arg)
3158 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3159 "Use -map_metadata instead.\n");
3160 opt_map_metadata(arg);
3163 static void opt_map_chapters(const char *arg)
3168 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3169 nb_chapter_maps + 1);
3170 c = &chapter_maps[nb_chapter_maps - 1];
3171 c->out_file = strtol(arg, &p, 0);
3175 c->in_file = strtol(p, &p, 0);
3178 static void opt_input_ts_scale(const char *arg)
3180 unsigned int stream;
3184 stream = strtol(arg, &p, 0);
3187 scale= strtod(p, &p);
3189 if(stream >= MAX_STREAMS)
3192 input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3193 input_files_ts_scale[nb_input_files][stream]= scale;
3196 static int opt_recording_time(const char *opt, const char *arg)
3198 recording_time = parse_time_or_die(opt, arg, 1);
3202 static int opt_start_time(const char *opt, const char *arg)
3204 start_time = parse_time_or_die(opt, arg, 1);
3208 static int opt_recording_timestamp(const char *opt, const char *arg)
3210 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3214 static int opt_input_ts_offset(const char *opt, const char *arg)
3216 input_ts_offset = parse_time_or_die(opt, arg, 1);
3220 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3222 const char *codec_string = encoder ? "encoder" : "decoder";
3226 return CODEC_ID_NONE;
3228 avcodec_find_encoder_by_name(name) :
3229 avcodec_find_decoder_by_name(name);
3231 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3234 if(codec->type != type) {
3235 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3238 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3239 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3240 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3241 "results.\nAdd '-strict experimental' if you want to use it.\n",
3242 codec_string, codec->name);
3244 avcodec_find_encoder(codec->id) :
3245 avcodec_find_decoder(codec->id);
3246 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3247 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3248 codec_string, codec->name);
3254 static void opt_input_file(const char *filename)
3256 AVFormatContext *ic;
3257 AVFormatParameters params, *ap = ¶ms;
3258 AVInputFormat *file_iformat = NULL;
3259 int err, i, ret, rfps, rfps_base;
3262 if (last_asked_format) {
3263 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3264 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3267 last_asked_format = NULL;
3270 if (!strcmp(filename, "-"))
3273 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3274 !strcmp(filename, "/dev/stdin");
3276 /* get default parameters from command line */
3277 ic = avformat_alloc_context();
3279 print_error(filename, AVERROR(ENOMEM));
3283 memset(ap, 0, sizeof(*ap));
3284 ap->prealloced_context = 1;
3285 ap->sample_rate = audio_sample_rate;
3286 ap->channels = audio_channels;
3287 ap->time_base.den = frame_rate.num;
3288 ap->time_base.num = frame_rate.den;
3289 ap->width = frame_width;
3290 ap->height = frame_height;
3291 ap->pix_fmt = frame_pix_fmt;
3292 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3293 ap->channel = video_channel;
3294 ap->standard = video_standard;
3296 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3298 ic->video_codec_id =
3299 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3300 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3301 ic->audio_codec_id =
3302 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3303 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3304 ic->subtitle_codec_id=
3305 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3306 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3307 ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3309 /* open the input file with generic libav function */
3310 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3312 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3313 err = av_demuxer_open(ic, ap);
3315 avformat_free_context(ic);
3318 print_error(filename, err);
3324 for(i=0; i<ic->nb_streams; i++){
3325 ic->streams[i]->discard= AVDISCARD_ALL;
3327 for(i=0; i<ic->nb_programs; i++){
3328 AVProgram *p= ic->programs[i];
3329 if(p->id != opt_programid){
3330 p->discard = AVDISCARD_ALL;
3333 for(j=0; j<p->nb_stream_indexes; j++){
3334 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3339 fprintf(stderr, "Specified program id not found\n");
3345 ic->loop_input = loop_input;
3347 /* If not enough info to get the stream parameters, we decode the
3348 first frames to get it. (used in mpeg case for example) */
3349 ret = av_find_stream_info(ic);
3350 if (ret < 0 && verbose >= 0) {
3351 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3352 av_close_input_file(ic);
3356 timestamp = start_time;
3357 /* add the stream start time */
3358 if (ic->start_time != AV_NOPTS_VALUE)
3359 timestamp += ic->start_time;
3361 /* if seeking requested, we execute it */
3362 if (start_time != 0) {
3363 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3365 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3366 filename, (double)timestamp / AV_TIME_BASE);
3368 /* reset seek info */
3372 /* update the current parameters so that they match the one of the input stream */
3373 for(i=0;i<ic->nb_streams;i++) {
3374 AVStream *st = ic->streams[i];
3375 AVCodecContext *dec = st->codec;
3376 dec->thread_count = thread_count;
3377 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3378 switch (dec->codec_type) {
3379 case AVMEDIA_TYPE_AUDIO:
3380 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3381 if(!input_codecs[nb_input_codecs-1])
3382 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3383 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3384 channel_layout = dec->channel_layout;
3385 audio_channels = dec->channels;
3386 audio_sample_rate = dec->sample_rate;
3387 audio_sample_fmt = dec->sample_fmt;
3389 st->discard= AVDISCARD_ALL;
3390 /* Note that av_find_stream_info can add more streams, and we
3391 * currently have no chance of setting up lowres decoding
3392 * early enough for them. */
3394 audio_sample_rate >>= dec->lowres;
3396 case AVMEDIA_TYPE_VIDEO:
3397 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3398 if(!input_codecs[nb_input_codecs-1])
3399 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3400 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3401 frame_height = dec->height;
3402 frame_width = dec->width;
3403 frame_pix_fmt = dec->pix_fmt;
3404 rfps = ic->streams[i]->r_frame_rate.num;
3405 rfps_base = ic->streams[i]->r_frame_rate.den;
3407 dec->flags |= CODEC_FLAG_EMU_EDGE;
3408 frame_height >>= dec->lowres;
3409 frame_width >>= dec->lowres;
3410 dec->height = frame_height;
3411 dec->width = frame_width;
3414 dec->debug |= FF_DEBUG_MV;
3416 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3419 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3420 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3422 (float)rfps / rfps_base, rfps, rfps_base);
3424 /* update the current frame rate to match the stream frame rate */
3425 frame_rate.num = rfps;
3426 frame_rate.den = rfps_base;
3429 st->discard= AVDISCARD_ALL;
3430 else if(video_discard)
3431 st->discard= video_discard;
3433 case AVMEDIA_TYPE_DATA:
3435 case AVMEDIA_TYPE_SUBTITLE:
3436 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3437 if(!input_codecs[nb_input_codecs-1])
3438 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3439 if(subtitle_disable)
3440 st->discard = AVDISCARD_ALL;
3442 case AVMEDIA_TYPE_ATTACHMENT:
3443 case AVMEDIA_TYPE_UNKNOWN:
3450 input_files[nb_input_files] = ic;
3451 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3452 /* dump the file content */
3454 av_dump_format(ic, nb_input_files, filename, 0);
3460 av_freep(&video_codec_name);
3461 av_freep(&audio_codec_name);
3462 av_freep(&subtitle_codec_name);
3467 static void check_inputs(int *has_video_ptr,
3469 int *has_subtitle_ptr,
3472 int has_video, has_audio, has_subtitle, has_data, i, j;
3473 AVFormatContext *ic;
3480 for(j=0;j<nb_input_files;j++) {
3481 ic = input_files[j];
3482 for(i=0;i<ic->nb_streams;i++) {
3483 AVCodecContext *enc = ic->streams[i]->codec;
3484 switch(enc->codec_type) {
3485 case AVMEDIA_TYPE_AUDIO:
3488 case AVMEDIA_TYPE_VIDEO:
3491 case AVMEDIA_TYPE_SUBTITLE:
3494 case AVMEDIA_TYPE_DATA:
3495 case AVMEDIA_TYPE_ATTACHMENT:
3496 case AVMEDIA_TYPE_UNKNOWN:
3504 *has_video_ptr = has_video;
3505 *has_audio_ptr = has_audio;
3506 *has_subtitle_ptr = has_subtitle;
3507 *has_data_ptr = has_data;
3510 static void new_video_stream(AVFormatContext *oc, int file_idx)
3513 AVOutputStream *ost;
3514 AVCodecContext *video_enc;
3515 enum CodecID codec_id = CODEC_ID_NONE;
3516 AVCodec *codec= NULL;
3518 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3520 fprintf(stderr, "Could not alloc stream\n");
3523 ost = new_output_stream(oc, file_idx);
3525 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3526 if(!video_stream_copy){
3527 if (video_codec_name) {
3528 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3529 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3530 codec = avcodec_find_encoder_by_name(video_codec_name);
3531 output_codecs[nb_output_codecs-1] = codec;
3533 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3534 codec = avcodec_find_encoder(codec_id);
3536 ost->frame_aspect_ratio = frame_aspect_ratio;
3537 frame_aspect_ratio = 0;
3539 ost->avfilter = vfilters;
3544 avcodec_get_context_defaults3(st->codec, codec);
3545 ost->bitstream_filters = video_bitstream_filters;
3546 video_bitstream_filters= NULL;
3548 st->codec->thread_count= thread_count;
3550 video_enc = st->codec;
3553 video_enc->codec_tag= video_codec_tag;
3555 if( (video_global_header&1)
3556 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3557 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3558 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3560 if(video_global_header&2){
3561 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3562 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3565 if (video_stream_copy) {
3566 st->stream_copy = 1;
3567 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3568 video_enc->sample_aspect_ratio =
3569 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3573 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3575 video_enc->codec_id = codec_id;
3576 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3578 if (codec && codec->supported_framerates && !force_fps)
3579 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3580 video_enc->time_base.den = fps.num;
3581 video_enc->time_base.num = fps.den;
3583 video_enc->width = frame_width;
3584 video_enc->height = frame_height;
3585 video_enc->pix_fmt = frame_pix_fmt;
3586 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3587 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3589 choose_pixel_fmt(st, codec);
3592 video_enc->gop_size = 0;
3593 if (video_qscale || same_quality) {
3594 video_enc->flags |= CODEC_FLAG_QSCALE;
3595 video_enc->global_quality=
3596 st->quality = FF_QP2LAMBDA * video_qscale;
3600 video_enc->intra_matrix = intra_matrix;
3602 video_enc->inter_matrix = inter_matrix;
3604 p= video_rc_override_string;
3607 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3609 fprintf(stderr, "error parsing rc_override\n");
3612 video_enc->rc_override=
3613 av_realloc(video_enc->rc_override,
3614 sizeof(RcOverride)*(i+1));
3615 video_enc->rc_override[i].start_frame= start;
3616 video_enc->rc_override[i].end_frame = end;
3618 video_enc->rc_override[i].qscale= q;
3619 video_enc->rc_override[i].quality_factor= 1.0;
3622 video_enc->rc_override[i].qscale= 0;
3623 video_enc->rc_override[i].quality_factor= -q/100.0;
3628 video_enc->rc_override_count=i;
3629 if (!video_enc->rc_initial_buffer_occupancy)
3630 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3631 video_enc->me_threshold= me_threshold;
3632 video_enc->intra_dc_precision= intra_dc_precision - 8;
3635 video_enc->flags|= CODEC_FLAG_PSNR;
3640 video_enc->flags |= CODEC_FLAG_PASS1;
3642 video_enc->flags |= CODEC_FLAG_PASS2;
3646 if (forced_key_frames)
3647 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3649 if (video_language) {
3650 av_metadata_set2(&st->metadata, "language", video_language, 0);
3651 av_freep(&video_language);
3654 /* reset some key parameters */
3656 av_freep(&video_codec_name);
3657 av_freep(&forced_key_frames);
3658 video_stream_copy = 0;
3659 frame_pix_fmt = PIX_FMT_NONE;
3662 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3665 AVOutputStream *ost;
3666 AVCodec *codec= NULL;
3667 AVCodecContext *audio_enc;
3668 enum CodecID codec_id = CODEC_ID_NONE;
3670 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3672 fprintf(stderr, "Could not alloc stream\n");
3675 ost = new_output_stream(oc, file_idx);
3677 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3678 if(!audio_stream_copy){
3679 if (audio_codec_name) {
3680 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3681 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3682 codec = avcodec_find_encoder_by_name(audio_codec_name);
3683 output_codecs[nb_output_codecs-1] = codec;
3685 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3686 codec = avcodec_find_encoder(codec_id);
3690 avcodec_get_context_defaults3(st->codec, codec);
3692 ost->bitstream_filters = audio_bitstream_filters;
3693 audio_bitstream_filters= NULL;
3695 st->codec->thread_count= thread_count;
3697 audio_enc = st->codec;
3698 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3701 audio_enc->codec_tag= audio_codec_tag;
3703 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3704 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3705 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3707 if (audio_stream_copy) {
3708 st->stream_copy = 1;
3709 audio_enc->channels = audio_channels;
3710 audio_enc->sample_rate = audio_sample_rate;
3712 audio_enc->codec_id = codec_id;
3713 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3715 if (audio_qscale > QSCALE_NONE) {
3716 audio_enc->flags |= CODEC_FLAG_QSCALE;
3717 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3719 audio_enc->channels = audio_channels;
3720 audio_enc->sample_fmt = audio_sample_fmt;
3721 audio_enc->sample_rate = audio_sample_rate;
3722 audio_enc->channel_layout = channel_layout;
3723 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3724 audio_enc->channel_layout = 0;
3725 choose_sample_fmt(st, codec);
3726 choose_sample_rate(st, codec);
3728 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3729 if (audio_language) {
3730 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3731 av_freep(&audio_language);
3734 /* reset some key parameters */
3736 av_freep(&audio_codec_name);
3737 audio_stream_copy = 0;
3740 static void new_data_stream(AVFormatContext *oc, int file_idx)
3743 AVOutputStream *ost;
3744 AVCodec *codec=NULL;
3745 AVCodecContext *data_enc;
3747 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3749 fprintf(stderr, "Could not alloc stream\n");
3752 ost = new_output_stream(oc, file_idx);
3753 data_enc = st->codec;
3754 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3755 if (!data_stream_copy) {
3756 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3759 avcodec_get_context_defaults3(st->codec, codec);
3761 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3764 data_enc->codec_tag= data_codec_tag;
3766 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3767 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3768 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3770 if (data_stream_copy) {
3771 st->stream_copy = 1;
3775 av_freep(&data_codec_name);
3776 data_stream_copy = 0;
3779 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3782 AVOutputStream *ost;
3783 AVCodec *codec=NULL;
3784 AVCodecContext *subtitle_enc;
3785 enum CodecID codec_id = CODEC_ID_NONE;
3787 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3789 fprintf(stderr, "Could not alloc stream\n");
3792 ost = new_output_stream(oc, file_idx);
3793 subtitle_enc = st->codec;
3794 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3795 if(!subtitle_stream_copy){
3796 if (subtitle_codec_name) {
3797 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3798 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3799 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3801 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3802 codec = avcodec_find_encoder(codec_id);
3805 avcodec_get_context_defaults3(st->codec, codec);
3807 ost->bitstream_filters = subtitle_bitstream_filters;
3808 subtitle_bitstream_filters= NULL;
3810 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3812 if(subtitle_codec_tag)
3813 subtitle_enc->codec_tag= subtitle_codec_tag;
3815 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3816 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3817 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3819 if (subtitle_stream_copy) {
3820 st->stream_copy = 1;
3822 subtitle_enc->codec_id = codec_id;
3823 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3826 if (subtitle_language) {
3827 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3828 av_freep(&subtitle_language);
3831 subtitle_disable = 0;
3832 av_freep(&subtitle_codec_name);
3833 subtitle_stream_copy = 0;
3836 static int opt_new_stream(const char *opt, const char *arg)
3838 AVFormatContext *oc;
3839 int file_idx = nb_output_files - 1;
3840 if (nb_output_files <= 0) {
3841 fprintf(stderr, "At least one output file must be specified\n");
3844 oc = output_files[file_idx];
3846 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3847 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3848 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3849 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3854 /* arg format is "output-stream-index:streamid-value". */
3855 static int opt_streamid(const char *opt, const char *arg)
3861 av_strlcpy(idx_str, arg, sizeof(idx_str));
3862 p = strchr(idx_str, ':');
3865 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3870 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3871 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3872 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3876 static void opt_output_file(const char *filename)
3878 AVFormatContext *oc;
3879 int err, use_video, use_audio, use_subtitle, use_data;
3880 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3881 AVFormatParameters params, *ap = ¶ms;
3882 AVOutputFormat *file_oformat;
3884 if (!strcmp(filename, "-"))
3887 oc = avformat_alloc_output_context(last_asked_format, NULL, filename);
3888 last_asked_format = NULL;
3890 print_error(filename, AVERROR(ENOMEM));
3893 file_oformat= oc->oformat;
3895 if (!strcmp(file_oformat->name, "ffm") &&
3896 av_strstart(filename, "http:", NULL)) {
3897 /* special case for files sent to ffserver: we get the stream
3898 parameters from ffserver */
3899 int err = read_ffserver_streams(oc, filename);
3901 print_error(filename, err);
3905 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3906 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3907 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3908 use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3910 /* disable if no corresponding type found and at least one
3912 if (nb_input_files > 0) {
3913 check_inputs(&input_has_video,
3915 &input_has_subtitle,
3918 if (!input_has_video)
3920 if (!input_has_audio)
3922 if (!input_has_subtitle)
3924 if (!input_has_data)
3928 /* manual disable */
3929 if (audio_disable) use_audio = 0;
3930 if (video_disable) use_video = 0;
3931 if (subtitle_disable) use_subtitle = 0;
3932 if (data_disable) use_data = 0;
3934 if (use_video) new_video_stream(oc, nb_output_files);
3935 if (use_audio) new_audio_stream(oc, nb_output_files);
3936 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3937 if (use_data) new_data_stream(oc, nb_output_files);
3939 oc->timestamp = recording_timestamp;
3941 av_metadata_copy(&oc->metadata, metadata, 0);
3942 av_metadata_free(&metadata);
3945 output_files[nb_output_files++] = oc;
3947 /* check filename in case of an image number is expected */
3948 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3949 if (!av_filename_number_test(oc->filename)) {
3950 print_error(oc->filename, AVERROR(EINVAL));
3955 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3956 /* test if it already exists to avoid loosing precious files */
3957 if (!file_overwrite &&
3958 (strchr(filename, ':') == NULL ||
3959 filename[1] == ':' ||
3960 av_strstart(filename, "file:", NULL))) {
3961 if (avio_check(filename, 0) == 0) {
3963 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3965 if (!read_yesno()) {
3966 fprintf(stderr, "Not overwriting - exiting\n");
3971 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3978 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3979 print_error(filename, err);
3984 memset(ap, 0, sizeof(*ap));
3985 if (av_set_parameters(oc, ap) < 0) {
3986 fprintf(stderr, "%s: Invalid encoding parameters\n",
3991 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3992 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3993 oc->loop_output = loop_output;
3995 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3997 av_freep(&forced_key_frames);
4002 /* same option as mencoder */
4003 static int opt_pass(const char *opt, const char *arg)
4005 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4009 static int64_t getutime(void)
4012 struct rusage rusage;
4014 getrusage(RUSAGE_SELF, &rusage);
4015 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4016 #elif HAVE_GETPROCESSTIMES
4018 FILETIME c, e, k, u;
4019 proc = GetCurrentProcess();
4020 GetProcessTimes(proc, &c, &e, &k, &u);
4021 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4023 return av_gettime();
4027 static int64_t getmaxrss(void)
4029 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4030 struct rusage rusage;
4031 getrusage(RUSAGE_SELF, &rusage);
4032 return (int64_t)rusage.ru_maxrss * 1024;
4033 #elif HAVE_GETPROCESSMEMORYINFO
4035 PROCESS_MEMORY_COUNTERS memcounters;
4036 proc = GetCurrentProcess();
4037 memcounters.cb = sizeof(memcounters);
4038 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4039 return memcounters.PeakPagefileUsage;
4045 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4048 const char *p = str;
4055 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4062 static void opt_inter_matrix(const char *arg)
4064 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4065 parse_matrix_coeffs(inter_matrix, arg);
4068 static void opt_intra_matrix(const char *arg)
4070 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4071 parse_matrix_coeffs(intra_matrix, arg);
4074 static void show_usage(void)
4076 printf("Hyper fast Audio and Video encoder\n");
4077 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4081 static void show_help(void)
4084 AVOutputFormat *oformat = NULL;
4086 av_log_set_callback(log_callback_help);
4088 show_help_options(options, "Main options:\n",
4089 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4090 show_help_options(options, "\nAdvanced options:\n",
4091 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4093 show_help_options(options, "\nVideo options:\n",
4094 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4096 show_help_options(options, "\nAdvanced Video options:\n",
4097 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4098 OPT_VIDEO | OPT_EXPERT);
4099 show_help_options(options, "\nAudio options:\n",
4100 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4102 show_help_options(options, "\nAdvanced Audio options:\n",
4103 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4104 OPT_AUDIO | OPT_EXPERT);
4105 show_help_options(options, "\nSubtitle options:\n",
4106 OPT_SUBTITLE | OPT_GRAB,
4108 show_help_options(options, "\nAudio/Video grab options:\n",
4112 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4115 /* individual codec options */
4117 while ((c = av_codec_next(c))) {
4118 if (c->priv_class) {
4119 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4124 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4127 /* individual muxer options */
4128 while ((oformat = av_oformat_next(oformat))) {
4129 if (oformat->priv_class) {
4130 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4135 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4138 static void opt_target(const char *arg)
4140 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4141 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4143 if(!strncmp(arg, "pal-", 4)) {
4146 } else if(!strncmp(arg, "ntsc-", 5)) {
4149 } else if(!strncmp(arg, "film-", 5)) {
4154 /* Calculate FR via float to avoid int overflow */
4155 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4158 } else if((fr == 29970) || (fr == 23976)) {
4161 /* Try to determine PAL/NTSC by peeking in the input files */
4162 if(nb_input_files) {
4164 for(j = 0; j < nb_input_files; j++) {
4165 for(i = 0; i < input_files[j]->nb_streams; i++) {
4166 AVCodecContext *c = input_files[j]->streams[i]->codec;
4167 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4169 fr = c->time_base.den * 1000 / c->time_base.num;
4173 } else if((fr == 29970) || (fr == 23976)) {
4183 if(verbose > 0 && norm != UNKNOWN)
4184 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4187 if(norm == UNKNOWN) {
4188 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4189 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4190 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4194 if(!strcmp(arg, "vcd")) {
4196 opt_video_codec("mpeg1video");
4197 opt_audio_codec("mp2");
4200 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4201 opt_frame_rate(NULL, frame_rates[norm]);
4202 opt_default("g", norm == PAL ? "15" : "18");
4204 opt_default("b", "1150000");
4205 opt_default("maxrate", "1150000");
4206 opt_default("minrate", "1150000");
4207 opt_default("bufsize", "327680"); // 40*1024*8;
4209 opt_default("ab", "224000");
4210 audio_sample_rate = 44100;
4213 opt_default("packetsize", "2324");
4214 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4216 /* We have to offset the PTS, so that it is consistent with the SCR.
4217 SCR starts at 36000, but the first two packs contain only padding
4218 and the first pack from the other stream, respectively, may also have
4219 been written before.
4220 So the real data starts at SCR 36000+3*1200. */
4221 mux_preload= (36000+3*1200) / 90000.0; //0.44
4222 } else if(!strcmp(arg, "svcd")) {
4224 opt_video_codec("mpeg2video");
4225 opt_audio_codec("mp2");
4228 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4229 opt_frame_rate(NULL, frame_rates[norm]);
4230 opt_default("g", norm == PAL ? "15" : "18");
4232 opt_default("b", "2040000");
4233 opt_default("maxrate", "2516000");
4234 opt_default("minrate", "0"); //1145000;
4235 opt_default("bufsize", "1835008"); //224*1024*8;
4236 opt_default("flags", "+scan_offset");
4239 opt_default("ab", "224000");
4240 audio_sample_rate = 44100;
4242 opt_default("packetsize", "2324");
4244 } else if(!strcmp(arg, "dvd")) {
4246 opt_video_codec("mpeg2video");
4247 opt_audio_codec("ac3");
4250 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4251 opt_frame_rate(NULL, frame_rates[norm]);
4252 opt_default("g", norm == PAL ? "15" : "18");
4254 opt_default("b", "6000000");
4255 opt_default("maxrate", "9000000");
4256 opt_default("minrate", "0"); //1500000;
4257 opt_default("bufsize", "1835008"); //224*1024*8;
4259 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4260 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4262 opt_default("ab", "448000");
4263 audio_sample_rate = 48000;
4265 } else if(!strncmp(arg, "dv", 2)) {
4269 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4270 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4271 (norm == PAL ? "yuv420p" : "yuv411p"));
4272 opt_frame_rate(NULL, frame_rates[norm]);
4274 audio_sample_rate = 48000;
4278 fprintf(stderr, "Unknown target: %s\n", arg);
4283 static void opt_vstats_file (const char *arg)
4285 av_free (vstats_filename);
4286 vstats_filename=av_strdup (arg);
4289 static void opt_vstats (void)
4292 time_t today2 = time(NULL);
4293 struct tm *today = localtime(&today2);
4295 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4297 opt_vstats_file(filename);
4300 static int opt_bsf(const char *opt, const char *arg)
4302 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4303 AVBitStreamFilterContext **bsfp;
4306 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4310 bsfp= *opt == 'v' ? &video_bitstream_filters :
4311 *opt == 'a' ? &audio_bitstream_filters :
4312 &subtitle_bitstream_filters;
4314 bsfp= &(*bsfp)->next;
4321 static int opt_preset(const char *opt, const char *arg)
4324 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4325 char *codec_name = *opt == 'v' ? video_codec_name :
4326 *opt == 'a' ? audio_codec_name :
4327 subtitle_codec_name;
4329 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4330 fprintf(stderr, "File for preset '%s' not found\n", arg);
4335 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4336 if(line[0] == '#' && !e)
4338 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4340 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4343 if(!strcmp(tmp, "acodec")){
4344 opt_audio_codec(tmp2);
4345 }else if(!strcmp(tmp, "vcodec")){
4346 opt_video_codec(tmp2);
4347 }else if(!strcmp(tmp, "scodec")){
4348 opt_subtitle_codec(tmp2);
4349 }else if(!strcmp(tmp, "dcodec")){
4350 opt_data_codec(tmp2);
4351 }else if(opt_default(tmp, tmp2) < 0){
4352 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4362 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4366 static void opt_passlogfile(const char *arg)
4368 pass_logfilename_prefix = arg;
4369 opt_default("passlogfile", arg);
4372 static const OptionDef options[] = {
4374 #include "cmdutils_common_opts.h"
4375 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4376 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4377 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4378 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4379 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4380 "outfile[,metadata]:infile[,metadata]" },
4381 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4382 "outfile[,metadata]:infile[,metadata]" },
4383 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4384 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4385 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4386 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4387 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4388 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4389 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4390 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4391 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4392 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4393 "add timings for benchmarking" },
4394 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4395 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4396 "dump each input packet" },
4397 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4398 "when dumping packets, also dump the payload" },
4399 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4400 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4401 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4402 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4403 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4404 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4405 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4406 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4407 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4408 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4409 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4410 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4411 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4412 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4413 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4414 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4415 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4418 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4419 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4420 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4421 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4422 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4423 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4424 { "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" },
4425 { "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" },
4426 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4427 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4428 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4429 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4430 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4431 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4432 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4433 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4434 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4435 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4436 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4437 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4438 { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4439 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4440 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4441 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4442 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4443 "use same quantizer as source (implies VBR)" },
4444 { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4445 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4446 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4447 "deinterlace pictures" },
4448 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4449 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4450 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4452 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4454 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4455 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4456 { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4457 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4458 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4459 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4460 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4461 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4462 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4463 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4464 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4467 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4468 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4469 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4470 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4471 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4472 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4473 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4474 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4475 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4476 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4477 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4478 { "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" },
4480 /* subtitle options */
4481 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4482 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4483 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4484 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4485 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4488 { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4489 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4490 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4493 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4494 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4496 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4497 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4498 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4500 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4501 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4502 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4503 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4504 /* data codec support */
4505 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4507 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4511 int main(int argc, char **argv)
4515 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4517 if(argc>1 && !strcmp(argv[1], "-d")){
4520 av_log_set_callback(log_callback_null);
4525 avcodec_register_all();
4527 avdevice_register_all();
4530 avfilter_register_all();
4535 if(isatty(STDIN_FILENO))
4536 avio_set_interrupt_cb(decode_interrupt_cb);
4544 parse_options(argc, argv, options, opt_output_file);
4546 if(nb_output_files <= 0 && nb_input_files == 0) {
4548 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4552 /* file converter / grab */
4553 if (nb_output_files <= 0) {
4554 fprintf(stderr, "At least one output file must be specified\n");
4558 if (nb_input_files == 0) {
4559 fprintf(stderr, "At least one input file must be specified\n");
4564 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4565 stream_maps, nb_stream_maps) < 0)
4567 ti = getutime() - ti;
4569 int maxrss = getmaxrss() / 1024;
4570 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4573 return ffmpeg_exit(0);