3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "ffmpeg";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
85 int sync_stream_index;
89 * select an input file for an output file
91 typedef struct MetadataMap {
92 int file; //< file index
93 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
94 int index; //< stream/chapter/program number
97 typedef struct ChapterMap {
102 static const OptionDef options[];
104 #define MAX_FILES 100
105 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
107 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
109 static const char *last_asked_format = NULL;
110 static double *ts_scale;
111 static int nb_ts_scale;
113 static AVFormatContext *output_files[MAX_FILES];
114 static AVDictionary *output_opts[MAX_FILES];
115 static int nb_output_files = 0;
117 static StreamMap *stream_maps = NULL;
118 static int nb_stream_maps;
120 /* first item specifies output metadata, second is input */
121 static MetadataMap (*meta_data_maps)[2] = NULL;
122 static int nb_meta_data_maps;
123 static int metadata_global_autocopy = 1;
124 static int metadata_streams_autocopy = 1;
125 static int metadata_chapters_autocopy = 1;
127 static ChapterMap *chapter_maps = NULL;
128 static int nb_chapter_maps;
130 /* indexed by output file stream index */
131 static int *streamid_map = NULL;
132 static int nb_streamid_map = 0;
134 static int frame_width = 0;
135 static int frame_height = 0;
136 static float frame_aspect_ratio = 0;
137 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
138 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
139 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
140 static AVRational frame_rate;
141 static float video_qscale = 0;
142 static uint16_t *intra_matrix = NULL;
143 static uint16_t *inter_matrix = NULL;
144 static const char *video_rc_override_string=NULL;
145 static int video_disable = 0;
146 static int video_discard = 0;
147 static char *video_codec_name = NULL;
148 static unsigned int video_codec_tag = 0;
149 static char *video_language = NULL;
150 static int same_quality = 0;
151 static int do_deinterlace = 0;
152 static int top_field_first = -1;
153 static int me_threshold = 0;
154 static int intra_dc_precision = 8;
155 static int loop_input = 0;
156 static int loop_output = AVFMT_NOOUTPUTLOOP;
157 static int qp_hist = 0;
159 static char *vfilters = NULL;
162 static int intra_only = 0;
163 static int audio_sample_rate = 0;
164 #define QSCALE_NONE -99999
165 static float audio_qscale = QSCALE_NONE;
166 static int audio_disable = 0;
167 static int audio_channels = 0;
168 static char *audio_codec_name = NULL;
169 static unsigned int audio_codec_tag = 0;
170 static char *audio_language = NULL;
172 static int subtitle_disable = 0;
173 static char *subtitle_codec_name = NULL;
174 static char *subtitle_language = NULL;
175 static unsigned int subtitle_codec_tag = 0;
177 static int data_disable = 0;
178 static char *data_codec_name = NULL;
179 static unsigned int data_codec_tag = 0;
181 static float mux_preload= 0.5;
182 static float mux_max_delay= 0.7;
184 static int64_t recording_time = INT64_MAX;
185 static int64_t start_time = 0;
186 static int64_t input_ts_offset = 0;
187 static int file_overwrite = 0;
188 static AVDictionary *metadata;
189 static int do_benchmark = 0;
190 static int do_hex_dump = 0;
191 static int do_pkt_dump = 0;
192 static int do_psnr = 0;
193 static int do_pass = 0;
194 static char *pass_logfilename_prefix = NULL;
195 static int audio_stream_copy = 0;
196 static int video_stream_copy = 0;
197 static int subtitle_stream_copy = 0;
198 static int data_stream_copy = 0;
199 static int video_sync_method= -1;
200 static int audio_sync_method= 0;
201 static float audio_drift_threshold= 0.1;
202 static int copy_ts= 0;
204 static int opt_shortest = 0;
205 static char *vstats_filename;
206 static FILE *vstats_file;
207 static int opt_programid = 0;
208 static int copy_initial_nonkeyframes = 0;
210 static int rate_emu = 0;
212 static int audio_volume = 256;
214 static int exit_on_error = 0;
215 static int using_stdin = 0;
216 static int verbose = 1;
217 static int thread_count= 1;
218 static int64_t video_size = 0;
219 static int64_t audio_size = 0;
220 static int64_t extra_size = 0;
221 static int nb_frames_dup = 0;
222 static int nb_frames_drop = 0;
223 static int input_sync;
224 static uint64_t limit_filesize = 0;
225 static int force_fps = 0;
226 static char *forced_key_frames = NULL;
228 static float dts_delta_threshold = 10;
230 static int64_t timer_start;
232 static uint8_t *audio_buf;
233 static uint8_t *audio_out;
234 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
236 static short *samples;
238 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
239 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
240 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
242 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
246 typedef struct OutputStream {
247 int file_index; /* file index */
248 int index; /* stream index in the output file */
249 int source_index; /* InputStream index */
250 AVStream *st; /* stream in the output file */
251 int encoding_needed; /* true if encoding needed for this stream */
253 /* input pts and corresponding output pts
255 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
256 struct InputStream *sync_ist; /* input stream to sync against */
257 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
258 AVBitStreamFilterContext *bitstream_filters;
263 AVFrame pict_tmp; /* temporary image for resampling */
264 struct SwsContext *img_resample_ctx; /* for image resampling */
267 int resample_pix_fmt;
268 AVRational frame_rate;
270 float frame_aspect_ratio;
272 /* forced key frames */
273 int64_t *forced_kf_pts;
279 ReSampleContext *resample; /* for audio resampling */
280 int resample_sample_fmt;
281 int resample_channels;
282 int resample_sample_rate;
284 AVAudioConvert *reformat_ctx;
285 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
289 AVFilterContext *output_video_filter;
290 AVFilterContext *input_video_filter;
291 AVFilterBufferRef *picref;
293 AVFilterGraph *graph;
299 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
300 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
302 typedef struct InputStream {
305 int discard; /* true if stream data should be discarded */
306 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
309 int64_t start; /* time when read started */
310 int64_t next_pts; /* synthetic pts for cases where pkt.pts
312 int64_t pts; /* current pts */
313 PtsCorrectionContext pts_ctx;
315 int is_start; /* is 1 at the start and after a discontinuity */
316 int showed_multi_packet_warning;
317 int is_past_recording_time;
320 typedef struct InputFile {
321 AVFormatContext *ctx;
322 int eof_reached; /* true if eof reached */
323 int ist_index; /* index of first stream in ist_table */
324 int buffer_size; /* current total buffer size */
328 static InputStream *input_streams = NULL;
329 static int nb_input_streams = 0;
330 static InputFile *input_files = NULL;
331 static int nb_input_files = 0;
335 static int configure_video_filters(InputStream *ist, OutputStream *ost)
337 AVFilterContext *last_filter, *filter;
338 /** filter graph containing all filters including input & output */
339 AVCodecContext *codec = ost->st->codec;
340 AVCodecContext *icodec = ist->st->codec;
341 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
342 AVRational sample_aspect_ratio;
346 ost->graph = avfilter_graph_alloc();
348 if (ist->st->sample_aspect_ratio.num){
349 sample_aspect_ratio = ist->st->sample_aspect_ratio;
351 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
353 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
354 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
355 sample_aspect_ratio.num, sample_aspect_ratio.den);
357 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
358 "src", args, NULL, ost->graph);
361 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
362 "out", NULL, &ffsink_ctx, ost->graph);
365 last_filter = ost->input_video_filter;
367 if (codec->width != icodec->width || codec->height != icodec->height) {
368 snprintf(args, 255, "%d:%d:flags=0x%X",
372 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
373 NULL, args, NULL, ost->graph)) < 0)
375 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
377 last_filter = filter;
380 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
381 ost->graph->scale_sws_opts = av_strdup(args);
384 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
385 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
387 outputs->name = av_strdup("in");
388 outputs->filter_ctx = last_filter;
389 outputs->pad_idx = 0;
390 outputs->next = NULL;
392 inputs->name = av_strdup("out");
393 inputs->filter_ctx = ost->output_video_filter;
397 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
399 av_freep(&ost->avfilter);
401 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
405 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
408 codec->width = ost->output_video_filter->inputs[0]->w;
409 codec->height = ost->output_video_filter->inputs[0]->h;
410 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
411 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
412 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
413 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
417 #endif /* CONFIG_AVFILTER */
419 static void term_exit(void)
421 av_log(NULL, AV_LOG_QUIET, "");
424 static volatile int received_sigterm = 0;
425 static volatile int received_nb_signals = 0;
428 sigterm_handler(int sig)
430 received_sigterm = sig;
431 received_nb_signals++;
435 static void term_init(void)
437 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
438 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
440 signal(SIGXCPU, sigterm_handler);
444 static int decode_interrupt_cb(void)
446 return received_nb_signals > 1;
449 static int ffmpeg_exit(int ret)
454 for(i=0;i<nb_output_files;i++) {
455 AVFormatContext *s = output_files[i];
456 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
458 avformat_free_context(s);
459 av_free(output_streams_for_file[i]);
460 av_dict_free(&output_opts[i]);
462 for(i=0;i<nb_input_files;i++) {
463 av_close_input_file(input_files[i].ctx);
466 av_free(intra_matrix);
467 av_free(inter_matrix);
471 av_free(vstats_filename);
473 av_free(streamid_map);
474 av_free(stream_maps);
475 av_free(meta_data_maps);
477 av_freep(&input_streams);
478 av_freep(&input_files);
480 av_free(video_codec_name);
481 av_free(audio_codec_name);
482 av_free(subtitle_codec_name);
483 av_free(data_codec_name);
488 allocated_audio_buf_size= allocated_audio_out_size= 0;
495 if (received_sigterm) {
497 "Received signal %d: terminating.\n",
498 (int) received_sigterm);
502 exit(ret); /* not all OS-es handle main() return value */
506 static void assert_avoptions(AVDictionary *m)
508 AVDictionaryEntry *t;
509 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
510 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
515 /* similar to ff_dynarray_add() and av_fast_realloc() */
516 static void *grow_array(void *array, int elem_size, int *size, int new_size)
518 if (new_size >= INT_MAX / elem_size) {
519 fprintf(stderr, "Array too big.\n");
522 if (*size < new_size) {
523 uint8_t *tmp = av_realloc(array, new_size*elem_size);
525 fprintf(stderr, "Could not alloc buffer.\n");
528 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
535 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
537 if(codec && codec->sample_fmts){
538 const enum AVSampleFormat *p= codec->sample_fmts;
540 if(*p == st->codec->sample_fmt)
544 av_log(NULL, AV_LOG_WARNING,
545 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
546 av_get_sample_fmt_name(st->codec->sample_fmt),
548 av_get_sample_fmt_name(codec->sample_fmts[0]));
549 st->codec->sample_fmt = codec->sample_fmts[0];
555 * Update the requested input sample format based on the output sample format.
556 * This is currently only used to request float output from decoders which
557 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
558 * Ideally this will be removed in the future when decoders do not do format
559 * conversion and only output in their native format.
561 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
564 /* if sample formats match or a decoder sample format has already been
565 requested, just return */
566 if (enc->sample_fmt == dec->sample_fmt ||
567 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
570 /* if decoder supports more than one output format */
571 if (dec_codec && dec_codec->sample_fmts &&
572 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
573 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
574 const enum AVSampleFormat *p;
575 int min_dec = -1, min_inc = -1;
577 /* find a matching sample format in the encoder */
578 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
579 if (*p == enc->sample_fmt) {
580 dec->request_sample_fmt = *p;
582 } else if (*p > enc->sample_fmt) {
583 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
585 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
588 /* if none match, provide the one that matches quality closest */
589 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
590 enc->sample_fmt - min_dec;
594 static void choose_sample_rate(AVStream *st, AVCodec *codec)
596 if(codec && codec->supported_samplerates){
597 const int *p= codec->supported_samplerates;
599 int best_dist=INT_MAX;
601 int dist= abs(st->codec->sample_rate - *p);
602 if(dist < best_dist){
608 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
610 st->codec->sample_rate= best;
614 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
616 if(codec && codec->pix_fmts){
617 const enum PixelFormat *p= codec->pix_fmts;
618 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
619 if(st->codec->codec_id==CODEC_ID_MJPEG){
620 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
621 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
622 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};
626 if(*p == st->codec->pix_fmt)
630 if(st->codec->pix_fmt != PIX_FMT_NONE)
631 av_log(NULL, AV_LOG_WARNING,
632 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
633 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
635 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
636 st->codec->pix_fmt = codec->pix_fmts[0];
641 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
644 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
645 int idx = oc->nb_streams - 1;
648 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
652 output_streams_for_file[file_idx] =
653 grow_array(output_streams_for_file[file_idx],
654 sizeof(*output_streams_for_file[file_idx]),
655 &nb_output_streams_for_file[file_idx],
657 ost = output_streams_for_file[file_idx][idx] =
658 av_mallocz(sizeof(OutputStream));
660 fprintf(stderr, "Could not alloc output stream\n");
663 ost->file_index = file_idx;
668 avcodec_get_context_defaults3(st->codec, codec);
670 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
674 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
677 AVFormatContext *ic = NULL;
680 err = avformat_open_input(&ic, filename, NULL, NULL);
683 /* copy stream format */
684 for(i=0;i<ic->nb_streams;i++) {
689 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
690 ost = new_output_stream(s, nb_output_files, codec);
693 // FIXME: a more elegant solution is needed
694 memcpy(st, ic->streams[i], sizeof(AVStream));
696 avcodec_copy_context(st->codec, ic->streams[i]->codec);
698 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
699 if (audio_stream_copy) {
702 choose_sample_fmt(st, codec);
703 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
704 if (video_stream_copy) {
707 choose_pixel_fmt(st, codec);
710 if(st->codec->flags & CODEC_FLAG_BITEXACT)
714 av_close_input_file(ic);
719 get_sync_ipts(const OutputStream *ost)
721 const InputStream *ist = ost->sync_ist;
722 return (double)(ist->pts - start_time)/AV_TIME_BASE;
725 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
729 AVPacket new_pkt= *pkt;
730 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
731 &new_pkt.data, &new_pkt.size,
732 pkt->data, pkt->size,
733 pkt->flags & AV_PKT_FLAG_KEY);
736 new_pkt.destruct= av_destruct_packet;
738 fprintf(stderr, "%s failed for stream %d, codec %s",
739 bsfc->filter->name, pkt->stream_index,
740 avctx->codec ? avctx->codec->name : "copy");
750 ret= av_interleaved_write_frame(s, pkt);
752 print_error("av_interleaved_write_frame()", ret);
757 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
759 static void do_audio_out(AVFormatContext *s,
762 unsigned char *buf, int size)
765 int64_t audio_out_size, audio_buf_size;
766 int64_t allocated_for_size= size;
768 int size_out, frame_bytes, ret, resample_changed;
769 AVCodecContext *enc= ost->st->codec;
770 AVCodecContext *dec= ist->st->codec;
771 int osize = av_get_bytes_per_sample(enc->sample_fmt);
772 int isize = av_get_bytes_per_sample(dec->sample_fmt);
773 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
776 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
777 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
778 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
779 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
780 audio_buf_size*= osize*enc->channels;
782 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
783 if(coded_bps > 8*osize)
784 audio_out_size= audio_out_size * coded_bps / (8*osize);
785 audio_out_size += FF_MIN_BUFFER_SIZE;
787 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
788 fprintf(stderr, "Buffer sizes too large\n");
792 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
793 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
794 if (!audio_buf || !audio_out){
795 fprintf(stderr, "Out of memory in do_audio_out\n");
799 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
800 ost->audio_resample = 1;
802 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
803 ost->resample_channels != dec->channels ||
804 ost->resample_sample_rate != dec->sample_rate;
806 if ((ost->audio_resample && !ost->resample) || resample_changed) {
807 if (resample_changed) {
808 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",
809 ist->file_index, ist->st->index,
810 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
811 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
812 ost->resample_sample_fmt = dec->sample_fmt;
813 ost->resample_channels = dec->channels;
814 ost->resample_sample_rate = dec->sample_rate;
816 audio_resample_close(ost->resample);
818 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
819 if (audio_sync_method <= 1 &&
820 ost->resample_sample_fmt == enc->sample_fmt &&
821 ost->resample_channels == enc->channels &&
822 ost->resample_sample_rate == enc->sample_rate) {
823 ost->resample = NULL;
824 ost->audio_resample = 0;
825 } else if (ost->audio_resample) {
826 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
827 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
828 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
829 enc->sample_rate, dec->sample_rate,
830 enc->sample_fmt, dec->sample_fmt,
832 if (!ost->resample) {
833 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
834 dec->channels, dec->sample_rate,
835 enc->channels, enc->sample_rate);
841 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
842 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
843 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
844 if (ost->reformat_ctx)
845 av_audio_convert_free(ost->reformat_ctx);
846 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
847 dec->sample_fmt, 1, NULL, 0);
848 if (!ost->reformat_ctx) {
849 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
850 av_get_sample_fmt_name(dec->sample_fmt),
851 av_get_sample_fmt_name(enc->sample_fmt));
854 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
857 if(audio_sync_method){
858 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
859 - av_fifo_size(ost->fifo)/(enc->channels * 2);
860 double idelta= delta*dec->sample_rate / enc->sample_rate;
861 int byte_delta= ((int)idelta)*2*dec->channels;
863 //FIXME resample delay
864 if(fabs(delta) > 50){
865 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
867 byte_delta= FFMAX(byte_delta, -size);
871 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
876 static uint8_t *input_tmp= NULL;
877 input_tmp= av_realloc(input_tmp, byte_delta + size);
879 if(byte_delta > allocated_for_size - size){
880 allocated_for_size= byte_delta + (int64_t)size;
885 memset(input_tmp, 0, byte_delta);
886 memcpy(input_tmp + byte_delta, buf, size);
890 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
892 }else if(audio_sync_method>1){
893 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
894 av_assert0(ost->audio_resample);
896 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
897 // 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));
898 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
902 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
903 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
905 if (ost->audio_resample) {
907 size_out = audio_resample(ost->resample,
908 (short *)buftmp, (short *)buf,
909 size / (dec->channels * isize));
910 size_out = size_out * enc->channels * osize;
916 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
917 const void *ibuf[6]= {buftmp};
918 void *obuf[6]= {audio_buf};
919 int istride[6]= {isize};
920 int ostride[6]= {osize};
921 int len= size_out/istride[0];
922 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
923 printf("av_audio_convert() failed\n");
929 size_out = len*osize;
932 /* now encode as many frames as possible */
933 if (enc->frame_size > 1) {
934 /* output resampled raw samples */
935 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
936 fprintf(stderr, "av_fifo_realloc2() failed\n");
939 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
941 frame_bytes = enc->frame_size * osize * enc->channels;
943 while (av_fifo_size(ost->fifo) >= frame_bytes) {
945 av_init_packet(&pkt);
947 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
949 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
951 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
954 fprintf(stderr, "Audio encoding failed\n");
958 pkt.stream_index= ost->index;
961 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
962 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
963 pkt.flags |= AV_PKT_FLAG_KEY;
964 write_frame(s, &pkt, enc, ost->bitstream_filters);
966 ost->sync_opts += enc->frame_size;
970 av_init_packet(&pkt);
972 ost->sync_opts += size_out / (osize * enc->channels);
974 /* output a pcm frame */
975 /* determine the size of the coded buffer */
978 size_out = size_out*coded_bps/8;
980 if(size_out > audio_out_size){
981 fprintf(stderr, "Internal error, buffer size too small\n");
985 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
986 ret = avcodec_encode_audio(enc, audio_out, size_out,
989 fprintf(stderr, "Audio encoding failed\n");
993 pkt.stream_index= ost->index;
996 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
997 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
998 pkt.flags |= AV_PKT_FLAG_KEY;
999 write_frame(s, &pkt, enc, ost->bitstream_filters);
1003 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1005 AVCodecContext *dec;
1006 AVPicture *picture2;
1007 AVPicture picture_tmp;
1010 dec = ist->st->codec;
1012 /* deinterlace : must be done before any resize */
1013 if (do_deinterlace) {
1016 /* create temporary picture */
1017 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1018 buf = av_malloc(size);
1022 picture2 = &picture_tmp;
1023 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1025 if(avpicture_deinterlace(picture2, picture,
1026 dec->pix_fmt, dec->width, dec->height) < 0) {
1027 /* if error, do not deinterlace */
1028 fprintf(stderr, "Deinterlacing failed\n");
1037 if (picture != picture2)
1038 *picture = *picture2;
1042 /* we begin to correct av delay at this threshold */
1043 #define AV_DELAY_MAX 0.100
1045 static void do_subtitle_out(AVFormatContext *s,
1051 static uint8_t *subtitle_out = NULL;
1052 int subtitle_out_max_size = 1024 * 1024;
1053 int subtitle_out_size, nb, i;
1054 AVCodecContext *enc;
1057 if (pts == AV_NOPTS_VALUE) {
1058 fprintf(stderr, "Subtitle packets must have a pts\n");
1064 enc = ost->st->codec;
1066 if (!subtitle_out) {
1067 subtitle_out = av_malloc(subtitle_out_max_size);
1070 /* Note: DVB subtitle need one packet to draw them and one other
1071 packet to clear them */
1072 /* XXX: signal it in the codec context ? */
1073 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1078 for(i = 0; i < nb; i++) {
1079 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1080 // start_display_time is required to be 0
1081 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1082 sub->end_display_time -= sub->start_display_time;
1083 sub->start_display_time = 0;
1084 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1085 subtitle_out_max_size, sub);
1086 if (subtitle_out_size < 0) {
1087 fprintf(stderr, "Subtitle encoding failed\n");
1091 av_init_packet(&pkt);
1092 pkt.stream_index = ost->index;
1093 pkt.data = subtitle_out;
1094 pkt.size = subtitle_out_size;
1095 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1096 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1097 /* XXX: the pts correction is handled here. Maybe handling
1098 it in the codec would be better */
1100 pkt.pts += 90 * sub->start_display_time;
1102 pkt.pts += 90 * sub->end_display_time;
1104 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1108 static int bit_buffer_size= 1024*256;
1109 static uint8_t *bit_buffer= NULL;
1111 static void do_video_out(AVFormatContext *s,
1114 AVFrame *in_picture,
1115 int *frame_size, float quality)
1117 int nb_frames, i, ret, resample_changed;
1118 AVFrame *final_picture, *formatted_picture;
1119 AVCodecContext *enc, *dec;
1122 enc = ost->st->codec;
1123 dec = ist->st->codec;
1125 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1127 /* by default, we output a single frame */
1132 if(video_sync_method){
1133 double vdelta = sync_ipts - ost->sync_opts;
1134 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1137 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1140 }else if(vdelta>0.6)
1141 ost->sync_opts= lrintf(sync_ipts);
1142 }else if (vdelta > 1.1)
1143 nb_frames = lrintf(vdelta);
1144 //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);
1145 if (nb_frames == 0){
1148 fprintf(stderr, "*** drop!\n");
1149 }else if (nb_frames > 1) {
1150 nb_frames_dup += nb_frames - 1;
1152 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1155 ost->sync_opts= lrintf(sync_ipts);
1157 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1161 formatted_picture = in_picture;
1162 final_picture = formatted_picture;
1164 resample_changed = ost->resample_width != dec->width ||
1165 ost->resample_height != dec->height ||
1166 ost->resample_pix_fmt != dec->pix_fmt;
1168 if (resample_changed) {
1169 av_log(NULL, AV_LOG_INFO,
1170 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1171 ist->file_index, ist->st->index,
1172 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1173 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1174 if(!ost->video_resample)
1178 #if !CONFIG_AVFILTER
1179 if (ost->video_resample) {
1180 final_picture = &ost->pict_tmp;
1181 if (resample_changed) {
1182 /* initialize a new scaler context */
1183 sws_freeContext(ost->img_resample_ctx);
1184 ost->img_resample_ctx = sws_getContext(
1185 ist->st->codec->width,
1186 ist->st->codec->height,
1187 ist->st->codec->pix_fmt,
1188 ost->st->codec->width,
1189 ost->st->codec->height,
1190 ost->st->codec->pix_fmt,
1191 ost->sws_flags, NULL, NULL, NULL);
1192 if (ost->img_resample_ctx == NULL) {
1193 fprintf(stderr, "Cannot get resampling context\n");
1197 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1198 0, ost->resample_height, final_picture->data, final_picture->linesize);
1202 /* duplicates frame if needed */
1203 for(i=0;i<nb_frames;i++) {
1205 av_init_packet(&pkt);
1206 pkt.stream_index= ost->index;
1208 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1209 /* raw pictures are written as AVPicture structure to
1210 avoid any copies. We support temorarily the older
1212 AVFrame* old_frame = enc->coded_frame;
1213 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1214 pkt.data= (uint8_t *)final_picture;
1215 pkt.size= sizeof(AVPicture);
1216 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1217 pkt.flags |= AV_PKT_FLAG_KEY;
1219 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1220 enc->coded_frame = old_frame;
1222 AVFrame big_picture;
1224 big_picture= *final_picture;
1225 /* better than nothing: use input picture interlaced
1227 big_picture.interlaced_frame = in_picture->interlaced_frame;
1228 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1229 if(top_field_first == -1)
1230 big_picture.top_field_first = in_picture->top_field_first;
1232 big_picture.top_field_first = top_field_first;
1235 /* handles sameq here. This is not correct because it may
1236 not be a global option */
1237 big_picture.quality = quality;
1239 big_picture.pict_type = 0;
1240 // big_picture.pts = AV_NOPTS_VALUE;
1241 big_picture.pts= ost->sync_opts;
1242 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1243 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1244 if (ost->forced_kf_index < ost->forced_kf_count &&
1245 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1246 big_picture.pict_type = AV_PICTURE_TYPE_I;
1247 ost->forced_kf_index++;
1249 ret = avcodec_encode_video(enc,
1250 bit_buffer, bit_buffer_size,
1253 fprintf(stderr, "Video encoding failed\n");
1258 pkt.data= bit_buffer;
1260 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1261 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1262 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1263 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1264 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1266 if(enc->coded_frame->key_frame)
1267 pkt.flags |= AV_PKT_FLAG_KEY;
1268 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1271 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1272 // enc->frame_number-1, ret, enc->pict_type);
1273 /* if two pass, output log */
1274 if (ost->logfile && enc->stats_out) {
1275 fprintf(ost->logfile, "%s", enc->stats_out);
1280 ost->frame_number++;
1284 static double psnr(double d){
1285 return -10.0*log(d)/log(10.0);
1288 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1291 AVCodecContext *enc;
1293 double ti1, bitrate, avg_bitrate;
1295 /* this is executed just the first time do_video_stats is called */
1297 vstats_file = fopen(vstats_filename, "w");
1304 enc = ost->st->codec;
1305 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1306 frame_number = ost->frame_number;
1307 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1308 if (enc->flags&CODEC_FLAG_PSNR)
1309 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1311 fprintf(vstats_file,"f_size= %6d ", frame_size);
1312 /* compute pts value */
1313 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1317 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1318 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1319 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1320 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1321 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1325 static void print_report(AVFormatContext **output_files,
1326 OutputStream **ost_table, int nb_ostreams,
1331 AVFormatContext *oc;
1333 AVCodecContext *enc;
1334 int frame_number, vid, i;
1335 double bitrate, ti1, pts;
1336 static int64_t last_time = -1;
1337 static int qp_histogram[52];
1339 if (!is_last_report) {
1341 /* display the report every 0.5 seconds */
1342 cur_time = av_gettime();
1343 if (last_time == -1) {
1344 last_time = cur_time;
1347 if ((cur_time - last_time) < 500000)
1349 last_time = cur_time;
1353 oc = output_files[0];
1355 total_size = avio_size(oc->pb);
1356 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1357 total_size= avio_tell(oc->pb);
1362 for(i=0;i<nb_ostreams;i++) {
1365 enc = ost->st->codec;
1366 if (!ost->st->stream_copy && enc->coded_frame)
1367 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1368 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1369 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1371 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1372 float t = (av_gettime()-timer_start) / 1000000.0;
1374 frame_number = ost->frame_number;
1375 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1376 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1378 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1382 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1385 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1387 if (enc->flags&CODEC_FLAG_PSNR){
1389 double error, error_sum=0;
1390 double scale, scale_sum=0;
1391 char type[3]= {'Y','U','V'};
1392 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1395 error= enc->error[j];
1396 scale= enc->width*enc->height*255.0*255.0*frame_number;
1398 error= enc->coded_frame->error[j];
1399 scale= enc->width*enc->height*255.0*255.0;
1404 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1406 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1410 /* compute min output value */
1411 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1412 if ((pts < ti1) && (pts > 0))
1418 if (verbose > 0 || is_last_report) {
1419 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1421 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1422 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1423 (double)total_size / 1024, ti1, bitrate);
1425 if (nb_frames_dup || nb_frames_drop)
1426 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1427 nb_frames_dup, nb_frames_drop);
1430 fprintf(stderr, "%s \r", buf);
1435 if (is_last_report && verbose >= 0){
1436 int64_t raw= audio_size + video_size + extra_size;
1437 fprintf(stderr, "\n");
1438 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1442 100.0*(total_size - raw)/raw
1447 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1449 int fill_char = 0x00;
1450 if (sample_fmt == AV_SAMPLE_FMT_U8)
1452 memset(buf, fill_char, size);
1455 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1456 static int output_packet(InputStream *ist, int ist_index,
1457 OutputStream **ost_table, int nb_ostreams,
1458 const AVPacket *pkt)
1460 AVFormatContext *os;
1465 void *buffer_to_free = NULL;
1466 static unsigned int samples_size= 0;
1467 AVSubtitle subtitle, *subtitle_to_free;
1468 int64_t pkt_pts = AV_NOPTS_VALUE;
1470 int frame_available;
1475 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1477 if(ist->next_pts == AV_NOPTS_VALUE)
1478 ist->next_pts= ist->pts;
1482 av_init_packet(&avpkt);
1490 if(pkt->dts != AV_NOPTS_VALUE)
1491 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1492 if(pkt->pts != AV_NOPTS_VALUE)
1493 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1495 //while we have more to decode or while the decoder did output something on EOF
1496 while (avpkt.size > 0 || (!pkt && got_output)) {
1497 uint8_t *data_buf, *decoded_data_buf;
1498 int data_size, decoded_data_size;
1500 ist->pts= ist->next_pts;
1502 if(avpkt.size && avpkt.size != pkt->size &&
1503 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1504 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1505 ist->showed_multi_packet_warning=1;
1508 /* decode the packet if needed */
1509 decoded_data_buf = NULL; /* fail safe */
1510 decoded_data_size= 0;
1511 data_buf = avpkt.data;
1512 data_size = avpkt.size;
1513 subtitle_to_free = NULL;
1514 if (ist->decoding_needed) {
1515 switch(ist->st->codec->codec_type) {
1516 case AVMEDIA_TYPE_AUDIO:{
1517 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1518 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1520 samples= av_malloc(samples_size);
1522 decoded_data_size= samples_size;
1523 /* XXX: could avoid copy if PCM 16 bits with same
1524 endianness as CPU */
1525 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1532 got_output = decoded_data_size > 0;
1533 /* Some bug in mpeg audio decoder gives */
1534 /* decoded_data_size < 0, it seems they are overflows */
1536 /* no audio frame */
1539 decoded_data_buf = (uint8_t *)samples;
1540 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1541 (ist->st->codec->sample_rate * ist->st->codec->channels);
1543 case AVMEDIA_TYPE_VIDEO:
1544 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1545 /* XXX: allocate picture correctly */
1546 avcodec_get_frame_defaults(&picture);
1547 avpkt.pts = pkt_pts;
1548 avpkt.dts = ist->pts;
1549 pkt_pts = AV_NOPTS_VALUE;
1551 ret = avcodec_decode_video2(ist->st->codec,
1552 &picture, &got_output, &avpkt);
1553 quality = same_quality ? picture.quality : 0;
1557 /* no picture yet */
1558 goto discard_packet;
1560 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1561 if (ist->st->codec->time_base.num != 0) {
1562 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1563 ist->next_pts += ((int64_t)AV_TIME_BASE *
1564 ist->st->codec->time_base.num * ticks) /
1565 ist->st->codec->time_base.den;
1568 buffer_to_free = NULL;
1569 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1571 case AVMEDIA_TYPE_SUBTITLE:
1572 ret = avcodec_decode_subtitle2(ist->st->codec,
1573 &subtitle, &got_output, &avpkt);
1577 goto discard_packet;
1579 subtitle_to_free = &subtitle;
1586 switch(ist->st->codec->codec_type) {
1587 case AVMEDIA_TYPE_AUDIO:
1588 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1589 ist->st->codec->sample_rate;
1591 case AVMEDIA_TYPE_VIDEO:
1592 if (ist->st->codec->time_base.num != 0) {
1593 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1594 ist->next_pts += ((int64_t)AV_TIME_BASE *
1595 ist->st->codec->time_base.num * ticks) /
1596 ist->st->codec->time_base.den;
1605 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1606 for (i = 0; i < nb_ostreams; i++) {
1608 if (ost->input_video_filter && ost->source_index == ist_index) {
1610 if (ist->st->sample_aspect_ratio.num)
1611 sar = ist->st->sample_aspect_ratio;
1613 sar = ist->st->codec->sample_aspect_ratio;
1614 // add it to be filtered
1615 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1623 // preprocess audio (volume)
1624 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1625 if (audio_volume != 256) {
1628 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1629 int v = ((*volp) * audio_volume + 128) >> 8;
1630 if (v < -32768) v = -32768;
1631 if (v > 32767) v = 32767;
1637 /* frame rate emulation */
1639 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1640 int64_t now = av_gettime() - ist->start;
1644 /* if output time reached then transcode raw format,
1645 encode packets and output them */
1646 if (start_time == 0 || ist->pts >= start_time)
1647 for(i=0;i<nb_ostreams;i++) {
1651 if (ost->source_index == ist_index) {
1653 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1654 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1655 while (frame_available) {
1656 AVRational ist_pts_tb;
1657 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1658 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1660 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1662 os = output_files[ost->file_index];
1664 /* set the input output pts pairs */
1665 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1667 if (ost->encoding_needed) {
1668 av_assert0(ist->decoding_needed);
1669 switch(ost->st->codec->codec_type) {
1670 case AVMEDIA_TYPE_AUDIO:
1671 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1673 case AVMEDIA_TYPE_VIDEO:
1675 if (ost->picref->video && !ost->frame_aspect_ratio)
1676 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1678 do_video_out(os, ost, ist, &picture, &frame_size,
1679 same_quality ? quality : ost->st->codec->global_quality);
1680 if (vstats_filename && frame_size)
1681 do_video_stats(os, ost, frame_size);
1683 case AVMEDIA_TYPE_SUBTITLE:
1684 do_subtitle_out(os, ost, ist, &subtitle,
1691 AVFrame avframe; //FIXME/XXX remove this
1693 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1695 av_init_packet(&opkt);
1697 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1698 #if !CONFIG_AVFILTER
1704 /* no reencoding needed : output the packet directly */
1705 /* force the input stream PTS */
1707 avcodec_get_frame_defaults(&avframe);
1708 ost->st->codec->coded_frame= &avframe;
1709 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1711 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1712 audio_size += data_size;
1713 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1714 video_size += data_size;
1718 opkt.stream_index= ost->index;
1719 if(pkt->pts != AV_NOPTS_VALUE)
1720 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1722 opkt.pts= AV_NOPTS_VALUE;
1724 if (pkt->dts == AV_NOPTS_VALUE)
1725 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1727 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1728 opkt.dts -= ost_tb_start_time;
1730 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1731 opkt.flags= pkt->flags;
1733 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1734 if( ost->st->codec->codec_id != CODEC_ID_H264
1735 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1736 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1738 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1739 opkt.destruct= av_destruct_packet;
1741 opkt.data = data_buf;
1742 opkt.size = data_size;
1745 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1746 ost->st->codec->frame_number++;
1747 ost->frame_number++;
1748 av_free_packet(&opkt);
1752 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1753 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1755 avfilter_unref_buffer(ost->picref);
1761 av_free(buffer_to_free);
1762 /* XXX: allocate the subtitles in the codec ? */
1763 if (subtitle_to_free) {
1764 avsubtitle_free(subtitle_to_free);
1765 subtitle_to_free = NULL;
1772 for(i=0;i<nb_ostreams;i++) {
1774 if (ost->source_index == ist_index) {
1775 AVCodecContext *enc= ost->st->codec;
1776 os = output_files[ost->file_index];
1778 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1780 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1783 if (ost->encoding_needed) {
1787 av_init_packet(&pkt);
1788 pkt.stream_index= ost->index;
1790 switch(ost->st->codec->codec_type) {
1791 case AVMEDIA_TYPE_AUDIO:
1792 fifo_bytes = av_fifo_size(ost->fifo);
1794 /* encode any samples remaining in fifo */
1795 if (fifo_bytes > 0) {
1796 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1797 int fs_tmp = enc->frame_size;
1799 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1800 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1801 enc->frame_size = fifo_bytes / (osize * enc->channels);
1803 int frame_bytes = enc->frame_size*osize*enc->channels;
1804 if (allocated_audio_buf_size < frame_bytes)
1806 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1809 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1810 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1811 ost->st->time_base.num, enc->sample_rate);
1812 enc->frame_size = fs_tmp;
1815 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1818 fprintf(stderr, "Audio encoding failed\n");
1822 pkt.flags |= AV_PKT_FLAG_KEY;
1824 case AVMEDIA_TYPE_VIDEO:
1825 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1827 fprintf(stderr, "Video encoding failed\n");
1831 if(enc->coded_frame && enc->coded_frame->key_frame)
1832 pkt.flags |= AV_PKT_FLAG_KEY;
1833 if (ost->logfile && enc->stats_out) {
1834 fprintf(ost->logfile, "%s", enc->stats_out);
1843 pkt.data= bit_buffer;
1845 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1846 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1847 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1859 static void print_sdp(AVFormatContext **avc, int n)
1863 av_sdp_create(avc, n, sdp, sizeof(sdp));
1864 printf("SDP:\n%s\n", sdp);
1868 static int copy_chapters(int infile, int outfile)
1870 AVFormatContext *is = input_files[infile].ctx;
1871 AVFormatContext *os = output_files[outfile];
1874 for (i = 0; i < is->nb_chapters; i++) {
1875 AVChapter *in_ch = is->chapters[i], *out_ch;
1876 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1877 AV_TIME_BASE_Q, in_ch->time_base);
1878 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1879 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1882 if (in_ch->end < ts_off)
1884 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1887 out_ch = av_mallocz(sizeof(AVChapter));
1889 return AVERROR(ENOMEM);
1891 out_ch->id = in_ch->id;
1892 out_ch->time_base = in_ch->time_base;
1893 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1894 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1896 if (metadata_chapters_autocopy)
1897 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1900 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1902 return AVERROR(ENOMEM);
1903 os->chapters[os->nb_chapters - 1] = out_ch;
1908 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1909 AVCodecContext *avctx)
1915 for (p = kf; *p; p++)
1918 ost->forced_kf_count = n;
1919 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1920 if (!ost->forced_kf_pts) {
1921 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1924 for (i = 0; i < n; i++) {
1925 p = i ? strchr(p, ',') + 1 : kf;
1926 t = parse_time_or_die("force_key_frames", p, 1);
1927 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1932 * The following code is the main loop of the file converter
1934 static int transcode(AVFormatContext **output_files,
1935 int nb_output_files,
1936 InputFile *input_files,
1938 StreamMap *stream_maps, int nb_stream_maps)
1940 int ret = 0, i, j, k, n, nb_ostreams = 0;
1941 AVFormatContext *is, *os;
1942 AVCodecContext *codec, *icodec;
1943 OutputStream *ost, **ost_table = NULL;
1947 uint8_t no_packet[MAX_FILES]={0};
1948 int no_packet_count=0;
1951 for (i = 0; i < nb_input_streams; i++)
1952 input_streams[i].start = av_gettime();
1954 /* output stream init */
1956 for(i=0;i<nb_output_files;i++) {
1957 os = output_files[i];
1958 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1959 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1960 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1961 ret = AVERROR(EINVAL);
1964 nb_ostreams += os->nb_streams;
1966 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1967 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1968 ret = AVERROR(EINVAL);
1972 /* Sanity check the mapping args -- do the input files & streams exist? */
1973 for(i=0;i<nb_stream_maps;i++) {
1974 int fi = stream_maps[i].file_index;
1975 int si = stream_maps[i].stream_index;
1977 if (fi < 0 || fi > nb_input_files - 1 ||
1978 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1979 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1980 ret = AVERROR(EINVAL);
1983 fi = stream_maps[i].sync_file_index;
1984 si = stream_maps[i].sync_stream_index;
1985 if (fi < 0 || fi > nb_input_files - 1 ||
1986 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1987 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1988 ret = AVERROR(EINVAL);
1993 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1997 for(k=0;k<nb_output_files;k++) {
1998 os = output_files[k];
1999 for(i=0;i<os->nb_streams;i++,n++) {
2001 ost = ost_table[n] = output_streams_for_file[k][i];
2002 if (nb_stream_maps > 0) {
2003 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2004 stream_maps[n].stream_index;
2006 /* Sanity check that the stream types match */
2007 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2008 int i= ost->file_index;
2009 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2010 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2011 stream_maps[n].file_index, stream_maps[n].stream_index,
2012 ost->file_index, ost->index);
2017 int best_nb_frames=-1;
2018 /* get corresponding input stream index : we select the first one with the right type */
2020 for (j = 0; j < nb_input_streams; j++) {
2022 ist = &input_streams[j];
2025 AVFormatContext *f = input_files[ist->file_index].ctx;
2027 for(pi=0; pi<f->nb_programs; pi++){
2028 AVProgram *p= f->programs[pi];
2029 if(p->id == opt_programid)
2030 for(si=0; si<p->nb_stream_indexes; si++){
2031 if(f->streams[ p->stream_index[si] ] == ist->st)
2036 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2037 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2038 if(best_nb_frames < ist->st->codec_info_nb_frames){
2039 best_nb_frames= ist->st->codec_info_nb_frames;
2040 ost->source_index = j;
2047 if(! opt_programid) {
2048 /* try again and reuse existing stream */
2049 for (j = 0; j < nb_input_streams; j++) {
2050 ist = &input_streams[j];
2051 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2052 && ist->st->discard != AVDISCARD_ALL) {
2053 ost->source_index = j;
2059 int i= ost->file_index;
2060 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2061 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2062 ost->file_index, ost->index);
2067 ist = &input_streams[ost->source_index];
2069 ost->sync_ist = (nb_stream_maps > 0) ?
2070 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2071 stream_maps[n].sync_stream_index] : ist;
2075 /* for each output stream, we compute the right encoding parameters */
2076 for(i=0;i<nb_ostreams;i++) {
2078 os = output_files[ost->file_index];
2079 ist = &input_streams[ost->source_index];
2081 codec = ost->st->codec;
2082 icodec = ist->st->codec;
2084 if (metadata_streams_autocopy)
2085 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2086 AV_DICT_DONT_OVERWRITE);
2088 ost->st->disposition = ist->st->disposition;
2089 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2090 codec->chroma_sample_location = icodec->chroma_sample_location;
2092 if (ost->st->stream_copy) {
2093 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2095 if (extra_size > INT_MAX)
2098 /* if stream_copy is selected, no need to decode or encode */
2099 codec->codec_id = icodec->codec_id;
2100 codec->codec_type = icodec->codec_type;
2102 if(!codec->codec_tag){
2103 if( !os->oformat->codec_tag
2104 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2105 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2106 codec->codec_tag = icodec->codec_tag;
2109 codec->bit_rate = icodec->bit_rate;
2110 codec->rc_max_rate = icodec->rc_max_rate;
2111 codec->rc_buffer_size = icodec->rc_buffer_size;
2112 codec->extradata= av_mallocz(extra_size);
2113 if (!codec->extradata)
2115 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2116 codec->extradata_size= icodec->extradata_size;
2117 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){
2118 codec->time_base = icodec->time_base;
2119 codec->time_base.num *= icodec->ticks_per_frame;
2120 av_reduce(&codec->time_base.num, &codec->time_base.den,
2121 codec->time_base.num, codec->time_base.den, INT_MAX);
2123 codec->time_base = ist->st->time_base;
2124 switch(codec->codec_type) {
2125 case AVMEDIA_TYPE_AUDIO:
2126 if(audio_volume != 256) {
2127 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2130 codec->channel_layout = icodec->channel_layout;
2131 codec->sample_rate = icodec->sample_rate;
2132 codec->channels = icodec->channels;
2133 codec->frame_size = icodec->frame_size;
2134 codec->audio_service_type = icodec->audio_service_type;
2135 codec->block_align= icodec->block_align;
2136 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2137 codec->block_align= 0;
2138 if(codec->codec_id == CODEC_ID_AC3)
2139 codec->block_align= 0;
2141 case AVMEDIA_TYPE_VIDEO:
2142 codec->pix_fmt = icodec->pix_fmt;
2143 codec->width = icodec->width;
2144 codec->height = icodec->height;
2145 codec->has_b_frames = icodec->has_b_frames;
2146 if (!codec->sample_aspect_ratio.num) {
2147 codec->sample_aspect_ratio =
2148 ost->st->sample_aspect_ratio =
2149 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2150 ist->st->codec->sample_aspect_ratio.num ?
2151 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2154 case AVMEDIA_TYPE_SUBTITLE:
2155 codec->width = icodec->width;
2156 codec->height = icodec->height;
2158 case AVMEDIA_TYPE_DATA:
2165 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2166 switch(codec->codec_type) {
2167 case AVMEDIA_TYPE_AUDIO:
2168 ost->fifo= av_fifo_alloc(1024);
2171 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2172 if (!codec->sample_rate) {
2173 codec->sample_rate = icodec->sample_rate;
2175 codec->sample_rate >>= icodec->lowres;
2177 choose_sample_rate(ost->st, ost->enc);
2178 codec->time_base = (AVRational){1, codec->sample_rate};
2179 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2180 codec->sample_fmt = icodec->sample_fmt;
2181 choose_sample_fmt(ost->st, ost->enc);
2182 if (!codec->channels)
2183 codec->channels = icodec->channels;
2184 codec->channel_layout = icodec->channel_layout;
2185 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2186 codec->channel_layout = 0;
2187 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2188 icodec->request_channels = codec->channels;
2189 ist->decoding_needed = 1;
2190 ost->encoding_needed = 1;
2191 ost->resample_sample_fmt = icodec->sample_fmt;
2192 ost->resample_sample_rate = icodec->sample_rate;
2193 ost->resample_channels = icodec->channels;
2195 case AVMEDIA_TYPE_VIDEO:
2196 if (codec->pix_fmt == PIX_FMT_NONE)
2197 codec->pix_fmt = icodec->pix_fmt;
2198 choose_pixel_fmt(ost->st, ost->enc);
2200 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2201 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2204 ost->video_resample = codec->width != icodec->width ||
2205 codec->height != icodec->height ||
2206 codec->pix_fmt != icodec->pix_fmt;
2207 if (ost->video_resample) {
2208 #if !CONFIG_AVFILTER
2209 avcodec_get_frame_defaults(&ost->pict_tmp);
2210 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2211 codec->width, codec->height)) {
2212 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2215 ost->img_resample_ctx = sws_getContext(
2222 ost->sws_flags, NULL, NULL, NULL);
2223 if (ost->img_resample_ctx == NULL) {
2224 fprintf(stderr, "Cannot get resampling context\n");
2228 codec->bits_per_raw_sample= 0;
2230 if (!codec->width || !codec->height) {
2231 codec->width = icodec->width;
2232 codec->height = icodec->height;
2234 ost->resample_height = icodec->height;
2235 ost->resample_width = icodec->width;
2236 ost->resample_pix_fmt= icodec->pix_fmt;
2237 ost->encoding_needed = 1;
2238 ist->decoding_needed = 1;
2240 if (!ost->frame_rate.num)
2241 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2242 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2243 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2244 ost->frame_rate = ost->enc->supported_framerates[idx];
2246 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2249 if (configure_video_filters(ist, ost)) {
2250 fprintf(stderr, "Error opening filters!\n");
2255 case AVMEDIA_TYPE_SUBTITLE:
2256 ost->encoding_needed = 1;
2257 ist->decoding_needed = 1;
2264 if (ost->encoding_needed &&
2265 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2266 char logfilename[1024];
2269 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2270 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2272 if (codec->flags & CODEC_FLAG_PASS1) {
2273 f = fopen(logfilename, "wb");
2275 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2281 size_t logbuffer_size;
2282 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2283 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2286 codec->stats_in = logbuffer;
2290 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2291 int size= codec->width * codec->height;
2292 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2297 bit_buffer = av_malloc(bit_buffer_size);
2299 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2301 ret = AVERROR(ENOMEM);
2305 /* open each encoder */
2306 for(i=0;i<nb_ostreams;i++) {
2308 if (ost->encoding_needed) {
2309 AVCodec *codec = ost->enc;
2310 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2312 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2313 ost->st->codec->codec_id, ost->file_index, ost->index);
2314 ret = AVERROR(EINVAL);
2317 if (dec->subtitle_header) {
2318 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2319 if (!ost->st->codec->subtitle_header) {
2320 ret = AVERROR(ENOMEM);
2323 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2324 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2326 if (avcodec_open(ost->st->codec, codec) < 0) {
2327 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2328 ost->file_index, ost->index);
2329 ret = AVERROR(EINVAL);
2332 extra_size += ost->st->codec->extradata_size;
2336 /* open each decoder */
2337 for (i = 0; i < nb_input_streams; i++) {
2338 ist = &input_streams[i];
2339 if (ist->decoding_needed) {
2340 AVCodec *codec = ist->dec;
2342 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2344 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2345 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2346 ret = AVERROR(EINVAL);
2350 /* update requested sample format for the decoder based on the
2351 corresponding encoder sample format */
2352 for (j = 0; j < nb_ostreams; j++) {
2354 if (ost->source_index == i) {
2355 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2360 if (avcodec_open(ist->st->codec, codec) < 0) {
2361 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2362 ist->file_index, ist->st->index);
2363 ret = AVERROR(EINVAL);
2366 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2367 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2372 for (i = 0; i < nb_input_streams; i++) {
2374 ist = &input_streams[i];
2376 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2377 ist->next_pts = AV_NOPTS_VALUE;
2378 init_pts_correction(&ist->pts_ctx);
2382 /* set meta data information from input file if required */
2383 for (i=0;i<nb_meta_data_maps;i++) {
2384 AVFormatContext *files[2];
2385 AVDictionary **meta[2];
2388 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2389 if ((index) < 0 || (index) >= (nb_elems)) {\
2390 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2392 ret = AVERROR(EINVAL);\
2396 int out_file_index = meta_data_maps[i][0].file;
2397 int in_file_index = meta_data_maps[i][1].file;
2398 if (in_file_index < 0 || out_file_index < 0)
2400 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2401 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2403 files[0] = output_files[out_file_index];
2404 files[1] = input_files[in_file_index].ctx;
2406 for (j = 0; j < 2; j++) {
2407 MetadataMap *map = &meta_data_maps[i][j];
2409 switch (map->type) {
2411 meta[j] = &files[j]->metadata;
2414 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2415 meta[j] = &files[j]->streams[map->index]->metadata;
2418 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2419 meta[j] = &files[j]->chapters[map->index]->metadata;
2422 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2423 meta[j] = &files[j]->programs[map->index]->metadata;
2428 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2431 /* copy global metadata by default */
2432 if (metadata_global_autocopy) {
2434 for (i = 0; i < nb_output_files; i++)
2435 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2436 AV_DICT_DONT_OVERWRITE);
2439 /* copy chapters according to chapter maps */
2440 for (i = 0; i < nb_chapter_maps; i++) {
2441 int infile = chapter_maps[i].in_file;
2442 int outfile = chapter_maps[i].out_file;
2444 if (infile < 0 || outfile < 0)
2446 if (infile >= nb_input_files) {
2447 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2448 ret = AVERROR(EINVAL);
2451 if (outfile >= nb_output_files) {
2452 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2453 ret = AVERROR(EINVAL);
2456 copy_chapters(infile, outfile);
2459 /* copy chapters from the first input file that has them*/
2460 if (!nb_chapter_maps)
2461 for (i = 0; i < nb_input_files; i++) {
2462 if (!input_files[i].ctx->nb_chapters)
2465 for (j = 0; j < nb_output_files; j++)
2466 if ((ret = copy_chapters(i, j)) < 0)
2471 /* open files and write file headers */
2472 for(i=0;i<nb_output_files;i++) {
2473 os = output_files[i];
2474 if (avformat_write_header(os, &output_opts[i]) < 0) {
2475 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2476 ret = AVERROR(EINVAL);
2479 assert_avoptions(output_opts[i]);
2480 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2486 /* dump the file output parameters - cannot be done before in case
2488 for(i=0;i<nb_output_files;i++) {
2489 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2492 /* dump the stream mapping */
2494 fprintf(stderr, "Stream mapping:\n");
2495 for(i=0;i<nb_ostreams;i++) {
2497 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2498 input_streams[ost->source_index].file_index,
2499 input_streams[ost->source_index].st->index,
2502 if (ost->sync_ist != &input_streams[ost->source_index])
2503 fprintf(stderr, " [sync #%d.%d]",
2504 ost->sync_ist->file_index,
2505 ost->sync_ist->st->index);
2506 fprintf(stderr, "\n");
2511 fprintf(stderr, "%s\n", error);
2516 print_sdp(output_files, nb_output_files);
2520 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2523 timer_start = av_gettime();
2525 for(; received_sigterm == 0;) {
2526 int file_index, ist_index;
2535 /* select the stream that we must read now by looking at the
2536 smallest output pts */
2538 for(i=0;i<nb_ostreams;i++) {
2541 os = output_files[ost->file_index];
2542 ist = &input_streams[ost->source_index];
2543 if(ist->is_past_recording_time || no_packet[ist->file_index])
2545 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2546 ipts = (double)ist->pts;
2547 if (!input_files[ist->file_index].eof_reached){
2548 if(ipts < ipts_min) {
2550 if(input_sync ) file_index = ist->file_index;
2552 if(opts < opts_min) {
2554 if(!input_sync) file_index = ist->file_index;
2557 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2562 /* if none, if is finished */
2563 if (file_index < 0) {
2564 if(no_packet_count){
2566 memset(no_packet, 0, sizeof(no_packet));
2573 /* finish if limit size exhausted */
2574 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2577 /* read a frame from it and output it in the fifo */
2578 is = input_files[file_index].ctx;
2579 ret= av_read_frame(is, &pkt);
2580 if(ret == AVERROR(EAGAIN)){
2581 no_packet[file_index]=1;
2586 input_files[file_index].eof_reached = 1;
2594 memset(no_packet, 0, sizeof(no_packet));
2597 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2598 is->streams[pkt.stream_index]);
2600 /* the following test is needed in case new streams appear
2601 dynamically in stream : we ignore them */
2602 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2603 goto discard_packet;
2604 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2605 ist = &input_streams[ist_index];
2607 goto discard_packet;
2609 if (pkt.dts != AV_NOPTS_VALUE)
2610 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2611 if (pkt.pts != AV_NOPTS_VALUE)
2612 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2614 if (ist->ts_scale) {
2615 if(pkt.pts != AV_NOPTS_VALUE)
2616 pkt.pts *= ist->ts_scale;
2617 if(pkt.dts != AV_NOPTS_VALUE)
2618 pkt.dts *= ist->ts_scale;
2621 // 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);
2622 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2623 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2624 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2625 int64_t delta= pkt_dts - ist->next_pts;
2626 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2627 input_files[ist->file_index].ts_offset -= delta;
2629 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2630 delta, input_files[ist->file_index].ts_offset);
2631 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2632 if(pkt.pts != AV_NOPTS_VALUE)
2633 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2637 /* finish if recording time exhausted */
2638 if (recording_time != INT64_MAX &&
2639 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2640 ist->is_past_recording_time = 1;
2641 goto discard_packet;
2644 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2645 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2648 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2649 ist->file_index, ist->st->index);
2652 av_free_packet(&pkt);
2657 av_free_packet(&pkt);
2659 /* dump report by using the output first video and audio streams */
2660 print_report(output_files, ost_table, nb_ostreams, 0);
2663 /* at the end of stream, we must flush the decoder buffers */
2664 for (i = 0; i < nb_input_streams; i++) {
2665 ist = &input_streams[i];
2666 if (ist->decoding_needed) {
2667 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2673 /* write the trailer if needed and close file */
2674 for(i=0;i<nb_output_files;i++) {
2675 os = output_files[i];
2676 av_write_trailer(os);
2679 /* dump report by using the first video and audio streams */
2680 print_report(output_files, ost_table, nb_ostreams, 1);
2682 /* close each encoder */
2683 for(i=0;i<nb_ostreams;i++) {
2685 if (ost->encoding_needed) {
2686 av_freep(&ost->st->codec->stats_in);
2687 avcodec_close(ost->st->codec);
2690 avfilter_graph_free(&ost->graph);
2694 /* close each decoder */
2695 for (i = 0; i < nb_input_streams; i++) {
2696 ist = &input_streams[i];
2697 if (ist->decoding_needed) {
2698 avcodec_close(ist->st->codec);
2706 av_freep(&bit_buffer);
2709 for(i=0;i<nb_ostreams;i++) {
2712 if (ost->st->stream_copy)
2713 av_freep(&ost->st->codec->extradata);
2715 fclose(ost->logfile);
2716 ost->logfile = NULL;
2718 av_fifo_free(ost->fifo); /* works even if fifo is not
2719 initialized but set to zero */
2720 av_freep(&ost->st->codec->subtitle_header);
2721 av_free(ost->pict_tmp.data[0]);
2722 av_free(ost->forced_kf_pts);
2723 if (ost->video_resample)
2724 sws_freeContext(ost->img_resample_ctx);
2726 audio_resample_close(ost->resample);
2727 if (ost->reformat_ctx)
2728 av_audio_convert_free(ost->reformat_ctx);
2737 static int opt_format(const char *opt, const char *arg)
2739 last_asked_format = arg;
2743 static int opt_video_rc_override_string(const char *opt, const char *arg)
2745 video_rc_override_string = arg;
2749 static int opt_me_threshold(const char *opt, const char *arg)
2751 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2755 static int opt_verbose(const char *opt, const char *arg)
2757 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2761 static int opt_frame_rate(const char *opt, const char *arg)
2763 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2764 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2770 static int opt_bitrate(const char *opt, const char *arg)
2772 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2774 opt_default(opt, arg);
2776 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2777 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2782 static int opt_frame_crop(const char *opt, const char *arg)
2784 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2785 return AVERROR(EINVAL);
2788 static int opt_frame_size(const char *opt, const char *arg)
2790 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2791 fprintf(stderr, "Incorrect frame size\n");
2792 return AVERROR(EINVAL);
2797 static int opt_pad(const char *opt, const char *arg) {
2798 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2802 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2804 if (strcmp(arg, "list")) {
2805 frame_pix_fmt = av_get_pix_fmt(arg);
2806 if (frame_pix_fmt == PIX_FMT_NONE) {
2807 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2808 return AVERROR(EINVAL);
2817 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2824 p = strchr(arg, ':');
2826 x = strtol(arg, &end, 10);
2828 y = strtol(end+1, &end, 10);
2830 ar = (double)x / (double)y;
2832 ar = strtod(arg, NULL);
2835 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2836 return AVERROR(EINVAL);
2838 frame_aspect_ratio = ar;
2842 static int opt_metadata(const char *opt, const char *arg)
2844 char *mid= strchr(arg, '=');
2847 fprintf(stderr, "Missing =\n");
2852 av_dict_set(&metadata, arg, mid, 0);
2857 static int opt_qscale(const char *opt, const char *arg)
2859 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2860 if (video_qscale == 0) {
2861 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2862 return AVERROR(EINVAL);
2867 static int opt_top_field_first(const char *opt, const char *arg)
2869 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2873 static int opt_thread_count(const char *opt, const char *arg)
2875 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2878 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2883 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2885 if (strcmp(arg, "list")) {
2886 audio_sample_fmt = av_get_sample_fmt(arg);
2887 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2888 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2889 return AVERROR(EINVAL);
2894 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2895 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2901 static int opt_audio_rate(const char *opt, const char *arg)
2903 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2907 static int opt_audio_channels(const char *opt, const char *arg)
2909 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2913 static int opt_video_channel(const char *opt, const char *arg)
2915 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2916 opt_default("channel", arg);
2920 static int opt_video_standard(const char *opt, const char *arg)
2922 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2923 opt_default("standard", arg);
2927 static int opt_codec(int *pstream_copy, char **pcodec_name,
2928 int codec_type, const char *arg)
2930 av_freep(pcodec_name);
2931 if (!strcmp(arg, "copy")) {
2934 *pcodec_name = av_strdup(arg);
2939 static int opt_audio_codec(const char *opt, const char *arg)
2941 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2944 static int opt_video_codec(const char *opt, const char *arg)
2946 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2949 static int opt_subtitle_codec(const char *opt, const char *arg)
2951 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2954 static int opt_data_codec(const char *opt, const char *arg)
2956 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2959 static int opt_codec_tag(const char *opt, const char *arg)
2962 uint32_t *codec_tag;
2964 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2965 !strcmp(opt, "vtag") ? &video_codec_tag :
2966 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2970 *codec_tag = strtol(arg, &tail, 0);
2972 *codec_tag = AV_RL32(arg);
2977 static int opt_map(const char *opt, const char *arg)
2982 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2983 m = &stream_maps[nb_stream_maps-1];
2985 m->file_index = strtol(arg, &p, 0);
2989 m->stream_index = strtol(p, &p, 0);
2992 m->sync_file_index = strtol(p, &p, 0);
2995 m->sync_stream_index = strtol(p, &p, 0);
2997 m->sync_file_index = m->file_index;
2998 m->sync_stream_index = m->stream_index;
3003 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3014 *index = strtol(++arg, endptr, 0);
3017 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3024 static int opt_map_metadata(const char *opt, const char *arg)
3026 MetadataMap *m, *m1;
3029 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3030 &nb_meta_data_maps, nb_meta_data_maps + 1);
3032 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3033 m->file = strtol(arg, &p, 0);
3034 parse_meta_type(p, &m->type, &m->index, &p);
3038 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3039 m1->file = strtol(p, &p, 0);
3040 parse_meta_type(p, &m1->type, &m1->index, &p);
3042 if (m->type == 'g' || m1->type == 'g')
3043 metadata_global_autocopy = 0;
3044 if (m->type == 's' || m1->type == 's')
3045 metadata_streams_autocopy = 0;
3046 if (m->type == 'c' || m1->type == 'c')
3047 metadata_chapters_autocopy = 0;
3052 static int opt_map_meta_data(const char *opt, const char *arg)
3054 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3055 "Use -map_metadata instead.\n");
3056 return opt_map_metadata(opt, arg);
3059 static int opt_map_chapters(const char *opt, const char *arg)
3064 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3065 nb_chapter_maps + 1);
3066 c = &chapter_maps[nb_chapter_maps - 1];
3067 c->out_file = strtol(arg, &p, 0);
3071 c->in_file = strtol(p, &p, 0);
3075 static int opt_input_ts_scale(const char *opt, const char *arg)
3077 unsigned int stream;
3081 stream = strtol(arg, &p, 0);
3084 scale= strtod(p, &p);
3086 if(stream >= MAX_STREAMS)
3089 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3090 ts_scale[stream] = scale;
3094 static int opt_recording_time(const char *opt, const char *arg)
3096 recording_time = parse_time_or_die(opt, arg, 1);
3100 static int opt_start_time(const char *opt, const char *arg)
3102 start_time = parse_time_or_die(opt, arg, 1);
3106 static int opt_recording_timestamp(const char *opt, const char *arg)
3109 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3110 struct tm time = *gmtime((time_t*)&recording_timestamp);
3111 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3112 opt_metadata("metadata", buf);
3114 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3115 "tag instead.\n", opt);
3119 static int opt_input_ts_offset(const char *opt, const char *arg)
3121 input_ts_offset = parse_time_or_die(opt, arg, 1);
3125 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3127 const char *codec_string = encoder ? "encoder" : "decoder";
3131 return CODEC_ID_NONE;
3133 avcodec_find_encoder_by_name(name) :
3134 avcodec_find_decoder_by_name(name);
3136 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3139 if(codec->type != type) {
3140 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3143 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3144 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3145 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3146 "results.\nAdd '-strict experimental' if you want to use it.\n",
3147 codec_string, codec->name);
3149 avcodec_find_encoder(codec->id) :
3150 avcodec_find_decoder(codec->id);
3151 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3152 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3153 codec_string, codec->name);
3159 static int opt_input_file(const char *opt, const char *filename)
3161 AVFormatContext *ic;
3162 AVInputFormat *file_iformat = NULL;
3163 int err, i, ret, rfps, rfps_base;
3167 if (last_asked_format) {
3168 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3169 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3172 last_asked_format = NULL;
3175 if (!strcmp(filename, "-"))
3178 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3179 !strcmp(filename, "/dev/stdin");
3181 /* get default parameters from command line */
3182 ic = avformat_alloc_context();
3184 print_error(filename, AVERROR(ENOMEM));
3187 if (audio_sample_rate) {
3188 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3189 av_dict_set(&format_opts, "sample_rate", buf, 0);
3191 if (audio_channels) {
3192 snprintf(buf, sizeof(buf), "%d", audio_channels);
3193 av_dict_set(&format_opts, "channels", buf, 0);
3195 if (frame_rate.num) {
3196 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3197 av_dict_set(&format_opts, "framerate", buf, 0);
3199 if (frame_width && frame_height) {
3200 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3201 av_dict_set(&format_opts, "video_size", buf, 0);
3203 if (frame_pix_fmt != PIX_FMT_NONE)
3204 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3206 ic->video_codec_id =
3207 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3208 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3209 ic->audio_codec_id =
3210 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3211 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3212 ic->subtitle_codec_id=
3213 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3214 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3215 ic->flags |= AVFMT_FLAG_NONBLOCK;
3217 /* open the input file with generic libav function */
3218 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3220 print_error(filename, err);
3223 assert_avoptions(format_opts);
3228 for(i=0; i<ic->nb_streams; i++){
3229 ic->streams[i]->discard= AVDISCARD_ALL;
3231 for(i=0; i<ic->nb_programs; i++){
3232 AVProgram *p= ic->programs[i];
3233 if(p->id != opt_programid){
3234 p->discard = AVDISCARD_ALL;
3237 for(j=0; j<p->nb_stream_indexes; j++){
3238 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3243 fprintf(stderr, "Specified program id not found\n");
3250 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3251 ic->loop_input = loop_input;
3254 /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3255 for (i = 0; i < ic->nb_streams; i++) {
3256 AVCodecContext *dec = ic->streams[i]->codec;
3257 switch (dec->codec_type) {
3258 case AVMEDIA_TYPE_AUDIO:
3259 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3260 AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3263 case AVMEDIA_TYPE_VIDEO:
3264 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3265 AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3271 /* If not enough info to get the stream parameters, we decode the
3272 first frames to get it. (used in mpeg case for example) */
3273 ret = av_find_stream_info(ic);
3274 if (ret < 0 && verbose >= 0) {
3275 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3276 av_close_input_file(ic);
3280 timestamp = start_time;
3281 /* add the stream start time */
3282 if (ic->start_time != AV_NOPTS_VALUE)
3283 timestamp += ic->start_time;
3285 /* if seeking requested, we execute it */
3286 if (start_time != 0) {
3287 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3289 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3290 filename, (double)timestamp / AV_TIME_BASE);
3292 /* reset seek info */
3296 /* update the current parameters so that they match the one of the input stream */
3297 for(i=0;i<ic->nb_streams;i++) {
3298 AVStream *st = ic->streams[i];
3299 AVCodecContext *dec = st->codec;
3302 dec->thread_count = thread_count;
3304 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3305 ist = &input_streams[nb_input_streams - 1];
3307 ist->file_index = nb_input_files;
3310 if (i < nb_ts_scale)
3311 ist->ts_scale = ts_scale[i];
3313 switch (dec->codec_type) {
3314 case AVMEDIA_TYPE_AUDIO:
3315 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3316 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3318 st->discard= AVDISCARD_ALL;
3320 case AVMEDIA_TYPE_VIDEO:
3321 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3322 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3323 rfps = ic->streams[i]->r_frame_rate.num;
3324 rfps_base = ic->streams[i]->r_frame_rate.den;
3326 dec->flags |= CODEC_FLAG_EMU_EDGE;
3327 dec->height >>= dec->lowres;
3328 dec->width >>= dec->lowres;
3331 dec->debug |= FF_DEBUG_MV;
3333 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3336 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3337 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3339 (float)rfps / rfps_base, rfps, rfps_base);
3343 st->discard= AVDISCARD_ALL;
3344 else if(video_discard)
3345 st->discard= video_discard;
3347 case AVMEDIA_TYPE_DATA:
3349 case AVMEDIA_TYPE_SUBTITLE:
3350 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3351 if(subtitle_disable)
3352 st->discard = AVDISCARD_ALL;
3354 case AVMEDIA_TYPE_ATTACHMENT:
3355 case AVMEDIA_TYPE_UNKNOWN:
3362 /* dump the file content */
3364 av_dump_format(ic, nb_input_files, filename, 0);
3366 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3367 input_files[nb_input_files - 1].ctx = ic;
3368 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3369 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3371 frame_rate = (AVRational){0, 0};
3372 frame_pix_fmt = PIX_FMT_NONE;
3375 audio_sample_rate = 0;
3377 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3378 av_freep(&ts_scale);
3381 av_freep(&video_codec_name);
3382 av_freep(&audio_codec_name);
3383 av_freep(&subtitle_codec_name);
3389 static void check_inputs(int *has_video_ptr,
3391 int *has_subtitle_ptr,
3394 int has_video, has_audio, has_subtitle, has_data, i, j;
3395 AVFormatContext *ic;
3402 for(j=0;j<nb_input_files;j++) {
3403 ic = input_files[j].ctx;
3404 for(i=0;i<ic->nb_streams;i++) {
3405 AVCodecContext *enc = ic->streams[i]->codec;
3406 switch(enc->codec_type) {
3407 case AVMEDIA_TYPE_AUDIO:
3410 case AVMEDIA_TYPE_VIDEO:
3413 case AVMEDIA_TYPE_SUBTITLE:
3416 case AVMEDIA_TYPE_DATA:
3417 case AVMEDIA_TYPE_ATTACHMENT:
3418 case AVMEDIA_TYPE_UNKNOWN:
3426 *has_video_ptr = has_video;
3427 *has_audio_ptr = has_audio;
3428 *has_subtitle_ptr = has_subtitle;
3429 *has_data_ptr = has_data;
3432 static void new_video_stream(AVFormatContext *oc, int file_idx)
3436 AVCodecContext *video_enc;
3437 enum CodecID codec_id = CODEC_ID_NONE;
3438 AVCodec *codec= NULL;
3440 if(!video_stream_copy){
3441 if (video_codec_name) {
3442 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3443 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3444 codec = avcodec_find_encoder_by_name(video_codec_name);
3446 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3447 codec = avcodec_find_encoder(codec_id);
3451 ost = new_output_stream(oc, file_idx, codec);
3453 if (!video_stream_copy) {
3454 ost->frame_aspect_ratio = frame_aspect_ratio;
3455 frame_aspect_ratio = 0;
3457 ost->avfilter= vfilters;
3462 ost->bitstream_filters = video_bitstream_filters;
3463 video_bitstream_filters= NULL;
3465 st->codec->thread_count= thread_count;
3467 video_enc = st->codec;
3470 video_enc->codec_tag= video_codec_tag;
3472 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3473 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3474 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3477 if (video_stream_copy) {
3478 st->stream_copy = 1;
3479 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3480 video_enc->sample_aspect_ratio =
3481 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3487 ost->frame_rate = frame_rate;
3488 video_enc->codec_id = codec_id;
3489 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3491 video_enc->width = frame_width;
3492 video_enc->height = frame_height;
3493 video_enc->pix_fmt = frame_pix_fmt;
3494 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3497 video_enc->gop_size = 0;
3498 if (video_qscale || same_quality) {
3499 video_enc->flags |= CODEC_FLAG_QSCALE;
3500 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3504 video_enc->intra_matrix = intra_matrix;
3506 video_enc->inter_matrix = inter_matrix;
3508 p= video_rc_override_string;
3511 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3513 fprintf(stderr, "error parsing rc_override\n");
3516 video_enc->rc_override=
3517 av_realloc(video_enc->rc_override,
3518 sizeof(RcOverride)*(i+1));
3519 video_enc->rc_override[i].start_frame= start;
3520 video_enc->rc_override[i].end_frame = end;
3522 video_enc->rc_override[i].qscale= q;
3523 video_enc->rc_override[i].quality_factor= 1.0;
3526 video_enc->rc_override[i].qscale= 0;
3527 video_enc->rc_override[i].quality_factor= -q/100.0;
3532 video_enc->rc_override_count=i;
3533 if (!video_enc->rc_initial_buffer_occupancy)
3534 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3535 video_enc->me_threshold= me_threshold;
3536 video_enc->intra_dc_precision= intra_dc_precision - 8;
3539 video_enc->flags|= CODEC_FLAG_PSNR;
3544 video_enc->flags |= CODEC_FLAG_PASS1;
3546 video_enc->flags |= CODEC_FLAG_PASS2;
3550 if (forced_key_frames)
3551 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3553 if (video_language) {
3554 av_dict_set(&st->metadata, "language", video_language, 0);
3555 av_freep(&video_language);
3558 /* reset some key parameters */
3560 av_freep(&video_codec_name);
3561 av_freep(&forced_key_frames);
3562 video_stream_copy = 0;
3563 frame_pix_fmt = PIX_FMT_NONE;
3566 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3570 AVCodec *codec= NULL;
3571 AVCodecContext *audio_enc;
3572 enum CodecID codec_id = CODEC_ID_NONE;
3574 if(!audio_stream_copy){
3575 if (audio_codec_name) {
3576 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3577 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3578 codec = avcodec_find_encoder_by_name(audio_codec_name);
3580 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3581 codec = avcodec_find_encoder(codec_id);
3584 ost = new_output_stream(oc, file_idx, codec);
3587 ost->bitstream_filters = audio_bitstream_filters;
3588 audio_bitstream_filters= NULL;
3590 st->codec->thread_count= thread_count;
3592 audio_enc = st->codec;
3593 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3596 audio_enc->codec_tag= audio_codec_tag;
3598 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3599 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3600 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3602 if (audio_stream_copy) {
3603 st->stream_copy = 1;
3605 audio_enc->codec_id = codec_id;
3606 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3608 if (audio_qscale > QSCALE_NONE) {
3609 audio_enc->flags |= CODEC_FLAG_QSCALE;
3610 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3613 audio_enc->channels = audio_channels;
3614 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3615 audio_enc->sample_fmt = audio_sample_fmt;
3616 if (audio_sample_rate)
3617 audio_enc->sample_rate = audio_sample_rate;
3619 if (audio_language) {
3620 av_dict_set(&st->metadata, "language", audio_language, 0);
3621 av_freep(&audio_language);
3624 /* reset some key parameters */
3626 av_freep(&audio_codec_name);
3627 audio_stream_copy = 0;
3630 static void new_data_stream(AVFormatContext *oc, int file_idx)
3634 AVCodecContext *data_enc;
3636 ost = new_output_stream(oc, file_idx, NULL);
3638 data_enc = st->codec;
3639 if (!data_stream_copy) {
3640 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3644 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3647 data_enc->codec_tag= data_codec_tag;
3649 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3650 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3651 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3653 if (data_stream_copy) {
3654 st->stream_copy = 1;
3658 av_freep(&data_codec_name);
3659 data_stream_copy = 0;
3662 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3666 AVCodec *codec=NULL;
3667 AVCodecContext *subtitle_enc;
3668 enum CodecID codec_id = CODEC_ID_NONE;
3670 if(!subtitle_stream_copy){
3671 if (subtitle_codec_name) {
3672 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3673 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3674 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3676 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3677 codec = avcodec_find_encoder(codec_id);
3680 ost = new_output_stream(oc, file_idx, codec);
3682 subtitle_enc = st->codec;
3684 ost->bitstream_filters = subtitle_bitstream_filters;
3685 subtitle_bitstream_filters= NULL;
3687 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3689 if(subtitle_codec_tag)
3690 subtitle_enc->codec_tag= subtitle_codec_tag;
3692 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3693 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3694 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3696 if (subtitle_stream_copy) {
3697 st->stream_copy = 1;
3699 subtitle_enc->codec_id = codec_id;
3700 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3703 if (subtitle_language) {
3704 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3705 av_freep(&subtitle_language);
3708 subtitle_disable = 0;
3709 av_freep(&subtitle_codec_name);
3710 subtitle_stream_copy = 0;
3713 static int opt_new_stream(const char *opt, const char *arg)
3715 AVFormatContext *oc;
3716 int file_idx = nb_output_files - 1;
3717 if (nb_output_files <= 0) {
3718 fprintf(stderr, "At least one output file must be specified\n");
3721 oc = output_files[file_idx];
3723 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3724 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3725 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3726 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3731 /* arg format is "output-stream-index:streamid-value". */
3732 static int opt_streamid(const char *opt, const char *arg)
3738 av_strlcpy(idx_str, arg, sizeof(idx_str));
3739 p = strchr(idx_str, ':');
3742 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3747 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3748 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3749 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3753 static void opt_output_file(const char *filename)
3755 AVFormatContext *oc;
3756 int err, use_video, use_audio, use_subtitle, use_data;
3757 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3758 AVOutputFormat *file_oformat;
3760 if (!strcmp(filename, "-"))
3763 oc = avformat_alloc_context();
3765 print_error(filename, AVERROR(ENOMEM));
3769 if (last_asked_format) {
3770 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3771 if (!file_oformat) {
3772 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3775 last_asked_format = NULL;
3777 file_oformat = av_guess_format(NULL, filename, NULL);
3778 if (!file_oformat) {
3779 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3785 oc->oformat = file_oformat;
3786 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3788 if (!strcmp(file_oformat->name, "ffm") &&
3789 av_strstart(filename, "http:", NULL)) {
3790 /* special case for files sent to ffserver: we get the stream
3791 parameters from ffserver */
3792 int err = read_ffserver_streams(oc, filename);
3794 print_error(filename, err);
3798 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3799 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3800 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3801 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 */
3803 /* disable if no corresponding type found */
3804 check_inputs(&input_has_video,
3806 &input_has_subtitle,
3809 if (!input_has_video)
3811 if (!input_has_audio)
3813 if (!input_has_subtitle)
3815 if (!input_has_data)
3818 /* manual disable */
3819 if (audio_disable) use_audio = 0;
3820 if (video_disable) use_video = 0;
3821 if (subtitle_disable) use_subtitle = 0;
3822 if (data_disable) use_data = 0;
3824 if (use_video) new_video_stream(oc, nb_output_files);
3825 if (use_audio) new_audio_stream(oc, nb_output_files);
3826 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3827 if (use_data) new_data_stream(oc, nb_output_files);
3829 av_dict_copy(&oc->metadata, metadata, 0);
3830 av_dict_free(&metadata);
3833 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3834 output_files[nb_output_files++] = oc;
3836 /* check filename in case of an image number is expected */
3837 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3838 if (!av_filename_number_test(oc->filename)) {
3839 print_error(oc->filename, AVERROR(EINVAL));
3844 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3845 /* test if it already exists to avoid loosing precious files */
3846 if (!file_overwrite &&
3847 (strchr(filename, ':') == NULL ||
3848 filename[1] == ':' ||
3849 av_strstart(filename, "file:", NULL))) {
3850 if (avio_check(filename, 0) == 0) {
3852 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3854 if (!read_yesno()) {
3855 fprintf(stderr, "Not overwriting - exiting\n");
3860 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3867 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3868 print_error(filename, err);
3873 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3874 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3875 if (loop_output >= 0) {
3876 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3877 oc->loop_output = loop_output;
3879 oc->flags |= AVFMT_FLAG_NONBLOCK;
3881 frame_rate = (AVRational){0, 0};
3884 audio_sample_rate = 0;
3886 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3888 av_freep(&forced_key_frames);
3893 /* same option as mencoder */
3894 static int opt_pass(const char *opt, const char *arg)
3896 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3900 static int64_t getutime(void)
3903 struct rusage rusage;
3905 getrusage(RUSAGE_SELF, &rusage);
3906 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3907 #elif HAVE_GETPROCESSTIMES
3909 FILETIME c, e, k, u;
3910 proc = GetCurrentProcess();
3911 GetProcessTimes(proc, &c, &e, &k, &u);
3912 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3914 return av_gettime();
3918 static int64_t getmaxrss(void)
3920 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3921 struct rusage rusage;
3922 getrusage(RUSAGE_SELF, &rusage);
3923 return (int64_t)rusage.ru_maxrss * 1024;
3924 #elif HAVE_GETPROCESSMEMORYINFO
3926 PROCESS_MEMORY_COUNTERS memcounters;
3927 proc = GetCurrentProcess();
3928 memcounters.cb = sizeof(memcounters);
3929 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3930 return memcounters.PeakPagefileUsage;
3936 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3939 const char *p = str;
3946 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3953 static void opt_inter_matrix(const char *arg)
3955 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3956 parse_matrix_coeffs(inter_matrix, arg);
3959 static void opt_intra_matrix(const char *arg)
3961 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3962 parse_matrix_coeffs(intra_matrix, arg);
3965 static void show_usage(void)
3967 printf("Hyper fast Audio and Video encoder\n");
3968 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3972 static void show_help(void)
3975 AVOutputFormat *oformat = NULL;
3976 AVInputFormat *iformat = NULL;
3978 av_log_set_callback(log_callback_help);
3980 show_help_options(options, "Main options:\n",
3981 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3982 show_help_options(options, "\nAdvanced options:\n",
3983 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3985 show_help_options(options, "\nVideo options:\n",
3986 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3988 show_help_options(options, "\nAdvanced Video options:\n",
3989 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3990 OPT_VIDEO | OPT_EXPERT);
3991 show_help_options(options, "\nAudio options:\n",
3992 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3994 show_help_options(options, "\nAdvanced Audio options:\n",
3995 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3996 OPT_AUDIO | OPT_EXPERT);
3997 show_help_options(options, "\nSubtitle options:\n",
3998 OPT_SUBTITLE | OPT_GRAB,
4000 show_help_options(options, "\nAudio/Video grab options:\n",
4004 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4007 /* individual codec options */
4009 while ((c = av_codec_next(c))) {
4010 if (c->priv_class) {
4011 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4016 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4019 /* individual muxer options */
4020 while ((oformat = av_oformat_next(oformat))) {
4021 if (oformat->priv_class) {
4022 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4027 /* individual demuxer options */
4028 while ((iformat = av_iformat_next(iformat))) {
4029 if (iformat->priv_class) {
4030 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4035 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4038 static int opt_target(const char *opt, const char *arg)
4040 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4041 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4043 if(!strncmp(arg, "pal-", 4)) {
4046 } else if(!strncmp(arg, "ntsc-", 5)) {
4049 } else if(!strncmp(arg, "film-", 5)) {
4054 /* Calculate FR via float to avoid int overflow */
4055 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4058 } else if((fr == 29970) || (fr == 23976)) {
4061 /* Try to determine PAL/NTSC by peeking in the input files */
4062 if(nb_input_files) {
4064 for (j = 0; j < nb_input_files; j++) {
4065 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4066 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4067 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4069 fr = c->time_base.den * 1000 / c->time_base.num;
4073 } else if((fr == 29970) || (fr == 23976)) {
4083 if(verbose > 0 && norm != UNKNOWN)
4084 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4087 if(norm == UNKNOWN) {
4088 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4089 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4090 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4094 if(!strcmp(arg, "vcd")) {
4095 opt_video_codec("vcodec", "mpeg1video");
4096 opt_audio_codec("vcodec", "mp2");
4097 opt_format("f", "vcd");
4099 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4100 opt_frame_rate("r", frame_rates[norm]);
4101 opt_default("g", norm == PAL ? "15" : "18");
4103 opt_default("b", "1150000");
4104 opt_default("maxrate", "1150000");
4105 opt_default("minrate", "1150000");
4106 opt_default("bufsize", "327680"); // 40*1024*8;
4108 opt_default("ab", "224000");
4109 audio_sample_rate = 44100;
4112 opt_default("packetsize", "2324");
4113 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4115 /* We have to offset the PTS, so that it is consistent with the SCR.
4116 SCR starts at 36000, but the first two packs contain only padding
4117 and the first pack from the other stream, respectively, may also have
4118 been written before.
4119 So the real data starts at SCR 36000+3*1200. */
4120 mux_preload= (36000+3*1200) / 90000.0; //0.44
4121 } else if(!strcmp(arg, "svcd")) {
4123 opt_video_codec("vcodec", "mpeg2video");
4124 opt_audio_codec("acodec", "mp2");
4125 opt_format("f", "svcd");
4127 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4128 opt_frame_rate("r", frame_rates[norm]);
4129 opt_default("g", norm == PAL ? "15" : "18");
4131 opt_default("b", "2040000");
4132 opt_default("maxrate", "2516000");
4133 opt_default("minrate", "0"); //1145000;
4134 opt_default("bufsize", "1835008"); //224*1024*8;
4135 opt_default("flags", "+scan_offset");
4138 opt_default("ab", "224000");
4139 audio_sample_rate = 44100;
4141 opt_default("packetsize", "2324");
4143 } else if(!strcmp(arg, "dvd")) {
4145 opt_video_codec("vcodec", "mpeg2video");
4146 opt_audio_codec("vcodec", "ac3");
4147 opt_format("f", "dvd");
4149 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4150 opt_frame_rate("r", frame_rates[norm]);
4151 opt_default("g", norm == PAL ? "15" : "18");
4153 opt_default("b", "6000000");
4154 opt_default("maxrate", "9000000");
4155 opt_default("minrate", "0"); //1500000;
4156 opt_default("bufsize", "1835008"); //224*1024*8;
4158 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4159 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4161 opt_default("ab", "448000");
4162 audio_sample_rate = 48000;
4164 } else if(!strncmp(arg, "dv", 2)) {
4166 opt_format("f", "dv");
4168 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4169 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4170 norm == PAL ? "yuv420p" : "yuv411p");
4171 opt_frame_rate("r", frame_rates[norm]);
4173 audio_sample_rate = 48000;
4177 fprintf(stderr, "Unknown target: %s\n", arg);
4178 return AVERROR(EINVAL);
4183 static int opt_vstats_file(const char *opt, const char *arg)
4185 av_free (vstats_filename);
4186 vstats_filename=av_strdup (arg);
4190 static int opt_vstats(const char *opt, const char *arg)
4193 time_t today2 = time(NULL);
4194 struct tm *today = localtime(&today2);
4196 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4198 return opt_vstats_file(opt, filename);
4201 static int opt_bsf(const char *opt, const char *arg)
4203 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4204 AVBitStreamFilterContext **bsfp;
4207 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4211 bsfp= *opt == 'v' ? &video_bitstream_filters :
4212 *opt == 'a' ? &audio_bitstream_filters :
4213 &subtitle_bitstream_filters;
4215 bsfp= &(*bsfp)->next;
4222 static int opt_preset(const char *opt, const char *arg)
4225 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4226 char *codec_name = *opt == 'v' ? video_codec_name :
4227 *opt == 'a' ? audio_codec_name :
4228 subtitle_codec_name;
4230 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4231 fprintf(stderr, "File for preset '%s' not found\n", arg);
4236 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4237 if(line[0] == '#' && !e)
4239 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4241 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4244 if(!strcmp(tmp, "acodec")){
4245 opt_audio_codec(tmp, tmp2);
4246 }else if(!strcmp(tmp, "vcodec")){
4247 opt_video_codec(tmp, tmp2);
4248 }else if(!strcmp(tmp, "scodec")){
4249 opt_subtitle_codec(tmp, tmp2);
4250 }else if(!strcmp(tmp, "dcodec")){
4251 opt_data_codec(tmp, tmp2);
4252 }else if(opt_default(tmp, tmp2) < 0){
4253 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4263 static const OptionDef options[] = {
4265 #include "cmdutils_common_opts.h"
4266 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4267 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4268 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4269 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4270 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4271 "outfile[,metadata]:infile[,metadata]" },
4272 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4273 "outfile[,metadata]:infile[,metadata]" },
4274 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4275 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4276 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4277 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4278 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4279 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4280 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4281 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4282 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4283 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4284 "add timings for benchmarking" },
4285 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4286 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4287 "dump each input packet" },
4288 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4289 "when dumping packets, also dump the payload" },
4290 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4291 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4292 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4293 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4294 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4295 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4296 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4297 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4298 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4299 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4300 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4301 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4302 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4303 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4304 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4305 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4308 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4309 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4310 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4311 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4312 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4313 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4314 { "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" },
4315 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4316 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4317 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4318 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4319 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4320 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4321 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4322 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4323 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4324 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4325 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4326 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4327 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4328 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4329 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4330 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4331 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4332 "use same quantizer as source (implies VBR)" },
4333 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4334 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4335 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4336 "deinterlace pictures" },
4337 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4338 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4339 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4341 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4343 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4344 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4345 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4346 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4347 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4348 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4349 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4350 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4351 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4352 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4353 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4356 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4357 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4358 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4359 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4360 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4361 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4362 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4363 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4364 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4365 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4366 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4367 { "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" },
4369 /* subtitle options */
4370 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4371 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4372 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4373 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4374 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4377 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4378 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4379 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4382 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4383 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4385 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4386 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4387 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4389 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4390 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4391 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4392 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4393 /* data codec support */
4394 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4396 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4400 int main(int argc, char **argv)
4404 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4406 avcodec_register_all();
4408 avdevice_register_all();
4411 avfilter_register_all();
4415 avio_set_interrupt_cb(decode_interrupt_cb);
4422 parse_options(argc, argv, options, opt_output_file);
4424 if(nb_output_files <= 0 && nb_input_files == 0) {
4426 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4430 /* file converter / grab */
4431 if (nb_output_files <= 0) {
4432 fprintf(stderr, "At least one output file must be specified\n");
4436 if (nb_input_files == 0) {
4437 fprintf(stderr, "At least one input file must be specified\n");
4442 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4443 stream_maps, nb_stream_maps) < 0)
4445 ti = getutime() - ti;
4447 int maxrss = getmaxrss() / 1024;
4448 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4451 return ffmpeg_exit(0);