3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/vsink_buffer.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "ffmpeg";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
97 int sync_stream_index;
101 * select an input file for an output file
103 typedef struct MetadataMap {
104 int file; ///< file index
105 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
106 int index; ///< stream/chapter/program number
109 typedef struct ChapterMap {
114 static const OptionDef options[];
116 #define MAX_FILES 100
117 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static double *ts_scale;
120 static int nb_ts_scale;
122 static AVFormatContext *output_files[MAX_FILES];
123 static AVDictionary *output_opts[MAX_FILES];
124 static int nb_output_files = 0;
126 static StreamMap *stream_maps = NULL;
127 static int nb_stream_maps;
129 /* first item specifies output metadata, second is input */
130 static MetadataMap (*meta_data_maps)[2] = NULL;
131 static int nb_meta_data_maps;
132 static int metadata_global_autocopy = 1;
133 static int metadata_streams_autocopy = 1;
134 static int metadata_chapters_autocopy = 1;
136 static ChapterMap *chapter_maps = NULL;
137 static int nb_chapter_maps;
139 /* indexed by output file stream index */
140 static int *streamid_map = NULL;
141 static int nb_streamid_map = 0;
143 static int frame_width = 0;
144 static int frame_height = 0;
145 static float frame_aspect_ratio = 0;
146 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
147 static int frame_bits_per_raw_sample = 0;
148 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
149 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
150 static AVRational frame_rate;
151 static float video_qscale = 0;
152 static uint16_t *intra_matrix = NULL;
153 static uint16_t *inter_matrix = NULL;
154 static const char *video_rc_override_string=NULL;
155 static int video_disable = 0;
156 static int video_discard = 0;
157 static char *video_codec_name = NULL;
158 static unsigned int video_codec_tag = 0;
159 static char *video_language = NULL;
160 static int same_quality = 0;
161 static int do_deinterlace = 0;
162 static int top_field_first = -1;
163 static int me_threshold = 0;
164 static int intra_dc_precision = 8;
165 static int loop_input = 0;
166 static int loop_output = AVFMT_NOOUTPUTLOOP;
167 static int qp_hist = 0;
169 static char *vfilters = NULL;
172 static int intra_only = 0;
173 static int audio_sample_rate = 0;
174 #define QSCALE_NONE -99999
175 static float audio_qscale = QSCALE_NONE;
176 static int audio_disable = 0;
177 static int audio_channels = 0;
178 static char *audio_codec_name = NULL;
179 static unsigned int audio_codec_tag = 0;
180 static char *audio_language = NULL;
182 static int subtitle_disable = 0;
183 static char *subtitle_codec_name = NULL;
184 static char *subtitle_language = NULL;
185 static unsigned int subtitle_codec_tag = 0;
187 static int data_disable = 0;
188 static char *data_codec_name = NULL;
189 static unsigned int data_codec_tag = 0;
191 static float mux_preload= 0.5;
192 static float mux_max_delay= 0.7;
194 static int64_t recording_time = INT64_MAX;
195 static int64_t start_time = 0;
196 static int64_t input_ts_offset = 0;
197 static int file_overwrite = 0;
198 static AVDictionary *metadata;
199 static int do_benchmark = 0;
200 static int do_hex_dump = 0;
201 static int do_pkt_dump = 0;
202 static int do_psnr = 0;
203 static int do_pass = 0;
204 static const char *pass_logfilename_prefix;
205 static int audio_stream_copy = 0;
206 static int video_stream_copy = 0;
207 static int subtitle_stream_copy = 0;
208 static int data_stream_copy = 0;
209 static int video_sync_method= -1;
210 static int audio_sync_method= 0;
211 static float audio_drift_threshold= 0.1;
212 static int copy_ts= 0;
213 static int copy_tb= 0;
214 static int opt_shortest = 0;
215 static char *vstats_filename;
216 static FILE *vstats_file;
217 static int opt_programid = 0;
218 static int copy_initial_nonkeyframes = 0;
220 static int rate_emu = 0;
222 static int audio_volume = 256;
224 static int exit_on_error = 0;
225 static int using_stdin = 0;
226 static int verbose = 1;
227 static int run_as_daemon = 0;
228 static int thread_count= 1;
229 static int q_pressed = 0;
230 static int64_t video_size = 0;
231 static int64_t audio_size = 0;
232 static int64_t extra_size = 0;
233 static int nb_frames_dup = 0;
234 static int nb_frames_drop = 0;
235 static int input_sync;
236 static uint64_t limit_filesize = 0;
237 static int force_fps = 0;
238 static char *forced_key_frames = NULL;
240 static float dts_delta_threshold = 10;
242 static int64_t timer_start;
244 static uint8_t *audio_buf;
245 static uint8_t *audio_out;
246 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
248 static short *samples;
250 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
251 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
252 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
254 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
258 typedef struct OutputStream {
259 int file_index; /* file index */
260 int index; /* stream index in the output file */
261 int source_index; /* InputStream index */
262 AVStream *st; /* stream in the output file */
263 int encoding_needed; /* true if encoding needed for this stream */
265 /* input pts and corresponding output pts
267 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
268 struct InputStream *sync_ist; /* input stream to sync against */
269 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
270 AVBitStreamFilterContext *bitstream_filters;
275 AVFrame resample_frame; /* temporary frame for image resampling */
276 struct SwsContext *img_resample_ctx; /* for image resampling */
279 int resample_pix_fmt;
280 AVRational frame_rate;
282 float frame_aspect_ratio;
284 /* forced key frames */
285 int64_t *forced_kf_pts;
291 ReSampleContext *resample; /* for audio resampling */
292 int resample_sample_fmt;
293 int resample_channels;
294 int resample_sample_rate;
296 AVAudioConvert *reformat_ctx;
297 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
301 AVFilterContext *output_video_filter;
302 AVFilterContext *input_video_filter;
303 AVFilterBufferRef *picref;
305 AVFilterGraph *graph;
312 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
313 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
315 typedef struct InputStream {
318 int discard; /* true if stream data should be discarded */
319 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
322 int64_t start; /* time when read started */
323 int64_t next_pts; /* synthetic pts for cases where pkt.pts
325 int64_t pts; /* current pts */
327 int is_start; /* is 1 at the start and after a discontinuity */
328 int showed_multi_packet_warning;
329 int is_past_recording_time;
333 typedef struct InputFile {
334 AVFormatContext *ctx;
335 int eof_reached; /* true if eof reached */
336 int ist_index; /* index of first stream in ist_table */
337 int buffer_size; /* current total buffer size */
344 /* init terminal so that we can grab keys */
345 static struct termios oldtty;
348 static InputStream *input_streams = NULL;
349 static int nb_input_streams = 0;
350 static InputFile *input_files = NULL;
351 static int nb_input_files = 0;
355 static int configure_video_filters(InputStream *ist, OutputStream *ost)
357 AVFilterContext *last_filter, *filter;
358 /** filter graph containing all filters including input & output */
359 AVCodecContext *codec = ost->st->codec;
360 AVCodecContext *icodec = ist->st->codec;
361 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
362 AVRational sample_aspect_ratio;
366 ost->graph = avfilter_graph_alloc();
368 if (ist->st->sample_aspect_ratio.num){
369 sample_aspect_ratio = ist->st->sample_aspect_ratio;
371 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
373 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
374 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
375 sample_aspect_ratio.num, sample_aspect_ratio.den);
377 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
378 "src", args, NULL, ost->graph);
381 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
382 "out", NULL, pix_fmts, ost->graph);
385 last_filter = ost->input_video_filter;
387 if (codec->width != icodec->width || codec->height != icodec->height) {
388 snprintf(args, 255, "%d:%d:flags=0x%X",
392 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
393 NULL, args, NULL, ost->graph)) < 0)
395 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
397 last_filter = filter;
400 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
401 ost->graph->scale_sws_opts = av_strdup(args);
404 AVFilterInOut *outputs = avfilter_inout_alloc();
405 AVFilterInOut *inputs = avfilter_inout_alloc();
407 outputs->name = av_strdup("in");
408 outputs->filter_ctx = last_filter;
409 outputs->pad_idx = 0;
410 outputs->next = NULL;
412 inputs->name = av_strdup("out");
413 inputs->filter_ctx = ost->output_video_filter;
417 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
419 av_freep(&ost->avfilter);
421 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
425 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
428 codec->width = ost->output_video_filter->inputs[0]->w;
429 codec->height = ost->output_video_filter->inputs[0]->h;
430 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
431 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
432 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
433 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
437 #endif /* CONFIG_AVFILTER */
439 static void term_exit(void)
441 av_log(NULL, AV_LOG_QUIET, "%s", "");
444 tcsetattr (0, TCSANOW, &oldtty);
448 static volatile int received_sigterm = 0;
451 sigterm_handler(int sig)
453 received_sigterm = sig;
458 static void term_init(void)
468 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
469 |INLCR|IGNCR|ICRNL|IXON);
470 tty.c_oflag |= OPOST;
471 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
472 tty.c_cflag &= ~(CSIZE|PARENB);
477 tcsetattr (0, TCSANOW, &tty);
478 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
482 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
483 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
485 signal(SIGXCPU, sigterm_handler);
489 /* read a key without blocking */
490 static int read_key(void)
505 n = select(1, &rfds, NULL, NULL, &tv);
520 static int decode_interrupt_cb(void)
522 q_pressed += read_key() == 'q';
523 return q_pressed > 1;
526 static int ffmpeg_exit(int ret)
531 for(i=0;i<nb_output_files;i++) {
532 AVFormatContext *s = output_files[i];
533 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
535 avformat_free_context(s);
536 av_free(output_streams_for_file[i]);
537 av_dict_free(&output_opts[i]);
539 for(i=0;i<nb_input_files;i++) {
540 av_close_input_file(input_files[i].ctx);
542 for (i = 0; i < nb_input_streams; i++)
543 av_dict_free(&input_streams[i].opts);
545 av_free(intra_matrix);
546 av_free(inter_matrix);
550 av_free(vstats_filename);
552 av_free(streamid_map);
553 av_free(stream_maps);
554 av_free(meta_data_maps);
556 av_freep(&input_streams);
557 av_freep(&input_files);
559 av_free(video_codec_name);
560 av_free(audio_codec_name);
561 av_free(subtitle_codec_name);
562 av_free(data_codec_name);
567 allocated_audio_buf_size= allocated_audio_out_size= 0;
574 if (received_sigterm) {
576 "Received signal %d: terminating.\n",
577 (int) received_sigterm);
581 exit(ret); /* not all OS-es handle main() return value */
585 static void assert_avoptions(AVDictionary *m)
587 AVDictionaryEntry *t;
588 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
589 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
594 static void assert_codec_experimental(AVCodecContext *c, int encoder)
596 const char *codec_string = encoder ? "encoder" : "decoder";
598 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
599 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
600 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
601 "results.\nAdd '-strict experimental' if you want to use it.\n",
602 codec_string, c->codec->name);
603 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
604 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
605 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
606 codec_string, codec->name);
611 /* similar to ff_dynarray_add() and av_fast_realloc() */
612 static void *grow_array(void *array, int elem_size, int *size, int new_size)
614 if (new_size >= INT_MAX / elem_size) {
615 fprintf(stderr, "Array too big.\n");
618 if (*size < new_size) {
619 uint8_t *tmp = av_realloc(array, new_size*elem_size);
621 fprintf(stderr, "Could not alloc buffer.\n");
624 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
631 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
633 if(codec && codec->sample_fmts){
634 const enum AVSampleFormat *p= codec->sample_fmts;
636 if(*p == st->codec->sample_fmt)
640 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
641 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
642 av_log(NULL, AV_LOG_WARNING,
643 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
644 av_get_sample_fmt_name(st->codec->sample_fmt),
646 av_get_sample_fmt_name(codec->sample_fmts[0]));
647 st->codec->sample_fmt = codec->sample_fmts[0];
652 static void choose_sample_rate(AVStream *st, AVCodec *codec)
654 if(codec && codec->supported_samplerates){
655 const int *p= codec->supported_samplerates;
657 int best_dist=INT_MAX;
659 int dist= abs(st->codec->sample_rate - *p);
660 if(dist < best_dist){
666 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
668 st->codec->sample_rate= best;
672 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
674 if(codec && codec->pix_fmts){
675 const enum PixelFormat *p= codec->pix_fmts;
676 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
677 if(st->codec->codec_id==CODEC_ID_MJPEG){
678 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
679 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
680 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};
684 if(*p == st->codec->pix_fmt)
688 if(st->codec->pix_fmt != PIX_FMT_NONE)
689 av_log(NULL, AV_LOG_WARNING,
690 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
691 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
693 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
694 st->codec->pix_fmt = codec->pix_fmts[0];
699 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
702 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
703 int idx = oc->nb_streams - 1;
706 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
710 output_streams_for_file[file_idx] =
711 grow_array(output_streams_for_file[file_idx],
712 sizeof(*output_streams_for_file[file_idx]),
713 &nb_output_streams_for_file[file_idx],
715 ost = output_streams_for_file[file_idx][idx] =
716 av_mallocz(sizeof(OutputStream));
718 fprintf(stderr, "Could not alloc output stream\n");
721 ost->file_index = file_idx;
726 ost->opts = filter_codec_opts(codec_opts, codec->id, 1);
728 avcodec_get_context_defaults3(st->codec, codec);
730 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
734 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
737 AVFormatContext *ic = NULL;
740 err = avformat_open_input(&ic, filename, NULL, NULL);
743 /* copy stream format */
744 for(i=0;i<ic->nb_streams;i++) {
749 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
750 ost = new_output_stream(s, nb_output_files, codec);
753 // FIXME: a more elegant solution is needed
754 memcpy(st, ic->streams[i], sizeof(AVStream));
755 st->info = av_malloc(sizeof(*st->info));
756 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
757 avcodec_copy_context(st->codec, ic->streams[i]->codec);
759 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
760 if (audio_stream_copy) {
763 choose_sample_fmt(st, codec);
764 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
765 if (video_stream_copy) {
768 choose_pixel_fmt(st, codec);
771 if(st->codec->flags & CODEC_FLAG_BITEXACT)
775 av_close_input_file(ic);
780 get_sync_ipts(const OutputStream *ost)
782 const InputStream *ist = ost->sync_ist;
783 return (double)(ist->pts - start_time)/AV_TIME_BASE;
786 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
790 AVPacket new_pkt= *pkt;
791 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
792 &new_pkt.data, &new_pkt.size,
793 pkt->data, pkt->size,
794 pkt->flags & AV_PKT_FLAG_KEY);
797 new_pkt.destruct= av_destruct_packet;
799 fprintf(stderr, "%s failed for stream %d, codec %s",
800 bsfc->filter->name, pkt->stream_index,
801 avctx->codec ? avctx->codec->name : "copy");
811 ret= av_interleaved_write_frame(s, pkt);
813 print_error("av_interleaved_write_frame()", ret);
818 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
820 static void do_audio_out(AVFormatContext *s,
823 unsigned char *buf, int size)
826 int64_t audio_out_size, audio_buf_size;
827 int64_t allocated_for_size= size;
829 int size_out, frame_bytes, ret, resample_changed;
830 AVCodecContext *enc= ost->st->codec;
831 AVCodecContext *dec= ist->st->codec;
832 int osize = av_get_bytes_per_sample(enc->sample_fmt);
833 int isize = av_get_bytes_per_sample(dec->sample_fmt);
834 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
837 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
838 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
839 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
840 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
841 audio_buf_size*= osize*enc->channels;
843 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
844 if(coded_bps > 8*osize)
845 audio_out_size= audio_out_size * coded_bps / (8*osize);
846 audio_out_size += FF_MIN_BUFFER_SIZE;
848 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
849 fprintf(stderr, "Buffer sizes too large\n");
853 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
854 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
855 if (!audio_buf || !audio_out){
856 fprintf(stderr, "Out of memory in do_audio_out\n");
860 if (enc->channels != dec->channels)
861 ost->audio_resample = 1;
863 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
864 ost->resample_channels != dec->channels ||
865 ost->resample_sample_rate != dec->sample_rate;
867 if ((ost->audio_resample && !ost->resample) || resample_changed) {
868 if (resample_changed) {
869 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",
870 ist->file_index, ist->st->index,
871 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
872 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
873 ost->resample_sample_fmt = dec->sample_fmt;
874 ost->resample_channels = dec->channels;
875 ost->resample_sample_rate = dec->sample_rate;
877 audio_resample_close(ost->resample);
879 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
880 if (audio_sync_method <= 1 &&
881 ost->resample_sample_fmt == enc->sample_fmt &&
882 ost->resample_channels == enc->channels &&
883 ost->resample_sample_rate == enc->sample_rate) {
884 ost->resample = NULL;
885 ost->audio_resample = 0;
887 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
888 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
889 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
890 enc->sample_rate, dec->sample_rate,
891 enc->sample_fmt, dec->sample_fmt,
893 if (!ost->resample) {
894 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
895 dec->channels, dec->sample_rate,
896 enc->channels, enc->sample_rate);
902 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
903 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
904 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
905 if (ost->reformat_ctx)
906 av_audio_convert_free(ost->reformat_ctx);
907 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
908 dec->sample_fmt, 1, NULL, 0);
909 if (!ost->reformat_ctx) {
910 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
911 av_get_sample_fmt_name(dec->sample_fmt),
912 av_get_sample_fmt_name(enc->sample_fmt));
915 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
918 if(audio_sync_method){
919 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
920 - av_fifo_size(ost->fifo)/(enc->channels * 2);
921 double idelta= delta*dec->sample_rate / enc->sample_rate;
922 int byte_delta= ((int)idelta)*2*dec->channels;
924 //FIXME resample delay
925 if(fabs(delta) > 50){
926 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
928 byte_delta= FFMAX(byte_delta, -size);
932 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
937 static uint8_t *input_tmp= NULL;
938 input_tmp= av_realloc(input_tmp, byte_delta + size);
940 if(byte_delta > allocated_for_size - size){
941 allocated_for_size= byte_delta + (int64_t)size;
946 memset(input_tmp, 0, byte_delta);
947 memcpy(input_tmp + byte_delta, buf, size);
951 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
953 }else if(audio_sync_method>1){
954 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
955 av_assert0(ost->audio_resample);
957 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
958 // 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));
959 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
963 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
964 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
966 if (ost->audio_resample) {
968 size_out = audio_resample(ost->resample,
969 (short *)buftmp, (short *)buf,
970 size / (dec->channels * isize));
971 size_out = size_out * enc->channels * osize;
977 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
978 const void *ibuf[6]= {buftmp};
979 void *obuf[6]= {audio_buf};
980 int istride[6]= {isize};
981 int ostride[6]= {osize};
982 int len= size_out/istride[0];
983 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
984 printf("av_audio_convert() failed\n");
990 size_out = len*osize;
993 /* now encode as many frames as possible */
994 if (enc->frame_size > 1) {
995 /* output resampled raw samples */
996 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
997 fprintf(stderr, "av_fifo_realloc2() failed\n");
1000 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1002 frame_bytes = enc->frame_size * osize * enc->channels;
1004 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1006 av_init_packet(&pkt);
1008 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1010 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1012 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1013 (short *)audio_buf);
1015 fprintf(stderr, "Audio encoding failed\n");
1019 pkt.stream_index= ost->index;
1020 pkt.data= audio_out;
1022 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1023 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1024 pkt.flags |= AV_PKT_FLAG_KEY;
1025 write_frame(s, &pkt, enc, ost->bitstream_filters);
1027 ost->sync_opts += enc->frame_size;
1031 av_init_packet(&pkt);
1033 ost->sync_opts += size_out / (osize * enc->channels);
1035 /* output a pcm frame */
1036 /* determine the size of the coded buffer */
1039 size_out = size_out*coded_bps/8;
1041 if(size_out > audio_out_size){
1042 fprintf(stderr, "Internal error, buffer size too small\n");
1046 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1047 ret = avcodec_encode_audio(enc, audio_out, size_out,
1050 fprintf(stderr, "Audio encoding failed\n");
1054 pkt.stream_index= ost->index;
1055 pkt.data= audio_out;
1057 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1058 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1059 pkt.flags |= AV_PKT_FLAG_KEY;
1060 write_frame(s, &pkt, enc, ost->bitstream_filters);
1064 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1066 AVCodecContext *dec;
1067 AVPicture *picture2;
1068 AVPicture picture_tmp;
1071 dec = ist->st->codec;
1073 /* deinterlace : must be done before any resize */
1074 if (do_deinterlace) {
1077 /* create temporary picture */
1078 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1079 buf = av_malloc(size);
1083 picture2 = &picture_tmp;
1084 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1086 if(avpicture_deinterlace(picture2, picture,
1087 dec->pix_fmt, dec->width, dec->height) < 0) {
1088 /* if error, do not deinterlace */
1089 fprintf(stderr, "Deinterlacing failed\n");
1098 if (picture != picture2)
1099 *picture = *picture2;
1103 /* we begin to correct av delay at this threshold */
1104 #define AV_DELAY_MAX 0.100
1106 static void do_subtitle_out(AVFormatContext *s,
1112 static uint8_t *subtitle_out = NULL;
1113 int subtitle_out_max_size = 1024 * 1024;
1114 int subtitle_out_size, nb, i;
1115 AVCodecContext *enc;
1118 if (pts == AV_NOPTS_VALUE) {
1119 fprintf(stderr, "Subtitle packets must have a pts\n");
1125 enc = ost->st->codec;
1127 if (!subtitle_out) {
1128 subtitle_out = av_malloc(subtitle_out_max_size);
1131 /* Note: DVB subtitle need one packet to draw them and one other
1132 packet to clear them */
1133 /* XXX: signal it in the codec context ? */
1134 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1139 for(i = 0; i < nb; i++) {
1140 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1141 // start_display_time is required to be 0
1142 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1143 sub->end_display_time -= sub->start_display_time;
1144 sub->start_display_time = 0;
1145 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1146 subtitle_out_max_size, sub);
1147 if (subtitle_out_size < 0) {
1148 fprintf(stderr, "Subtitle encoding failed\n");
1152 av_init_packet(&pkt);
1153 pkt.stream_index = ost->index;
1154 pkt.data = subtitle_out;
1155 pkt.size = subtitle_out_size;
1156 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1157 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1158 /* XXX: the pts correction is handled here. Maybe handling
1159 it in the codec would be better */
1161 pkt.pts += 90 * sub->start_display_time;
1163 pkt.pts += 90 * sub->end_display_time;
1165 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1169 static int bit_buffer_size= 1024*256;
1170 static uint8_t *bit_buffer= NULL;
1172 static void do_video_out(AVFormatContext *s,
1175 AVFrame *in_picture,
1176 int *frame_size, float quality)
1178 int nb_frames, i, ret, av_unused resample_changed;
1179 AVFrame *final_picture, *formatted_picture;
1180 AVCodecContext *enc, *dec;
1183 enc = ost->st->codec;
1184 dec = ist->st->codec;
1186 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1188 /* by default, we output a single frame */
1193 if(video_sync_method){
1194 double vdelta = sync_ipts - ost->sync_opts;
1195 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1198 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1201 }else if(vdelta>0.6)
1202 ost->sync_opts= lrintf(sync_ipts);
1203 }else if (vdelta > 1.1)
1204 nb_frames = lrintf(vdelta);
1205 //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);
1206 if (nb_frames == 0){
1209 fprintf(stderr, "*** drop!\n");
1210 }else if (nb_frames > 1) {
1211 nb_frames_dup += nb_frames - 1;
1213 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1216 ost->sync_opts= lrintf(sync_ipts);
1218 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1222 formatted_picture = in_picture;
1223 final_picture = formatted_picture;
1225 #if !CONFIG_AVFILTER
1226 resample_changed = ost->resample_width != dec->width ||
1227 ost->resample_height != dec->height ||
1228 ost->resample_pix_fmt != dec->pix_fmt;
1230 if (resample_changed) {
1231 av_log(NULL, AV_LOG_INFO,
1232 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1233 ist->file_index, ist->st->index,
1234 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1235 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1236 ost->resample_width = dec->width;
1237 ost->resample_height = dec->height;
1238 ost->resample_pix_fmt = dec->pix_fmt;
1241 ost->video_resample = dec->width != enc->width ||
1242 dec->height != enc->height ||
1243 dec->pix_fmt != enc->pix_fmt;
1245 if (ost->video_resample) {
1246 final_picture = &ost->resample_frame;
1247 if (!ost->img_resample_ctx || resample_changed) {
1248 /* initialize the destination picture */
1249 if (!ost->resample_frame.data[0]) {
1250 avcodec_get_frame_defaults(&ost->resample_frame);
1251 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1252 enc->width, enc->height)) {
1253 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1257 /* initialize a new scaler context */
1258 sws_freeContext(ost->img_resample_ctx);
1259 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1260 enc->width, enc->height, enc->pix_fmt,
1261 ost->sws_flags, NULL, NULL, NULL);
1262 if (ost->img_resample_ctx == NULL) {
1263 fprintf(stderr, "Cannot get resampling context\n");
1267 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1268 0, ost->resample_height, final_picture->data, final_picture->linesize);
1272 /* duplicates frame if needed */
1273 for(i=0;i<nb_frames;i++) {
1275 av_init_packet(&pkt);
1276 pkt.stream_index= ost->index;
1278 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1279 /* raw pictures are written as AVPicture structure to
1280 avoid any copies. We support temorarily the older
1282 AVFrame* old_frame = enc->coded_frame;
1283 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1284 pkt.data= (uint8_t *)final_picture;
1285 pkt.size= sizeof(AVPicture);
1286 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1287 pkt.flags |= AV_PKT_FLAG_KEY;
1289 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1290 enc->coded_frame = old_frame;
1292 AVFrame big_picture;
1294 big_picture= *final_picture;
1295 /* better than nothing: use input picture interlaced
1297 big_picture.interlaced_frame = in_picture->interlaced_frame;
1298 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1299 if(top_field_first == -1)
1300 big_picture.top_field_first = in_picture->top_field_first;
1302 big_picture.top_field_first = top_field_first;
1305 /* handles sameq here. This is not correct because it may
1306 not be a global option */
1307 big_picture.quality = quality;
1309 big_picture.pict_type = 0;
1310 // big_picture.pts = AV_NOPTS_VALUE;
1311 big_picture.pts= ost->sync_opts;
1312 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1313 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1314 if (ost->forced_kf_index < ost->forced_kf_count &&
1315 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1316 big_picture.pict_type = AV_PICTURE_TYPE_I;
1317 ost->forced_kf_index++;
1319 ret = avcodec_encode_video(enc,
1320 bit_buffer, bit_buffer_size,
1323 fprintf(stderr, "Video encoding failed\n");
1328 pkt.data= bit_buffer;
1330 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1331 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1332 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1333 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1334 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1336 if(enc->coded_frame->key_frame)
1337 pkt.flags |= AV_PKT_FLAG_KEY;
1338 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1341 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1342 // enc->frame_number-1, ret, enc->pict_type);
1343 /* if two pass, output log */
1344 if (ost->logfile && enc->stats_out) {
1345 fprintf(ost->logfile, "%s", enc->stats_out);
1350 ost->frame_number++;
1354 static double psnr(double d){
1355 return -10.0*log(d)/log(10.0);
1358 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1361 AVCodecContext *enc;
1363 double ti1, bitrate, avg_bitrate;
1365 /* this is executed just the first time do_video_stats is called */
1367 vstats_file = fopen(vstats_filename, "w");
1374 enc = ost->st->codec;
1375 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1376 frame_number = ost->frame_number;
1377 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1378 if (enc->flags&CODEC_FLAG_PSNR)
1379 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1381 fprintf(vstats_file,"f_size= %6d ", frame_size);
1382 /* compute pts value */
1383 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1387 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1388 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1389 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1390 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1391 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1395 static void print_report(AVFormatContext **output_files,
1396 OutputStream **ost_table, int nb_ostreams,
1401 AVFormatContext *oc;
1403 AVCodecContext *enc;
1404 int frame_number, vid, i;
1406 int64_t pts = INT64_MAX;
1407 static int64_t last_time = -1;
1408 static int qp_histogram[52];
1410 if (!is_last_report) {
1412 /* display the report every 0.5 seconds */
1413 cur_time = av_gettime();
1414 if (last_time == -1) {
1415 last_time = cur_time;
1418 if ((cur_time - last_time) < 500000)
1420 last_time = cur_time;
1424 oc = output_files[0];
1426 total_size = avio_size(oc->pb);
1427 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1428 total_size= avio_tell(oc->pb);
1432 for(i=0;i<nb_ostreams;i++) {
1435 enc = ost->st->codec;
1436 if (!ost->st->stream_copy && enc->coded_frame)
1437 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1438 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1439 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1441 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1442 float t = (av_gettime()-timer_start) / 1000000.0;
1444 frame_number = ost->frame_number;
1445 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1446 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1448 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1452 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1455 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1457 if (enc->flags&CODEC_FLAG_PSNR){
1459 double error, error_sum=0;
1460 double scale, scale_sum=0;
1461 char type[3]= {'Y','U','V'};
1462 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1465 error= enc->error[j];
1466 scale= enc->width*enc->height*255.0*255.0*frame_number;
1468 error= enc->coded_frame->error[j];
1469 scale= enc->width*enc->height*255.0*255.0;
1474 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1476 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1480 /* compute min output value */
1481 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1482 ost->st->time_base, AV_TIME_BASE_Q));
1485 if (verbose > 0 || is_last_report) {
1486 int hours, mins, secs, us;
1487 secs = pts / AV_TIME_BASE;
1488 us = pts % AV_TIME_BASE;
1494 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1496 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1497 "size=%8.0fkB time=", total_size / 1024.0);
1498 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1499 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1500 (100 * us) / AV_TIME_BASE);
1501 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1502 "bitrate=%6.1fkbits/s", bitrate);
1504 if (nb_frames_dup || nb_frames_drop)
1505 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1506 nb_frames_dup, nb_frames_drop);
1509 fprintf(stderr, "%s \r", buf);
1514 if (is_last_report && verbose >= 0){
1515 int64_t raw= audio_size + video_size + extra_size;
1516 fprintf(stderr, "\n");
1517 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1521 100.0*(total_size - raw)/raw
1526 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1528 int fill_char = 0x00;
1529 if (sample_fmt == AV_SAMPLE_FMT_U8)
1531 memset(buf, fill_char, size);
1534 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1535 static int output_packet(InputStream *ist, int ist_index,
1536 OutputStream **ost_table, int nb_ostreams,
1537 const AVPacket *pkt)
1539 AVFormatContext *os;
1544 void *buffer_to_free = NULL;
1545 static unsigned int samples_size= 0;
1546 AVSubtitle subtitle, *subtitle_to_free;
1547 int64_t pkt_pts = AV_NOPTS_VALUE;
1549 int frame_available;
1554 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1556 if(ist->next_pts == AV_NOPTS_VALUE)
1557 ist->next_pts= ist->pts;
1561 av_init_packet(&avpkt);
1569 if(pkt->dts != AV_NOPTS_VALUE)
1570 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1571 if(pkt->pts != AV_NOPTS_VALUE)
1572 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1574 //while we have more to decode or while the decoder did output something on EOF
1575 while (avpkt.size > 0 || (!pkt && got_output)) {
1576 uint8_t *data_buf, *decoded_data_buf;
1577 int data_size, decoded_data_size;
1579 ist->pts= ist->next_pts;
1581 if(avpkt.size && avpkt.size != pkt->size &&
1582 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1583 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1584 ist->showed_multi_packet_warning=1;
1587 /* decode the packet if needed */
1588 decoded_data_buf = NULL; /* fail safe */
1589 decoded_data_size= 0;
1590 data_buf = avpkt.data;
1591 data_size = avpkt.size;
1592 subtitle_to_free = NULL;
1593 if (ist->decoding_needed) {
1594 switch(ist->st->codec->codec_type) {
1595 case AVMEDIA_TYPE_AUDIO:{
1596 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1597 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1599 samples= av_malloc(samples_size);
1601 decoded_data_size= samples_size;
1602 /* XXX: could avoid copy if PCM 16 bits with same
1603 endianness as CPU */
1604 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1611 got_output = decoded_data_size > 0;
1612 /* Some bug in mpeg audio decoder gives */
1613 /* decoded_data_size < 0, it seems they are overflows */
1615 /* no audio frame */
1618 decoded_data_buf = (uint8_t *)samples;
1619 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1620 (ist->st->codec->sample_rate * ist->st->codec->channels);
1622 case AVMEDIA_TYPE_VIDEO:
1623 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1624 /* XXX: allocate picture correctly */
1625 avcodec_get_frame_defaults(&picture);
1626 avpkt.pts = pkt_pts;
1627 avpkt.dts = ist->pts;
1628 pkt_pts = AV_NOPTS_VALUE;
1630 ret = avcodec_decode_video2(ist->st->codec,
1631 &picture, &got_output, &avpkt);
1632 quality = same_quality ? picture.quality : 0;
1636 /* no picture yet */
1637 goto discard_packet;
1639 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1640 if (ist->st->codec->time_base.num != 0) {
1641 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1642 ist->next_pts += ((int64_t)AV_TIME_BASE *
1643 ist->st->codec->time_base.num * ticks) /
1644 ist->st->codec->time_base.den;
1647 buffer_to_free = NULL;
1648 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1650 case AVMEDIA_TYPE_SUBTITLE:
1651 ret = avcodec_decode_subtitle2(ist->st->codec,
1652 &subtitle, &got_output, &avpkt);
1656 goto discard_packet;
1658 subtitle_to_free = &subtitle;
1665 switch(ist->st->codec->codec_type) {
1666 case AVMEDIA_TYPE_AUDIO:
1667 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1668 ist->st->codec->sample_rate;
1670 case AVMEDIA_TYPE_VIDEO:
1671 if (ist->st->codec->time_base.num != 0) {
1672 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1673 ist->next_pts += ((int64_t)AV_TIME_BASE *
1674 ist->st->codec->time_base.num * ticks) /
1675 ist->st->codec->time_base.den;
1684 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1685 if (start_time == 0 || ist->pts >= start_time) {
1686 for(i=0;i<nb_ostreams;i++) {
1688 if (ost->input_video_filter && ost->source_index == ist_index) {
1689 if (!picture.sample_aspect_ratio.num)
1690 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1691 picture.pts = ist->pts;
1693 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1699 // preprocess audio (volume)
1700 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1701 if (audio_volume != 256) {
1704 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1705 int v = ((*volp) * audio_volume + 128) >> 8;
1706 if (v < -32768) v = -32768;
1707 if (v > 32767) v = 32767;
1713 /* frame rate emulation */
1715 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1716 int64_t now = av_gettime() - ist->start;
1720 /* if output time reached then transcode raw format,
1721 encode packets and output them */
1722 if (start_time == 0 || ist->pts >= start_time)
1723 for(i=0;i<nb_ostreams;i++) {
1727 if (ost->source_index == ist_index) {
1729 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1730 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1731 while (frame_available) {
1732 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1733 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1734 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1737 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1738 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1742 os = output_files[ost->file_index];
1744 /* set the input output pts pairs */
1745 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1747 if (ost->encoding_needed) {
1748 av_assert0(ist->decoding_needed);
1749 switch(ost->st->codec->codec_type) {
1750 case AVMEDIA_TYPE_AUDIO:
1751 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1753 case AVMEDIA_TYPE_VIDEO:
1755 if (ost->picref->video && !ost->frame_aspect_ratio)
1756 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1758 do_video_out(os, ost, ist, &picture, &frame_size,
1759 same_quality ? quality : ost->st->codec->global_quality);
1760 if (vstats_filename && frame_size)
1761 do_video_stats(os, ost, frame_size);
1763 case AVMEDIA_TYPE_SUBTITLE:
1764 do_subtitle_out(os, ost, ist, &subtitle,
1771 AVFrame avframe; //FIXME/XXX remove this
1774 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1776 av_init_packet(&opkt);
1778 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1779 #if !CONFIG_AVFILTER
1785 /* no reencoding needed : output the packet directly */
1786 /* force the input stream PTS */
1788 avcodec_get_frame_defaults(&avframe);
1789 ost->st->codec->coded_frame= &avframe;
1790 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1792 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1793 audio_size += data_size;
1794 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1795 video_size += data_size;
1799 opkt.stream_index= ost->index;
1800 if(pkt->pts != AV_NOPTS_VALUE)
1801 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1803 opkt.pts= AV_NOPTS_VALUE;
1805 if (pkt->dts == AV_NOPTS_VALUE)
1806 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1808 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1809 opkt.dts -= ost_tb_start_time;
1811 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1812 opkt.flags= pkt->flags;
1814 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1815 if( ost->st->codec->codec_id != CODEC_ID_H264
1816 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1817 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1819 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1820 opkt.destruct= av_destruct_packet;
1822 opkt.data = data_buf;
1823 opkt.size = data_size;
1826 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1827 /* store AVPicture in AVPacket, as expected by the output format */
1828 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1829 opkt.data = (uint8_t *)&pict;
1830 opkt.size = sizeof(AVPicture);
1831 opkt.flags |= AV_PKT_FLAG_KEY;
1833 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1834 ost->st->codec->frame_number++;
1835 ost->frame_number++;
1836 av_free_packet(&opkt);
1840 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1841 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1842 avfilter_unref_buffer(ost->picref);
1848 av_free(buffer_to_free);
1849 /* XXX: allocate the subtitles in the codec ? */
1850 if (subtitle_to_free) {
1851 avsubtitle_free(subtitle_to_free);
1852 subtitle_to_free = NULL;
1859 for(i=0;i<nb_ostreams;i++) {
1861 if (ost->source_index == ist_index) {
1862 AVCodecContext *enc= ost->st->codec;
1863 os = output_files[ost->file_index];
1865 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1867 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1870 if (ost->encoding_needed) {
1874 av_init_packet(&pkt);
1875 pkt.stream_index= ost->index;
1877 switch(ost->st->codec->codec_type) {
1878 case AVMEDIA_TYPE_AUDIO:
1879 fifo_bytes = av_fifo_size(ost->fifo);
1881 /* encode any samples remaining in fifo */
1882 if (fifo_bytes > 0) {
1883 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1884 int fs_tmp = enc->frame_size;
1886 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1887 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1888 enc->frame_size = fifo_bytes / (osize * enc->channels);
1890 int frame_bytes = enc->frame_size*osize*enc->channels;
1891 if (allocated_audio_buf_size < frame_bytes)
1893 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1896 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1897 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1898 ost->st->time_base.num, enc->sample_rate);
1899 enc->frame_size = fs_tmp;
1902 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1905 fprintf(stderr, "Audio encoding failed\n");
1909 pkt.flags |= AV_PKT_FLAG_KEY;
1911 case AVMEDIA_TYPE_VIDEO:
1912 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1914 fprintf(stderr, "Video encoding failed\n");
1918 if(enc->coded_frame && enc->coded_frame->key_frame)
1919 pkt.flags |= AV_PKT_FLAG_KEY;
1920 if (ost->logfile && enc->stats_out) {
1921 fprintf(ost->logfile, "%s", enc->stats_out);
1930 pkt.data= bit_buffer;
1932 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1933 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1934 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1944 static void print_sdp(AVFormatContext **avc, int n)
1948 av_sdp_create(avc, n, sdp, sizeof(sdp));
1949 printf("SDP:\n%s\n", sdp);
1953 static int copy_chapters(int infile, int outfile)
1955 AVFormatContext *is = input_files[infile].ctx;
1956 AVFormatContext *os = output_files[outfile];
1959 for (i = 0; i < is->nb_chapters; i++) {
1960 AVChapter *in_ch = is->chapters[i], *out_ch;
1961 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1962 AV_TIME_BASE_Q, in_ch->time_base);
1963 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1964 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1967 if (in_ch->end < ts_off)
1969 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1972 out_ch = av_mallocz(sizeof(AVChapter));
1974 return AVERROR(ENOMEM);
1976 out_ch->id = in_ch->id;
1977 out_ch->time_base = in_ch->time_base;
1978 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1979 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1981 if (metadata_chapters_autocopy)
1982 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1985 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1987 return AVERROR(ENOMEM);
1988 os->chapters[os->nb_chapters - 1] = out_ch;
1993 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1994 AVCodecContext *avctx)
2000 for (p = kf; *p; p++)
2003 ost->forced_kf_count = n;
2004 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2005 if (!ost->forced_kf_pts) {
2006 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2009 for (i = 0; i < n; i++) {
2010 p = i ? strchr(p, ',') + 1 : kf;
2011 t = parse_time_or_die("force_key_frames", p, 1);
2012 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2017 * The following code is the main loop of the file converter
2019 static int transcode(AVFormatContext **output_files,
2020 int nb_output_files,
2021 InputFile *input_files,
2023 StreamMap *stream_maps, int nb_stream_maps)
2025 int ret = 0, i, j, k, n, nb_ostreams = 0, step;
2027 AVFormatContext *is, *os;
2028 AVCodecContext *codec, *icodec;
2029 OutputStream *ost, **ost_table = NULL;
2034 uint8_t no_packet[MAX_FILES]={0};
2035 int no_packet_count=0;
2036 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
2037 int nb_streams[AVMEDIA_TYPE_NB]={0};
2040 for (i = 0; i < nb_input_streams; i++)
2041 input_streams[i].start = av_gettime();
2043 /* output stream init */
2045 for(i=0;i<nb_output_files;i++) {
2046 os = output_files[i];
2047 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2048 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2049 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2050 ret = AVERROR(EINVAL);
2053 nb_ostreams += os->nb_streams;
2055 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2056 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2057 ret = AVERROR(EINVAL);
2061 /* Sanity check the mapping args -- do the input files & streams exist? */
2062 for(i=0;i<nb_stream_maps;i++) {
2063 int fi = stream_maps[i].file_index;
2064 int si = stream_maps[i].stream_index;
2066 if (fi < 0 || fi > nb_input_files - 1 ||
2067 si < 0 || si > input_files[fi].nb_streams - 1) {
2068 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2069 ret = AVERROR(EINVAL);
2072 fi = stream_maps[i].sync_file_index;
2073 si = stream_maps[i].sync_stream_index;
2074 if (fi < 0 || fi > nb_input_files - 1 ||
2075 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2076 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2077 ret = AVERROR(EINVAL);
2082 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2086 for(k=0;k<nb_output_files;k++) {
2087 os = output_files[k];
2088 for(i=0;i<os->nb_streams;i++,n++) {
2089 nb_streams[os->streams[i]->codec->codec_type]++;
2092 for(step=1<<30; step; step>>=1){
2093 int found_streams[AVMEDIA_TYPE_NB]={0};
2094 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2095 nb_frame_threshold[j] += step;
2097 for(j=0; j<nb_input_streams; j++) {
2099 ist = &input_streams[j];
2102 AVFormatContext *f= input_files[ ist->file_index ].ctx;
2104 for(pi=0; pi<f->nb_programs; pi++){
2105 AVProgram *p= f->programs[pi];
2106 if(p->id == opt_programid)
2107 for(si=0; si<p->nb_stream_indexes; si++){
2108 if(f->streams[ p->stream_index[si] ] == ist->st)
2113 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2114 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2115 found_streams[ist->st->codec->codec_type]++;
2118 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2119 if(found_streams[j] < nb_streams[j])
2120 nb_frame_threshold[j] -= step;
2123 for(k=0;k<nb_output_files;k++) {
2124 os = output_files[k];
2125 for(i=0;i<os->nb_streams;i++,n++) {
2127 ost = ost_table[n] = output_streams_for_file[k][i];
2128 if (nb_stream_maps > 0) {
2129 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2130 stream_maps[n].stream_index;
2132 /* Sanity check that the stream types match */
2133 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2134 int i= ost->file_index;
2135 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2136 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2137 stream_maps[n].file_index, stream_maps[n].stream_index,
2138 ost->file_index, ost->index);
2143 /* get corresponding input stream index : we select the first one with the right type */
2145 for (j = 0; j < nb_input_streams; j++) {
2147 ist = &input_streams[j];
2150 AVFormatContext *f = input_files[ist->file_index].ctx;
2152 for(pi=0; pi<f->nb_programs; pi++){
2153 AVProgram *p= f->programs[pi];
2154 if(p->id == opt_programid)
2155 for(si=0; si<p->nb_stream_indexes; si++){
2156 if(f->streams[ p->stream_index[si] ] == ist->st)
2161 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2162 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2163 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2164 ost->source_index = j;
2171 if(! opt_programid) {
2172 /* try again and reuse existing stream */
2173 for (j = 0; j < nb_input_streams; j++) {
2174 ist = &input_streams[j];
2175 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2176 && ist->st->discard != AVDISCARD_ALL) {
2177 ost->source_index = j;
2183 int i= ost->file_index;
2184 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2185 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2186 ost->file_index, ost->index);
2191 ist = &input_streams[ost->source_index];
2193 ost->sync_ist = (nb_stream_maps > 0) ?
2194 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2195 stream_maps[n].sync_stream_index] : ist;
2199 /* for each output stream, we compute the right encoding parameters */
2200 for(i=0;i<nb_ostreams;i++) {
2202 os = output_files[ost->file_index];
2203 ist = &input_streams[ost->source_index];
2205 codec = ost->st->codec;
2206 icodec = ist->st->codec;
2208 if (metadata_streams_autocopy)
2209 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2210 AV_DICT_DONT_OVERWRITE);
2212 ost->st->disposition = ist->st->disposition;
2213 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2214 codec->chroma_sample_location = icodec->chroma_sample_location;
2216 if (ost->st->stream_copy) {
2217 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2219 if (extra_size > INT_MAX)
2222 /* if stream_copy is selected, no need to decode or encode */
2223 codec->codec_id = icodec->codec_id;
2224 codec->codec_type = icodec->codec_type;
2226 if(!codec->codec_tag){
2227 if( !os->oformat->codec_tag
2228 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2229 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2230 codec->codec_tag = icodec->codec_tag;
2233 codec->bit_rate = icodec->bit_rate;
2234 codec->rc_max_rate = icodec->rc_max_rate;
2235 codec->rc_buffer_size = icodec->rc_buffer_size;
2236 codec->extradata= av_mallocz(extra_size);
2237 if (!codec->extradata)
2239 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2240 codec->extradata_size= icodec->extradata_size;
2242 codec->time_base = ist->st->time_base;
2243 if(!strcmp(os->oformat->name, "avi")) {
2244 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2245 codec->time_base = icodec->time_base;
2246 codec->time_base.num *= icodec->ticks_per_frame;
2247 codec->time_base.den *= 2;
2249 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2250 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){
2251 codec->time_base = icodec->time_base;
2252 codec->time_base.num *= icodec->ticks_per_frame;
2255 av_reduce(&codec->time_base.num, &codec->time_base.den,
2256 codec->time_base.num, codec->time_base.den, INT_MAX);
2258 switch(codec->codec_type) {
2259 case AVMEDIA_TYPE_AUDIO:
2260 if(audio_volume != 256) {
2261 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2264 codec->channel_layout = icodec->channel_layout;
2265 codec->sample_rate = icodec->sample_rate;
2266 codec->channels = icodec->channels;
2267 codec->frame_size = icodec->frame_size;
2268 codec->audio_service_type = icodec->audio_service_type;
2269 codec->block_align= icodec->block_align;
2270 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2271 codec->block_align= 0;
2272 if(codec->codec_id == CODEC_ID_AC3)
2273 codec->block_align= 0;
2275 case AVMEDIA_TYPE_VIDEO:
2276 codec->pix_fmt = icodec->pix_fmt;
2277 codec->width = icodec->width;
2278 codec->height = icodec->height;
2279 codec->has_b_frames = icodec->has_b_frames;
2280 if (!codec->sample_aspect_ratio.num) {
2281 codec->sample_aspect_ratio =
2282 ost->st->sample_aspect_ratio =
2283 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2284 ist->st->codec->sample_aspect_ratio.num ?
2285 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2288 case AVMEDIA_TYPE_SUBTITLE:
2289 codec->width = icodec->width;
2290 codec->height = icodec->height;
2292 case AVMEDIA_TYPE_DATA:
2299 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2300 switch(codec->codec_type) {
2301 case AVMEDIA_TYPE_AUDIO:
2302 ost->fifo= av_fifo_alloc(1024);
2305 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2306 if (!codec->sample_rate) {
2307 codec->sample_rate = icodec->sample_rate;
2309 choose_sample_rate(ost->st, ost->enc);
2310 codec->time_base = (AVRational){1, codec->sample_rate};
2311 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2312 codec->sample_fmt = icodec->sample_fmt;
2313 choose_sample_fmt(ost->st, ost->enc);
2314 if (!codec->channels) {
2315 codec->channels = icodec->channels;
2316 codec->channel_layout = icodec->channel_layout;
2318 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2319 codec->channel_layout = 0;
2320 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2321 icodec->request_channels = codec->channels;
2322 ist->decoding_needed = 1;
2323 ost->encoding_needed = 1;
2324 ost->resample_sample_fmt = icodec->sample_fmt;
2325 ost->resample_sample_rate = icodec->sample_rate;
2326 ost->resample_channels = icodec->channels;
2328 case AVMEDIA_TYPE_VIDEO:
2329 if (codec->pix_fmt == PIX_FMT_NONE)
2330 codec->pix_fmt = icodec->pix_fmt;
2331 choose_pixel_fmt(ost->st, ost->enc);
2333 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2334 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2338 if (!codec->width || !codec->height) {
2339 codec->width = icodec->width;
2340 codec->height = icodec->height;
2343 ost->video_resample = codec->width != icodec->width ||
2344 codec->height != icodec->height ||
2345 codec->pix_fmt != icodec->pix_fmt;
2346 if (ost->video_resample) {
2347 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2350 ost->resample_height = icodec->height;
2351 ost->resample_width = icodec->width;
2352 ost->resample_pix_fmt= icodec->pix_fmt;
2353 ost->encoding_needed = 1;
2354 ist->decoding_needed = 1;
2356 if (!ost->frame_rate.num)
2357 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2358 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2359 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2360 ost->frame_rate = ost->enc->supported_framerates[idx];
2362 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2363 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2364 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2365 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2366 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2370 if (configure_video_filters(ist, ost)) {
2371 fprintf(stderr, "Error opening filters!\n");
2376 case AVMEDIA_TYPE_SUBTITLE:
2377 ost->encoding_needed = 1;
2378 ist->decoding_needed = 1;
2385 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2386 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2387 char logfilename[1024];
2390 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2391 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2393 if (codec->flags & CODEC_FLAG_PASS1) {
2394 f = fopen(logfilename, "wb");
2396 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2402 size_t logbuffer_size;
2403 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2404 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2407 codec->stats_in = logbuffer;
2411 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2412 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2413 int size= codec->width * codec->height;
2414 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2419 bit_buffer = av_malloc(bit_buffer_size);
2421 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2423 ret = AVERROR(ENOMEM);
2427 /* open each encoder */
2428 for(i=0;i<nb_ostreams;i++) {
2430 if (ost->encoding_needed) {
2431 AVCodec *codec = ost->enc;
2432 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2434 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2435 ost->st->codec->codec_id, ost->file_index, ost->index);
2436 ret = AVERROR(EINVAL);
2439 if (dec->subtitle_header) {
2440 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2441 if (!ost->st->codec->subtitle_header) {
2442 ret = AVERROR(ENOMEM);
2445 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2446 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2448 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2449 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2450 ost->file_index, ost->index);
2451 ret = AVERROR(EINVAL);
2454 assert_codec_experimental(ost->st->codec, 1);
2455 assert_avoptions(ost->opts);
2456 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2457 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2458 "It takes bits/s as argument, not kbits/s\n");
2459 extra_size += ost->st->codec->extradata_size;
2463 /* open each decoder */
2464 for (i = 0; i < nb_input_streams; i++) {
2465 ist = &input_streams[i];
2466 if (ist->decoding_needed) {
2467 AVCodec *codec = ist->dec;
2469 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2471 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2472 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2473 ret = AVERROR(EINVAL);
2476 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2477 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2478 ist->file_index, ist->st->index);
2479 ret = AVERROR(EINVAL);
2482 assert_codec_experimental(ist->st->codec, 0);
2483 assert_avoptions(ost->opts);
2484 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2485 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2490 for (i = 0; i < nb_input_streams; i++) {
2492 ist = &input_streams[i];
2494 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2495 ist->next_pts = AV_NOPTS_VALUE;
2499 /* set meta data information from input file if required */
2500 for (i=0;i<nb_meta_data_maps;i++) {
2501 AVFormatContext *files[2];
2502 AVDictionary **meta[2];
2505 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2506 if ((index) < 0 || (index) >= (nb_elems)) {\
2507 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2509 ret = AVERROR(EINVAL);\
2513 int out_file_index = meta_data_maps[i][0].file;
2514 int in_file_index = meta_data_maps[i][1].file;
2515 if (in_file_index < 0 || out_file_index < 0)
2517 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2518 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2520 files[0] = output_files[out_file_index];
2521 files[1] = input_files[in_file_index].ctx;
2523 for (j = 0; j < 2; j++) {
2524 MetadataMap *map = &meta_data_maps[i][j];
2526 switch (map->type) {
2528 meta[j] = &files[j]->metadata;
2531 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2532 meta[j] = &files[j]->streams[map->index]->metadata;
2535 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2536 meta[j] = &files[j]->chapters[map->index]->metadata;
2539 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2540 meta[j] = &files[j]->programs[map->index]->metadata;
2545 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2548 /* copy global metadata by default */
2549 if (metadata_global_autocopy) {
2551 for (i = 0; i < nb_output_files; i++)
2552 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2553 AV_DICT_DONT_OVERWRITE);
2556 /* copy chapters according to chapter maps */
2557 for (i = 0; i < nb_chapter_maps; i++) {
2558 int infile = chapter_maps[i].in_file;
2559 int outfile = chapter_maps[i].out_file;
2561 if (infile < 0 || outfile < 0)
2563 if (infile >= nb_input_files) {
2564 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2565 ret = AVERROR(EINVAL);
2568 if (outfile >= nb_output_files) {
2569 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2570 ret = AVERROR(EINVAL);
2573 copy_chapters(infile, outfile);
2576 /* copy chapters from the first input file that has them*/
2577 if (!nb_chapter_maps)
2578 for (i = 0; i < nb_input_files; i++) {
2579 if (!input_files[i].ctx->nb_chapters)
2582 for (j = 0; j < nb_output_files; j++)
2583 if ((ret = copy_chapters(i, j)) < 0)
2588 /* open files and write file headers */
2589 for(i=0;i<nb_output_files;i++) {
2590 os = output_files[i];
2591 if (avformat_write_header(os, &output_opts[i]) < 0) {
2592 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2593 ret = AVERROR(EINVAL);
2596 // assert_avoptions(output_opts[i]);
2597 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2603 /* dump the file output parameters - cannot be done before in case
2605 for(i=0;i<nb_output_files;i++) {
2606 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2609 /* dump the stream mapping */
2611 fprintf(stderr, "Stream mapping:\n");
2612 for(i=0;i<nb_ostreams;i++) {
2614 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2615 input_streams[ost->source_index].file_index,
2616 input_streams[ost->source_index].st->index,
2619 if (ost->sync_ist != &input_streams[ost->source_index])
2620 fprintf(stderr, " [sync #%d.%d]",
2621 ost->sync_ist->file_index,
2622 ost->sync_ist->st->index);
2623 fprintf(stderr, "\n");
2628 fprintf(stderr, "%s\n", error);
2633 print_sdp(output_files, nb_output_files);
2638 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2639 avio_set_interrupt_cb(decode_interrupt_cb);
2643 timer_start = av_gettime();
2645 for(; received_sigterm == 0;) {
2646 int file_index, ist_index;
2654 /* if 'q' pressed, exits */
2658 /* read_key() returns 0 on EOF */
2662 if (key == '+') verbose++;
2663 if (key == '-') verbose--;
2664 if (key == 's') qp_hist ^= 1;
2667 do_hex_dump = do_pkt_dump = 0;
2668 } else if(do_pkt_dump){
2672 av_log_set_level(AV_LOG_DEBUG);
2674 if (key == 'd' || key == 'D'){
2677 debug = input_streams[0].st->codec->debug<<1;
2678 if(!debug) debug = 1;
2679 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2682 scanf("%d", &debug);
2683 for(i=0;i<nb_input_streams;i++) {
2684 input_streams[i].st->codec->debug = debug;
2686 for(i=0;i<nb_ostreams;i++) {
2688 ost->st->codec->debug = debug;
2690 if(debug) av_log_set_level(AV_LOG_DEBUG);
2691 fprintf(stderr,"debug=%d\n", debug);
2694 fprintf(stderr, "key function\n"
2695 "? show this help\n"
2696 "+ increase verbosity\n"
2697 "- decrease verbosity\n"
2698 "D cycle through available debug modes\n"
2699 "h dump packets/hex press to cycle through the 3 states\n"
2701 "s Show QP histogram\n"
2706 /* select the stream that we must read now by looking at the
2707 smallest output pts */
2709 for(i=0;i<nb_ostreams;i++) {
2712 os = output_files[ost->file_index];
2713 ist = &input_streams[ost->source_index];
2714 if(ist->is_past_recording_time || no_packet[ist->file_index])
2716 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2717 ipts = (double)ist->pts;
2718 if (!input_files[ist->file_index].eof_reached){
2719 if(ipts < ipts_min) {
2721 if(input_sync ) file_index = ist->file_index;
2723 if(opts < opts_min) {
2725 if(!input_sync) file_index = ist->file_index;
2728 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2733 /* if none, if is finished */
2734 if (file_index < 0) {
2735 if(no_packet_count){
2737 memset(no_packet, 0, sizeof(no_packet));
2744 /* finish if limit size exhausted */
2745 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2748 /* read a frame from it and output it in the fifo */
2749 is = input_files[file_index].ctx;
2750 ret= av_read_frame(is, &pkt);
2751 if(ret == AVERROR(EAGAIN)){
2752 no_packet[file_index]=1;
2757 input_files[file_index].eof_reached = 1;
2765 memset(no_packet, 0, sizeof(no_packet));
2768 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2769 is->streams[pkt.stream_index]);
2771 /* the following test is needed in case new streams appear
2772 dynamically in stream : we ignore them */
2773 if (pkt.stream_index >= input_files[file_index].nb_streams)
2774 goto discard_packet;
2775 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2776 ist = &input_streams[ist_index];
2778 goto discard_packet;
2780 if (pkt.dts != AV_NOPTS_VALUE)
2781 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2782 if (pkt.pts != AV_NOPTS_VALUE)
2783 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2785 if (ist->ts_scale) {
2786 if(pkt.pts != AV_NOPTS_VALUE)
2787 pkt.pts *= ist->ts_scale;
2788 if(pkt.dts != AV_NOPTS_VALUE)
2789 pkt.dts *= ist->ts_scale;
2792 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2793 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2794 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2795 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2796 int64_t delta= pkt_dts - ist->next_pts;
2797 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2798 input_files[ist->file_index].ts_offset -= delta;
2800 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2801 delta, input_files[ist->file_index].ts_offset);
2802 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2803 if(pkt.pts != AV_NOPTS_VALUE)
2804 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2808 /* finish if recording time exhausted */
2809 if (recording_time != INT64_MAX &&
2810 (pkt.pts != AV_NOPTS_VALUE ?
2811 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2813 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2815 ist->is_past_recording_time = 1;
2816 goto discard_packet;
2819 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2820 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2823 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2824 ist->file_index, ist->st->index);
2827 av_free_packet(&pkt);
2832 av_free_packet(&pkt);
2834 /* dump report by using the output first video and audio streams */
2835 print_report(output_files, ost_table, nb_ostreams, 0);
2838 /* at the end of stream, we must flush the decoder buffers */
2839 for (i = 0; i < nb_input_streams; i++) {
2840 ist = &input_streams[i];
2841 if (ist->decoding_needed) {
2842 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2848 /* write the trailer if needed and close file */
2849 for(i=0;i<nb_output_files;i++) {
2850 os = output_files[i];
2851 av_write_trailer(os);
2854 /* dump report by using the first video and audio streams */
2855 print_report(output_files, ost_table, nb_ostreams, 1);
2857 /* close each encoder */
2858 for(i=0;i<nb_ostreams;i++) {
2860 if (ost->encoding_needed) {
2861 av_freep(&ost->st->codec->stats_in);
2862 avcodec_close(ost->st->codec);
2865 avfilter_graph_free(&ost->graph);
2869 /* close each decoder */
2870 for (i = 0; i < nb_input_streams; i++) {
2871 ist = &input_streams[i];
2872 if (ist->decoding_needed) {
2873 avcodec_close(ist->st->codec);
2881 av_freep(&bit_buffer);
2884 for(i=0;i<nb_ostreams;i++) {
2887 if (ost->st->stream_copy)
2888 av_freep(&ost->st->codec->extradata);
2890 fclose(ost->logfile);
2891 ost->logfile = NULL;
2893 av_fifo_free(ost->fifo); /* works even if fifo is not
2894 initialized but set to zero */
2895 av_freep(&ost->st->codec->subtitle_header);
2896 av_free(ost->resample_frame.data[0]);
2897 av_free(ost->forced_kf_pts);
2898 if (ost->video_resample)
2899 sws_freeContext(ost->img_resample_ctx);
2901 audio_resample_close(ost->resample);
2902 if (ost->reformat_ctx)
2903 av_audio_convert_free(ost->reformat_ctx);
2904 av_dict_free(&ost->opts);
2913 static int opt_format(const char *opt, const char *arg)
2915 last_asked_format = arg;
2919 static int opt_video_rc_override_string(const char *opt, const char *arg)
2921 video_rc_override_string = arg;
2925 static int opt_me_threshold(const char *opt, const char *arg)
2927 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2931 static int opt_verbose(const char *opt, const char *arg)
2933 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2937 static int opt_frame_rate(const char *opt, const char *arg)
2939 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2940 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2946 static int opt_frame_crop(const char *opt, const char *arg)
2948 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2949 return AVERROR(EINVAL);
2952 static int opt_frame_size(const char *opt, const char *arg)
2954 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2955 fprintf(stderr, "Incorrect frame size\n");
2956 return AVERROR(EINVAL);
2961 static int opt_pad(const char *opt, const char *arg) {
2962 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2966 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2968 if (strcmp(arg, "list")) {
2969 frame_pix_fmt = av_get_pix_fmt(arg);
2970 if (frame_pix_fmt == PIX_FMT_NONE) {
2971 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2972 return AVERROR(EINVAL);
2975 opt_pix_fmts(NULL, NULL);
2981 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2988 p = strchr(arg, ':');
2990 x = strtol(arg, &end, 10);
2992 y = strtol(end+1, &end, 10);
2994 ar = (double)x / (double)y;
2996 ar = strtod(arg, NULL);
2999 fprintf(stderr, "Incorrect aspect ratio specification.\n");
3000 return AVERROR(EINVAL);
3002 frame_aspect_ratio = ar;
3006 static int opt_metadata(const char *opt, const char *arg)
3008 char *mid= strchr(arg, '=');
3011 fprintf(stderr, "Missing =\n");
3016 av_dict_set(&metadata, arg, mid, 0);
3021 static int opt_qscale(const char *opt, const char *arg)
3023 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
3024 if (video_qscale <= 0 || video_qscale > 255) {
3025 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
3026 return AVERROR(EINVAL);
3031 static int opt_top_field_first(const char *opt, const char *arg)
3033 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
3034 return opt_default(opt, arg);
3037 static int opt_thread_count(const char *opt, const char *arg)
3039 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3042 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
3047 static int opt_audio_sample_fmt(const char *opt, const char *arg)
3049 if (strcmp(arg, "list")) {
3050 audio_sample_fmt = av_get_sample_fmt(arg);
3051 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3052 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3053 return AVERROR(EINVAL);
3058 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3059 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3065 static int opt_audio_rate(const char *opt, const char *arg)
3067 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3071 static int opt_audio_channels(const char *opt, const char *arg)
3073 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3077 static int opt_video_channel(const char *opt, const char *arg)
3079 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3080 return opt_default("channel", arg);
3083 static int opt_video_standard(const char *opt, const char *arg)
3085 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3086 return opt_default("standard", arg);
3089 static int opt_codec(const char *opt, const char *arg)
3091 int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3093 if (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy; pcodec_name = &audio_codec_name; codec_type = AVMEDIA_TYPE_AUDIO; }
3094 else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy; pcodec_name = &video_codec_name; codec_type = AVMEDIA_TYPE_VIDEO; }
3095 else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3096 else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy; pcodec_name = &data_codec_name; codec_type = AVMEDIA_TYPE_DATA; }
3098 av_freep(pcodec_name);
3099 if (!strcmp(arg, "copy")) {
3102 *pcodec_name = av_strdup(arg);
3107 static int opt_codec_tag(const char *opt, const char *arg)
3110 uint32_t *codec_tag;
3112 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3113 !strcmp(opt, "vtag") ? &video_codec_tag :
3114 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3118 *codec_tag = strtol(arg, &tail, 0);
3120 *codec_tag = AV_RL32(arg);
3125 static int opt_map(const char *opt, const char *arg)
3130 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3131 m = &stream_maps[nb_stream_maps-1];
3133 m->file_index = strtol(arg, &p, 0);
3137 m->stream_index = strtol(p, &p, 0);
3140 m->sync_file_index = strtol(p, &p, 0);
3143 m->sync_stream_index = strtol(p, &p, 0);
3145 m->sync_file_index = m->file_index;
3146 m->sync_stream_index = m->stream_index;
3151 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3162 *index = strtol(++arg, endptr, 0);
3165 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3172 static int opt_map_metadata(const char *opt, const char *arg)
3174 MetadataMap *m, *m1;
3177 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3178 &nb_meta_data_maps, nb_meta_data_maps + 1);
3180 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3181 m->file = strtol(arg, &p, 0);
3182 parse_meta_type(p, &m->type, &m->index, &p);
3186 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3187 m1->file = strtol(p, &p, 0);
3188 parse_meta_type(p, &m1->type, &m1->index, &p);
3190 if (m->type == 'g' || m1->type == 'g')
3191 metadata_global_autocopy = 0;
3192 if (m->type == 's' || m1->type == 's')
3193 metadata_streams_autocopy = 0;
3194 if (m->type == 'c' || m1->type == 'c')
3195 metadata_chapters_autocopy = 0;
3200 static int opt_map_meta_data(const char *opt, const char *arg)
3202 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3203 "Use -map_metadata instead.\n");
3204 return opt_map_metadata(opt, arg);
3207 static int opt_map_chapters(const char *opt, const char *arg)
3212 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3213 nb_chapter_maps + 1);
3214 c = &chapter_maps[nb_chapter_maps - 1];
3215 c->out_file = strtol(arg, &p, 0);
3219 c->in_file = strtol(p, &p, 0);
3223 static int opt_input_ts_scale(const char *opt, const char *arg)
3225 unsigned int stream;
3229 stream = strtol(arg, &p, 0);
3232 scale= strtod(p, &p);
3234 if(stream >= MAX_STREAMS)
3237 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3238 ts_scale[stream] = scale;
3242 static int opt_recording_time(const char *opt, const char *arg)
3244 recording_time = parse_time_or_die(opt, arg, 1);
3248 static int opt_start_time(const char *opt, const char *arg)
3250 start_time = parse_time_or_die(opt, arg, 1);
3254 static int opt_recording_timestamp(const char *opt, const char *arg)
3257 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3258 struct tm time = *gmtime((time_t*)&recording_timestamp);
3259 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3260 opt_metadata("metadata", buf);
3262 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3263 "tag instead.\n", opt);
3267 static int opt_input_ts_offset(const char *opt, const char *arg)
3269 input_ts_offset = parse_time_or_die(opt, arg, 1);
3273 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3275 const char *codec_string = encoder ? "encoder" : "decoder";
3279 return CODEC_ID_NONE;
3281 avcodec_find_encoder_by_name(name) :
3282 avcodec_find_decoder_by_name(name);
3284 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3287 if(codec->type != type) {
3288 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3294 static int opt_input_file(const char *opt, const char *filename)
3296 AVFormatContext *ic;
3297 AVInputFormat *file_iformat = NULL;
3298 int err, i, ret, rfps, rfps_base;
3301 AVDictionary **opts;
3302 int orig_nb_streams; // number of streams before avformat_find_stream_info
3304 if (last_asked_format) {
3305 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3306 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3309 last_asked_format = NULL;
3312 if (!strcmp(filename, "-"))
3315 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3316 !strcmp(filename, "/dev/stdin");
3318 /* get default parameters from command line */
3319 ic = avformat_alloc_context();
3321 print_error(filename, AVERROR(ENOMEM));
3324 if (audio_sample_rate) {
3325 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3326 av_dict_set(&format_opts, "sample_rate", buf, 0);
3328 if (audio_channels) {
3329 snprintf(buf, sizeof(buf), "%d", audio_channels);
3330 av_dict_set(&format_opts, "channels", buf, 0);
3332 if (frame_rate.num) {
3333 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3334 av_dict_set(&format_opts, "framerate", buf, 0);
3336 if (frame_width && frame_height) {
3337 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3338 av_dict_set(&format_opts, "video_size", buf, 0);
3340 if (frame_pix_fmt != PIX_FMT_NONE)
3341 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3343 ic->video_codec_id =
3344 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3345 ic->audio_codec_id =
3346 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3347 ic->subtitle_codec_id=
3348 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3349 ic->flags |= AVFMT_FLAG_NONBLOCK;
3352 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3353 ic->loop_input = loop_input;
3356 /* open the input file with generic libav function */
3357 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3359 print_error(filename, err);
3362 assert_avoptions(format_opts);
3367 for(i=0; i<ic->nb_streams; i++){
3368 ic->streams[i]->discard= AVDISCARD_ALL;
3370 for(i=0; i<ic->nb_programs; i++){
3371 AVProgram *p= ic->programs[i];
3372 if(p->id != opt_programid){
3373 p->discard = AVDISCARD_ALL;
3376 for(j=0; j<p->nb_stream_indexes; j++){
3377 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3382 fprintf(stderr, "Specified program id not found\n");
3388 /* Set AVCodecContext options for avformat_find_stream_info */
3389 opts = setup_find_stream_info_opts(ic, codec_opts);
3390 orig_nb_streams = ic->nb_streams;
3392 /* If not enough info to get the stream parameters, we decode the
3393 first frames to get it. (used in mpeg case for example) */
3394 ret = avformat_find_stream_info(ic, opts);
3395 if (ret < 0 && verbose >= 0) {
3396 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3397 av_close_input_file(ic);
3401 timestamp = start_time;
3402 /* add the stream start time */
3403 if (ic->start_time != AV_NOPTS_VALUE)
3404 timestamp += ic->start_time;
3406 /* if seeking requested, we execute it */
3407 if (start_time != 0) {
3408 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3410 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3411 filename, (double)timestamp / AV_TIME_BASE);
3413 /* reset seek info */
3417 /* update the current parameters so that they match the one of the input stream */
3418 for(i=0;i<ic->nb_streams;i++) {
3419 AVStream *st = ic->streams[i];
3420 AVCodecContext *dec = st->codec;
3423 dec->thread_count = thread_count;
3425 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3426 ist = &input_streams[nb_input_streams - 1];
3428 ist->file_index = nb_input_files;
3430 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3432 if (i < nb_ts_scale)
3433 ist->ts_scale = ts_scale[i];
3435 switch (dec->codec_type) {
3436 case AVMEDIA_TYPE_AUDIO:
3437 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3439 ist->dec = avcodec_find_decoder(dec->codec_id);
3441 st->discard= AVDISCARD_ALL;
3443 case AVMEDIA_TYPE_VIDEO:
3444 ist->dec= avcodec_find_decoder_by_name(video_codec_name);
3446 ist->dec = avcodec_find_decoder(dec->codec_id);
3447 rfps = ic->streams[i]->r_frame_rate.num;
3448 rfps_base = ic->streams[i]->r_frame_rate.den;
3450 dec->flags |= CODEC_FLAG_EMU_EDGE;
3453 dec->debug |= FF_DEBUG_MV;
3455 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3458 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3459 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3461 (float)rfps / rfps_base, rfps, rfps_base);
3465 st->discard= AVDISCARD_ALL;
3466 else if(video_discard)
3467 st->discard= video_discard;
3469 case AVMEDIA_TYPE_DATA:
3471 case AVMEDIA_TYPE_SUBTITLE:
3472 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3474 ist->dec = avcodec_find_decoder(dec->codec_id);
3475 if(subtitle_disable)
3476 st->discard = AVDISCARD_ALL;
3478 case AVMEDIA_TYPE_ATTACHMENT:
3479 case AVMEDIA_TYPE_UNKNOWN:
3486 /* dump the file content */
3488 av_dump_format(ic, nb_input_files, filename, 0);
3490 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3491 input_files[nb_input_files - 1].ctx = ic;
3492 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3493 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3494 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3496 top_field_first = -1;
3497 frame_rate = (AVRational){0, 0};
3498 frame_pix_fmt = PIX_FMT_NONE;
3501 audio_sample_rate = 0;
3503 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3504 av_freep(&ts_scale);
3507 for (i = 0; i < orig_nb_streams; i++)
3508 av_dict_free(&opts[i]);
3510 av_freep(&video_codec_name);
3511 av_freep(&audio_codec_name);
3512 av_freep(&subtitle_codec_name);
3518 static void check_inputs(int *has_video_ptr,
3520 int *has_subtitle_ptr,
3523 int has_video, has_audio, has_subtitle, has_data, i, j;
3524 AVFormatContext *ic;
3531 for(j=0;j<nb_input_files;j++) {
3532 ic = input_files[j].ctx;
3533 for(i=0;i<ic->nb_streams;i++) {
3534 AVCodecContext *enc = ic->streams[i]->codec;
3535 switch(enc->codec_type) {
3536 case AVMEDIA_TYPE_AUDIO:
3539 case AVMEDIA_TYPE_VIDEO:
3542 case AVMEDIA_TYPE_SUBTITLE:
3545 case AVMEDIA_TYPE_DATA:
3546 case AVMEDIA_TYPE_ATTACHMENT:
3547 case AVMEDIA_TYPE_UNKNOWN:
3555 *has_video_ptr = has_video;
3556 *has_audio_ptr = has_audio;
3557 *has_subtitle_ptr = has_subtitle;
3558 *has_data_ptr = has_data;
3561 static void new_video_stream(AVFormatContext *oc, int file_idx)
3565 AVCodecContext *video_enc;
3566 enum CodecID codec_id = CODEC_ID_NONE;
3567 AVCodec *codec= NULL;
3569 if(!video_stream_copy){
3570 if (video_codec_name) {
3571 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3572 codec = avcodec_find_encoder_by_name(video_codec_name);
3574 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3575 codec = avcodec_find_encoder(codec_id);
3579 ost = new_output_stream(oc, file_idx, codec);
3581 if (!video_stream_copy) {
3582 ost->frame_aspect_ratio = frame_aspect_ratio;
3583 frame_aspect_ratio = 0;
3585 ost->avfilter = vfilters;
3590 ost->bitstream_filters = video_bitstream_filters;
3591 video_bitstream_filters= NULL;
3593 st->codec->thread_count= thread_count;
3595 video_enc = st->codec;
3598 video_enc->codec_tag= video_codec_tag;
3600 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3601 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3604 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3605 if (video_stream_copy) {
3606 st->stream_copy = 1;
3607 video_enc->sample_aspect_ratio =
3608 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3614 ost->frame_rate = frame_rate;
3615 video_enc->codec_id = codec_id;
3617 video_enc->width = frame_width;
3618 video_enc->height = frame_height;
3619 video_enc->pix_fmt = frame_pix_fmt;
3620 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3621 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3624 video_enc->gop_size = 0;
3625 if (video_qscale || same_quality) {
3626 video_enc->flags |= CODEC_FLAG_QSCALE;
3627 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3631 video_enc->intra_matrix = intra_matrix;
3633 video_enc->inter_matrix = inter_matrix;
3635 p= video_rc_override_string;
3638 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3640 fprintf(stderr, "error parsing rc_override\n");
3643 video_enc->rc_override=
3644 av_realloc(video_enc->rc_override,
3645 sizeof(RcOverride)*(i+1));
3646 video_enc->rc_override[i].start_frame= start;
3647 video_enc->rc_override[i].end_frame = end;
3649 video_enc->rc_override[i].qscale= q;
3650 video_enc->rc_override[i].quality_factor= 1.0;
3653 video_enc->rc_override[i].qscale= 0;
3654 video_enc->rc_override[i].quality_factor= -q/100.0;
3659 video_enc->rc_override_count=i;
3660 if (!video_enc->rc_initial_buffer_occupancy)
3661 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3662 video_enc->me_threshold= me_threshold;
3663 video_enc->intra_dc_precision= intra_dc_precision - 8;
3666 video_enc->flags|= CODEC_FLAG_PSNR;
3671 video_enc->flags |= CODEC_FLAG_PASS1;
3673 video_enc->flags |= CODEC_FLAG_PASS2;
3677 if (forced_key_frames)
3678 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3680 if (video_language) {
3681 av_dict_set(&st->metadata, "language", video_language, 0);
3682 av_freep(&video_language);
3685 /* reset some key parameters */
3687 av_freep(&video_codec_name);
3688 av_freep(&forced_key_frames);
3689 video_stream_copy = 0;
3690 frame_pix_fmt = PIX_FMT_NONE;
3693 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3697 AVCodec *codec= NULL;
3698 AVCodecContext *audio_enc;
3699 enum CodecID codec_id = CODEC_ID_NONE;
3701 if(!audio_stream_copy){
3702 if (audio_codec_name) {
3703 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3704 codec = avcodec_find_encoder_by_name(audio_codec_name);
3706 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3707 codec = avcodec_find_encoder(codec_id);
3710 ost = new_output_stream(oc, file_idx, codec);
3713 ost->bitstream_filters = audio_bitstream_filters;
3714 audio_bitstream_filters= NULL;
3716 st->codec->thread_count= thread_count;
3718 audio_enc = st->codec;
3719 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3722 audio_enc->codec_tag= audio_codec_tag;
3724 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3725 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3727 if (audio_stream_copy) {
3728 st->stream_copy = 1;
3730 audio_enc->codec_id = codec_id;
3732 if (audio_qscale > QSCALE_NONE) {
3733 audio_enc->flags |= CODEC_FLAG_QSCALE;
3734 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3737 audio_enc->channels = audio_channels;
3738 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3739 audio_enc->sample_fmt = audio_sample_fmt;
3740 if (audio_sample_rate)
3741 audio_enc->sample_rate = audio_sample_rate;
3743 if (audio_language) {
3744 av_dict_set(&st->metadata, "language", audio_language, 0);
3745 av_freep(&audio_language);
3748 /* reset some key parameters */
3750 av_freep(&audio_codec_name);
3751 audio_stream_copy = 0;
3754 static void new_data_stream(AVFormatContext *oc, int file_idx)
3758 AVCodecContext *data_enc;
3760 ost = new_output_stream(oc, file_idx, NULL);
3762 data_enc = st->codec;
3763 if (!data_stream_copy) {
3764 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3768 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3771 data_enc->codec_tag= data_codec_tag;
3773 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3774 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3776 if (data_stream_copy) {
3777 st->stream_copy = 1;
3781 av_freep(&data_codec_name);
3782 data_stream_copy = 0;
3785 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3789 AVCodec *codec=NULL;
3790 AVCodecContext *subtitle_enc;
3791 enum CodecID codec_id = CODEC_ID_NONE;
3793 if(!subtitle_stream_copy){
3794 if (subtitle_codec_name) {
3795 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3796 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3798 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3799 codec = avcodec_find_encoder(codec_id);
3802 ost = new_output_stream(oc, file_idx, codec);
3804 subtitle_enc = st->codec;
3806 ost->bitstream_filters = subtitle_bitstream_filters;
3807 subtitle_bitstream_filters= NULL;
3809 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3811 if(subtitle_codec_tag)
3812 subtitle_enc->codec_tag= subtitle_codec_tag;
3814 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3815 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3817 if (subtitle_stream_copy) {
3818 st->stream_copy = 1;
3820 subtitle_enc->codec_id = codec_id;
3823 if (subtitle_language) {
3824 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3825 av_freep(&subtitle_language);
3828 subtitle_disable = 0;
3829 av_freep(&subtitle_codec_name);
3830 subtitle_stream_copy = 0;
3833 static int opt_new_stream(const char *opt, const char *arg)
3835 AVFormatContext *oc;
3836 int file_idx = nb_output_files - 1;
3837 if (nb_output_files <= 0) {
3838 fprintf(stderr, "At least one output file must be specified\n");
3841 oc = output_files[file_idx];
3843 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3844 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3845 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3846 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3851 /* arg format is "output-stream-index:streamid-value". */
3852 static int opt_streamid(const char *opt, const char *arg)
3858 av_strlcpy(idx_str, arg, sizeof(idx_str));
3859 p = strchr(idx_str, ':');
3862 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3867 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3868 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3869 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3873 static int opt_output_file(const char *opt, const char *filename)
3875 AVFormatContext *oc;
3876 int err, use_video, use_audio, use_subtitle, use_data;
3877 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3878 AVOutputFormat *file_oformat;
3880 if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3881 fprintf(stderr, "Too many output files\n");
3885 if (!strcmp(filename, "-"))
3888 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3889 last_asked_format = NULL;
3891 print_error(filename, err);
3894 file_oformat= oc->oformat;
3896 if (!strcmp(file_oformat->name, "ffm") &&
3897 av_strstart(filename, "http:", NULL)) {
3898 /* special case for files sent to ffserver: we get the stream
3899 parameters from ffserver */
3900 int err = read_ffserver_streams(oc, filename);
3902 print_error(filename, err);
3906 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3907 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3908 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3909 use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3911 /* disable if no corresponding type found */
3912 check_inputs(&input_has_video,
3914 &input_has_subtitle,
3917 if (!input_has_video)
3919 if (!input_has_audio)
3921 if (!input_has_subtitle)
3923 if (!input_has_data)
3926 /* manual disable */
3927 if (audio_disable) use_audio = 0;
3928 if (video_disable) use_video = 0;
3929 if (subtitle_disable) use_subtitle = 0;
3930 if (data_disable) use_data = 0;
3932 if (use_video) new_video_stream(oc, nb_output_files);
3933 if (use_audio) new_audio_stream(oc, nb_output_files);
3934 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3935 if (use_data) new_data_stream(oc, nb_output_files);
3937 av_dict_copy(&oc->metadata, metadata, 0);
3938 av_dict_free(&metadata);
3941 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3942 output_files[nb_output_files++] = oc;
3944 /* check filename in case of an image number is expected */
3945 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3946 if (!av_filename_number_test(oc->filename)) {
3947 print_error(oc->filename, AVERROR(EINVAL));
3952 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3953 /* test if it already exists to avoid loosing precious files */
3954 if (!file_overwrite &&
3955 (strchr(filename, ':') == NULL ||
3956 filename[1] == ':' ||
3957 av_strstart(filename, "file:", NULL))) {
3958 if (avio_check(filename, 0) == 0) {
3960 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3962 if (!read_yesno()) {
3963 fprintf(stderr, "Not overwriting - exiting\n");
3968 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3975 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3976 print_error(filename, err);
3981 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3982 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3984 if (loop_output >= 0) {
3985 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3986 oc->loop_output = loop_output;
3989 frame_rate = (AVRational){0, 0};
3992 audio_sample_rate = 0;
3994 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3996 av_freep(&forced_key_frames);
4002 /* same option as mencoder */
4003 static int opt_pass(const char *opt, const char *arg)
4005 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4009 static int64_t getutime(void)
4012 struct rusage rusage;
4014 getrusage(RUSAGE_SELF, &rusage);
4015 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4016 #elif HAVE_GETPROCESSTIMES
4018 FILETIME c, e, k, u;
4019 proc = GetCurrentProcess();
4020 GetProcessTimes(proc, &c, &e, &k, &u);
4021 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4023 return av_gettime();
4027 static int64_t getmaxrss(void)
4029 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4030 struct rusage rusage;
4031 getrusage(RUSAGE_SELF, &rusage);
4032 return (int64_t)rusage.ru_maxrss * 1024;
4033 #elif HAVE_GETPROCESSMEMORYINFO
4035 PROCESS_MEMORY_COUNTERS memcounters;
4036 proc = GetCurrentProcess();
4037 memcounters.cb = sizeof(memcounters);
4038 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4039 return memcounters.PeakPagefileUsage;
4045 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4048 const char *p = str;
4055 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4062 static int opt_inter_matrix(const char *opt, const char *arg)
4064 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4065 parse_matrix_coeffs(inter_matrix, arg);
4069 static int opt_intra_matrix(const char *opt, const char *arg)
4071 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4072 parse_matrix_coeffs(intra_matrix, arg);
4076 static void show_usage(void)
4078 printf("Hyper fast Audio and Video encoder\n");
4079 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4083 static int opt_help(const char *opt, const char *arg)
4086 AVOutputFormat *oformat = NULL;
4087 AVInputFormat *iformat = NULL;
4089 av_log_set_callback(log_callback_help);
4091 show_help_options(options, "Main options:\n",
4092 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4093 show_help_options(options, "\nAdvanced options:\n",
4094 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4096 show_help_options(options, "\nVideo options:\n",
4097 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4099 show_help_options(options, "\nAdvanced Video options:\n",
4100 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4101 OPT_VIDEO | OPT_EXPERT);
4102 show_help_options(options, "\nAudio options:\n",
4103 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4105 show_help_options(options, "\nAdvanced Audio options:\n",
4106 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4107 OPT_AUDIO | OPT_EXPERT);
4108 show_help_options(options, "\nSubtitle options:\n",
4109 OPT_SUBTITLE | OPT_GRAB,
4111 show_help_options(options, "\nAudio/Video grab options:\n",
4115 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4118 /* individual codec options */
4120 while ((c = av_codec_next(c))) {
4121 if (c->priv_class) {
4122 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4127 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4130 /* individual muxer options */
4131 while ((oformat = av_oformat_next(oformat))) {
4132 if (oformat->priv_class) {
4133 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4138 /* individual demuxer options */
4139 while ((iformat = av_iformat_next(iformat))) {
4140 if (iformat->priv_class) {
4141 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4146 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 int opt_passlogfile(const char *opt, const char *arg)
4380 pass_logfilename_prefix = arg;
4381 return 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}, "deprecated, use -loop" },
4413 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
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 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4430 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4431 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4432 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4433 { "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" },
4434 { "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" },
4435 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4436 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4437 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4438 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4439 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4440 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4441 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4442 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4443 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4444 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4445 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4446 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4447 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4448 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4449 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4450 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4451 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4452 "use same quantizer as source (implies VBR)" },
4453 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4454 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4455 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4456 "deinterlace pictures" },
4457 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4458 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4459 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4461 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4463 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4464 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4465 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4466 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4467 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4468 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4469 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4470 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4471 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4472 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4473 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4476 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4477 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4478 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4479 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4480 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4481 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4482 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4483 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4484 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4485 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4486 { "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" },
4488 /* subtitle options */
4489 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4490 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4491 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4492 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4493 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4496 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4497 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4498 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4501 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4502 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4504 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4505 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4506 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4508 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4509 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4510 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4511 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4512 /* data codec support */
4513 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4515 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4519 int main(int argc, char **argv)
4523 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4525 if(argc>1 && !strcmp(argv[1], "-d")){
4528 av_log_set_callback(log_callback_null);
4533 avcodec_register_all();
4535 avdevice_register_all();
4538 avfilter_register_all();
4543 if(isatty(STDIN_FILENO))
4544 avio_set_interrupt_cb(decode_interrupt_cb);
4553 parse_options(argc, argv, options, opt_output_file);
4555 if(nb_output_files <= 0 && nb_input_files == 0) {
4557 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4561 /* file converter / grab */
4562 if (nb_output_files <= 0) {
4563 fprintf(stderr, "At least one output file must be specified\n");
4567 if (nb_input_files == 0) {
4568 fprintf(stderr, "At least one input file must be specified\n");
4573 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4574 stream_maps, nb_stream_maps) < 0)
4576 ti = getutime() - ti;
4578 int maxrss = getmaxrss() / 1024;
4579 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4582 return ffmpeg_exit(0);