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 s->streams = av_mallocz(sizeof(*s->streams) * ic->nb_streams);
707 for(i=0;i<ic->nb_streams;i++) {
713 // FIXME: a more elegant solution is needed
714 st = av_mallocz(sizeof(AVStream));
715 memcpy(st, ic->streams[i], sizeof(AVStream));
716 st->codec = avcodec_alloc_context();
718 print_error(filename, AVERROR(ENOMEM));
721 avcodec_copy_context(st->codec, ic->streams[i]->codec);
724 codec = avcodec_find_encoder(st->codec->codec_id);
725 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
726 if (audio_stream_copy) {
729 choose_sample_fmt(st, codec);
730 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
731 if (video_stream_copy) {
734 choose_pixel_fmt(st, codec);
737 if(st->codec->flags & CODEC_FLAG_BITEXACT)
740 new_output_stream(s, nb_output_files);
744 s->timestamp = av_gettime();
746 av_close_input_file(ic);
751 get_sync_ipts(const AVOutputStream *ost)
753 const AVInputStream *ist = ost->sync_ist;
754 return (double)(ist->pts - start_time)/AV_TIME_BASE;
757 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
761 AVPacket new_pkt= *pkt;
762 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
763 &new_pkt.data, &new_pkt.size,
764 pkt->data, pkt->size,
765 pkt->flags & AV_PKT_FLAG_KEY);
768 new_pkt.destruct= av_destruct_packet;
770 fprintf(stderr, "%s failed for stream %d, codec %s",
771 bsfc->filter->name, pkt->stream_index,
772 avctx->codec ? avctx->codec->name : "copy");
782 ret= av_interleaved_write_frame(s, pkt);
784 print_error("av_interleaved_write_frame()", ret);
789 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
791 static void do_audio_out(AVFormatContext *s,
794 unsigned char *buf, int size)
797 int64_t audio_out_size, audio_buf_size;
798 int64_t allocated_for_size= size;
800 int size_out, frame_bytes, ret, resample_changed;
801 AVCodecContext *enc= ost->st->codec;
802 AVCodecContext *dec= ist->st->codec;
803 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
804 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
805 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
808 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
809 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
810 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
811 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
812 audio_buf_size*= osize*enc->channels;
814 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
815 if(coded_bps > 8*osize)
816 audio_out_size= audio_out_size * coded_bps / (8*osize);
817 audio_out_size += FF_MIN_BUFFER_SIZE;
819 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
820 fprintf(stderr, "Buffer sizes too large\n");
824 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
825 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
826 if (!audio_buf || !audio_out){
827 fprintf(stderr, "Out of memory in do_audio_out\n");
831 if (enc->channels != dec->channels)
832 ost->audio_resample = 1;
834 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
835 ost->resample_channels != dec->channels ||
836 ost->resample_sample_rate != dec->sample_rate;
838 if ((ost->audio_resample && !ost->resample) || resample_changed) {
839 if (resample_changed) {
840 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",
841 ist->file_index, ist->index,
842 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
843 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
844 ost->resample_sample_fmt = dec->sample_fmt;
845 ost->resample_channels = dec->channels;
846 ost->resample_sample_rate = dec->sample_rate;
848 audio_resample_close(ost->resample);
850 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
851 if (audio_sync_method <= 1 &&
852 ost->resample_sample_fmt == enc->sample_fmt &&
853 ost->resample_channels == enc->channels &&
854 ost->resample_sample_rate == enc->sample_rate) {
855 ost->resample = NULL;
856 ost->audio_resample = 0;
858 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
859 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
860 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
861 enc->sample_rate, dec->sample_rate,
862 enc->sample_fmt, dec->sample_fmt,
864 if (!ost->resample) {
865 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
866 dec->channels, dec->sample_rate,
867 enc->channels, enc->sample_rate);
873 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
874 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
875 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
876 if (ost->reformat_ctx)
877 av_audio_convert_free(ost->reformat_ctx);
878 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
879 dec->sample_fmt, 1, NULL, 0);
880 if (!ost->reformat_ctx) {
881 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
882 av_get_sample_fmt_name(dec->sample_fmt),
883 av_get_sample_fmt_name(enc->sample_fmt));
886 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
889 if(audio_sync_method){
890 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
891 - av_fifo_size(ost->fifo)/(enc->channels * 2);
892 double idelta= delta*dec->sample_rate / enc->sample_rate;
893 int byte_delta= ((int)idelta)*2*dec->channels;
895 //FIXME resample delay
896 if(fabs(delta) > 50){
897 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
899 byte_delta= FFMAX(byte_delta, -size);
903 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
908 static uint8_t *input_tmp= NULL;
909 input_tmp= av_realloc(input_tmp, byte_delta + size);
911 if(byte_delta > allocated_for_size - size){
912 allocated_for_size= byte_delta + (int64_t)size;
917 memset(input_tmp, 0, byte_delta);
918 memcpy(input_tmp + byte_delta, buf, size);
922 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
924 }else if(audio_sync_method>1){
925 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
926 av_assert0(ost->audio_resample);
928 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
929 // 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));
930 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
934 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
935 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
937 if (ost->audio_resample) {
939 size_out = audio_resample(ost->resample,
940 (short *)buftmp, (short *)buf,
941 size / (dec->channels * isize));
942 size_out = size_out * enc->channels * osize;
948 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
949 const void *ibuf[6]= {buftmp};
950 void *obuf[6]= {audio_buf};
951 int istride[6]= {isize};
952 int ostride[6]= {osize};
953 int len= size_out/istride[0];
954 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
955 printf("av_audio_convert() failed\n");
961 size_out = len*osize;
964 /* now encode as many frames as possible */
965 if (enc->frame_size > 1) {
966 /* output resampled raw samples */
967 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
968 fprintf(stderr, "av_fifo_realloc2() failed\n");
971 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
973 frame_bytes = enc->frame_size * osize * enc->channels;
975 while (av_fifo_size(ost->fifo) >= frame_bytes) {
977 av_init_packet(&pkt);
979 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
981 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
983 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
986 fprintf(stderr, "Audio encoding failed\n");
990 pkt.stream_index= ost->index;
993 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
994 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
995 pkt.flags |= AV_PKT_FLAG_KEY;
996 write_frame(s, &pkt, enc, ost->bitstream_filters);
998 ost->sync_opts += enc->frame_size;
1002 av_init_packet(&pkt);
1004 ost->sync_opts += size_out / (osize * enc->channels);
1006 /* output a pcm frame */
1007 /* determine the size of the coded buffer */
1010 size_out = size_out*coded_bps/8;
1012 if(size_out > audio_out_size){
1013 fprintf(stderr, "Internal error, buffer size too small\n");
1017 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1018 ret = avcodec_encode_audio(enc, audio_out, size_out,
1021 fprintf(stderr, "Audio encoding failed\n");
1025 pkt.stream_index= ost->index;
1026 pkt.data= audio_out;
1028 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1029 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1030 pkt.flags |= AV_PKT_FLAG_KEY;
1031 write_frame(s, &pkt, enc, ost->bitstream_filters);
1035 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1037 AVCodecContext *dec;
1038 AVPicture *picture2;
1039 AVPicture picture_tmp;
1042 dec = ist->st->codec;
1044 /* deinterlace : must be done before any resize */
1045 if (do_deinterlace) {
1048 /* create temporary picture */
1049 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1050 buf = av_malloc(size);
1054 picture2 = &picture_tmp;
1055 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1057 if(avpicture_deinterlace(picture2, picture,
1058 dec->pix_fmt, dec->width, dec->height) < 0) {
1059 /* if error, do not deinterlace */
1060 fprintf(stderr, "Deinterlacing failed\n");
1069 if (picture != picture2)
1070 *picture = *picture2;
1074 /* we begin to correct av delay at this threshold */
1075 #define AV_DELAY_MAX 0.100
1077 static void do_subtitle_out(AVFormatContext *s,
1078 AVOutputStream *ost,
1083 static uint8_t *subtitle_out = NULL;
1084 int subtitle_out_max_size = 1024 * 1024;
1085 int subtitle_out_size, nb, i;
1086 AVCodecContext *enc;
1089 if (pts == AV_NOPTS_VALUE) {
1090 fprintf(stderr, "Subtitle packets must have a pts\n");
1096 enc = ost->st->codec;
1098 if (!subtitle_out) {
1099 subtitle_out = av_malloc(subtitle_out_max_size);
1102 /* Note: DVB subtitle need one packet to draw them and one other
1103 packet to clear them */
1104 /* XXX: signal it in the codec context ? */
1105 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1110 for(i = 0; i < nb; i++) {
1111 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1112 // start_display_time is required to be 0
1113 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1114 sub->end_display_time -= sub->start_display_time;
1115 sub->start_display_time = 0;
1116 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1117 subtitle_out_max_size, sub);
1118 if (subtitle_out_size < 0) {
1119 fprintf(stderr, "Subtitle encoding failed\n");
1123 av_init_packet(&pkt);
1124 pkt.stream_index = ost->index;
1125 pkt.data = subtitle_out;
1126 pkt.size = subtitle_out_size;
1127 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1128 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1129 /* XXX: the pts correction is handled here. Maybe handling
1130 it in the codec would be better */
1132 pkt.pts += 90 * sub->start_display_time;
1134 pkt.pts += 90 * sub->end_display_time;
1136 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1140 static int bit_buffer_size= 1024*256;
1141 static uint8_t *bit_buffer= NULL;
1143 static void do_video_out(AVFormatContext *s,
1144 AVOutputStream *ost,
1146 AVFrame *in_picture,
1149 int nb_frames, i, ret, av_unused resample_changed;
1150 AVFrame *final_picture, *formatted_picture;
1151 AVCodecContext *enc, *dec;
1154 enc = ost->st->codec;
1155 dec = ist->st->codec;
1157 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1159 /* by default, we output a single frame */
1164 if(video_sync_method){
1165 double vdelta = sync_ipts - ost->sync_opts;
1166 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1169 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1172 }else if(vdelta>0.6)
1173 ost->sync_opts= lrintf(sync_ipts);
1174 }else if (vdelta > 1.1)
1175 nb_frames = lrintf(vdelta);
1176 //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);
1177 if (nb_frames == 0){
1180 fprintf(stderr, "*** drop!\n");
1181 }else if (nb_frames > 1) {
1182 nb_frames_dup += nb_frames - 1;
1184 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1187 ost->sync_opts= lrintf(sync_ipts);
1189 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1193 formatted_picture = in_picture;
1194 final_picture = formatted_picture;
1196 #if !CONFIG_AVFILTER
1197 resample_changed = ost->resample_width != dec->width ||
1198 ost->resample_height != dec->height ||
1199 ost->resample_pix_fmt != dec->pix_fmt;
1201 if (resample_changed) {
1202 av_log(NULL, AV_LOG_INFO,
1203 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1204 ist->file_index, ist->index,
1205 ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1206 dec->width , dec->height , avcodec_get_pix_fmt_name(dec->pix_fmt));
1207 ost->resample_width = dec->width;
1208 ost->resample_height = dec->height;
1209 ost->resample_pix_fmt = dec->pix_fmt;
1212 ost->video_resample = dec->width != enc->width ||
1213 dec->height != enc->height ||
1214 dec->pix_fmt != enc->pix_fmt;
1216 if (ost->video_resample) {
1217 final_picture = &ost->resample_frame;
1218 if (!ost->img_resample_ctx || resample_changed) {
1219 /* initialize the destination picture */
1220 if (!ost->resample_frame.data[0]) {
1221 avcodec_get_frame_defaults(&ost->resample_frame);
1222 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1223 enc->width, enc->height)) {
1224 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1228 /* initialize a new scaler context */
1229 sws_freeContext(ost->img_resample_ctx);
1230 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1231 enc->width, enc->height, enc->pix_fmt,
1232 ost->sws_flags, NULL, NULL, NULL);
1233 if (ost->img_resample_ctx == NULL) {
1234 fprintf(stderr, "Cannot get resampling context\n");
1238 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1239 0, ost->resample_height, ost->resample_frame.data, ost->resample_frame.linesize);
1243 /* duplicates frame if needed */
1244 for(i=0;i<nb_frames;i++) {
1246 av_init_packet(&pkt);
1247 pkt.stream_index= ost->index;
1249 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1250 /* raw pictures are written as AVPicture structure to
1251 avoid any copies. We support temorarily the older
1253 AVFrame* old_frame = enc->coded_frame;
1254 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1255 pkt.data= (uint8_t *)final_picture;
1256 pkt.size= sizeof(AVPicture);
1257 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1258 pkt.flags |= AV_PKT_FLAG_KEY;
1260 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1261 enc->coded_frame = old_frame;
1263 AVFrame big_picture;
1265 big_picture= *final_picture;
1266 /* better than nothing: use input picture interlaced
1268 big_picture.interlaced_frame = in_picture->interlaced_frame;
1269 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1270 if(top_field_first == -1)
1271 big_picture.top_field_first = in_picture->top_field_first;
1273 big_picture.top_field_first = top_field_first;
1276 /* handles sameq here. This is not correct because it may
1277 not be a global option */
1278 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1280 big_picture.pict_type = 0;
1281 // big_picture.pts = AV_NOPTS_VALUE;
1282 big_picture.pts= ost->sync_opts;
1283 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1284 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1285 if (ost->forced_kf_index < ost->forced_kf_count &&
1286 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1287 big_picture.pict_type = AV_PICTURE_TYPE_I;
1288 ost->forced_kf_index++;
1290 ret = avcodec_encode_video(enc,
1291 bit_buffer, bit_buffer_size,
1294 fprintf(stderr, "Video encoding failed\n");
1299 pkt.data= bit_buffer;
1301 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1302 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1303 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1304 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1305 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1307 if(enc->coded_frame->key_frame)
1308 pkt.flags |= AV_PKT_FLAG_KEY;
1309 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1312 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1313 // enc->frame_number-1, ret, enc->pict_type);
1314 /* if two pass, output log */
1315 if (ost->logfile && enc->stats_out) {
1316 fprintf(ost->logfile, "%s", enc->stats_out);
1321 ost->frame_number++;
1325 static double psnr(double d){
1326 return -10.0*log(d)/log(10.0);
1329 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1332 AVCodecContext *enc;
1334 double ti1, bitrate, avg_bitrate;
1336 /* this is executed just the first time do_video_stats is called */
1338 vstats_file = fopen(vstats_filename, "w");
1345 enc = ost->st->codec;
1346 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1347 frame_number = ost->frame_number;
1348 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1349 if (enc->flags&CODEC_FLAG_PSNR)
1350 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1352 fprintf(vstats_file,"f_size= %6d ", frame_size);
1353 /* compute pts value */
1354 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1358 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1359 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1360 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1361 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1362 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1366 static void print_report(AVFormatContext **output_files,
1367 AVOutputStream **ost_table, int nb_ostreams,
1371 AVOutputStream *ost;
1372 AVFormatContext *oc;
1374 AVCodecContext *enc;
1375 int frame_number, vid, i;
1376 double bitrate, ti1, pts;
1377 static int64_t last_time = -1;
1378 static int qp_histogram[52];
1380 if (!is_last_report) {
1382 /* display the report every 0.5 seconds */
1383 cur_time = av_gettime();
1384 if (last_time == -1) {
1385 last_time = cur_time;
1388 if ((cur_time - last_time) < 500000)
1390 last_time = cur_time;
1394 oc = output_files[0];
1396 total_size = avio_size(oc->pb);
1397 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1398 total_size= avio_tell(oc->pb);
1403 for(i=0;i<nb_ostreams;i++) {
1406 enc = ost->st->codec;
1407 if (!ost->st->stream_copy && enc->coded_frame)
1408 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1409 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1410 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1412 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1413 float t = (av_gettime()-timer_start) / 1000000.0;
1415 frame_number = ost->frame_number;
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1417 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1423 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1426 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1428 if (enc->flags&CODEC_FLAG_PSNR){
1430 double error, error_sum=0;
1431 double scale, scale_sum=0;
1432 char type[3]= {'Y','U','V'};
1433 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1436 error= enc->error[j];
1437 scale= enc->width*enc->height*255.0*255.0*frame_number;
1439 error= enc->coded_frame->error[j];
1440 scale= enc->width*enc->height*255.0*255.0;
1445 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1447 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1451 /* compute min output value */
1452 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1453 if ((pts < ti1) && (pts > 0))
1459 if (verbose > 0 || is_last_report) {
1460 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1462 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1463 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1464 (double)total_size / 1024, ti1, bitrate);
1466 if (nb_frames_dup || nb_frames_drop)
1467 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1468 nb_frames_dup, nb_frames_drop);
1471 fprintf(stderr, "%s \r", buf);
1476 if (is_last_report && verbose >= 0){
1477 int64_t raw= audio_size + video_size + extra_size;
1478 fprintf(stderr, "\n");
1479 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1483 100.0*(total_size - raw)/raw
1488 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1490 int fill_char = 0x00;
1491 if (sample_fmt == AV_SAMPLE_FMT_U8)
1493 memset(buf, fill_char, size);
1496 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1497 static int output_packet(AVInputStream *ist, int ist_index,
1498 AVOutputStream **ost_table, int nb_ostreams,
1499 const AVPacket *pkt)
1501 AVFormatContext *os;
1502 AVOutputStream *ost;
1506 void *buffer_to_free = NULL;
1507 static unsigned int samples_size= 0;
1508 AVSubtitle subtitle, *subtitle_to_free;
1509 int64_t pkt_pts = AV_NOPTS_VALUE;
1511 int frame_available;
1515 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1517 if(ist->next_pts == AV_NOPTS_VALUE)
1518 ist->next_pts= ist->pts;
1522 av_init_packet(&avpkt);
1530 if(pkt->dts != AV_NOPTS_VALUE)
1531 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1532 if(pkt->pts != AV_NOPTS_VALUE)
1533 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1535 //while we have more to decode or while the decoder did output something on EOF
1536 while (avpkt.size > 0 || (!pkt && got_output)) {
1537 uint8_t *data_buf, *decoded_data_buf;
1538 int data_size, decoded_data_size;
1540 ist->pts= ist->next_pts;
1542 if(avpkt.size && avpkt.size != pkt->size &&
1543 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1544 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1545 ist->showed_multi_packet_warning=1;
1548 /* decode the packet if needed */
1549 decoded_data_buf = NULL; /* fail safe */
1550 decoded_data_size= 0;
1551 data_buf = avpkt.data;
1552 data_size = avpkt.size;
1553 subtitle_to_free = NULL;
1554 if (ist->decoding_needed) {
1555 switch(ist->st->codec->codec_type) {
1556 case AVMEDIA_TYPE_AUDIO:{
1557 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1558 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1560 samples= av_malloc(samples_size);
1562 decoded_data_size= samples_size;
1563 /* XXX: could avoid copy if PCM 16 bits with same
1564 endianness as CPU */
1565 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1572 got_output = decoded_data_size > 0;
1573 /* Some bug in mpeg audio decoder gives */
1574 /* decoded_data_size < 0, it seems they are overflows */
1576 /* no audio frame */
1579 decoded_data_buf = (uint8_t *)samples;
1580 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1581 (ist->st->codec->sample_rate * ist->st->codec->channels);
1583 case AVMEDIA_TYPE_VIDEO:
1584 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1585 /* XXX: allocate picture correctly */
1586 avcodec_get_frame_defaults(&picture);
1587 avpkt.pts = pkt_pts;
1588 avpkt.dts = ist->pts;
1589 pkt_pts = AV_NOPTS_VALUE;
1591 ret = avcodec_decode_video2(ist->st->codec,
1592 &picture, &got_output, &avpkt);
1593 ist->st->quality= picture.quality;
1597 /* no picture yet */
1598 goto discard_packet;
1600 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1601 if (ist->st->codec->time_base.num != 0) {
1602 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1603 ist->next_pts += ((int64_t)AV_TIME_BASE *
1604 ist->st->codec->time_base.num * ticks) /
1605 ist->st->codec->time_base.den;
1608 buffer_to_free = NULL;
1609 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1611 case AVMEDIA_TYPE_SUBTITLE:
1612 ret = avcodec_decode_subtitle2(ist->st->codec,
1613 &subtitle, &got_output, &avpkt);
1617 goto discard_packet;
1619 subtitle_to_free = &subtitle;
1626 switch(ist->st->codec->codec_type) {
1627 case AVMEDIA_TYPE_AUDIO:
1628 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1629 ist->st->codec->sample_rate;
1631 case AVMEDIA_TYPE_VIDEO:
1632 if (ist->st->codec->time_base.num != 0) {
1633 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1634 ist->next_pts += ((int64_t)AV_TIME_BASE *
1635 ist->st->codec->time_base.num * ticks) /
1636 ist->st->codec->time_base.den;
1645 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1646 for(i=0;i<nb_ostreams;i++) {
1648 if (ost->input_video_filter && ost->source_index == ist_index) {
1649 if (!picture.sample_aspect_ratio.num)
1650 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1651 picture.pts = ist->pts;
1653 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture);
1659 // preprocess audio (volume)
1660 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1661 if (audio_volume != 256) {
1664 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1665 int v = ((*volp) * audio_volume + 128) >> 8;
1666 if (v < -32768) v = -32768;
1667 if (v > 32767) v = 32767;
1673 /* frame rate emulation */
1675 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1676 int64_t now = av_gettime() - ist->start;
1680 /* if output time reached then transcode raw format,
1681 encode packets and output them */
1682 if (start_time == 0 || ist->pts >= start_time)
1683 for(i=0;i<nb_ostreams;i++) {
1687 if (ost->source_index == ist_index) {
1689 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1690 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1691 while (frame_available) {
1692 AVRational ist_pts_tb;
1693 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1694 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1696 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1698 os = output_files[ost->file_index];
1700 /* set the input output pts pairs */
1701 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1703 if (ost->encoding_needed) {
1704 av_assert0(ist->decoding_needed);
1705 switch(ost->st->codec->codec_type) {
1706 case AVMEDIA_TYPE_AUDIO:
1707 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1709 case AVMEDIA_TYPE_VIDEO:
1711 if (ost->picref->video && !ost->frame_aspect_ratio)
1712 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1714 do_video_out(os, ost, ist, &picture, &frame_size);
1715 if (vstats_filename && frame_size)
1716 do_video_stats(os, ost, frame_size);
1718 case AVMEDIA_TYPE_SUBTITLE:
1719 do_subtitle_out(os, ost, ist, &subtitle,
1726 AVFrame avframe; //FIXME/XXX remove this
1728 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1730 av_init_packet(&opkt);
1732 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1733 #if !CONFIG_AVFILTER
1739 /* no reencoding needed : output the packet directly */
1740 /* force the input stream PTS */
1742 avcodec_get_frame_defaults(&avframe);
1743 ost->st->codec->coded_frame= &avframe;
1744 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1746 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1747 audio_size += data_size;
1748 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1749 video_size += data_size;
1753 opkt.stream_index= ost->index;
1754 if(pkt->pts != AV_NOPTS_VALUE)
1755 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1757 opkt.pts= AV_NOPTS_VALUE;
1759 if (pkt->dts == AV_NOPTS_VALUE)
1760 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1762 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1763 opkt.dts -= ost_tb_start_time;
1765 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1766 opkt.flags= pkt->flags;
1768 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1769 if( ost->st->codec->codec_id != CODEC_ID_H264
1770 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1771 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1773 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1774 opkt.destruct= av_destruct_packet;
1776 opkt.data = data_buf;
1777 opkt.size = data_size;
1780 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1781 ost->st->codec->frame_number++;
1782 ost->frame_number++;
1783 av_free_packet(&opkt);
1787 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1788 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);
3459 top_field_first = -1;
3461 av_freep(&video_codec_name);
3462 av_freep(&audio_codec_name);
3463 av_freep(&subtitle_codec_name);
3468 static void check_inputs(int *has_video_ptr,
3470 int *has_subtitle_ptr,
3473 int has_video, has_audio, has_subtitle, has_data, i, j;
3474 AVFormatContext *ic;
3481 for(j=0;j<nb_input_files;j++) {
3482 ic = input_files[j];
3483 for(i=0;i<ic->nb_streams;i++) {
3484 AVCodecContext *enc = ic->streams[i]->codec;
3485 switch(enc->codec_type) {
3486 case AVMEDIA_TYPE_AUDIO:
3489 case AVMEDIA_TYPE_VIDEO:
3492 case AVMEDIA_TYPE_SUBTITLE:
3495 case AVMEDIA_TYPE_DATA:
3496 case AVMEDIA_TYPE_ATTACHMENT:
3497 case AVMEDIA_TYPE_UNKNOWN:
3505 *has_video_ptr = has_video;
3506 *has_audio_ptr = has_audio;
3507 *has_subtitle_ptr = has_subtitle;
3508 *has_data_ptr = has_data;
3511 static void new_video_stream(AVFormatContext *oc, int file_idx)
3514 AVOutputStream *ost;
3515 AVCodecContext *video_enc;
3516 enum CodecID codec_id = CODEC_ID_NONE;
3517 AVCodec *codec= NULL;
3519 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3521 fprintf(stderr, "Could not alloc stream\n");
3524 ost = new_output_stream(oc, file_idx);
3526 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3527 if(!video_stream_copy){
3528 if (video_codec_name) {
3529 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3530 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3531 codec = avcodec_find_encoder_by_name(video_codec_name);
3532 output_codecs[nb_output_codecs-1] = codec;
3534 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3535 codec = avcodec_find_encoder(codec_id);
3537 ost->frame_aspect_ratio = frame_aspect_ratio;
3538 frame_aspect_ratio = 0;
3540 ost->avfilter = vfilters;
3545 avcodec_get_context_defaults3(st->codec, codec);
3546 ost->bitstream_filters = video_bitstream_filters;
3547 video_bitstream_filters= NULL;
3549 st->codec->thread_count= thread_count;
3551 video_enc = st->codec;
3554 video_enc->codec_tag= video_codec_tag;
3556 if( (video_global_header&1)
3557 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3558 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3559 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3561 if(video_global_header&2){
3562 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3563 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3566 if (video_stream_copy) {
3567 st->stream_copy = 1;
3568 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3569 video_enc->sample_aspect_ratio =
3570 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3574 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3576 video_enc->codec_id = codec_id;
3577 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3579 if (codec && codec->supported_framerates && !force_fps)
3580 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3581 video_enc->time_base.den = fps.num;
3582 video_enc->time_base.num = fps.den;
3584 video_enc->width = frame_width;
3585 video_enc->height = frame_height;
3586 video_enc->pix_fmt = frame_pix_fmt;
3587 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3588 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3590 choose_pixel_fmt(st, codec);
3593 video_enc->gop_size = 0;
3594 if (video_qscale || same_quality) {
3595 video_enc->flags |= CODEC_FLAG_QSCALE;
3596 video_enc->global_quality=
3597 st->quality = FF_QP2LAMBDA * video_qscale;
3601 video_enc->intra_matrix = intra_matrix;
3603 video_enc->inter_matrix = inter_matrix;
3605 p= video_rc_override_string;
3608 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3610 fprintf(stderr, "error parsing rc_override\n");
3613 video_enc->rc_override=
3614 av_realloc(video_enc->rc_override,
3615 sizeof(RcOverride)*(i+1));
3616 video_enc->rc_override[i].start_frame= start;
3617 video_enc->rc_override[i].end_frame = end;
3619 video_enc->rc_override[i].qscale= q;
3620 video_enc->rc_override[i].quality_factor= 1.0;
3623 video_enc->rc_override[i].qscale= 0;
3624 video_enc->rc_override[i].quality_factor= -q/100.0;
3629 video_enc->rc_override_count=i;
3630 if (!video_enc->rc_initial_buffer_occupancy)
3631 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3632 video_enc->me_threshold= me_threshold;
3633 video_enc->intra_dc_precision= intra_dc_precision - 8;
3636 video_enc->flags|= CODEC_FLAG_PSNR;
3641 video_enc->flags |= CODEC_FLAG_PASS1;
3643 video_enc->flags |= CODEC_FLAG_PASS2;
3647 if (forced_key_frames)
3648 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3650 if (video_language) {
3651 av_metadata_set2(&st->metadata, "language", video_language, 0);
3652 av_freep(&video_language);
3655 /* reset some key parameters */
3657 av_freep(&video_codec_name);
3658 av_freep(&forced_key_frames);
3659 video_stream_copy = 0;
3660 frame_pix_fmt = PIX_FMT_NONE;
3663 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3666 AVOutputStream *ost;
3667 AVCodec *codec= NULL;
3668 AVCodecContext *audio_enc;
3669 enum CodecID codec_id = CODEC_ID_NONE;
3671 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3673 fprintf(stderr, "Could not alloc stream\n");
3676 ost = new_output_stream(oc, file_idx);
3678 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3679 if(!audio_stream_copy){
3680 if (audio_codec_name) {
3681 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3682 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3683 codec = avcodec_find_encoder_by_name(audio_codec_name);
3684 output_codecs[nb_output_codecs-1] = codec;
3686 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3687 codec = avcodec_find_encoder(codec_id);
3691 avcodec_get_context_defaults3(st->codec, codec);
3693 ost->bitstream_filters = audio_bitstream_filters;
3694 audio_bitstream_filters= NULL;
3696 st->codec->thread_count= thread_count;
3698 audio_enc = st->codec;
3699 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3702 audio_enc->codec_tag= audio_codec_tag;
3704 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3705 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3706 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3708 if (audio_stream_copy) {
3709 st->stream_copy = 1;
3710 audio_enc->channels = audio_channels;
3711 audio_enc->sample_rate = audio_sample_rate;
3713 audio_enc->codec_id = codec_id;
3714 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3716 if (audio_qscale > QSCALE_NONE) {
3717 audio_enc->flags |= CODEC_FLAG_QSCALE;
3718 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3720 audio_enc->channels = audio_channels;
3721 audio_enc->sample_fmt = audio_sample_fmt;
3722 audio_enc->sample_rate = audio_sample_rate;
3723 audio_enc->channel_layout = channel_layout;
3724 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3725 audio_enc->channel_layout = 0;
3726 choose_sample_fmt(st, codec);
3727 choose_sample_rate(st, codec);
3729 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3730 if (audio_language) {
3731 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3732 av_freep(&audio_language);
3735 /* reset some key parameters */
3737 av_freep(&audio_codec_name);
3738 audio_stream_copy = 0;
3741 static void new_data_stream(AVFormatContext *oc, int file_idx)
3744 AVOutputStream *ost;
3745 AVCodec *codec=NULL;
3746 AVCodecContext *data_enc;
3748 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3750 fprintf(stderr, "Could not alloc stream\n");
3753 ost = new_output_stream(oc, file_idx);
3754 data_enc = st->codec;
3755 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3756 if (!data_stream_copy) {
3757 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3760 avcodec_get_context_defaults3(st->codec, codec);
3762 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3765 data_enc->codec_tag= data_codec_tag;
3767 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3768 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3769 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3771 if (data_stream_copy) {
3772 st->stream_copy = 1;
3776 av_freep(&data_codec_name);
3777 data_stream_copy = 0;
3780 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3783 AVOutputStream *ost;
3784 AVCodec *codec=NULL;
3785 AVCodecContext *subtitle_enc;
3786 enum CodecID codec_id = CODEC_ID_NONE;
3788 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3790 fprintf(stderr, "Could not alloc stream\n");
3793 ost = new_output_stream(oc, file_idx);
3794 subtitle_enc = st->codec;
3795 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3796 if(!subtitle_stream_copy){
3797 if (subtitle_codec_name) {
3798 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3799 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3800 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3802 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3803 codec = avcodec_find_encoder(codec_id);
3806 avcodec_get_context_defaults3(st->codec, codec);
3808 ost->bitstream_filters = subtitle_bitstream_filters;
3809 subtitle_bitstream_filters= NULL;
3811 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3813 if(subtitle_codec_tag)
3814 subtitle_enc->codec_tag= subtitle_codec_tag;
3816 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3817 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3818 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3820 if (subtitle_stream_copy) {
3821 st->stream_copy = 1;
3823 subtitle_enc->codec_id = codec_id;
3824 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3827 if (subtitle_language) {
3828 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3829 av_freep(&subtitle_language);
3832 subtitle_disable = 0;
3833 av_freep(&subtitle_codec_name);
3834 subtitle_stream_copy = 0;
3837 static int opt_new_stream(const char *opt, const char *arg)
3839 AVFormatContext *oc;
3840 int file_idx = nb_output_files - 1;
3841 if (nb_output_files <= 0) {
3842 fprintf(stderr, "At least one output file must be specified\n");
3845 oc = output_files[file_idx];
3847 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3848 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3849 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3850 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3855 /* arg format is "output-stream-index:streamid-value". */
3856 static int opt_streamid(const char *opt, const char *arg)
3862 av_strlcpy(idx_str, arg, sizeof(idx_str));
3863 p = strchr(idx_str, ':');
3866 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3871 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3872 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3873 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3877 static void opt_output_file(const char *filename)
3879 AVFormatContext *oc;
3880 int err, use_video, use_audio, use_subtitle, use_data;
3881 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3882 AVFormatParameters params, *ap = ¶ms;
3883 AVOutputFormat *file_oformat;
3885 if (!strcmp(filename, "-"))
3888 oc = avformat_alloc_output_context(last_asked_format, NULL, filename);
3889 last_asked_format = NULL;
3891 print_error(filename, AVERROR(ENOMEM));
3894 file_oformat= oc->oformat;
3896 if (!strcmp(file_oformat->name, "ffm") &&
3897 av_strstart(filename, "http:", NULL)) {
3898 /* special case for files sent to ffserver: we get the stream
3899 parameters from ffserver */
3900 int err = read_ffserver_streams(oc, filename);
3902 print_error(filename, err);
3906 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3907 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3908 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3909 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 */
3911 /* disable if no corresponding type found and at least one
3913 if (nb_input_files > 0) {
3914 check_inputs(&input_has_video,
3916 &input_has_subtitle,
3919 if (!input_has_video)
3921 if (!input_has_audio)
3923 if (!input_has_subtitle)
3925 if (!input_has_data)
3929 /* manual disable */
3930 if (audio_disable) use_audio = 0;
3931 if (video_disable) use_video = 0;
3932 if (subtitle_disable) use_subtitle = 0;
3933 if (data_disable) use_data = 0;
3935 if (use_video) new_video_stream(oc, nb_output_files);
3936 if (use_audio) new_audio_stream(oc, nb_output_files);
3937 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3938 if (use_data) new_data_stream(oc, nb_output_files);
3940 oc->timestamp = recording_timestamp;
3942 av_metadata_copy(&oc->metadata, metadata, 0);
3943 av_metadata_free(&metadata);
3946 output_files[nb_output_files++] = oc;
3948 /* check filename in case of an image number is expected */
3949 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3950 if (!av_filename_number_test(oc->filename)) {
3951 print_error(oc->filename, AVERROR(EINVAL));
3956 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3957 /* test if it already exists to avoid loosing precious files */
3958 if (!file_overwrite &&
3959 (strchr(filename, ':') == NULL ||
3960 filename[1] == ':' ||
3961 av_strstart(filename, "file:", NULL))) {
3962 if (avio_check(filename, 0) == 0) {
3964 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3966 if (!read_yesno()) {
3967 fprintf(stderr, "Not overwriting - exiting\n");
3972 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3979 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3980 print_error(filename, err);
3985 memset(ap, 0, sizeof(*ap));
3986 if (av_set_parameters(oc, ap) < 0) {
3987 fprintf(stderr, "%s: Invalid encoding parameters\n",
3992 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3993 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3994 oc->loop_output = loop_output;
3996 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3998 av_freep(&forced_key_frames);
4003 /* same option as mencoder */
4004 static int opt_pass(const char *opt, const char *arg)
4006 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4010 static int64_t getutime(void)
4013 struct rusage rusage;
4015 getrusage(RUSAGE_SELF, &rusage);
4016 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4017 #elif HAVE_GETPROCESSTIMES
4019 FILETIME c, e, k, u;
4020 proc = GetCurrentProcess();
4021 GetProcessTimes(proc, &c, &e, &k, &u);
4022 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4024 return av_gettime();
4028 static int64_t getmaxrss(void)
4030 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4031 struct rusage rusage;
4032 getrusage(RUSAGE_SELF, &rusage);
4033 return (int64_t)rusage.ru_maxrss * 1024;
4034 #elif HAVE_GETPROCESSMEMORYINFO
4036 PROCESS_MEMORY_COUNTERS memcounters;
4037 proc = GetCurrentProcess();
4038 memcounters.cb = sizeof(memcounters);
4039 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4040 return memcounters.PeakPagefileUsage;
4046 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4049 const char *p = str;
4056 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4063 static void opt_inter_matrix(const char *arg)
4065 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4066 parse_matrix_coeffs(inter_matrix, arg);
4069 static void opt_intra_matrix(const char *arg)
4071 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4072 parse_matrix_coeffs(intra_matrix, arg);
4075 static void show_usage(void)
4077 printf("Hyper fast Audio and Video encoder\n");
4078 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4082 static void show_help(void)
4085 AVOutputFormat *oformat = NULL;
4087 av_log_set_callback(log_callback_help);
4089 show_help_options(options, "Main options:\n",
4090 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4091 show_help_options(options, "\nAdvanced options:\n",
4092 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4094 show_help_options(options, "\nVideo options:\n",
4095 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4097 show_help_options(options, "\nAdvanced Video options:\n",
4098 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4099 OPT_VIDEO | OPT_EXPERT);
4100 show_help_options(options, "\nAudio options:\n",
4101 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4103 show_help_options(options, "\nAdvanced Audio options:\n",
4104 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4105 OPT_AUDIO | OPT_EXPERT);
4106 show_help_options(options, "\nSubtitle options:\n",
4107 OPT_SUBTITLE | OPT_GRAB,
4109 show_help_options(options, "\nAudio/Video grab options:\n",
4113 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4116 /* individual codec options */
4118 while ((c = av_codec_next(c))) {
4119 if (c->priv_class) {
4120 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4125 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4128 /* individual muxer options */
4129 while ((oformat = av_oformat_next(oformat))) {
4130 if (oformat->priv_class) {
4131 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4136 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4139 static void opt_target(const char *arg)
4141 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4142 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4144 if(!strncmp(arg, "pal-", 4)) {
4147 } else if(!strncmp(arg, "ntsc-", 5)) {
4150 } else if(!strncmp(arg, "film-", 5)) {
4155 /* Calculate FR via float to avoid int overflow */
4156 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4159 } else if((fr == 29970) || (fr == 23976)) {
4162 /* Try to determine PAL/NTSC by peeking in the input files */
4163 if(nb_input_files) {
4165 for(j = 0; j < nb_input_files; j++) {
4166 for(i = 0; i < input_files[j]->nb_streams; i++) {
4167 AVCodecContext *c = input_files[j]->streams[i]->codec;
4168 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4170 fr = c->time_base.den * 1000 / c->time_base.num;
4174 } else if((fr == 29970) || (fr == 23976)) {
4184 if(verbose > 0 && norm != UNKNOWN)
4185 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4188 if(norm == UNKNOWN) {
4189 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4190 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4191 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4195 if(!strcmp(arg, "vcd")) {
4197 opt_video_codec("mpeg1video");
4198 opt_audio_codec("mp2");
4201 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4202 opt_frame_rate(NULL, frame_rates[norm]);
4203 opt_default("g", norm == PAL ? "15" : "18");
4205 opt_default("b", "1150000");
4206 opt_default("maxrate", "1150000");
4207 opt_default("minrate", "1150000");
4208 opt_default("bufsize", "327680"); // 40*1024*8;
4210 opt_default("ab", "224000");
4211 audio_sample_rate = 44100;
4214 opt_default("packetsize", "2324");
4215 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4217 /* We have to offset the PTS, so that it is consistent with the SCR.
4218 SCR starts at 36000, but the first two packs contain only padding
4219 and the first pack from the other stream, respectively, may also have
4220 been written before.
4221 So the real data starts at SCR 36000+3*1200. */
4222 mux_preload= (36000+3*1200) / 90000.0; //0.44
4223 } else if(!strcmp(arg, "svcd")) {
4225 opt_video_codec("mpeg2video");
4226 opt_audio_codec("mp2");
4229 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4230 opt_frame_rate(NULL, frame_rates[norm]);
4231 opt_default("g", norm == PAL ? "15" : "18");
4233 opt_default("b", "2040000");
4234 opt_default("maxrate", "2516000");
4235 opt_default("minrate", "0"); //1145000;
4236 opt_default("bufsize", "1835008"); //224*1024*8;
4237 opt_default("flags", "+scan_offset");
4240 opt_default("ab", "224000");
4241 audio_sample_rate = 44100;
4243 opt_default("packetsize", "2324");
4245 } else if(!strcmp(arg, "dvd")) {
4247 opt_video_codec("mpeg2video");
4248 opt_audio_codec("ac3");
4251 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4252 opt_frame_rate(NULL, frame_rates[norm]);
4253 opt_default("g", norm == PAL ? "15" : "18");
4255 opt_default("b", "6000000");
4256 opt_default("maxrate", "9000000");
4257 opt_default("minrate", "0"); //1500000;
4258 opt_default("bufsize", "1835008"); //224*1024*8;
4260 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4261 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4263 opt_default("ab", "448000");
4264 audio_sample_rate = 48000;
4266 } else if(!strncmp(arg, "dv", 2)) {
4270 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4271 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4272 (norm == PAL ? "yuv420p" : "yuv411p"));
4273 opt_frame_rate(NULL, frame_rates[norm]);
4275 audio_sample_rate = 48000;
4279 fprintf(stderr, "Unknown target: %s\n", arg);
4284 static void opt_vstats_file (const char *arg)
4286 av_free (vstats_filename);
4287 vstats_filename=av_strdup (arg);
4290 static void opt_vstats (void)
4293 time_t today2 = time(NULL);
4294 struct tm *today = localtime(&today2);
4296 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4298 opt_vstats_file(filename);
4301 static int opt_bsf(const char *opt, const char *arg)
4303 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4304 AVBitStreamFilterContext **bsfp;
4307 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4311 bsfp= *opt == 'v' ? &video_bitstream_filters :
4312 *opt == 'a' ? &audio_bitstream_filters :
4313 &subtitle_bitstream_filters;
4315 bsfp= &(*bsfp)->next;
4322 static int opt_preset(const char *opt, const char *arg)
4325 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4326 char *codec_name = *opt == 'v' ? video_codec_name :
4327 *opt == 'a' ? audio_codec_name :
4328 subtitle_codec_name;
4330 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4331 fprintf(stderr, "File for preset '%s' not found\n", arg);
4336 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4337 if(line[0] == '#' && !e)
4339 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4341 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4344 if(!strcmp(tmp, "acodec")){
4345 opt_audio_codec(tmp2);
4346 }else if(!strcmp(tmp, "vcodec")){
4347 opt_video_codec(tmp2);
4348 }else if(!strcmp(tmp, "scodec")){
4349 opt_subtitle_codec(tmp2);
4350 }else if(!strcmp(tmp, "dcodec")){
4351 opt_data_codec(tmp2);
4352 }else if(opt_default(tmp, tmp2) < 0){
4353 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4363 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4367 static void opt_passlogfile(const char *arg)
4369 pass_logfilename_prefix = arg;
4370 opt_default("passlogfile", arg);
4373 static const OptionDef options[] = {
4375 #include "cmdutils_common_opts.h"
4376 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4377 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4378 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4379 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4380 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4381 "outfile[,metadata]:infile[,metadata]" },
4382 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4383 "outfile[,metadata]:infile[,metadata]" },
4384 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4385 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4386 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4387 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4388 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4389 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4390 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4391 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4392 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4393 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4394 "add timings for benchmarking" },
4395 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4396 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4397 "dump each input packet" },
4398 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4399 "when dumping packets, also dump the payload" },
4400 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4401 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4402 { "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)", "" },
4403 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4404 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4405 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4406 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4407 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4408 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4409 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4410 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4411 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4412 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4413 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4414 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4415 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4416 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4419 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4420 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4421 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4422 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4423 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4424 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4425 { "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" },
4426 { "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" },
4427 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4428 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4429 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4430 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4431 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4432 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4433 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4434 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4435 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4436 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4437 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4438 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4439 { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4440 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4441 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4442 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4443 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4444 "use same quantizer as source (implies VBR)" },
4445 { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4446 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4447 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4448 "deinterlace pictures" },
4449 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4450 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4451 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4453 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4455 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4456 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4457 { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4458 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4459 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4460 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4461 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4462 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4463 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4464 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4465 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4468 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4469 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4470 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4471 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4472 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4473 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4474 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4475 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4476 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4477 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4478 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4479 { "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" },
4481 /* subtitle options */
4482 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4483 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4484 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4485 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4486 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4489 { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4490 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4491 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4494 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4495 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4497 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4498 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4499 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4501 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4502 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4503 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4504 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4505 /* data codec support */
4506 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4508 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4512 int main(int argc, char **argv)
4516 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4518 if(argc>1 && !strcmp(argv[1], "-d")){
4521 av_log_set_callback(log_callback_null);
4526 avcodec_register_all();
4528 avdevice_register_all();
4531 avfilter_register_all();
4536 if(isatty(STDIN_FILENO))
4537 avio_set_interrupt_cb(decode_interrupt_cb);
4546 parse_options(argc, argv, options, opt_output_file);
4548 if(nb_output_files <= 0 && nb_input_files == 0) {
4550 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4554 /* file converter / grab */
4555 if (nb_output_files <= 0) {
4556 fprintf(stderr, "At least one output file must be specified\n");
4560 if (nb_input_files == 0) {
4561 fprintf(stderr, "At least one input file must be specified\n");
4566 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4567 stream_maps, nb_stream_maps) < 0)
4569 ti = getutime() - ti;
4571 int maxrss = getmaxrss() / 1024;
4572 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4575 return ffmpeg_exit(0);