3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/pixdesc.h"
44 #include "libavutil/avstring.h"
45 #include "libavutil/libm.h"
46 #include "libavformat/os_support.h"
48 #include "libavformat/ffm.h" // not public API
51 # include "libavfilter/avcodec.h"
52 # include "libavfilter/avfilter.h"
53 # include "libavfilter/avfiltergraph.h"
54 # include "libavfilter/vsink_buffer.h"
55 # include "libavfilter/vsrc_buffer.h"
58 #if HAVE_SYS_RESOURCE_H
59 #include <sys/types.h>
61 #include <sys/resource.h>
62 #elif HAVE_GETPROCESSTIMES
65 #if HAVE_GETPROCESSMEMORYINFO
71 #include <sys/select.h>
76 #include <sys/ioctl.h>
86 #include "libavutil/avassert.h"
88 const char program_name[] = "ffmpeg";
89 const int program_birth_year = 2000;
91 /* select an input stream for an output stream */
92 typedef struct AVStreamMap {
96 int sync_stream_index;
100 * select an input file for an output file
102 typedef struct AVMetaDataMap {
103 int file; //< file index
104 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
105 int index; //< stream/chapter/program number
108 typedef struct AVChapterMap {
113 static const OptionDef options[];
115 #define MAX_FILES 100
116 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static int64_t input_files_ts_offset[MAX_FILES];
120 static double *input_files_ts_scale[MAX_FILES] = {NULL};
121 static AVCodec **input_codecs = NULL;
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 int nb_output_files = 0;
128 static AVStreamMap *stream_maps = NULL;
129 static int nb_stream_maps;
131 /* first item specifies output metadata, second is input */
132 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
133 static int nb_meta_data_maps;
134 static int metadata_global_autocopy = 1;
135 static int metadata_streams_autocopy = 1;
136 static int metadata_chapters_autocopy = 1;
138 static AVChapterMap *chapter_maps = NULL;
139 static int nb_chapter_maps;
141 /* indexed by output file stream index */
142 static int *streamid_map = NULL;
143 static int nb_streamid_map = 0;
145 static int frame_width = 0;
146 static int frame_height = 0;
147 static float frame_aspect_ratio = 0;
148 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
149 static int frame_bits_per_raw_sample = 0;
150 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
151 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
152 static AVRational frame_rate;
153 static float video_qscale = 0;
154 static uint16_t *intra_matrix = NULL;
155 static uint16_t *inter_matrix = NULL;
156 static const char *video_rc_override_string=NULL;
157 static int video_disable = 0;
158 static int video_discard = 0;
159 static char *video_codec_name = NULL;
160 static unsigned int video_codec_tag = 0;
161 static char *video_language = NULL;
162 static int same_quality = 0;
163 static int do_deinterlace = 0;
164 static int top_field_first = -1;
165 static int me_threshold = 0;
166 static int intra_dc_precision = 8;
167 static int loop_input = 0;
168 static int loop_output = AVFMT_NOOUTPUTLOOP;
169 static int qp_hist = 0;
171 static char *vfilters = NULL;
174 static int intra_only = 0;
175 static int audio_sample_rate = 0;
176 static int64_t channel_layout = 0;
177 #define QSCALE_NONE -99999
178 static float audio_qscale = QSCALE_NONE;
179 static int audio_disable = 0;
180 static int audio_channels = 0;
181 static char *audio_codec_name = NULL;
182 static unsigned int audio_codec_tag = 0;
183 static char *audio_language = NULL;
185 static int subtitle_disable = 0;
186 static char *subtitle_codec_name = NULL;
187 static char *subtitle_language = NULL;
188 static unsigned int subtitle_codec_tag = 0;
190 static int data_disable = 0;
191 static char *data_codec_name = NULL;
192 static unsigned int data_codec_tag = 0;
194 static float mux_preload= 0.5;
195 static float mux_max_delay= 0.7;
197 static int64_t recording_time = INT64_MAX;
198 static int64_t start_time = 0;
199 static int64_t recording_timestamp = 0;
200 static int64_t input_ts_offset = 0;
201 static int file_overwrite = 0;
202 static AVDictionary *metadata;
203 static int do_benchmark = 0;
204 static int do_hex_dump = 0;
205 static int do_pkt_dump = 0;
206 static int do_psnr = 0;
207 static int do_pass = 0;
208 static const char *pass_logfilename_prefix;
209 static int audio_stream_copy = 0;
210 static int video_stream_copy = 0;
211 static int subtitle_stream_copy = 0;
212 static int data_stream_copy = 0;
213 static int video_sync_method= -1;
214 static int audio_sync_method= 0;
215 static float audio_drift_threshold= 0.1;
216 static int copy_ts= 0;
217 static int copy_tb= 0;
218 static int opt_shortest = 0;
219 static char *vstats_filename;
220 static FILE *vstats_file;
221 static int opt_programid = 0;
222 static int copy_initial_nonkeyframes = 0;
224 static int rate_emu = 0;
226 static int video_channel = 0;
227 static char *video_standard;
229 static int audio_volume = 256;
231 static int exit_on_error = 0;
232 static int using_stdin = 0;
233 static int verbose = 1;
234 static int run_as_daemon = 0;
235 static int thread_count= 1;
236 static int q_pressed = 0;
237 static int64_t video_size = 0;
238 static int64_t audio_size = 0;
239 static int64_t extra_size = 0;
240 static int nb_frames_dup = 0;
241 static int nb_frames_drop = 0;
242 static int input_sync;
243 static uint64_t limit_filesize = 0;
244 static int force_fps = 0;
245 static char *forced_key_frames = NULL;
247 static float dts_delta_threshold = 10;
249 static int64_t timer_start;
251 static uint8_t *audio_buf;
252 static uint8_t *audio_out;
253 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
255 static short *samples;
257 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
258 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
261 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263 struct AVInputStream;
265 typedef struct AVOutputStream {
266 int file_index; /* file index */
267 int index; /* stream index in the output file */
268 int source_index; /* AVInputStream index */
269 AVStream *st; /* stream in the output file */
270 int encoding_needed; /* true if encoding needed for this stream */
272 /* input pts and corresponding output pts
274 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
275 struct AVInputStream *sync_ist; /* input stream to sync against */
276 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
277 AVBitStreamFilterContext *bitstream_filters;
282 AVFrame resample_frame; /* temporary frame for image resampling */
283 struct SwsContext *img_resample_ctx; /* for image resampling */
286 int resample_pix_fmt;
287 AVRational frame_rate;
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 {
324 int discard; /* true if stream data should be discarded */
325 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
326 int64_t sample_index; /* current sample */
328 int64_t start; /* time when read started */
329 int64_t next_pts; /* synthetic pts for cases where pkt.pts
331 int64_t pts; /* current pts */
332 int is_start; /* is 1 at the start and after a discontinuity */
333 int showed_multi_packet_warning;
334 int is_past_recording_time;
336 AVFrame *filter_frame;
337 int has_filter_frame;
341 typedef struct AVInputFile {
342 AVFormatContext *ctx;
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 */
350 /* init terminal so that we can grab keys */
351 static struct termios oldtty;
354 static AVInputStream *input_streams = NULL;
355 static int nb_input_streams = 0;
356 static AVInputFile *input_files = NULL;
357 static int nb_input_files = 0;
361 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
363 AVFilterContext *last_filter, *filter;
364 /** filter graph containing all filters including input & output */
365 AVCodecContext *codec = ost->st->codec;
366 AVCodecContext *icodec = ist->st->codec;
367 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
368 AVRational sample_aspect_ratio;
372 ost->graph = avfilter_graph_alloc();
374 if (ist->st->sample_aspect_ratio.num){
375 sample_aspect_ratio = ist->st->sample_aspect_ratio;
377 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
379 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
380 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
381 sample_aspect_ratio.num, sample_aspect_ratio.den);
383 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
384 "src", args, NULL, ost->graph);
387 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
388 "out", NULL, pix_fmts, ost->graph);
391 last_filter = ost->input_video_filter;
393 if (codec->width != icodec->width || codec->height != icodec->height) {
394 snprintf(args, 255, "%d:%d:flags=0x%X",
398 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
399 NULL, args, NULL, ost->graph)) < 0)
401 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
403 last_filter = filter;
406 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
407 ost->graph->scale_sws_opts = av_strdup(args);
410 AVFilterInOut *outputs = avfilter_inout_alloc();
411 AVFilterInOut *inputs = avfilter_inout_alloc();
413 outputs->name = av_strdup("in");
414 outputs->filter_ctx = last_filter;
415 outputs->pad_idx = 0;
416 outputs->next = NULL;
418 inputs->name = av_strdup("out");
419 inputs->filter_ctx = ost->output_video_filter;
423 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
425 av_freep(&ost->avfilter);
427 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
431 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
434 codec->width = ost->output_video_filter->inputs[0]->w;
435 codec->height = ost->output_video_filter->inputs[0]->h;
436 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
437 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
438 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
439 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
443 #endif /* CONFIG_AVFILTER */
445 static void term_exit(void)
447 av_log(NULL, AV_LOG_QUIET, "%s", "");
450 tcsetattr (0, TCSANOW, &oldtty);
454 static volatile int received_sigterm = 0;
457 sigterm_handler(int sig)
459 received_sigterm = sig;
464 static void term_init(void)
474 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
475 |INLCR|IGNCR|ICRNL|IXON);
476 tty.c_oflag |= OPOST;
477 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
478 tty.c_cflag &= ~(CSIZE|PARENB);
483 tcsetattr (0, TCSANOW, &tty);
484 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
488 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
489 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
491 signal(SIGXCPU, sigterm_handler);
495 /* read a key without blocking */
496 static int read_key(void)
511 n = select(1, &rfds, NULL, NULL, &tv);
526 static int decode_interrupt_cb(void)
528 q_pressed += read_key() == 'q';
529 return q_pressed > 1;
532 static int ffmpeg_exit(int ret)
537 for(i=0;i<nb_output_files;i++) {
538 AVFormatContext *s = output_files[i];
539 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
541 avformat_free_context(s);
542 av_free(output_streams_for_file[i]);
544 for(i=0;i<nb_input_files;i++) {
545 av_close_input_file(input_files[i].ctx);
546 av_free(input_files_ts_scale[i]);
549 av_free(intra_matrix);
550 av_free(inter_matrix);
554 av_free(vstats_filename);
556 av_free(streamid_map);
557 av_free(input_codecs);
558 av_free(stream_maps);
559 av_free(meta_data_maps);
561 av_freep(&input_streams);
562 av_freep(&input_files);
564 av_free(video_codec_name);
565 av_free(audio_codec_name);
566 av_free(subtitle_codec_name);
567 av_free(data_codec_name);
569 av_free(video_standard);
574 allocated_audio_buf_size= allocated_audio_out_size= 0;
581 if (received_sigterm) {
583 "Received signal %d: terminating.\n",
584 (int) received_sigterm);
588 exit(ret); /* not all OS-es handle main() return value */
592 /* similar to ff_dynarray_add() and av_fast_realloc() */
593 static void *grow_array(void *array, int elem_size, int *size, int new_size)
595 if (new_size >= INT_MAX / elem_size) {
596 fprintf(stderr, "Array too big.\n");
599 if (*size < new_size) {
600 uint8_t *tmp = av_realloc(array, new_size*elem_size);
602 fprintf(stderr, "Could not alloc buffer.\n");
605 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
612 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
614 if(codec && codec->sample_fmts){
615 const enum AVSampleFormat *p= codec->sample_fmts;
617 if(*p == st->codec->sample_fmt)
621 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
622 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
623 av_log(NULL, AV_LOG_WARNING,
624 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
625 av_get_sample_fmt_name(st->codec->sample_fmt),
627 av_get_sample_fmt_name(codec->sample_fmts[0]));
628 st->codec->sample_fmt = codec->sample_fmts[0];
633 static void choose_sample_rate(AVStream *st, AVCodec *codec)
635 if(codec && codec->supported_samplerates){
636 const int *p= codec->supported_samplerates;
638 int best_dist=INT_MAX;
640 int dist= abs(st->codec->sample_rate - *p);
641 if(dist < best_dist){
647 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
649 st->codec->sample_rate= best;
653 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
655 if(codec && codec->pix_fmts){
656 const enum PixelFormat *p= codec->pix_fmts;
657 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
658 if(st->codec->codec_id==CODEC_ID_MJPEG){
659 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
660 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
661 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};
665 if(*p == st->codec->pix_fmt)
669 if(st->codec->pix_fmt != PIX_FMT_NONE)
670 av_log(NULL, AV_LOG_WARNING,
671 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
672 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
674 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
675 st->codec->pix_fmt = codec->pix_fmts[0];
680 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
682 int idx = oc->nb_streams - 1;
685 output_streams_for_file[file_idx] =
686 grow_array(output_streams_for_file[file_idx],
687 sizeof(*output_streams_for_file[file_idx]),
688 &nb_output_streams_for_file[file_idx],
690 ost = output_streams_for_file[file_idx][idx] =
691 av_mallocz(sizeof(AVOutputStream));
693 fprintf(stderr, "Could not alloc output stream\n");
696 ost->file_index = file_idx;
699 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
703 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
709 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
712 /* copy stream format */
714 s->streams = av_mallocz(sizeof(AVStream *) * ic->nb_streams);
715 for(i=0;i<ic->nb_streams;i++) {
721 // FIXME: a more elegant solution is needed
722 st = av_mallocz(sizeof(AVStream));
723 memcpy(st, ic->streams[i], sizeof(AVStream));
724 st->info = av_malloc(sizeof(*st->info));
725 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
726 st->codec = avcodec_alloc_context();
728 print_error(filename, AVERROR(ENOMEM));
731 avcodec_copy_context(st->codec, ic->streams[i]->codec);
734 codec = avcodec_find_encoder(st->codec->codec_id);
735 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
736 if (audio_stream_copy) {
739 choose_sample_fmt(st, codec);
740 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
741 if (video_stream_copy) {
744 choose_pixel_fmt(st, codec);
747 if(st->codec->flags & CODEC_FLAG_BITEXACT)
750 new_output_stream(s, nb_output_files);
754 s->timestamp = av_gettime();
756 av_close_input_file(ic);
761 get_sync_ipts(const AVOutputStream *ost)
763 const AVInputStream *ist = ost->sync_ist;
764 return (double)(ist->pts - start_time)/AV_TIME_BASE;
767 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
771 AVPacket new_pkt= *pkt;
772 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
773 &new_pkt.data, &new_pkt.size,
774 pkt->data, pkt->size,
775 pkt->flags & AV_PKT_FLAG_KEY);
778 new_pkt.destruct= av_destruct_packet;
780 fprintf(stderr, "%s failed for stream %d, codec %s",
781 bsfc->filter->name, pkt->stream_index,
782 avctx->codec ? avctx->codec->name : "copy");
792 ret= av_interleaved_write_frame(s, pkt);
794 print_error("av_interleaved_write_frame()", ret);
799 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
801 static void do_audio_out(AVFormatContext *s,
804 unsigned char *buf, int size)
807 int64_t audio_out_size, audio_buf_size;
808 int64_t allocated_for_size= size;
810 int size_out, frame_bytes, ret, resample_changed;
811 AVCodecContext *enc= ost->st->codec;
812 AVCodecContext *dec= ist->st->codec;
813 int osize = av_get_bytes_per_sample(enc->sample_fmt);
814 int isize = av_get_bytes_per_sample(dec->sample_fmt);
815 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
818 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
819 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
820 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
821 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
822 audio_buf_size*= osize*enc->channels;
824 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
825 if(coded_bps > 8*osize)
826 audio_out_size= audio_out_size * coded_bps / (8*osize);
827 audio_out_size += FF_MIN_BUFFER_SIZE;
829 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
830 fprintf(stderr, "Buffer sizes too large\n");
834 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
835 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
836 if (!audio_buf || !audio_out){
837 fprintf(stderr, "Out of memory in do_audio_out\n");
841 if (enc->channels != dec->channels)
842 ost->audio_resample = 1;
844 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
845 ost->resample_channels != dec->channels ||
846 ost->resample_sample_rate != dec->sample_rate;
848 if ((ost->audio_resample && !ost->resample) || resample_changed) {
849 if (resample_changed) {
850 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",
851 ist->file_index, ist->st->index,
852 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
853 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
854 ost->resample_sample_fmt = dec->sample_fmt;
855 ost->resample_channels = dec->channels;
856 ost->resample_sample_rate = dec->sample_rate;
858 audio_resample_close(ost->resample);
860 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
861 if (audio_sync_method <= 1 &&
862 ost->resample_sample_fmt == enc->sample_fmt &&
863 ost->resample_channels == enc->channels &&
864 ost->resample_sample_rate == enc->sample_rate) {
865 ost->resample = NULL;
866 ost->audio_resample = 0;
868 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
869 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
870 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
871 enc->sample_rate, dec->sample_rate,
872 enc->sample_fmt, dec->sample_fmt,
874 if (!ost->resample) {
875 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
876 dec->channels, dec->sample_rate,
877 enc->channels, enc->sample_rate);
883 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
884 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
885 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
886 if (ost->reformat_ctx)
887 av_audio_convert_free(ost->reformat_ctx);
888 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
889 dec->sample_fmt, 1, NULL, 0);
890 if (!ost->reformat_ctx) {
891 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
892 av_get_sample_fmt_name(dec->sample_fmt),
893 av_get_sample_fmt_name(enc->sample_fmt));
896 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
899 if(audio_sync_method){
900 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
901 - av_fifo_size(ost->fifo)/(enc->channels * 2);
902 double idelta= delta*dec->sample_rate / enc->sample_rate;
903 int byte_delta= ((int)idelta)*2*dec->channels;
905 //FIXME resample delay
906 if(fabs(delta) > 50){
907 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
909 byte_delta= FFMAX(byte_delta, -size);
913 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
918 static uint8_t *input_tmp= NULL;
919 input_tmp= av_realloc(input_tmp, byte_delta + size);
921 if(byte_delta > allocated_for_size - size){
922 allocated_for_size= byte_delta + (int64_t)size;
927 memset(input_tmp, 0, byte_delta);
928 memcpy(input_tmp + byte_delta, buf, size);
932 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
934 }else if(audio_sync_method>1){
935 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
936 av_assert0(ost->audio_resample);
938 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
939 // 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));
940 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
944 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
945 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
947 if (ost->audio_resample) {
949 size_out = audio_resample(ost->resample,
950 (short *)buftmp, (short *)buf,
951 size / (dec->channels * isize));
952 size_out = size_out * enc->channels * osize;
958 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
959 const void *ibuf[6]= {buftmp};
960 void *obuf[6]= {audio_buf};
961 int istride[6]= {isize};
962 int ostride[6]= {osize};
963 int len= size_out/istride[0];
964 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
965 printf("av_audio_convert() failed\n");
971 size_out = len*osize;
974 /* now encode as many frames as possible */
975 if (enc->frame_size > 1) {
976 /* output resampled raw samples */
977 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
978 fprintf(stderr, "av_fifo_realloc2() failed\n");
981 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
983 frame_bytes = enc->frame_size * osize * enc->channels;
985 while (av_fifo_size(ost->fifo) >= frame_bytes) {
987 av_init_packet(&pkt);
989 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
991 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
993 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
996 fprintf(stderr, "Audio encoding failed\n");
1000 pkt.stream_index= ost->index;
1001 pkt.data= audio_out;
1003 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1004 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1005 pkt.flags |= AV_PKT_FLAG_KEY;
1006 write_frame(s, &pkt, enc, ost->bitstream_filters);
1008 ost->sync_opts += enc->frame_size;
1012 av_init_packet(&pkt);
1014 ost->sync_opts += size_out / (osize * enc->channels);
1016 /* output a pcm frame */
1017 /* determine the size of the coded buffer */
1020 size_out = size_out*coded_bps/8;
1022 if(size_out > audio_out_size){
1023 fprintf(stderr, "Internal error, buffer size too small\n");
1027 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1028 ret = avcodec_encode_audio(enc, audio_out, size_out,
1031 fprintf(stderr, "Audio encoding failed\n");
1035 pkt.stream_index= ost->index;
1036 pkt.data= audio_out;
1038 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1039 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1040 pkt.flags |= AV_PKT_FLAG_KEY;
1041 write_frame(s, &pkt, enc, ost->bitstream_filters);
1045 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1047 AVCodecContext *dec;
1048 AVPicture *picture2;
1049 AVPicture picture_tmp;
1052 dec = ist->st->codec;
1054 /* deinterlace : must be done before any resize */
1055 if (do_deinterlace) {
1058 /* create temporary picture */
1059 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1060 buf = av_malloc(size);
1064 picture2 = &picture_tmp;
1065 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1067 if(avpicture_deinterlace(picture2, picture,
1068 dec->pix_fmt, dec->width, dec->height) < 0) {
1069 /* if error, do not deinterlace */
1070 fprintf(stderr, "Deinterlacing failed\n");
1079 if (picture != picture2)
1080 *picture = *picture2;
1084 /* we begin to correct av delay at this threshold */
1085 #define AV_DELAY_MAX 0.100
1087 static void do_subtitle_out(AVFormatContext *s,
1088 AVOutputStream *ost,
1093 static uint8_t *subtitle_out = NULL;
1094 int subtitle_out_max_size = 1024 * 1024;
1095 int subtitle_out_size, nb, i;
1096 AVCodecContext *enc;
1099 if (pts == AV_NOPTS_VALUE) {
1100 fprintf(stderr, "Subtitle packets must have a pts\n");
1106 enc = ost->st->codec;
1108 if (!subtitle_out) {
1109 subtitle_out = av_malloc(subtitle_out_max_size);
1112 /* Note: DVB subtitle need one packet to draw them and one other
1113 packet to clear them */
1114 /* XXX: signal it in the codec context ? */
1115 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1120 for(i = 0; i < nb; i++) {
1121 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1122 // start_display_time is required to be 0
1123 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1124 sub->end_display_time -= sub->start_display_time;
1125 sub->start_display_time = 0;
1126 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1127 subtitle_out_max_size, sub);
1128 if (subtitle_out_size < 0) {
1129 fprintf(stderr, "Subtitle encoding failed\n");
1133 av_init_packet(&pkt);
1134 pkt.stream_index = ost->index;
1135 pkt.data = subtitle_out;
1136 pkt.size = subtitle_out_size;
1137 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1138 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1139 /* XXX: the pts correction is handled here. Maybe handling
1140 it in the codec would be better */
1142 pkt.pts += 90 * sub->start_display_time;
1144 pkt.pts += 90 * sub->end_display_time;
1146 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1150 static int bit_buffer_size= 1024*256;
1151 static uint8_t *bit_buffer= NULL;
1153 static void do_video_out(AVFormatContext *s,
1154 AVOutputStream *ost,
1156 AVFrame *in_picture,
1159 int nb_frames, i, ret, av_unused resample_changed;
1160 AVFrame *final_picture, *formatted_picture;
1161 AVCodecContext *enc, *dec;
1164 enc = ost->st->codec;
1165 dec = ist->st->codec;
1167 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1169 /* by default, we output a single frame */
1174 if(video_sync_method){
1175 double vdelta = sync_ipts - ost->sync_opts;
1176 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1179 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1182 }else if(vdelta>0.6)
1183 ost->sync_opts= lrintf(sync_ipts);
1184 }else if (vdelta > 1.1)
1185 nb_frames = lrintf(vdelta);
1186 //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);
1187 if (nb_frames == 0){
1190 fprintf(stderr, "*** drop!\n");
1191 }else if (nb_frames > 1) {
1192 nb_frames_dup += nb_frames - 1;
1194 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1197 ost->sync_opts= lrintf(sync_ipts);
1199 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1203 formatted_picture = in_picture;
1204 final_picture = formatted_picture;
1206 #if !CONFIG_AVFILTER
1207 resample_changed = ost->resample_width != dec->width ||
1208 ost->resample_height != dec->height ||
1209 ost->resample_pix_fmt != dec->pix_fmt;
1211 if (resample_changed) {
1212 av_log(NULL, AV_LOG_INFO,
1213 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1214 ist->file_index, ist->st->index,
1215 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1216 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1217 ost->resample_width = dec->width;
1218 ost->resample_height = dec->height;
1219 ost->resample_pix_fmt = dec->pix_fmt;
1222 ost->video_resample = dec->width != enc->width ||
1223 dec->height != enc->height ||
1224 dec->pix_fmt != enc->pix_fmt;
1226 if (ost->video_resample) {
1227 final_picture = &ost->resample_frame;
1228 if (!ost->img_resample_ctx || resample_changed) {
1229 /* initialize the destination picture */
1230 if (!ost->resample_frame.data[0]) {
1231 avcodec_get_frame_defaults(&ost->resample_frame);
1232 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1233 enc->width, enc->height)) {
1234 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1238 /* initialize a new scaler context */
1239 sws_freeContext(ost->img_resample_ctx);
1240 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1241 enc->width, enc->height, enc->pix_fmt,
1242 ost->sws_flags, NULL, NULL, NULL);
1243 if (ost->img_resample_ctx == NULL) {
1244 fprintf(stderr, "Cannot get resampling context\n");
1248 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1249 0, ost->resample_height, final_picture->data, final_picture->linesize);
1253 /* duplicates frame if needed */
1254 for(i=0;i<nb_frames;i++) {
1256 av_init_packet(&pkt);
1257 pkt.stream_index= ost->index;
1259 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1260 /* raw pictures are written as AVPicture structure to
1261 avoid any copies. We support temorarily the older
1263 AVFrame* old_frame = enc->coded_frame;
1264 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1265 pkt.data= (uint8_t *)final_picture;
1266 pkt.size= sizeof(AVPicture);
1267 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1268 pkt.flags |= AV_PKT_FLAG_KEY;
1270 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1271 enc->coded_frame = old_frame;
1273 AVFrame big_picture;
1275 big_picture= *final_picture;
1276 /* better than nothing: use input picture interlaced
1278 big_picture.interlaced_frame = in_picture->interlaced_frame;
1279 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1280 if(top_field_first == -1)
1281 big_picture.top_field_first = in_picture->top_field_first;
1283 big_picture.top_field_first = top_field_first;
1286 /* handles sameq here. This is not correct because it may
1287 not be a global option */
1288 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1290 big_picture.pict_type = 0;
1291 // big_picture.pts = AV_NOPTS_VALUE;
1292 big_picture.pts= ost->sync_opts;
1293 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1294 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1295 if (ost->forced_kf_index < ost->forced_kf_count &&
1296 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1297 big_picture.pict_type = AV_PICTURE_TYPE_I;
1298 ost->forced_kf_index++;
1300 ret = avcodec_encode_video(enc,
1301 bit_buffer, bit_buffer_size,
1304 fprintf(stderr, "Video encoding failed\n");
1309 pkt.data= bit_buffer;
1311 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1312 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1313 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1314 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1315 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1317 if(enc->coded_frame->key_frame)
1318 pkt.flags |= AV_PKT_FLAG_KEY;
1319 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1322 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1323 // enc->frame_number-1, ret, enc->pict_type);
1324 /* if two pass, output log */
1325 if (ost->logfile && enc->stats_out) {
1326 fprintf(ost->logfile, "%s", enc->stats_out);
1331 ost->frame_number++;
1335 static double psnr(double d){
1336 return -10.0*log(d)/log(10.0);
1339 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1342 AVCodecContext *enc;
1344 double ti1, bitrate, avg_bitrate;
1346 /* this is executed just the first time do_video_stats is called */
1348 vstats_file = fopen(vstats_filename, "w");
1355 enc = ost->st->codec;
1356 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1357 frame_number = ost->frame_number;
1358 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1359 if (enc->flags&CODEC_FLAG_PSNR)
1360 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1362 fprintf(vstats_file,"f_size= %6d ", frame_size);
1363 /* compute pts value */
1364 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1368 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1369 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1370 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1371 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1372 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1376 static void print_report(AVFormatContext **output_files,
1377 AVOutputStream **ost_table, int nb_ostreams,
1381 AVOutputStream *ost;
1382 AVFormatContext *oc;
1384 AVCodecContext *enc;
1385 int frame_number, vid, i;
1387 int64_t pts = INT64_MAX;
1388 static int64_t last_time = -1;
1389 static int qp_histogram[52];
1391 if (!is_last_report) {
1393 /* display the report every 0.5 seconds */
1394 cur_time = av_gettime();
1395 if (last_time == -1) {
1396 last_time = cur_time;
1399 if ((cur_time - last_time) < 500000)
1401 last_time = cur_time;
1405 oc = output_files[0];
1407 total_size = avio_size(oc->pb);
1408 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1409 total_size= avio_tell(oc->pb);
1413 for(i=0;i<nb_ostreams;i++) {
1416 enc = ost->st->codec;
1417 if (!ost->st->stream_copy && enc->coded_frame)
1418 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1419 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1422 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1423 float t = (av_gettime()-timer_start) / 1000000.0;
1425 frame_number = ost->frame_number;
1426 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1427 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1429 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1433 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1438 if (enc->flags&CODEC_FLAG_PSNR){
1440 double error, error_sum=0;
1441 double scale, scale_sum=0;
1442 char type[3]= {'Y','U','V'};
1443 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1446 error= enc->error[j];
1447 scale= enc->width*enc->height*255.0*255.0*frame_number;
1449 error= enc->coded_frame->error[j];
1450 scale= enc->width*enc->height*255.0*255.0;
1455 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1457 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1461 /* compute min output value */
1462 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1463 ost->st->time_base, AV_TIME_BASE_Q));
1466 if (verbose > 0 || is_last_report) {
1467 int hours, mins, secs, us;
1468 secs = pts / AV_TIME_BASE;
1469 us = pts % AV_TIME_BASE;
1475 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1477 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1478 "size=%8.0fkB time=", total_size / 1024.0);
1479 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1480 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1481 (100 * us) / AV_TIME_BASE);
1482 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1483 "bitrate=%6.1fkbits/s", bitrate);
1485 if (nb_frames_dup || nb_frames_drop)
1486 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1487 nb_frames_dup, nb_frames_drop);
1490 fprintf(stderr, "%s \r", buf);
1495 if (is_last_report && verbose >= 0){
1496 int64_t raw= audio_size + video_size + extra_size;
1497 fprintf(stderr, "\n");
1498 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1502 100.0*(total_size - raw)/raw
1507 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1509 int fill_char = 0x00;
1510 if (sample_fmt == AV_SAMPLE_FMT_U8)
1512 memset(buf, fill_char, size);
1515 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1516 static int output_packet(AVInputStream *ist, int ist_index,
1517 AVOutputStream **ost_table, int nb_ostreams,
1518 const AVPacket *pkt)
1520 AVFormatContext *os;
1521 AVOutputStream *ost;
1525 void *buffer_to_free = NULL;
1526 static unsigned int samples_size= 0;
1527 AVSubtitle subtitle, *subtitle_to_free;
1528 int64_t pkt_pts = AV_NOPTS_VALUE;
1530 int frame_available;
1534 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1536 if(ist->next_pts == AV_NOPTS_VALUE)
1537 ist->next_pts= ist->pts;
1541 av_init_packet(&avpkt);
1549 if(pkt->dts != AV_NOPTS_VALUE)
1550 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1551 if(pkt->pts != AV_NOPTS_VALUE)
1552 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1554 //while we have more to decode or while the decoder did output something on EOF
1555 while (avpkt.size > 0 || (!pkt && got_output)) {
1556 uint8_t *data_buf, *decoded_data_buf;
1557 int data_size, decoded_data_size;
1559 ist->pts= ist->next_pts;
1561 if(avpkt.size && avpkt.size != pkt->size &&
1562 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1563 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1564 ist->showed_multi_packet_warning=1;
1567 /* decode the packet if needed */
1568 decoded_data_buf = NULL; /* fail safe */
1569 decoded_data_size= 0;
1570 data_buf = avpkt.data;
1571 data_size = avpkt.size;
1572 subtitle_to_free = NULL;
1573 if (ist->decoding_needed) {
1574 switch(ist->st->codec->codec_type) {
1575 case AVMEDIA_TYPE_AUDIO:{
1576 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1577 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1579 samples= av_malloc(samples_size);
1581 decoded_data_size= samples_size;
1582 /* XXX: could avoid copy if PCM 16 bits with same
1583 endianness as CPU */
1584 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1591 got_output = decoded_data_size > 0;
1592 /* Some bug in mpeg audio decoder gives */
1593 /* decoded_data_size < 0, it seems they are overflows */
1595 /* no audio frame */
1598 decoded_data_buf = (uint8_t *)samples;
1599 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1600 (ist->st->codec->sample_rate * ist->st->codec->channels);
1602 case AVMEDIA_TYPE_VIDEO:
1603 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1604 /* XXX: allocate picture correctly */
1605 avcodec_get_frame_defaults(&picture);
1606 avpkt.pts = pkt_pts;
1607 avpkt.dts = ist->pts;
1608 pkt_pts = AV_NOPTS_VALUE;
1610 ret = avcodec_decode_video2(ist->st->codec,
1611 &picture, &got_output, &avpkt);
1612 ist->st->quality= picture.quality;
1616 /* no picture yet */
1617 goto discard_packet;
1619 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1620 if (ist->st->codec->time_base.num != 0) {
1621 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1622 ist->next_pts += ((int64_t)AV_TIME_BASE *
1623 ist->st->codec->time_base.num * ticks) /
1624 ist->st->codec->time_base.den;
1627 buffer_to_free = NULL;
1628 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1630 case AVMEDIA_TYPE_SUBTITLE:
1631 ret = avcodec_decode_subtitle2(ist->st->codec,
1632 &subtitle, &got_output, &avpkt);
1636 goto discard_packet;
1638 subtitle_to_free = &subtitle;
1645 switch(ist->st->codec->codec_type) {
1646 case AVMEDIA_TYPE_AUDIO:
1647 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1648 ist->st->codec->sample_rate;
1650 case AVMEDIA_TYPE_VIDEO:
1651 if (ist->st->codec->time_base.num != 0) {
1652 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1653 ist->next_pts += ((int64_t)AV_TIME_BASE *
1654 ist->st->codec->time_base.num * ticks) /
1655 ist->st->codec->time_base.den;
1664 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1665 if (start_time == 0 || ist->pts >= start_time) {
1666 for(i=0;i<nb_ostreams;i++) {
1668 if (ost->input_video_filter && ost->source_index == ist_index) {
1669 if (!picture.sample_aspect_ratio.num)
1670 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1671 picture.pts = ist->pts;
1673 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1679 // preprocess audio (volume)
1680 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1681 if (audio_volume != 256) {
1684 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1685 int v = ((*volp) * audio_volume + 128) >> 8;
1686 if (v < -32768) v = -32768;
1687 if (v > 32767) v = 32767;
1693 /* frame rate emulation */
1695 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1696 int64_t now = av_gettime() - ist->start;
1700 /* if output time reached then transcode raw format,
1701 encode packets and output them */
1702 if (start_time == 0 || ist->pts >= start_time)
1703 for(i=0;i<nb_ostreams;i++) {
1707 if (ost->source_index == ist_index) {
1709 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1710 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1711 while (frame_available) {
1712 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1713 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1714 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1717 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1718 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1722 os = output_files[ost->file_index];
1724 /* set the input output pts pairs */
1725 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1727 if (ost->encoding_needed) {
1728 av_assert0(ist->decoding_needed);
1729 switch(ost->st->codec->codec_type) {
1730 case AVMEDIA_TYPE_AUDIO:
1731 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1733 case AVMEDIA_TYPE_VIDEO:
1735 if (ost->picref->video && !ost->frame_aspect_ratio)
1736 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1738 do_video_out(os, ost, ist, &picture, &frame_size);
1739 if (vstats_filename && frame_size)
1740 do_video_stats(os, ost, frame_size);
1742 case AVMEDIA_TYPE_SUBTITLE:
1743 do_subtitle_out(os, ost, ist, &subtitle,
1750 AVFrame avframe; //FIXME/XXX remove this
1753 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1755 av_init_packet(&opkt);
1757 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1758 #if !CONFIG_AVFILTER
1764 /* no reencoding needed : output the packet directly */
1765 /* force the input stream PTS */
1767 avcodec_get_frame_defaults(&avframe);
1768 ost->st->codec->coded_frame= &avframe;
1769 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1771 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1772 audio_size += data_size;
1773 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1774 video_size += data_size;
1778 opkt.stream_index= ost->index;
1779 if(pkt->pts != AV_NOPTS_VALUE)
1780 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1782 opkt.pts= AV_NOPTS_VALUE;
1784 if (pkt->dts == AV_NOPTS_VALUE)
1785 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1787 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1788 opkt.dts -= ost_tb_start_time;
1790 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1791 opkt.flags= pkt->flags;
1793 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1794 if( ost->st->codec->codec_id != CODEC_ID_H264
1795 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1796 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1798 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1799 opkt.destruct= av_destruct_packet;
1801 opkt.data = data_buf;
1802 opkt.size = data_size;
1805 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1806 /* store AVPicture in AVPacket, as expected by the output format */
1807 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1808 opkt.data = (uint8_t *)&pict;
1809 opkt.size = sizeof(AVPicture);
1810 opkt.flags |= AV_PKT_FLAG_KEY;
1812 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1813 ost->st->codec->frame_number++;
1814 ost->frame_number++;
1815 av_free_packet(&opkt);
1819 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1820 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1821 avfilter_unref_buffer(ost->picref);
1827 av_free(buffer_to_free);
1828 /* XXX: allocate the subtitles in the codec ? */
1829 if (subtitle_to_free) {
1830 avsubtitle_free(subtitle_to_free);
1831 subtitle_to_free = NULL;
1838 for(i=0;i<nb_ostreams;i++) {
1840 if (ost->source_index == ist_index) {
1841 AVCodecContext *enc= ost->st->codec;
1842 os = output_files[ost->file_index];
1844 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1846 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1849 if (ost->encoding_needed) {
1853 av_init_packet(&pkt);
1854 pkt.stream_index= ost->index;
1856 switch(ost->st->codec->codec_type) {
1857 case AVMEDIA_TYPE_AUDIO:
1858 fifo_bytes = av_fifo_size(ost->fifo);
1860 /* encode any samples remaining in fifo */
1861 if (fifo_bytes > 0) {
1862 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1863 int fs_tmp = enc->frame_size;
1865 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1866 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1867 enc->frame_size = fifo_bytes / (osize * enc->channels);
1869 int frame_bytes = enc->frame_size*osize*enc->channels;
1870 if (allocated_audio_buf_size < frame_bytes)
1872 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1875 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1876 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1877 ost->st->time_base.num, enc->sample_rate);
1878 enc->frame_size = fs_tmp;
1881 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1884 fprintf(stderr, "Audio encoding failed\n");
1888 pkt.flags |= AV_PKT_FLAG_KEY;
1890 case AVMEDIA_TYPE_VIDEO:
1891 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1893 fprintf(stderr, "Video encoding failed\n");
1897 if(enc->coded_frame && enc->coded_frame->key_frame)
1898 pkt.flags |= AV_PKT_FLAG_KEY;
1899 if (ost->logfile && enc->stats_out) {
1900 fprintf(ost->logfile, "%s", enc->stats_out);
1909 pkt.data= bit_buffer;
1911 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1912 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1913 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1925 static void print_sdp(AVFormatContext **avc, int n)
1929 av_sdp_create(avc, n, sdp, sizeof(sdp));
1930 printf("SDP:\n%s\n", sdp);
1934 static int copy_chapters(int infile, int outfile)
1936 AVFormatContext *is = input_files[infile].ctx;
1937 AVFormatContext *os = output_files[outfile];
1940 for (i = 0; i < is->nb_chapters; i++) {
1941 AVChapter *in_ch = is->chapters[i], *out_ch;
1942 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1943 AV_TIME_BASE_Q, in_ch->time_base);
1944 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1945 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1948 if (in_ch->end < ts_off)
1950 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1953 out_ch = av_mallocz(sizeof(AVChapter));
1955 return AVERROR(ENOMEM);
1957 out_ch->id = in_ch->id;
1958 out_ch->time_base = in_ch->time_base;
1959 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1960 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1962 if (metadata_chapters_autocopy)
1963 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1966 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1968 return AVERROR(ENOMEM);
1969 os->chapters[os->nb_chapters - 1] = out_ch;
1974 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1975 AVCodecContext *avctx)
1981 for (p = kf; *p; p++)
1984 ost->forced_kf_count = n;
1985 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1986 if (!ost->forced_kf_pts) {
1987 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1990 for (i = 0; i < n; i++) {
1991 p = i ? strchr(p, ',') + 1 : kf;
1992 t = parse_time_or_die("force_key_frames", p, 1);
1993 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1998 * The following code is the main loop of the file converter
2000 static int transcode(AVFormatContext **output_files,
2001 int nb_output_files,
2002 AVInputFile *input_files,
2004 AVStreamMap *stream_maps, int nb_stream_maps)
2006 int ret = 0, i, j, k, n, nb_ostreams = 0, step;
2008 AVFormatContext *is, *os;
2009 AVCodecContext *codec, *icodec;
2010 AVOutputStream *ost, **ost_table = NULL;
2015 uint8_t no_packet[MAX_FILES]={0};
2016 int no_packet_count=0;
2017 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
2018 int nb_streams[AVMEDIA_TYPE_NB]={0};
2021 for (i = 0; i < nb_input_streams; i++)
2022 input_streams[i].start = av_gettime();
2024 /* output stream init */
2026 for(i=0;i<nb_output_files;i++) {
2027 os = output_files[i];
2028 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2029 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2030 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2031 ret = AVERROR(EINVAL);
2034 nb_ostreams += os->nb_streams;
2036 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2037 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2038 ret = AVERROR(EINVAL);
2042 /* Sanity check the mapping args -- do the input files & streams exist? */
2043 for(i=0;i<nb_stream_maps;i++) {
2044 int fi = stream_maps[i].file_index;
2045 int si = stream_maps[i].stream_index;
2047 if (fi < 0 || fi > nb_input_files - 1 ||
2048 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2049 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2050 ret = AVERROR(EINVAL);
2053 fi = stream_maps[i].sync_file_index;
2054 si = stream_maps[i].sync_stream_index;
2055 if (fi < 0 || fi > nb_input_files - 1 ||
2056 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2057 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2058 ret = AVERROR(EINVAL);
2063 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2067 for(k=0;k<nb_output_files;k++) {
2068 os = output_files[k];
2069 for(i=0;i<os->nb_streams;i++,n++) {
2070 nb_streams[os->streams[i]->codec->codec_type]++;
2073 for(step=1<<30; step; step>>=1){
2074 int found_streams[AVMEDIA_TYPE_NB]={0};
2075 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2076 nb_frame_threshold[j] += step;
2078 for(j=0; j<nb_input_streams; j++) {
2080 ist = &input_streams[j];
2083 AVFormatContext *f= input_files[ ist->file_index ].ctx;
2085 for(pi=0; pi<f->nb_programs; pi++){
2086 AVProgram *p= f->programs[pi];
2087 if(p->id == opt_programid)
2088 for(si=0; si<p->nb_stream_indexes; si++){
2089 if(f->streams[ p->stream_index[si] ] == ist->st)
2094 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2095 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2096 found_streams[ist->st->codec->codec_type]++;
2099 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2100 if(found_streams[j] < nb_streams[j])
2101 nb_frame_threshold[j] -= step;
2104 for(k=0;k<nb_output_files;k++) {
2105 os = output_files[k];
2106 for(i=0;i<os->nb_streams;i++,n++) {
2108 ost = ost_table[n] = output_streams_for_file[k][i];
2109 ost->st = os->streams[i];
2110 if (nb_stream_maps > 0) {
2111 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2112 stream_maps[n].stream_index;
2114 /* Sanity check that the stream types match */
2115 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2116 int i= ost->file_index;
2117 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2118 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2119 stream_maps[n].file_index, stream_maps[n].stream_index,
2120 ost->file_index, ost->index);
2125 /* get corresponding input stream index : we select the first one with the right type */
2127 for (j = 0; j < nb_input_streams; j++) {
2129 ist = &input_streams[j];
2132 AVFormatContext *f = input_files[ist->file_index].ctx;
2134 for(pi=0; pi<f->nb_programs; pi++){
2135 AVProgram *p= f->programs[pi];
2136 if(p->id == opt_programid)
2137 for(si=0; si<p->nb_stream_indexes; si++){
2138 if(f->streams[ p->stream_index[si] ] == ist->st)
2143 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2144 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2145 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2146 ost->source_index = j;
2153 if(! opt_programid) {
2154 /* try again and reuse existing stream */
2155 for (j = 0; j < nb_input_streams; j++) {
2156 ist = &input_streams[j];
2157 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2158 && ist->st->discard != AVDISCARD_ALL) {
2159 ost->source_index = j;
2165 int i= ost->file_index;
2166 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2167 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2168 ost->file_index, ost->index);
2173 ist = &input_streams[ost->source_index];
2175 ost->sync_ist = (nb_stream_maps > 0) ?
2176 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2177 stream_maps[n].sync_stream_index] : ist;
2181 /* for each output stream, we compute the right encoding parameters */
2182 for(i=0;i<nb_ostreams;i++) {
2184 os = output_files[ost->file_index];
2185 ist = &input_streams[ost->source_index];
2187 codec = ost->st->codec;
2188 icodec = ist->st->codec;
2190 if (metadata_streams_autocopy)
2191 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2192 AV_DICT_DONT_OVERWRITE);
2194 ost->st->disposition = ist->st->disposition;
2195 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2196 codec->chroma_sample_location = icodec->chroma_sample_location;
2198 if (ost->st->stream_copy) {
2199 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2201 if (extra_size > INT_MAX)
2204 /* if stream_copy is selected, no need to decode or encode */
2205 codec->codec_id = icodec->codec_id;
2206 codec->codec_type = icodec->codec_type;
2208 if(!codec->codec_tag){
2209 if( !os->oformat->codec_tag
2210 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2211 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2212 codec->codec_tag = icodec->codec_tag;
2215 codec->bit_rate = icodec->bit_rate;
2216 codec->rc_max_rate = icodec->rc_max_rate;
2217 codec->rc_buffer_size = icodec->rc_buffer_size;
2218 codec->extradata= av_mallocz(extra_size);
2219 if (!codec->extradata)
2221 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2222 codec->extradata_size= icodec->extradata_size;
2223 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){
2224 codec->time_base = icodec->time_base;
2225 codec->time_base.num *= icodec->ticks_per_frame;
2226 av_reduce(&codec->time_base.num, &codec->time_base.den,
2227 codec->time_base.num, codec->time_base.den, INT_MAX);
2229 codec->time_base = ist->st->time_base;
2230 switch(codec->codec_type) {
2231 case AVMEDIA_TYPE_AUDIO:
2232 if(audio_volume != 256) {
2233 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2236 codec->channel_layout = icodec->channel_layout;
2237 codec->sample_rate = icodec->sample_rate;
2238 codec->channels = icodec->channels;
2239 codec->frame_size = icodec->frame_size;
2240 codec->audio_service_type = icodec->audio_service_type;
2241 codec->block_align= icodec->block_align;
2242 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2243 codec->block_align= 0;
2244 if(codec->codec_id == CODEC_ID_AC3)
2245 codec->block_align= 0;
2247 case AVMEDIA_TYPE_VIDEO:
2248 codec->pix_fmt = icodec->pix_fmt;
2249 codec->width = icodec->width;
2250 codec->height = icodec->height;
2251 codec->has_b_frames = icodec->has_b_frames;
2252 if (!codec->sample_aspect_ratio.num) {
2253 codec->sample_aspect_ratio =
2254 ost->st->sample_aspect_ratio =
2255 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2256 ist->st->codec->sample_aspect_ratio.num ?
2257 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2260 case AVMEDIA_TYPE_SUBTITLE:
2261 codec->width = icodec->width;
2262 codec->height = icodec->height;
2264 case AVMEDIA_TYPE_DATA:
2271 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2272 switch(codec->codec_type) {
2273 case AVMEDIA_TYPE_AUDIO:
2274 ost->fifo= av_fifo_alloc(1024);
2277 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2278 if (!codec->sample_rate) {
2279 codec->sample_rate = icodec->sample_rate;
2281 codec->sample_rate >>= icodec->lowres;
2283 choose_sample_rate(ost->st, ost->enc);
2284 codec->time_base = (AVRational){1, codec->sample_rate};
2285 if (!codec->channels)
2286 codec->channels = icodec->channels;
2287 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2288 codec->channel_layout = 0;
2289 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2290 icodec->request_channels = codec->channels;
2291 ist->decoding_needed = 1;
2292 ost->encoding_needed = 1;
2293 ost->resample_sample_fmt = icodec->sample_fmt;
2294 ost->resample_sample_rate = icodec->sample_rate;
2295 ost->resample_channels = icodec->channels;
2297 case AVMEDIA_TYPE_VIDEO:
2298 if (codec->pix_fmt == PIX_FMT_NONE)
2299 codec->pix_fmt = icodec->pix_fmt;
2300 choose_pixel_fmt(ost->st, ost->enc);
2302 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2303 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2306 ost->video_resample = codec->width != icodec->width ||
2307 codec->height != icodec->height ||
2308 codec->pix_fmt != icodec->pix_fmt;
2309 if (ost->video_resample) {
2310 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2312 if (!codec->width || !codec->height) {
2313 codec->width = icodec->width;
2314 codec->height = icodec->height;
2316 ost->resample_height = icodec->height;
2317 ost->resample_width = icodec->width;
2318 ost->resample_pix_fmt= icodec->pix_fmt;
2319 ost->encoding_needed = 1;
2320 ist->decoding_needed = 1;
2322 if (!ost->frame_rate.num)
2323 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2324 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2325 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2326 ost->frame_rate = ost->enc->supported_framerates[idx];
2328 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2329 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2330 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2331 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2332 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2336 if (configure_video_filters(ist, ost)) {
2337 fprintf(stderr, "Error opening filters!\n");
2342 case AVMEDIA_TYPE_SUBTITLE:
2343 ost->encoding_needed = 1;
2344 ist->decoding_needed = 1;
2351 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2352 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2353 char logfilename[1024];
2356 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2357 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2359 if (codec->flags & CODEC_FLAG_PASS1) {
2360 f = fopen(logfilename, "wb");
2362 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2368 size_t logbuffer_size;
2369 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2370 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2373 codec->stats_in = logbuffer;
2377 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2378 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2379 int size= codec->width * codec->height;
2380 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2385 bit_buffer = av_malloc(bit_buffer_size);
2387 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2389 ret = AVERROR(ENOMEM);
2393 /* open each encoder */
2394 for(i=0;i<nb_ostreams;i++) {
2396 if (ost->encoding_needed) {
2397 AVCodec *codec = ost->enc;
2398 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2400 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2401 ost->st->codec->codec_id, ost->file_index, ost->index);
2402 ret = AVERROR(EINVAL);
2405 if (dec->subtitle_header) {
2406 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2407 if (!ost->st->codec->subtitle_header) {
2408 ret = AVERROR(ENOMEM);
2411 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2412 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2414 if (avcodec_open(ost->st->codec, codec) < 0) {
2415 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2416 ost->file_index, ost->index);
2417 ret = AVERROR(EINVAL);
2420 extra_size += ost->st->codec->extradata_size;
2424 /* open each decoder */
2425 for (i = 0; i < nb_input_streams; i++) {
2426 ist = &input_streams[i];
2427 if (ist->decoding_needed) {
2428 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2430 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2432 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2433 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2434 ret = AVERROR(EINVAL);
2437 if (avcodec_open(ist->st->codec, codec) < 0) {
2438 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2439 ist->file_index, ist->st->index);
2440 ret = AVERROR(EINVAL);
2443 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2444 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2449 for (i = 0; i < nb_input_streams; i++) {
2451 ist = &input_streams[i];
2453 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2454 ist->next_pts = AV_NOPTS_VALUE;
2458 /* set meta data information from input file if required */
2459 for (i=0;i<nb_meta_data_maps;i++) {
2460 AVFormatContext *files[2];
2461 AVDictionary **meta[2];
2464 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2465 if ((index) < 0 || (index) >= (nb_elems)) {\
2466 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2468 ret = AVERROR(EINVAL);\
2472 int out_file_index = meta_data_maps[i][0].file;
2473 int in_file_index = meta_data_maps[i][1].file;
2474 if (in_file_index < 0 || out_file_index < 0)
2476 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2477 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2479 files[0] = output_files[out_file_index];
2480 files[1] = input_files[in_file_index].ctx;
2482 for (j = 0; j < 2; j++) {
2483 AVMetaDataMap *map = &meta_data_maps[i][j];
2485 switch (map->type) {
2487 meta[j] = &files[j]->metadata;
2490 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2491 meta[j] = &files[j]->streams[map->index]->metadata;
2494 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2495 meta[j] = &files[j]->chapters[map->index]->metadata;
2498 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2499 meta[j] = &files[j]->programs[map->index]->metadata;
2504 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2507 /* copy global metadata by default */
2508 if (metadata_global_autocopy) {
2510 for (i = 0; i < nb_output_files; i++)
2511 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2512 AV_DICT_DONT_OVERWRITE);
2515 /* copy chapters according to chapter maps */
2516 for (i = 0; i < nb_chapter_maps; i++) {
2517 int infile = chapter_maps[i].in_file;
2518 int outfile = chapter_maps[i].out_file;
2520 if (infile < 0 || outfile < 0)
2522 if (infile >= nb_input_files) {
2523 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2524 ret = AVERROR(EINVAL);
2527 if (outfile >= nb_output_files) {
2528 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2529 ret = AVERROR(EINVAL);
2532 copy_chapters(infile, outfile);
2535 /* copy chapters from the first input file that has them*/
2536 if (!nb_chapter_maps)
2537 for (i = 0; i < nb_input_files; i++) {
2538 if (!input_files[i].ctx->nb_chapters)
2541 for (j = 0; j < nb_output_files; j++)
2542 if ((ret = copy_chapters(i, j)) < 0)
2547 /* open files and write file headers */
2548 for(i=0;i<nb_output_files;i++) {
2549 os = output_files[i];
2550 if (av_write_header(os) < 0) {
2551 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2552 ret = AVERROR(EINVAL);
2555 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2561 /* dump the file output parameters - cannot be done before in case
2563 for(i=0;i<nb_output_files;i++) {
2564 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2567 /* dump the stream mapping */
2569 fprintf(stderr, "Stream mapping:\n");
2570 for(i=0;i<nb_ostreams;i++) {
2572 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2573 input_streams[ost->source_index].file_index,
2574 input_streams[ost->source_index].st->index,
2577 if (ost->sync_ist != &input_streams[ost->source_index])
2578 fprintf(stderr, " [sync #%d.%d]",
2579 ost->sync_ist->file_index,
2580 ost->sync_ist->st->index);
2581 fprintf(stderr, "\n");
2586 fprintf(stderr, "%s\n", error);
2591 print_sdp(output_files, nb_output_files);
2596 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2597 avio_set_interrupt_cb(decode_interrupt_cb);
2601 timer_start = av_gettime();
2603 for(; received_sigterm == 0;) {
2604 int file_index, ist_index;
2612 /* if 'q' pressed, exits */
2616 /* read_key() returns 0 on EOF */
2620 if (key == '+') verbose++;
2621 if (key == '-') verbose--;
2622 if (key == 's') qp_hist ^= 1;
2625 do_hex_dump = do_pkt_dump = 0;
2626 } else if(do_pkt_dump){
2630 av_log_set_level(AV_LOG_DEBUG);
2632 if (key == 'd' || key == 'D'){
2635 debug = input_streams[0].st->codec->debug<<1;
2636 if(!debug) debug = 1;
2637 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2640 scanf("%d", &debug);
2641 for(i=0;i<nb_input_streams;i++) {
2642 input_streams[i].st->codec->debug = debug;
2644 for(i=0;i<nb_ostreams;i++) {
2646 ost->st->codec->debug = debug;
2648 if(debug) av_log_set_level(AV_LOG_DEBUG);
2649 fprintf(stderr,"debug=%d\n", debug);
2652 fprintf(stderr, "key function\n"
2653 "? show this help\n"
2654 "+ increase verbosity\n"
2655 "- decrease verbosity\n"
2656 "D cycle through available debug modes\n"
2657 "h dump packets/hex press to cycle through the 3 states\n"
2659 "s Show QP histogram\n"
2664 /* select the stream that we must read now by looking at the
2665 smallest output pts */
2667 for(i=0;i<nb_ostreams;i++) {
2670 os = output_files[ost->file_index];
2671 ist = &input_streams[ost->source_index];
2672 if(ist->is_past_recording_time || no_packet[ist->file_index])
2674 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2675 ipts = (double)ist->pts;
2676 if (!input_files[ist->file_index].eof_reached){
2677 if(ipts < ipts_min) {
2679 if(input_sync ) file_index = ist->file_index;
2681 if(opts < opts_min) {
2683 if(!input_sync) file_index = ist->file_index;
2686 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2691 /* if none, if is finished */
2692 if (file_index < 0) {
2693 if(no_packet_count){
2695 memset(no_packet, 0, sizeof(no_packet));
2702 /* finish if limit size exhausted */
2703 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2706 /* read a frame from it and output it in the fifo */
2707 is = input_files[file_index].ctx;
2708 ret= av_read_frame(is, &pkt);
2709 if(ret == AVERROR(EAGAIN)){
2710 no_packet[file_index]=1;
2715 input_files[file_index].eof_reached = 1;
2723 memset(no_packet, 0, sizeof(no_packet));
2726 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2727 is->streams[pkt.stream_index]);
2729 /* the following test is needed in case new streams appear
2730 dynamically in stream : we ignore them */
2731 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2732 goto discard_packet;
2733 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2734 ist = &input_streams[ist_index];
2736 goto discard_packet;
2738 if (pkt.dts != AV_NOPTS_VALUE)
2739 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2740 if (pkt.pts != AV_NOPTS_VALUE)
2741 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2743 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2744 && input_files_ts_scale[file_index][pkt.stream_index]){
2745 if(pkt.pts != AV_NOPTS_VALUE)
2746 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2747 if(pkt.dts != AV_NOPTS_VALUE)
2748 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2751 // 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);
2752 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2753 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2754 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2755 int64_t delta= pkt_dts - ist->next_pts;
2756 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2757 input_files_ts_offset[ist->file_index]-= delta;
2759 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2760 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2761 if(pkt.pts != AV_NOPTS_VALUE)
2762 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2766 /* finish if recording time exhausted */
2767 if (recording_time != INT64_MAX &&
2768 (pkt.pts != AV_NOPTS_VALUE ?
2769 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2771 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2773 ist->is_past_recording_time = 1;
2774 goto discard_packet;
2777 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2778 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2781 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2782 ist->file_index, ist->st->index);
2785 av_free_packet(&pkt);
2790 av_free_packet(&pkt);
2792 /* dump report by using the output first video and audio streams */
2793 print_report(output_files, ost_table, nb_ostreams, 0);
2796 /* at the end of stream, we must flush the decoder buffers */
2797 for (i = 0; i < nb_input_streams; i++) {
2798 ist = &input_streams[i];
2799 if (ist->decoding_needed) {
2800 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2806 /* write the trailer if needed and close file */
2807 for(i=0;i<nb_output_files;i++) {
2808 os = output_files[i];
2809 av_write_trailer(os);
2812 /* dump report by using the first video and audio streams */
2813 print_report(output_files, ost_table, nb_ostreams, 1);
2815 /* close each encoder */
2816 for(i=0;i<nb_ostreams;i++) {
2818 if (ost->encoding_needed) {
2819 av_freep(&ost->st->codec->stats_in);
2820 avcodec_close(ost->st->codec);
2823 avfilter_graph_free(&ost->graph);
2827 /* close each decoder */
2828 for (i = 0; i < nb_input_streams; i++) {
2829 ist = &input_streams[i];
2830 if (ist->decoding_needed) {
2831 avcodec_close(ist->st->codec);
2839 av_freep(&bit_buffer);
2842 for(i=0;i<nb_ostreams;i++) {
2845 if (ost->st->stream_copy)
2846 av_freep(&ost->st->codec->extradata);
2848 fclose(ost->logfile);
2849 ost->logfile = NULL;
2851 av_fifo_free(ost->fifo); /* works even if fifo is not
2852 initialized but set to zero */
2853 av_freep(&ost->st->codec->subtitle_header);
2854 av_free(ost->resample_frame.data[0]);
2855 av_free(ost->forced_kf_pts);
2856 if (ost->video_resample)
2857 sws_freeContext(ost->img_resample_ctx);
2859 audio_resample_close(ost->resample);
2860 if (ost->reformat_ctx)
2861 av_audio_convert_free(ost->reformat_ctx);
2870 static int opt_format(const char *opt, const char *arg)
2872 last_asked_format = arg;
2876 static int opt_video_rc_override_string(const char *opt, const char *arg)
2878 video_rc_override_string = arg;
2882 static int opt_me_threshold(const char *opt, const char *arg)
2884 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2888 static int opt_verbose(const char *opt, const char *arg)
2890 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2894 static int opt_frame_rate(const char *opt, const char *arg)
2896 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2897 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2903 static int opt_bitrate(const char *opt, const char *arg)
2905 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2907 opt_default(opt, arg);
2909 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2910 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2915 static int opt_frame_crop(const char *opt, const char *arg)
2917 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2918 return AVERROR(EINVAL);
2921 static int opt_frame_size(const char *opt, const char *arg)
2923 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2924 fprintf(stderr, "Incorrect frame size\n");
2925 return AVERROR(EINVAL);
2930 static int opt_pad(const char *opt, const char *arg) {
2931 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2935 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2937 if (strcmp(arg, "list")) {
2938 frame_pix_fmt = av_get_pix_fmt(arg);
2939 if (frame_pix_fmt == PIX_FMT_NONE) {
2940 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2941 return AVERROR(EINVAL);
2950 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2957 p = strchr(arg, ':');
2959 x = strtol(arg, &end, 10);
2961 y = strtol(end+1, &end, 10);
2963 ar = (double)x / (double)y;
2965 ar = strtod(arg, NULL);
2968 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2969 return AVERROR(EINVAL);
2971 frame_aspect_ratio = ar;
2975 static int opt_metadata(const char *opt, const char *arg)
2977 char *mid= strchr(arg, '=');
2980 fprintf(stderr, "Missing =\n");
2985 av_dict_set(&metadata, arg, mid, 0);
2990 static int opt_qscale(const char *opt, const char *arg)
2992 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2993 if (video_qscale <= 0 || video_qscale > 255) {
2994 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2995 return AVERROR(EINVAL);
3000 static int opt_top_field_first(const char *opt, const char *arg)
3002 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
3003 opt_default(opt, arg);
3007 static int opt_thread_count(const char *opt, const char *arg)
3009 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3012 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
3017 static int opt_audio_sample_fmt(const char *opt, const char *arg)
3019 if (strcmp(arg, "list")) {
3020 audio_sample_fmt = av_get_sample_fmt(arg);
3021 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3022 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3023 return AVERROR(EINVAL);
3028 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3029 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3035 static int opt_audio_rate(const char *opt, const char *arg)
3037 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3041 static int opt_audio_channels(const char *opt, const char *arg)
3043 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3047 static int opt_video_channel(const char *opt, const char *arg)
3049 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3053 static int opt_video_standard(const char *opt, const char *arg)
3055 video_standard = av_strdup(arg);
3059 static int opt_codec(const char *opt, const char *arg)
3061 int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3063 if (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy; pcodec_name = &audio_codec_name; codec_type = AVMEDIA_TYPE_AUDIO; }
3064 else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy; pcodec_name = &video_codec_name; codec_type = AVMEDIA_TYPE_VIDEO; }
3065 else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3066 else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy; pcodec_name = &data_codec_name; codec_type = AVMEDIA_TYPE_DATA; }
3068 av_freep(pcodec_name);
3069 if (!strcmp(arg, "copy")) {
3072 *pcodec_name = av_strdup(arg);
3077 static int opt_codec_tag(const char *opt, const char *arg)
3080 uint32_t *codec_tag;
3082 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3083 !strcmp(opt, "vtag") ? &video_codec_tag :
3084 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3088 *codec_tag = strtol(arg, &tail, 0);
3090 *codec_tag = AV_RL32(arg);
3095 static int opt_map(const char *opt, const char *arg)
3100 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3101 m = &stream_maps[nb_stream_maps-1];
3103 m->file_index = strtol(arg, &p, 0);
3107 m->stream_index = strtol(p, &p, 0);
3110 m->sync_file_index = strtol(p, &p, 0);
3113 m->sync_stream_index = strtol(p, &p, 0);
3115 m->sync_file_index = m->file_index;
3116 m->sync_stream_index = m->stream_index;
3121 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3132 *index = strtol(++arg, endptr, 0);
3135 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3142 static int opt_map_metadata(const char *opt, const char *arg)
3144 AVMetaDataMap *m, *m1;
3147 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3148 &nb_meta_data_maps, nb_meta_data_maps + 1);
3150 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3151 m->file = strtol(arg, &p, 0);
3152 parse_meta_type(p, &m->type, &m->index, &p);
3156 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3157 m1->file = strtol(p, &p, 0);
3158 parse_meta_type(p, &m1->type, &m1->index, &p);
3160 if (m->type == 'g' || m1->type == 'g')
3161 metadata_global_autocopy = 0;
3162 if (m->type == 's' || m1->type == 's')
3163 metadata_streams_autocopy = 0;
3164 if (m->type == 'c' || m1->type == 'c')
3165 metadata_chapters_autocopy = 0;
3170 static int opt_map_meta_data(const char *opt, const char *arg)
3172 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3173 "Use -map_metadata instead.\n");
3174 return opt_map_metadata(opt, arg);
3177 static int opt_map_chapters(const char *opt, const char *arg)
3182 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3183 nb_chapter_maps + 1);
3184 c = &chapter_maps[nb_chapter_maps - 1];
3185 c->out_file = strtol(arg, &p, 0);
3189 c->in_file = strtol(p, &p, 0);
3193 static int opt_input_ts_scale(const char *opt, const char *arg)
3195 unsigned int stream;
3199 stream = strtol(arg, &p, 0);
3202 scale= strtod(p, &p);
3204 if(stream >= MAX_STREAMS)
3207 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);
3208 input_files_ts_scale[nb_input_files][stream]= scale;
3212 static int opt_recording_time(const char *opt, const char *arg)
3214 recording_time = parse_time_or_die(opt, arg, 1);
3218 static int opt_start_time(const char *opt, const char *arg)
3220 start_time = parse_time_or_die(opt, arg, 1);
3224 static int opt_recording_timestamp(const char *opt, const char *arg)
3226 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3230 static int opt_input_ts_offset(const char *opt, const char *arg)
3232 input_ts_offset = parse_time_or_die(opt, arg, 1);
3236 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3238 const char *codec_string = encoder ? "encoder" : "decoder";
3242 return CODEC_ID_NONE;
3244 avcodec_find_encoder_by_name(name) :
3245 avcodec_find_decoder_by_name(name);
3247 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3250 if(codec->type != type) {
3251 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3254 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3255 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3256 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3257 "results.\nAdd '-strict experimental' if you want to use it.\n",
3258 codec_string, codec->name);
3260 avcodec_find_encoder(codec->id) :
3261 avcodec_find_decoder(codec->id);
3262 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3263 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3264 codec_string, codec->name);
3270 static int opt_input_file(const char *opt, const char *filename)
3272 AVFormatContext *ic;
3273 AVFormatParameters params, *ap = ¶ms;
3274 AVInputFormat *file_iformat = NULL;
3275 int err, i, ret, rfps, rfps_base;
3278 if (last_asked_format) {
3279 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3280 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3283 last_asked_format = NULL;
3286 if (!strcmp(filename, "-"))
3289 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3290 !strcmp(filename, "/dev/stdin");
3292 /* get default parameters from command line */
3293 ic = avformat_alloc_context();
3295 print_error(filename, AVERROR(ENOMEM));
3299 memset(ap, 0, sizeof(*ap));
3300 ap->prealloced_context = 1;
3301 ap->sample_rate = audio_sample_rate;
3302 ap->channels = audio_channels;
3303 ap->time_base.den = frame_rate.num;
3304 ap->time_base.num = frame_rate.den;
3305 ap->width = frame_width;
3306 ap->height = frame_height;
3307 ap->pix_fmt = frame_pix_fmt;
3308 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3309 ap->channel = video_channel;
3310 ap->standard = video_standard;
3312 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3314 ic->video_codec_id =
3315 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3316 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3317 ic->audio_codec_id =
3318 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3319 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3320 ic->subtitle_codec_id=
3321 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3322 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3323 ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3325 /* open the input file with generic libav function */
3326 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3328 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3329 err = av_demuxer_open(ic, ap);
3331 avformat_free_context(ic);
3334 print_error(filename, err);
3340 for(i=0; i<ic->nb_streams; i++){
3341 ic->streams[i]->discard= AVDISCARD_ALL;
3343 for(i=0; i<ic->nb_programs; i++){
3344 AVProgram *p= ic->programs[i];
3345 if(p->id != opt_programid){
3346 p->discard = AVDISCARD_ALL;
3349 for(j=0; j<p->nb_stream_indexes; j++){
3350 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3355 fprintf(stderr, "Specified program id not found\n");
3361 ic->loop_input = loop_input;
3363 /* If not enough info to get the stream parameters, we decode the
3364 first frames to get it. (used in mpeg case for example) */
3365 ret = av_find_stream_info(ic);
3366 if (ret < 0 && verbose >= 0) {
3367 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3368 av_close_input_file(ic);
3372 timestamp = start_time;
3373 /* add the stream start time */
3374 if (ic->start_time != AV_NOPTS_VALUE)
3375 timestamp += ic->start_time;
3377 /* if seeking requested, we execute it */
3378 if (start_time != 0) {
3379 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3381 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3382 filename, (double)timestamp / AV_TIME_BASE);
3384 /* reset seek info */
3388 /* update the current parameters so that they match the one of the input stream */
3389 for(i=0;i<ic->nb_streams;i++) {
3390 AVStream *st = ic->streams[i];
3391 AVCodecContext *dec = st->codec;
3394 dec->thread_count = thread_count;
3395 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3397 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3398 ist = &input_streams[nb_input_streams - 1];
3400 ist->file_index = nb_input_files;
3403 switch (dec->codec_type) {
3404 case AVMEDIA_TYPE_AUDIO:
3405 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3406 if(!input_codecs[nb_input_codecs-1])
3407 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3408 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]);
3409 channel_layout = dec->channel_layout;
3410 audio_sample_fmt = dec->sample_fmt;
3412 st->discard= AVDISCARD_ALL;
3414 case AVMEDIA_TYPE_VIDEO:
3415 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3416 if(!input_codecs[nb_input_codecs-1])
3417 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3418 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]);
3419 rfps = ic->streams[i]->r_frame_rate.num;
3420 rfps_base = ic->streams[i]->r_frame_rate.den;
3422 dec->flags |= CODEC_FLAG_EMU_EDGE;
3423 dec->height >>= dec->lowres;
3424 dec->width >>= dec->lowres;
3427 dec->debug |= FF_DEBUG_MV;
3429 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3432 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3433 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3435 (float)rfps / rfps_base, rfps, rfps_base);
3439 st->discard= AVDISCARD_ALL;
3440 else if(video_discard)
3441 st->discard= video_discard;
3443 case AVMEDIA_TYPE_DATA:
3445 case AVMEDIA_TYPE_SUBTITLE:
3446 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3447 if(!input_codecs[nb_input_codecs-1])
3448 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3449 if(subtitle_disable)
3450 st->discard = AVDISCARD_ALL;
3452 case AVMEDIA_TYPE_ATTACHMENT:
3453 case AVMEDIA_TYPE_UNKNOWN:
3460 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3461 /* dump the file content */
3463 av_dump_format(ic, nb_input_files, filename, 0);
3465 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3466 input_files[nb_input_files - 1].ctx = ic;
3467 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3469 top_field_first = -1;
3471 frame_rate = (AVRational){0, 0};
3472 frame_pix_fmt = PIX_FMT_NONE;
3475 audio_sample_rate = 0;
3478 av_freep(&video_codec_name);
3479 av_freep(&audio_codec_name);
3480 av_freep(&subtitle_codec_name);
3486 static void check_inputs(int *has_video_ptr,
3488 int *has_subtitle_ptr,
3491 int has_video, has_audio, has_subtitle, has_data, i, j;
3492 AVFormatContext *ic;
3499 for(j=0;j<nb_input_files;j++) {
3500 ic = input_files[j].ctx;
3501 for(i=0;i<ic->nb_streams;i++) {
3502 AVCodecContext *enc = ic->streams[i]->codec;
3503 switch(enc->codec_type) {
3504 case AVMEDIA_TYPE_AUDIO:
3507 case AVMEDIA_TYPE_VIDEO:
3510 case AVMEDIA_TYPE_SUBTITLE:
3513 case AVMEDIA_TYPE_DATA:
3514 case AVMEDIA_TYPE_ATTACHMENT:
3515 case AVMEDIA_TYPE_UNKNOWN:
3523 *has_video_ptr = has_video;
3524 *has_audio_ptr = has_audio;
3525 *has_subtitle_ptr = has_subtitle;
3526 *has_data_ptr = has_data;
3529 static void new_video_stream(AVFormatContext *oc, int file_idx)
3532 AVOutputStream *ost;
3533 AVCodecContext *video_enc;
3534 enum CodecID codec_id = CODEC_ID_NONE;
3535 AVCodec *codec= NULL;
3537 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3539 fprintf(stderr, "Could not alloc stream\n");
3542 ost = new_output_stream(oc, file_idx);
3544 if(!video_stream_copy){
3545 if (video_codec_name) {
3546 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3547 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3548 codec = avcodec_find_encoder_by_name(video_codec_name);
3551 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3552 codec = avcodec_find_encoder(codec_id);
3554 ost->frame_aspect_ratio = frame_aspect_ratio;
3555 frame_aspect_ratio = 0;
3557 ost->avfilter = vfilters;
3562 avcodec_get_context_defaults3(st->codec, codec);
3563 ost->bitstream_filters = video_bitstream_filters;
3564 video_bitstream_filters= NULL;
3566 st->codec->thread_count= thread_count;
3568 video_enc = st->codec;
3571 video_enc->codec_tag= video_codec_tag;
3573 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3574 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3578 if (video_stream_copy) {
3579 st->stream_copy = 1;
3580 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3581 video_enc->sample_aspect_ratio =
3582 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3588 ost->frame_rate = frame_rate;
3589 video_enc->codec_id = codec_id;
3590 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3592 video_enc->width = frame_width;
3593 video_enc->height = frame_height;
3594 video_enc->pix_fmt = frame_pix_fmt;
3595 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3596 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3599 video_enc->gop_size = 0;
3600 if (video_qscale || same_quality) {
3601 video_enc->flags |= CODEC_FLAG_QSCALE;
3602 video_enc->global_quality=
3603 st->quality = FF_QP2LAMBDA * video_qscale;
3607 video_enc->intra_matrix = intra_matrix;
3609 video_enc->inter_matrix = inter_matrix;
3611 p= video_rc_override_string;
3614 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3616 fprintf(stderr, "error parsing rc_override\n");
3619 video_enc->rc_override=
3620 av_realloc(video_enc->rc_override,
3621 sizeof(RcOverride)*(i+1));
3622 video_enc->rc_override[i].start_frame= start;
3623 video_enc->rc_override[i].end_frame = end;
3625 video_enc->rc_override[i].qscale= q;
3626 video_enc->rc_override[i].quality_factor= 1.0;
3629 video_enc->rc_override[i].qscale= 0;
3630 video_enc->rc_override[i].quality_factor= -q/100.0;
3635 video_enc->rc_override_count=i;
3636 if (!video_enc->rc_initial_buffer_occupancy)
3637 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3638 video_enc->me_threshold= me_threshold;
3639 video_enc->intra_dc_precision= intra_dc_precision - 8;
3642 video_enc->flags|= CODEC_FLAG_PSNR;
3647 video_enc->flags |= CODEC_FLAG_PASS1;
3649 video_enc->flags |= CODEC_FLAG_PASS2;
3653 if (forced_key_frames)
3654 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3656 if (video_language) {
3657 av_dict_set(&st->metadata, "language", video_language, 0);
3658 av_freep(&video_language);
3661 /* reset some key parameters */
3663 av_freep(&video_codec_name);
3664 av_freep(&forced_key_frames);
3665 video_stream_copy = 0;
3666 frame_pix_fmt = PIX_FMT_NONE;
3669 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3672 AVOutputStream *ost;
3673 AVCodec *codec= NULL;
3674 AVCodecContext *audio_enc;
3675 enum CodecID codec_id = CODEC_ID_NONE;
3677 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3679 fprintf(stderr, "Could not alloc stream\n");
3682 ost = new_output_stream(oc, file_idx);
3684 if(!audio_stream_copy){
3685 if (audio_codec_name) {
3686 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3687 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3688 codec = avcodec_find_encoder_by_name(audio_codec_name);
3691 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3692 codec = avcodec_find_encoder(codec_id);
3696 avcodec_get_context_defaults3(st->codec, codec);
3698 ost->bitstream_filters = audio_bitstream_filters;
3699 audio_bitstream_filters= NULL;
3701 st->codec->thread_count= thread_count;
3703 audio_enc = st->codec;
3704 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3707 audio_enc->codec_tag= audio_codec_tag;
3709 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3710 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3711 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3713 if (audio_stream_copy) {
3714 st->stream_copy = 1;
3716 audio_enc->codec_id = codec_id;
3717 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3719 if (audio_qscale > QSCALE_NONE) {
3720 audio_enc->flags |= CODEC_FLAG_QSCALE;
3721 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3724 audio_enc->channels = audio_channels;
3725 audio_enc->sample_fmt = audio_sample_fmt;
3726 if (audio_sample_rate)
3727 audio_enc->sample_rate = audio_sample_rate;
3728 audio_enc->channel_layout = channel_layout;
3729 choose_sample_fmt(st, codec);
3731 if (audio_language) {
3732 av_dict_set(&st->metadata, "language", audio_language, 0);
3733 av_freep(&audio_language);
3736 /* reset some key parameters */
3738 av_freep(&audio_codec_name);
3739 audio_stream_copy = 0;
3742 static void new_data_stream(AVFormatContext *oc, int file_idx)
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 new_output_stream(oc, file_idx);
3754 data_enc = st->codec;
3755 if (!data_stream_copy) {
3756 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3759 avcodec_get_context_defaults3(st->codec, codec);
3761 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3764 data_enc->codec_tag= data_codec_tag;
3766 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3767 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3768 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3770 if (data_stream_copy) {
3771 st->stream_copy = 1;
3775 av_freep(&data_codec_name);
3776 data_stream_copy = 0;
3779 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3782 AVOutputStream *ost;
3783 AVCodec *codec=NULL;
3784 AVCodecContext *subtitle_enc;
3785 enum CodecID codec_id = CODEC_ID_NONE;
3787 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3789 fprintf(stderr, "Could not alloc stream\n");
3792 ost = new_output_stream(oc, file_idx);
3793 subtitle_enc = st->codec;
3794 if(!subtitle_stream_copy){
3795 if (subtitle_codec_name) {
3796 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3797 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3798 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3801 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3802 codec = avcodec_find_encoder(codec_id);
3805 avcodec_get_context_defaults3(st->codec, codec);
3807 ost->bitstream_filters = subtitle_bitstream_filters;
3808 subtitle_bitstream_filters= NULL;
3810 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3812 if(subtitle_codec_tag)
3813 subtitle_enc->codec_tag= subtitle_codec_tag;
3815 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3816 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3817 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3819 if (subtitle_stream_copy) {
3820 st->stream_copy = 1;
3822 subtitle_enc->codec_id = codec_id;
3823 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3826 if (subtitle_language) {
3827 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3828 av_freep(&subtitle_language);
3831 subtitle_disable = 0;
3832 av_freep(&subtitle_codec_name);
3833 subtitle_stream_copy = 0;
3836 static int opt_new_stream(const char *opt, const char *arg)
3838 AVFormatContext *oc;
3839 int file_idx = nb_output_files - 1;
3840 if (nb_output_files <= 0) {
3841 fprintf(stderr, "At least one output file must be specified\n");
3844 oc = output_files[file_idx];
3846 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3847 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3848 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3849 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3854 /* arg format is "output-stream-index:streamid-value". */
3855 static int opt_streamid(const char *opt, const char *arg)
3861 av_strlcpy(idx_str, arg, sizeof(idx_str));
3862 p = strchr(idx_str, ':');
3865 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3870 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3871 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3872 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3876 static int opt_output_file(const char *opt, const char *filename)
3878 AVFormatContext *oc;
3879 int err, use_video, use_audio, use_subtitle, use_data;
3880 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3881 AVFormatParameters params, *ap = ¶ms;
3882 AVOutputFormat *file_oformat;
3884 if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3885 fprintf(stderr, "Too many output files\n");
3889 if (!strcmp(filename, "-"))
3892 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3893 last_asked_format = NULL;
3895 print_error(filename, err);
3898 file_oformat= oc->oformat;
3900 if (!strcmp(file_oformat->name, "ffm") &&
3901 av_strstart(filename, "http:", NULL)) {
3902 /* special case for files sent to ffserver: we get the stream
3903 parameters from ffserver */
3904 int err = read_ffserver_streams(oc, filename);
3906 print_error(filename, err);
3910 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3911 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3912 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3913 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 */
3915 /* disable if no corresponding type found and at least one
3917 if (nb_input_files > 0) {
3918 check_inputs(&input_has_video,
3920 &input_has_subtitle,
3923 if (!input_has_video)
3925 if (!input_has_audio)
3927 if (!input_has_subtitle)
3929 if (!input_has_data)
3933 /* manual disable */
3934 if (audio_disable) use_audio = 0;
3935 if (video_disable) use_video = 0;
3936 if (subtitle_disable) use_subtitle = 0;
3937 if (data_disable) use_data = 0;
3939 if (use_video) new_video_stream(oc, nb_output_files);
3940 if (use_audio) new_audio_stream(oc, nb_output_files);
3941 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3942 if (use_data) new_data_stream(oc, nb_output_files);
3944 oc->timestamp = recording_timestamp;
3946 av_dict_copy(&oc->metadata, metadata, 0);
3947 av_dict_free(&metadata);
3950 output_files[nb_output_files++] = oc;
3952 /* check filename in case of an image number is expected */
3953 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3954 if (!av_filename_number_test(oc->filename)) {
3955 print_error(oc->filename, AVERROR(EINVAL));
3960 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3961 /* test if it already exists to avoid loosing precious files */
3962 if (!file_overwrite &&
3963 (strchr(filename, ':') == NULL ||
3964 filename[1] == ':' ||
3965 av_strstart(filename, "file:", NULL))) {
3966 if (avio_check(filename, 0) == 0) {
3968 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3970 if (!read_yesno()) {
3971 fprintf(stderr, "Not overwriting - exiting\n");
3976 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3983 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3984 print_error(filename, err);
3989 memset(ap, 0, sizeof(*ap));
3990 if (av_set_parameters(oc, ap) < 0) {
3991 fprintf(stderr, "%s: Invalid encoding parameters\n",
3996 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3997 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3998 oc->loop_output = loop_output;
4000 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
4002 frame_rate = (AVRational){0, 0};
4005 audio_sample_rate = 0;
4008 av_freep(&forced_key_frames);
4014 /* same option as mencoder */
4015 static int opt_pass(const char *opt, const char *arg)
4017 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4021 static int64_t getutime(void)
4024 struct rusage rusage;
4026 getrusage(RUSAGE_SELF, &rusage);
4027 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4028 #elif HAVE_GETPROCESSTIMES
4030 FILETIME c, e, k, u;
4031 proc = GetCurrentProcess();
4032 GetProcessTimes(proc, &c, &e, &k, &u);
4033 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4035 return av_gettime();
4039 static int64_t getmaxrss(void)
4041 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4042 struct rusage rusage;
4043 getrusage(RUSAGE_SELF, &rusage);
4044 return (int64_t)rusage.ru_maxrss * 1024;
4045 #elif HAVE_GETPROCESSMEMORYINFO
4047 PROCESS_MEMORY_COUNTERS memcounters;
4048 proc = GetCurrentProcess();
4049 memcounters.cb = sizeof(memcounters);
4050 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4051 return memcounters.PeakPagefileUsage;
4057 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4060 const char *p = str;
4067 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4074 static void opt_inter_matrix(const char *opt, const char *arg)
4076 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4077 parse_matrix_coeffs(inter_matrix, arg);
4080 static void opt_intra_matrix(const char *opt, const char *arg)
4082 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4083 parse_matrix_coeffs(intra_matrix, arg);
4086 static void show_usage(void)
4088 printf("Hyper fast Audio and Video encoder\n");
4089 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4093 static void show_help(void)
4096 AVOutputFormat *oformat = NULL;
4098 av_log_set_callback(log_callback_help);
4100 show_help_options(options, "Main options:\n",
4101 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4102 show_help_options(options, "\nAdvanced options:\n",
4103 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4105 show_help_options(options, "\nVideo options:\n",
4106 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4108 show_help_options(options, "\nAdvanced Video options:\n",
4109 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4110 OPT_VIDEO | OPT_EXPERT);
4111 show_help_options(options, "\nAudio options:\n",
4112 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4114 show_help_options(options, "\nAdvanced Audio options:\n",
4115 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4116 OPT_AUDIO | OPT_EXPERT);
4117 show_help_options(options, "\nSubtitle options:\n",
4118 OPT_SUBTITLE | OPT_GRAB,
4120 show_help_options(options, "\nAudio/Video grab options:\n",
4124 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4127 /* individual codec options */
4129 while ((c = av_codec_next(c))) {
4130 if (c->priv_class) {
4131 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4136 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4139 /* individual muxer options */
4140 while ((oformat = av_oformat_next(oformat))) {
4141 if (oformat->priv_class) {
4142 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4147 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4150 static int opt_target(const char *opt, const char *arg)
4152 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4153 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4155 if(!strncmp(arg, "pal-", 4)) {
4158 } else if(!strncmp(arg, "ntsc-", 5)) {
4161 } else if(!strncmp(arg, "film-", 5)) {
4166 /* Calculate FR via float to avoid int overflow */
4167 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4170 } else if((fr == 29970) || (fr == 23976)) {
4173 /* Try to determine PAL/NTSC by peeking in the input files */
4174 if(nb_input_files) {
4176 for (j = 0; j < nb_input_files; j++) {
4177 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4178 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4179 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4181 fr = c->time_base.den * 1000 / c->time_base.num;
4185 } else if((fr == 29970) || (fr == 23976)) {
4195 if(verbose > 0 && norm != UNKNOWN)
4196 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4199 if(norm == UNKNOWN) {
4200 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4201 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4202 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4206 if(!strcmp(arg, "vcd")) {
4207 opt_codec("vcodec", "mpeg1video");
4208 opt_codec("acodec", "mp2");
4209 opt_format("f", "vcd");
4211 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4212 opt_frame_rate("r", frame_rates[norm]);
4213 opt_default("g", norm == PAL ? "15" : "18");
4215 opt_default("b", "1150000");
4216 opt_default("maxrate", "1150000");
4217 opt_default("minrate", "1150000");
4218 opt_default("bufsize", "327680"); // 40*1024*8;
4220 opt_default("ab", "224000");
4221 audio_sample_rate = 44100;
4224 opt_default("packetsize", "2324");
4225 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4227 /* We have to offset the PTS, so that it is consistent with the SCR.
4228 SCR starts at 36000, but the first two packs contain only padding
4229 and the first pack from the other stream, respectively, may also have
4230 been written before.
4231 So the real data starts at SCR 36000+3*1200. */
4232 mux_preload= (36000+3*1200) / 90000.0; //0.44
4233 } else if(!strcmp(arg, "svcd")) {
4235 opt_codec("vcodec", "mpeg2video");
4236 opt_codec("acodec", "mp2");
4237 opt_format("f", "svcd");
4239 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4240 opt_frame_rate("r", frame_rates[norm]);
4241 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4242 opt_default("g", norm == PAL ? "15" : "18");
4244 opt_default("b", "2040000");
4245 opt_default("maxrate", "2516000");
4246 opt_default("minrate", "0"); //1145000;
4247 opt_default("bufsize", "1835008"); //224*1024*8;
4248 opt_default("flags", "+scan_offset");
4251 opt_default("ab", "224000");
4252 audio_sample_rate = 44100;
4254 opt_default("packetsize", "2324");
4256 } else if(!strcmp(arg, "dvd")) {
4258 opt_codec("vcodec", "mpeg2video");
4259 opt_codec("acodec", "ac3");
4260 opt_format("f", "dvd");
4262 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4263 opt_frame_rate("r", frame_rates[norm]);
4264 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4265 opt_default("g", norm == PAL ? "15" : "18");
4267 opt_default("b", "6000000");
4268 opt_default("maxrate", "9000000");
4269 opt_default("minrate", "0"); //1500000;
4270 opt_default("bufsize", "1835008"); //224*1024*8;
4272 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4273 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4275 opt_default("ab", "448000");
4276 audio_sample_rate = 48000;
4278 } else if(!strncmp(arg, "dv", 2)) {
4280 opt_format("f", "dv");
4282 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4283 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4284 norm == PAL ? "yuv420p" : "yuv411p");
4285 opt_frame_rate("r", frame_rates[norm]);
4287 audio_sample_rate = 48000;
4291 fprintf(stderr, "Unknown target: %s\n", arg);
4292 return AVERROR(EINVAL);
4297 static int opt_vstats_file(const char *opt, const char *arg)
4299 av_free (vstats_filename);
4300 vstats_filename=av_strdup (arg);
4304 static int opt_vstats(const char *opt, const char *arg)
4307 time_t today2 = time(NULL);
4308 struct tm *today = localtime(&today2);
4310 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4312 return opt_vstats_file(opt, filename);
4315 static int opt_bsf(const char *opt, const char *arg)
4317 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4318 AVBitStreamFilterContext **bsfp;
4321 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4325 bsfp= *opt == 'v' ? &video_bitstream_filters :
4326 *opt == 'a' ? &audio_bitstream_filters :
4327 &subtitle_bitstream_filters;
4329 bsfp= &(*bsfp)->next;
4336 static int opt_preset(const char *opt, const char *arg)
4339 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4340 char *codec_name = *opt == 'v' ? video_codec_name :
4341 *opt == 'a' ? audio_codec_name :
4342 subtitle_codec_name;
4344 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4345 fprintf(stderr, "File for preset '%s' not found\n", arg);
4350 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4351 if(line[0] == '#' && !e)
4353 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4355 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4358 if (!strcmp(tmp, "acodec") ||
4359 !strcmp(tmp, "vcodec") ||
4360 !strcmp(tmp, "scodec") ||
4361 !strcmp(tmp, "dcodec")) {
4362 opt_codec(tmp, tmp2);
4363 }else if(opt_default(tmp, tmp2) < 0){
4364 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4374 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4378 static void opt_passlogfile(const char *opt, const char *arg)
4380 pass_logfilename_prefix = arg;
4381 opt_default("passlogfile", arg);
4384 static const OptionDef options[] = {
4386 #include "cmdutils_common_opts.h"
4387 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4388 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4389 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4390 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4391 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4392 "outfile[,metadata]:infile[,metadata]" },
4393 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4394 "outfile[,metadata]:infile[,metadata]" },
4395 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4396 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4397 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4398 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4399 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4400 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4401 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4402 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4403 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4404 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4405 "add timings for benchmarking" },
4406 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4407 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4408 "dump each input packet" },
4409 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4410 "when dumping packets, also dump the payload" },
4411 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4412 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4413 { "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)", "" },
4414 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4415 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4416 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4417 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4418 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4419 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4420 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4421 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4422 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4423 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4424 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4425 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4426 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4429 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4430 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4431 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4432 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4433 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4434 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4435 { "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" },
4436 { "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" },
4437 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4438 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4439 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4440 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4441 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4442 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4443 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4444 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4445 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4446 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4447 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4448 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4449 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4450 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4451 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4452 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4453 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4454 "use same quantizer as source (implies VBR)" },
4455 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4456 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4457 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4458 "deinterlace pictures" },
4459 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4460 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4461 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4463 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4465 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4466 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4467 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4468 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4469 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4470 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4471 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4472 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4473 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4474 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4475 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4478 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4479 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4480 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4481 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4482 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4483 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4484 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4485 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4486 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4487 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4488 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4489 { "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" },
4491 /* subtitle options */
4492 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4493 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4494 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4495 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4496 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4499 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4500 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4501 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4504 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4505 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4507 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4508 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4509 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4511 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4512 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4513 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4514 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4515 /* data codec support */
4516 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4518 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4522 int main(int argc, char **argv)
4526 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4528 if(argc>1 && !strcmp(argv[1], "-d")){
4531 av_log_set_callback(log_callback_null);
4536 avcodec_register_all();
4538 avdevice_register_all();
4541 avfilter_register_all();
4546 if(isatty(STDIN_FILENO))
4547 avio_set_interrupt_cb(decode_interrupt_cb);
4556 parse_options(argc, argv, options, opt_output_file);
4558 if(nb_output_files <= 0 && nb_input_files == 0) {
4560 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4564 /* file converter / grab */
4565 if (nb_output_files <= 0) {
4566 fprintf(stderr, "At least one output file must be specified\n");
4570 if (nb_input_files == 0) {
4571 fprintf(stderr, "At least one input file must be specified\n");
4576 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4577 stream_maps, nb_stream_maps) < 0)
4579 ti = getutime() - ti;
4581 int maxrss = getmaxrss() / 1024;
4582 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4585 return ffmpeg_exit(0);