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/pixdesc.h"
44 #include "libavutil/avstring.h"
45 #include "libavutil/libm.h"
46 #include "libavformat/os_support.h"
49 # include "libavfilter/avfilter.h"
50 # include "libavfilter/avfiltergraph.h"
51 # include "libavfilter/vsrc_buffer.h"
54 #if HAVE_SYS_RESOURCE_H
55 #include <sys/types.h>
57 #include <sys/resource.h>
58 #elif HAVE_GETPROCESSTIMES
61 #if HAVE_GETPROCESSMEMORYINFO
67 #include <sys/select.h>
74 #include "libavutil/avassert.h"
76 const char program_name[] = "ffmpeg";
77 const int program_birth_year = 2000;
79 /* select an input stream for an output stream */
80 typedef struct AVStreamMap {
84 int sync_stream_index;
88 * select an input file for an output file
90 typedef struct AVMetaDataMap {
91 int file; //< file index
92 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
93 int index; //< stream/chapter/program number
96 typedef struct AVChapterMap {
101 static const OptionDef options[];
103 #define MAX_FILES 100
104 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
106 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
108 static const char *last_asked_format = NULL;
109 static int64_t input_files_ts_offset[MAX_FILES];
110 static double *input_files_ts_scale[MAX_FILES] = {NULL};
111 static AVCodec **input_codecs = NULL;
112 static int nb_input_codecs = 0;
113 static int nb_input_files_ts_scale[MAX_FILES] = {0};
115 static AVFormatContext *output_files[MAX_FILES];
116 static int nb_output_files = 0;
118 static AVStreamMap *stream_maps = NULL;
119 static int nb_stream_maps;
121 /* first item specifies output metadata, second is input */
122 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
123 static int nb_meta_data_maps;
124 static int metadata_global_autocopy = 1;
125 static int metadata_streams_autocopy = 1;
126 static int metadata_chapters_autocopy = 1;
128 static AVChapterMap *chapter_maps = NULL;
129 static int nb_chapter_maps;
131 /* indexed by output file stream index */
132 static int *streamid_map = NULL;
133 static int nb_streamid_map = 0;
135 static int frame_width = 0;
136 static int frame_height = 0;
137 static float frame_aspect_ratio = 0;
138 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
139 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
140 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
141 static AVRational frame_rate;
142 static float video_qscale = 0;
143 static uint16_t *intra_matrix = NULL;
144 static uint16_t *inter_matrix = NULL;
145 static const char *video_rc_override_string=NULL;
146 static int video_disable = 0;
147 static int video_discard = 0;
148 static char *video_codec_name = NULL;
149 static unsigned int video_codec_tag = 0;
150 static char *video_language = NULL;
151 static int same_quality = 0;
152 static int do_deinterlace = 0;
153 static int top_field_first = -1;
154 static int me_threshold = 0;
155 static int intra_dc_precision = 8;
156 static int loop_input = 0;
157 static int loop_output = AVFMT_NOOUTPUTLOOP;
158 static int qp_hist = 0;
160 static char *vfilters = NULL;
163 static int intra_only = 0;
164 static int audio_sample_rate = 0;
165 static int64_t channel_layout = 0;
166 #define QSCALE_NONE -99999
167 static float audio_qscale = QSCALE_NONE;
168 static int audio_disable = 0;
169 static int audio_channels = 0;
170 static char *audio_codec_name = NULL;
171 static unsigned int audio_codec_tag = 0;
172 static char *audio_language = NULL;
174 static int subtitle_disable = 0;
175 static char *subtitle_codec_name = NULL;
176 static char *subtitle_language = NULL;
177 static unsigned int subtitle_codec_tag = 0;
179 static int data_disable = 0;
180 static char *data_codec_name = NULL;
181 static unsigned int data_codec_tag = 0;
183 static float mux_preload= 0.5;
184 static float mux_max_delay= 0.7;
186 static int64_t recording_time = INT64_MAX;
187 static int64_t start_time = 0;
188 static int64_t recording_timestamp = 0;
189 static int64_t input_ts_offset = 0;
190 static int file_overwrite = 0;
191 static AVDictionary *metadata;
192 static int do_benchmark = 0;
193 static int do_hex_dump = 0;
194 static int do_pkt_dump = 0;
195 static int do_psnr = 0;
196 static int do_pass = 0;
197 static char *pass_logfilename_prefix = NULL;
198 static int audio_stream_copy = 0;
199 static int video_stream_copy = 0;
200 static int subtitle_stream_copy = 0;
201 static int data_stream_copy = 0;
202 static int video_sync_method= -1;
203 static int audio_sync_method= 0;
204 static float audio_drift_threshold= 0.1;
205 static int copy_ts= 0;
207 static int opt_shortest = 0;
208 static char *vstats_filename;
209 static FILE *vstats_file;
210 static int opt_programid = 0;
211 static int copy_initial_nonkeyframes = 0;
213 static int rate_emu = 0;
215 static int video_channel = 0;
216 static char *video_standard;
218 static int audio_volume = 256;
220 static int exit_on_error = 0;
221 static int using_stdin = 0;
222 static int verbose = 1;
223 static int thread_count= 1;
224 static int64_t video_size = 0;
225 static int64_t audio_size = 0;
226 static int64_t extra_size = 0;
227 static int nb_frames_dup = 0;
228 static int nb_frames_drop = 0;
229 static int input_sync;
230 static uint64_t limit_filesize = 0;
231 static int force_fps = 0;
232 static char *forced_key_frames = NULL;
234 static float dts_delta_threshold = 10;
236 static int64_t timer_start;
238 static uint8_t *audio_buf;
239 static uint8_t *audio_out;
240 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
242 static short *samples;
244 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
245 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
246 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
248 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
250 struct AVInputStream;
252 typedef struct AVOutputStream {
253 int file_index; /* file index */
254 int index; /* stream index in the output file */
255 int source_index; /* AVInputStream index */
256 AVStream *st; /* stream in the output file */
257 int encoding_needed; /* true if encoding needed for this stream */
259 /* input pts and corresponding output pts
261 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
262 struct AVInputStream *sync_ist; /* input stream to sync against */
263 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
264 AVBitStreamFilterContext *bitstream_filters;
269 AVFrame pict_tmp; /* temporary image for resampling */
270 struct SwsContext *img_resample_ctx; /* for image resampling */
273 int resample_pix_fmt;
274 AVRational frame_rate;
276 float frame_aspect_ratio;
278 /* forced key frames */
279 int64_t *forced_kf_pts;
285 ReSampleContext *resample; /* for audio resampling */
286 int resample_sample_fmt;
287 int resample_channels;
288 int resample_sample_rate;
290 AVAudioConvert *reformat_ctx;
291 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
295 AVFilterContext *output_video_filter;
296 AVFilterContext *input_video_filter;
297 AVFilterBufferRef *picref;
299 AVFilterGraph *graph;
305 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
306 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
308 typedef struct AVInputStream {
311 int discard; /* true if stream data should be discarded */
312 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
313 int64_t sample_index; /* current sample */
315 int64_t start; /* time when read started */
316 int64_t next_pts; /* synthetic pts for cases where pkt.pts
318 int64_t pts; /* current pts */
319 PtsCorrectionContext pts_ctx;
320 int is_start; /* is 1 at the start and after a discontinuity */
321 int showed_multi_packet_warning;
322 int is_past_recording_time;
324 AVFrame *filter_frame;
325 int has_filter_frame;
329 typedef struct AVInputFile {
330 AVFormatContext *ctx;
331 int eof_reached; /* true if eof reached */
332 int ist_index; /* index of first stream in ist_table */
333 int buffer_size; /* current total buffer size */
336 static AVInputStream *input_streams = NULL;
337 static int nb_input_streams = 0;
338 static AVInputFile *input_files = NULL;
339 static int nb_input_files = 0;
343 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
345 AVFilterContext *last_filter, *filter;
346 /** filter graph containing all filters including input & output */
347 AVCodecContext *codec = ost->st->codec;
348 AVCodecContext *icodec = ist->st->codec;
349 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
350 AVRational sample_aspect_ratio;
354 ost->graph = avfilter_graph_alloc();
356 if (ist->st->sample_aspect_ratio.num){
357 sample_aspect_ratio = ist->st->sample_aspect_ratio;
359 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
361 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
362 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
363 sample_aspect_ratio.num, sample_aspect_ratio.den);
365 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
366 "src", args, NULL, ost->graph);
369 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
370 "out", NULL, &ffsink_ctx, ost->graph);
373 last_filter = ost->input_video_filter;
375 if (codec->width != icodec->width || codec->height != icodec->height) {
376 snprintf(args, 255, "%d:%d:flags=0x%X",
380 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
381 NULL, args, NULL, ost->graph)) < 0)
383 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
385 last_filter = filter;
388 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
389 ost->graph->scale_sws_opts = av_strdup(args);
392 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
395 outputs->name = av_strdup("in");
396 outputs->filter_ctx = last_filter;
397 outputs->pad_idx = 0;
398 outputs->next = NULL;
400 inputs->name = av_strdup("out");
401 inputs->filter_ctx = ost->output_video_filter;
405 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
407 av_freep(&ost->avfilter);
409 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
413 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
416 codec->width = ost->output_video_filter->inputs[0]->w;
417 codec->height = ost->output_video_filter->inputs[0]->h;
418 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
419 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
420 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
421 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
425 #endif /* CONFIG_AVFILTER */
427 static void term_exit(void)
429 av_log(NULL, AV_LOG_QUIET, "");
432 static volatile int received_sigterm = 0;
433 static volatile int received_nb_signals = 0;
436 sigterm_handler(int sig)
438 received_sigterm = sig;
439 received_nb_signals++;
443 static void term_init(void)
445 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
446 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
448 signal(SIGXCPU, sigterm_handler);
452 static int decode_interrupt_cb(void)
454 return received_nb_signals > 1;
457 static int ffmpeg_exit(int ret)
462 for(i=0;i<nb_output_files;i++) {
463 AVFormatContext *s = output_files[i];
464 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
466 avformat_free_context(s);
467 av_free(output_streams_for_file[i]);
469 for(i=0;i<nb_input_files;i++) {
470 av_close_input_file(input_files[i].ctx);
471 av_free(input_files_ts_scale[i]);
474 av_free(intra_matrix);
475 av_free(inter_matrix);
479 av_free(vstats_filename);
481 av_free(streamid_map);
482 av_free(input_codecs);
483 av_free(stream_maps);
484 av_free(meta_data_maps);
486 av_freep(&input_streams);
487 av_freep(&input_files);
489 av_free(video_codec_name);
490 av_free(audio_codec_name);
491 av_free(subtitle_codec_name);
492 av_free(data_codec_name);
494 av_free(video_standard);
499 allocated_audio_buf_size= allocated_audio_out_size= 0;
506 if (received_sigterm) {
508 "Received signal %d: terminating.\n",
509 (int) received_sigterm);
513 exit(ret); /* not all OS-es handle main() return value */
517 /* similar to ff_dynarray_add() and av_fast_realloc() */
518 static void *grow_array(void *array, int elem_size, int *size, int new_size)
520 if (new_size >= INT_MAX / elem_size) {
521 fprintf(stderr, "Array too big.\n");
524 if (*size < new_size) {
525 uint8_t *tmp = av_realloc(array, new_size*elem_size);
527 fprintf(stderr, "Could not alloc buffer.\n");
530 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
537 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
539 if(codec && codec->sample_fmts){
540 const enum AVSampleFormat *p= codec->sample_fmts;
542 if(*p == st->codec->sample_fmt)
546 av_log(NULL, AV_LOG_WARNING,
547 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
548 av_get_sample_fmt_name(st->codec->sample_fmt),
550 av_get_sample_fmt_name(codec->sample_fmts[0]));
551 st->codec->sample_fmt = codec->sample_fmts[0];
557 * Update the requested input sample format based on the output sample format.
558 * This is currently only used to request float output from decoders which
559 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
560 * Ideally this will be removed in the future when decoders do not do format
561 * conversion and only output in their native format.
563 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
566 /* if sample formats match or a decoder sample format has already been
567 requested, just return */
568 if (enc->sample_fmt == dec->sample_fmt ||
569 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
572 /* if decoder supports more than one output format */
573 if (dec_codec && dec_codec->sample_fmts &&
574 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
575 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
576 const enum AVSampleFormat *p;
577 int min_dec = -1, min_inc = -1;
579 /* find a matching sample format in the encoder */
580 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
581 if (*p == enc->sample_fmt) {
582 dec->request_sample_fmt = *p;
584 } else if (*p > enc->sample_fmt) {
585 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
587 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
590 /* if none match, provide the one that matches quality closest */
591 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
592 enc->sample_fmt - min_dec;
596 static void choose_sample_rate(AVStream *st, AVCodec *codec)
598 if(codec && codec->supported_samplerates){
599 const int *p= codec->supported_samplerates;
601 int best_dist=INT_MAX;
603 int dist= abs(st->codec->sample_rate - *p);
604 if(dist < best_dist){
610 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
612 st->codec->sample_rate= best;
616 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
618 if(codec && codec->pix_fmts){
619 const enum PixelFormat *p= codec->pix_fmts;
620 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
621 if(st->codec->codec_id==CODEC_ID_MJPEG){
622 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
623 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
624 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};
628 if(*p == st->codec->pix_fmt)
632 if(st->codec->pix_fmt != PIX_FMT_NONE)
633 av_log(NULL, AV_LOG_WARNING,
634 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
635 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
637 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
638 st->codec->pix_fmt = codec->pix_fmts[0];
643 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
645 int idx = oc->nb_streams - 1;
648 output_streams_for_file[file_idx] =
649 grow_array(output_streams_for_file[file_idx],
650 sizeof(*output_streams_for_file[file_idx]),
651 &nb_output_streams_for_file[file_idx],
653 ost = output_streams_for_file[file_idx][idx] =
654 av_mallocz(sizeof(AVOutputStream));
656 fprintf(stderr, "Could not alloc output stream\n");
659 ost->file_index = file_idx;
662 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
666 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
672 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
675 /* copy stream format */
677 s->streams = av_mallocz(sizeof(AVStream *) * ic->nb_streams);
678 for(i=0;i<ic->nb_streams;i++) {
684 // FIXME: a more elegant solution is needed
685 st = av_mallocz(sizeof(AVStream));
686 memcpy(st, ic->streams[i], sizeof(AVStream));
688 st->codec = avcodec_alloc_context();
690 print_error(filename, AVERROR(ENOMEM));
693 avcodec_copy_context(st->codec, ic->streams[i]->codec);
696 codec = avcodec_find_encoder(st->codec->codec_id);
697 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
698 if (audio_stream_copy) {
701 choose_sample_fmt(st, codec);
702 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
703 if (video_stream_copy) {
706 choose_pixel_fmt(st, codec);
709 if(st->codec->flags & CODEC_FLAG_BITEXACT)
712 new_output_stream(s, nb_output_files);
716 s->timestamp = av_gettime();
718 av_close_input_file(ic);
723 get_sync_ipts(const AVOutputStream *ost)
725 const AVInputStream *ist = ost->sync_ist;
726 return (double)(ist->pts - start_time)/AV_TIME_BASE;
729 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
733 AVPacket new_pkt= *pkt;
734 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
735 &new_pkt.data, &new_pkt.size,
736 pkt->data, pkt->size,
737 pkt->flags & AV_PKT_FLAG_KEY);
740 new_pkt.destruct= av_destruct_packet;
742 fprintf(stderr, "%s failed for stream %d, codec %s",
743 bsfc->filter->name, pkt->stream_index,
744 avctx->codec ? avctx->codec->name : "copy");
754 ret= av_interleaved_write_frame(s, pkt);
756 print_error("av_interleaved_write_frame()", ret);
761 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
763 static void do_audio_out(AVFormatContext *s,
766 unsigned char *buf, int size)
769 int64_t audio_out_size, audio_buf_size;
770 int64_t allocated_for_size= size;
772 int size_out, frame_bytes, ret, resample_changed;
773 AVCodecContext *enc= ost->st->codec;
774 AVCodecContext *dec= ist->st->codec;
775 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
776 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
777 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
780 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
781 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
782 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
783 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
784 audio_buf_size*= osize*enc->channels;
786 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
787 if(coded_bps > 8*osize)
788 audio_out_size= audio_out_size * coded_bps / (8*osize);
789 audio_out_size += FF_MIN_BUFFER_SIZE;
791 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
792 fprintf(stderr, "Buffer sizes too large\n");
796 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
797 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
798 if (!audio_buf || !audio_out){
799 fprintf(stderr, "Out of memory in do_audio_out\n");
803 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
804 ost->audio_resample = 1;
806 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
807 ost->resample_channels != dec->channels ||
808 ost->resample_sample_rate != dec->sample_rate;
810 if ((ost->audio_resample && !ost->resample) || resample_changed) {
811 if (resample_changed) {
812 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",
813 ist->file_index, ist->st->index,
814 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
815 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
816 ost->resample_sample_fmt = dec->sample_fmt;
817 ost->resample_channels = dec->channels;
818 ost->resample_sample_rate = dec->sample_rate;
820 audio_resample_close(ost->resample);
822 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
823 if (audio_sync_method <= 1 &&
824 ost->resample_sample_fmt == enc->sample_fmt &&
825 ost->resample_channels == enc->channels &&
826 ost->resample_sample_rate == enc->sample_rate) {
827 ost->resample = NULL;
828 ost->audio_resample = 0;
829 } else if (ost->audio_resample) {
830 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
831 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
832 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
833 enc->sample_rate, dec->sample_rate,
834 enc->sample_fmt, dec->sample_fmt,
836 if (!ost->resample) {
837 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
838 dec->channels, dec->sample_rate,
839 enc->channels, enc->sample_rate);
845 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
846 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
847 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
848 if (ost->reformat_ctx)
849 av_audio_convert_free(ost->reformat_ctx);
850 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
851 dec->sample_fmt, 1, NULL, 0);
852 if (!ost->reformat_ctx) {
853 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
854 av_get_sample_fmt_name(dec->sample_fmt),
855 av_get_sample_fmt_name(enc->sample_fmt));
858 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
861 if(audio_sync_method){
862 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
863 - av_fifo_size(ost->fifo)/(enc->channels * 2);
864 double idelta= delta*dec->sample_rate / enc->sample_rate;
865 int byte_delta= ((int)idelta)*2*dec->channels;
867 //FIXME resample delay
868 if(fabs(delta) > 50){
869 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
871 byte_delta= FFMAX(byte_delta, -size);
875 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
880 static uint8_t *input_tmp= NULL;
881 input_tmp= av_realloc(input_tmp, byte_delta + size);
883 if(byte_delta > allocated_for_size - size){
884 allocated_for_size= byte_delta + (int64_t)size;
889 memset(input_tmp, 0, byte_delta);
890 memcpy(input_tmp + byte_delta, buf, size);
894 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
896 }else if(audio_sync_method>1){
897 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
898 av_assert0(ost->audio_resample);
900 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
901 // 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));
902 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
906 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
907 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
909 if (ost->audio_resample) {
911 size_out = audio_resample(ost->resample,
912 (short *)buftmp, (short *)buf,
913 size / (dec->channels * isize));
914 size_out = size_out * enc->channels * osize;
920 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
921 const void *ibuf[6]= {buftmp};
922 void *obuf[6]= {audio_buf};
923 int istride[6]= {isize};
924 int ostride[6]= {osize};
925 int len= size_out/istride[0];
926 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
927 printf("av_audio_convert() failed\n");
933 size_out = len*osize;
936 /* now encode as many frames as possible */
937 if (enc->frame_size > 1) {
938 /* output resampled raw samples */
939 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
940 fprintf(stderr, "av_fifo_realloc2() failed\n");
943 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
945 frame_bytes = enc->frame_size * osize * enc->channels;
947 while (av_fifo_size(ost->fifo) >= frame_bytes) {
949 av_init_packet(&pkt);
951 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
953 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
955 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
958 fprintf(stderr, "Audio encoding failed\n");
962 pkt.stream_index= ost->index;
965 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
966 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
967 pkt.flags |= AV_PKT_FLAG_KEY;
968 write_frame(s, &pkt, enc, ost->bitstream_filters);
970 ost->sync_opts += enc->frame_size;
974 av_init_packet(&pkt);
976 ost->sync_opts += size_out / (osize * enc->channels);
978 /* output a pcm frame */
979 /* determine the size of the coded buffer */
982 size_out = size_out*coded_bps/8;
984 if(size_out > audio_out_size){
985 fprintf(stderr, "Internal error, buffer size too small\n");
989 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
990 ret = avcodec_encode_audio(enc, audio_out, size_out,
993 fprintf(stderr, "Audio encoding failed\n");
997 pkt.stream_index= ost->index;
1000 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1001 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1002 pkt.flags |= AV_PKT_FLAG_KEY;
1003 write_frame(s, &pkt, enc, ost->bitstream_filters);
1007 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1009 AVCodecContext *dec;
1010 AVPicture *picture2;
1011 AVPicture picture_tmp;
1014 dec = ist->st->codec;
1016 /* deinterlace : must be done before any resize */
1017 if (do_deinterlace) {
1020 /* create temporary picture */
1021 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1022 buf = av_malloc(size);
1026 picture2 = &picture_tmp;
1027 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1029 if(avpicture_deinterlace(picture2, picture,
1030 dec->pix_fmt, dec->width, dec->height) < 0) {
1031 /* if error, do not deinterlace */
1032 fprintf(stderr, "Deinterlacing failed\n");
1041 if (picture != picture2)
1042 *picture = *picture2;
1046 /* we begin to correct av delay at this threshold */
1047 #define AV_DELAY_MAX 0.100
1049 static void do_subtitle_out(AVFormatContext *s,
1050 AVOutputStream *ost,
1055 static uint8_t *subtitle_out = NULL;
1056 int subtitle_out_max_size = 1024 * 1024;
1057 int subtitle_out_size, nb, i;
1058 AVCodecContext *enc;
1061 if (pts == AV_NOPTS_VALUE) {
1062 fprintf(stderr, "Subtitle packets must have a pts\n");
1068 enc = ost->st->codec;
1070 if (!subtitle_out) {
1071 subtitle_out = av_malloc(subtitle_out_max_size);
1074 /* Note: DVB subtitle need one packet to draw them and one other
1075 packet to clear them */
1076 /* XXX: signal it in the codec context ? */
1077 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1082 for(i = 0; i < nb; i++) {
1083 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1084 // start_display_time is required to be 0
1085 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1086 sub->end_display_time -= sub->start_display_time;
1087 sub->start_display_time = 0;
1088 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1089 subtitle_out_max_size, sub);
1090 if (subtitle_out_size < 0) {
1091 fprintf(stderr, "Subtitle encoding failed\n");
1095 av_init_packet(&pkt);
1096 pkt.stream_index = ost->index;
1097 pkt.data = subtitle_out;
1098 pkt.size = subtitle_out_size;
1099 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1100 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1101 /* XXX: the pts correction is handled here. Maybe handling
1102 it in the codec would be better */
1104 pkt.pts += 90 * sub->start_display_time;
1106 pkt.pts += 90 * sub->end_display_time;
1108 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1112 static int bit_buffer_size= 1024*256;
1113 static uint8_t *bit_buffer= NULL;
1115 static void do_video_out(AVFormatContext *s,
1116 AVOutputStream *ost,
1118 AVFrame *in_picture,
1121 int nb_frames, i, ret, resample_changed;
1122 AVFrame *final_picture, *formatted_picture;
1123 AVCodecContext *enc, *dec;
1126 enc = ost->st->codec;
1127 dec = ist->st->codec;
1129 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1131 /* by default, we output a single frame */
1136 if(video_sync_method){
1137 double vdelta = sync_ipts - ost->sync_opts;
1138 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1141 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1144 }else if(vdelta>0.6)
1145 ost->sync_opts= lrintf(sync_ipts);
1146 }else if (vdelta > 1.1)
1147 nb_frames = lrintf(vdelta);
1148 //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);
1149 if (nb_frames == 0){
1152 fprintf(stderr, "*** drop!\n");
1153 }else if (nb_frames > 1) {
1154 nb_frames_dup += nb_frames - 1;
1156 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1159 ost->sync_opts= lrintf(sync_ipts);
1161 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1165 formatted_picture = in_picture;
1166 final_picture = formatted_picture;
1168 resample_changed = ost->resample_width != dec->width ||
1169 ost->resample_height != dec->height ||
1170 ost->resample_pix_fmt != dec->pix_fmt;
1172 if (resample_changed) {
1173 av_log(NULL, AV_LOG_INFO,
1174 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1175 ist->file_index, ist->st->index,
1176 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1177 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1178 if(!ost->video_resample)
1182 #if !CONFIG_AVFILTER
1183 if (ost->video_resample) {
1184 final_picture = &ost->pict_tmp;
1185 if (resample_changed) {
1186 /* initialize a new scaler context */
1187 sws_freeContext(ost->img_resample_ctx);
1188 ost->img_resample_ctx = sws_getContext(
1189 ist->st->codec->width,
1190 ist->st->codec->height,
1191 ist->st->codec->pix_fmt,
1192 ost->st->codec->width,
1193 ost->st->codec->height,
1194 ost->st->codec->pix_fmt,
1195 ost->sws_flags, NULL, NULL, NULL);
1196 if (ost->img_resample_ctx == NULL) {
1197 fprintf(stderr, "Cannot get resampling context\n");
1201 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1202 0, ost->resample_height, final_picture->data, final_picture->linesize);
1206 /* duplicates frame if needed */
1207 for(i=0;i<nb_frames;i++) {
1209 av_init_packet(&pkt);
1210 pkt.stream_index= ost->index;
1212 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1213 /* raw pictures are written as AVPicture structure to
1214 avoid any copies. We support temorarily the older
1216 AVFrame* old_frame = enc->coded_frame;
1217 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1218 pkt.data= (uint8_t *)final_picture;
1219 pkt.size= sizeof(AVPicture);
1220 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1221 pkt.flags |= AV_PKT_FLAG_KEY;
1223 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1224 enc->coded_frame = old_frame;
1226 AVFrame big_picture;
1228 big_picture= *final_picture;
1229 /* better than nothing: use input picture interlaced
1231 big_picture.interlaced_frame = in_picture->interlaced_frame;
1232 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1233 if(top_field_first == -1)
1234 big_picture.top_field_first = in_picture->top_field_first;
1236 big_picture.top_field_first = top_field_first;
1239 /* handles sameq here. This is not correct because it may
1240 not be a global option */
1241 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1243 big_picture.pict_type = 0;
1244 // big_picture.pts = AV_NOPTS_VALUE;
1245 big_picture.pts= ost->sync_opts;
1246 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1247 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1248 if (ost->forced_kf_index < ost->forced_kf_count &&
1249 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1250 big_picture.pict_type = AV_PICTURE_TYPE_I;
1251 ost->forced_kf_index++;
1253 ret = avcodec_encode_video(enc,
1254 bit_buffer, bit_buffer_size,
1257 fprintf(stderr, "Video encoding failed\n");
1262 pkt.data= bit_buffer;
1264 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1265 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1266 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1267 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1268 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1270 if(enc->coded_frame->key_frame)
1271 pkt.flags |= AV_PKT_FLAG_KEY;
1272 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1275 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1276 // enc->frame_number-1, ret, enc->pict_type);
1277 /* if two pass, output log */
1278 if (ost->logfile && enc->stats_out) {
1279 fprintf(ost->logfile, "%s", enc->stats_out);
1284 ost->frame_number++;
1288 static double psnr(double d){
1289 return -10.0*log(d)/log(10.0);
1292 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1295 AVCodecContext *enc;
1297 double ti1, bitrate, avg_bitrate;
1299 /* this is executed just the first time do_video_stats is called */
1301 vstats_file = fopen(vstats_filename, "w");
1308 enc = ost->st->codec;
1309 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1310 frame_number = ost->frame_number;
1311 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1312 if (enc->flags&CODEC_FLAG_PSNR)
1313 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1315 fprintf(vstats_file,"f_size= %6d ", frame_size);
1316 /* compute pts value */
1317 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1321 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1322 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1323 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1324 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1325 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1329 static void print_report(AVFormatContext **output_files,
1330 AVOutputStream **ost_table, int nb_ostreams,
1334 AVOutputStream *ost;
1335 AVFormatContext *oc;
1337 AVCodecContext *enc;
1338 int frame_number, vid, i;
1339 double bitrate, ti1, pts;
1340 static int64_t last_time = -1;
1341 static int qp_histogram[52];
1343 if (!is_last_report) {
1345 /* display the report every 0.5 seconds */
1346 cur_time = av_gettime();
1347 if (last_time == -1) {
1348 last_time = cur_time;
1351 if ((cur_time - last_time) < 500000)
1353 last_time = cur_time;
1357 oc = output_files[0];
1359 total_size = avio_size(oc->pb);
1360 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1361 total_size= avio_tell(oc->pb);
1366 for(i=0;i<nb_ostreams;i++) {
1369 enc = ost->st->codec;
1370 if (!ost->st->stream_copy && enc->coded_frame)
1371 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1372 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1373 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1375 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1376 float t = (av_gettime()-timer_start) / 1000000.0;
1378 frame_number = ost->frame_number;
1379 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1380 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1386 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1391 if (enc->flags&CODEC_FLAG_PSNR){
1393 double error, error_sum=0;
1394 double scale, scale_sum=0;
1395 char type[3]= {'Y','U','V'};
1396 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1399 error= enc->error[j];
1400 scale= enc->width*enc->height*255.0*255.0*frame_number;
1402 error= enc->coded_frame->error[j];
1403 scale= enc->width*enc->height*255.0*255.0;
1408 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1410 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1414 /* compute min output value */
1415 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1416 if ((pts < ti1) && (pts > 0))
1422 if (verbose > 0 || is_last_report) {
1423 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1425 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1426 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1427 (double)total_size / 1024, ti1, bitrate);
1429 if (nb_frames_dup || nb_frames_drop)
1430 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1431 nb_frames_dup, nb_frames_drop);
1434 fprintf(stderr, "%s \r", buf);
1439 if (is_last_report && verbose >= 0){
1440 int64_t raw= audio_size + video_size + extra_size;
1441 fprintf(stderr, "\n");
1442 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1446 100.0*(total_size - raw)/raw
1451 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1453 int fill_char = 0x00;
1454 if (sample_fmt == AV_SAMPLE_FMT_U8)
1456 memset(buf, fill_char, size);
1459 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1460 static int output_packet(AVInputStream *ist, int ist_index,
1461 AVOutputStream **ost_table, int nb_ostreams,
1462 const AVPacket *pkt)
1464 AVFormatContext *os;
1465 AVOutputStream *ost;
1469 void *buffer_to_free = NULL;
1470 static unsigned int samples_size= 0;
1471 AVSubtitle subtitle, *subtitle_to_free;
1472 int64_t pkt_pts = AV_NOPTS_VALUE;
1474 int frame_available;
1478 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1480 if(ist->next_pts == AV_NOPTS_VALUE)
1481 ist->next_pts= ist->pts;
1485 av_init_packet(&avpkt);
1493 if(pkt->dts != AV_NOPTS_VALUE)
1494 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1495 if(pkt->pts != AV_NOPTS_VALUE)
1496 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1498 //while we have more to decode or while the decoder did output something on EOF
1499 while (avpkt.size > 0 || (!pkt && got_output)) {
1500 uint8_t *data_buf, *decoded_data_buf;
1501 int data_size, decoded_data_size;
1503 ist->pts= ist->next_pts;
1505 if(avpkt.size && avpkt.size != pkt->size &&
1506 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1507 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1508 ist->showed_multi_packet_warning=1;
1511 /* decode the packet if needed */
1512 decoded_data_buf = NULL; /* fail safe */
1513 decoded_data_size= 0;
1514 data_buf = avpkt.data;
1515 data_size = avpkt.size;
1516 subtitle_to_free = NULL;
1517 if (ist->decoding_needed) {
1518 switch(ist->st->codec->codec_type) {
1519 case AVMEDIA_TYPE_AUDIO:{
1520 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1521 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1523 samples= av_malloc(samples_size);
1525 decoded_data_size= samples_size;
1526 /* XXX: could avoid copy if PCM 16 bits with same
1527 endianness as CPU */
1528 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1535 got_output = decoded_data_size > 0;
1536 /* Some bug in mpeg audio decoder gives */
1537 /* decoded_data_size < 0, it seems they are overflows */
1539 /* no audio frame */
1542 decoded_data_buf = (uint8_t *)samples;
1543 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1544 (ist->st->codec->sample_rate * ist->st->codec->channels);
1546 case AVMEDIA_TYPE_VIDEO:
1547 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1548 /* XXX: allocate picture correctly */
1549 avcodec_get_frame_defaults(&picture);
1550 avpkt.pts = pkt_pts;
1551 avpkt.dts = ist->pts;
1552 pkt_pts = AV_NOPTS_VALUE;
1554 ret = avcodec_decode_video2(ist->st->codec,
1555 &picture, &got_output, &avpkt);
1556 ist->st->quality= picture.quality;
1560 /* no picture yet */
1561 goto discard_packet;
1563 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1564 if (ist->st->codec->time_base.num != 0) {
1565 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1566 ist->next_pts += ((int64_t)AV_TIME_BASE *
1567 ist->st->codec->time_base.num * ticks) /
1568 ist->st->codec->time_base.den;
1571 buffer_to_free = NULL;
1572 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1574 case AVMEDIA_TYPE_SUBTITLE:
1575 ret = avcodec_decode_subtitle2(ist->st->codec,
1576 &subtitle, &got_output, &avpkt);
1580 goto discard_packet;
1582 subtitle_to_free = &subtitle;
1589 switch(ist->st->codec->codec_type) {
1590 case AVMEDIA_TYPE_AUDIO:
1591 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1592 ist->st->codec->sample_rate;
1594 case AVMEDIA_TYPE_VIDEO:
1595 if (ist->st->codec->time_base.num != 0) {
1596 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1597 ist->next_pts += ((int64_t)AV_TIME_BASE *
1598 ist->st->codec->time_base.num * ticks) /
1599 ist->st->codec->time_base.den;
1608 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1609 for (i = 0; i < nb_ostreams; i++) {
1611 if (ost->input_video_filter && ost->source_index == ist_index) {
1613 if (ist->st->sample_aspect_ratio.num)
1614 sar = ist->st->sample_aspect_ratio;
1616 sar = ist->st->codec->sample_aspect_ratio;
1617 // add it to be filtered
1618 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1626 // preprocess audio (volume)
1627 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1628 if (audio_volume != 256) {
1631 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1632 int v = ((*volp) * audio_volume + 128) >> 8;
1633 if (v < -32768) v = -32768;
1634 if (v > 32767) v = 32767;
1640 /* frame rate emulation */
1642 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1643 int64_t now = av_gettime() - ist->start;
1647 /* if output time reached then transcode raw format,
1648 encode packets and output them */
1649 if (start_time == 0 || ist->pts >= start_time)
1650 for(i=0;i<nb_ostreams;i++) {
1654 if (ost->source_index == ist_index) {
1656 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1657 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1658 while (frame_available) {
1659 AVRational ist_pts_tb;
1660 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1661 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1663 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1665 os = output_files[ost->file_index];
1667 /* set the input output pts pairs */
1668 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1670 if (ost->encoding_needed) {
1671 av_assert0(ist->decoding_needed);
1672 switch(ost->st->codec->codec_type) {
1673 case AVMEDIA_TYPE_AUDIO:
1674 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1676 case AVMEDIA_TYPE_VIDEO:
1678 if (ost->picref->video && !ost->frame_aspect_ratio)
1679 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1681 do_video_out(os, ost, ist, &picture, &frame_size);
1682 if (vstats_filename && frame_size)
1683 do_video_stats(os, ost, frame_size);
1685 case AVMEDIA_TYPE_SUBTITLE:
1686 do_subtitle_out(os, ost, ist, &subtitle,
1693 AVFrame avframe; //FIXME/XXX remove this
1695 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1697 av_init_packet(&opkt);
1699 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1700 #if !CONFIG_AVFILTER
1706 /* no reencoding needed : output the packet directly */
1707 /* force the input stream PTS */
1709 avcodec_get_frame_defaults(&avframe);
1710 ost->st->codec->coded_frame= &avframe;
1711 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1713 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1714 audio_size += data_size;
1715 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1716 video_size += data_size;
1720 opkt.stream_index= ost->index;
1721 if(pkt->pts != AV_NOPTS_VALUE)
1722 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1724 opkt.pts= AV_NOPTS_VALUE;
1726 if (pkt->dts == AV_NOPTS_VALUE)
1727 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1729 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1730 opkt.dts -= ost_tb_start_time;
1732 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1733 opkt.flags= pkt->flags;
1735 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1736 if( ost->st->codec->codec_id != CODEC_ID_H264
1737 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1738 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1740 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1741 opkt.destruct= av_destruct_packet;
1743 opkt.data = data_buf;
1744 opkt.size = data_size;
1747 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1748 ost->st->codec->frame_number++;
1749 ost->frame_number++;
1750 av_free_packet(&opkt);
1754 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1755 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1757 avfilter_unref_buffer(ost->picref);
1763 av_free(buffer_to_free);
1764 /* XXX: allocate the subtitles in the codec ? */
1765 if (subtitle_to_free) {
1766 avsubtitle_free(subtitle_to_free);
1767 subtitle_to_free = NULL;
1774 for(i=0;i<nb_ostreams;i++) {
1776 if (ost->source_index == ist_index) {
1777 AVCodecContext *enc= ost->st->codec;
1778 os = output_files[ost->file_index];
1780 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1782 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1785 if (ost->encoding_needed) {
1789 av_init_packet(&pkt);
1790 pkt.stream_index= ost->index;
1792 switch(ost->st->codec->codec_type) {
1793 case AVMEDIA_TYPE_AUDIO:
1794 fifo_bytes = av_fifo_size(ost->fifo);
1796 /* encode any samples remaining in fifo */
1797 if (fifo_bytes > 0) {
1798 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1799 int fs_tmp = enc->frame_size;
1801 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1802 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1803 enc->frame_size = fifo_bytes / (osize * enc->channels);
1805 int frame_bytes = enc->frame_size*osize*enc->channels;
1806 if (allocated_audio_buf_size < frame_bytes)
1808 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1811 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1812 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1813 ost->st->time_base.num, enc->sample_rate);
1814 enc->frame_size = fs_tmp;
1817 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1820 fprintf(stderr, "Audio encoding failed\n");
1824 pkt.flags |= AV_PKT_FLAG_KEY;
1826 case AVMEDIA_TYPE_VIDEO:
1827 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1829 fprintf(stderr, "Video encoding failed\n");
1833 if(enc->coded_frame && enc->coded_frame->key_frame)
1834 pkt.flags |= AV_PKT_FLAG_KEY;
1835 if (ost->logfile && enc->stats_out) {
1836 fprintf(ost->logfile, "%s", enc->stats_out);
1845 pkt.data= bit_buffer;
1847 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1848 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1849 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1861 static void print_sdp(AVFormatContext **avc, int n)
1865 av_sdp_create(avc, n, sdp, sizeof(sdp));
1866 printf("SDP:\n%s\n", sdp);
1870 static int copy_chapters(int infile, int outfile)
1872 AVFormatContext *is = input_files[infile].ctx;
1873 AVFormatContext *os = output_files[outfile];
1876 for (i = 0; i < is->nb_chapters; i++) {
1877 AVChapter *in_ch = is->chapters[i], *out_ch;
1878 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1879 AV_TIME_BASE_Q, in_ch->time_base);
1880 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1881 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1884 if (in_ch->end < ts_off)
1886 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1889 out_ch = av_mallocz(sizeof(AVChapter));
1891 return AVERROR(ENOMEM);
1893 out_ch->id = in_ch->id;
1894 out_ch->time_base = in_ch->time_base;
1895 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1896 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1898 if (metadata_chapters_autocopy)
1899 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1902 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1904 return AVERROR(ENOMEM);
1905 os->chapters[os->nb_chapters - 1] = out_ch;
1910 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1911 AVCodecContext *avctx)
1917 for (p = kf; *p; p++)
1920 ost->forced_kf_count = n;
1921 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1922 if (!ost->forced_kf_pts) {
1923 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1926 for (i = 0; i < n; i++) {
1927 p = i ? strchr(p, ',') + 1 : kf;
1928 t = parse_time_or_die("force_key_frames", p, 1);
1929 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1934 * The following code is the main loop of the file converter
1936 static int transcode(AVFormatContext **output_files,
1937 int nb_output_files,
1938 AVInputFile *input_files,
1940 AVStreamMap *stream_maps, int nb_stream_maps)
1942 int ret = 0, i, j, k, n, nb_ostreams = 0;
1943 AVFormatContext *is, *os;
1944 AVCodecContext *codec, *icodec;
1945 AVOutputStream *ost, **ost_table = NULL;
1949 uint8_t no_packet[MAX_FILES]={0};
1950 int no_packet_count=0;
1953 for (i = 0; i < nb_input_streams; i++)
1954 input_streams[i].start = av_gettime();
1956 /* output stream init */
1958 for(i=0;i<nb_output_files;i++) {
1959 os = output_files[i];
1960 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1961 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1962 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1963 ret = AVERROR(EINVAL);
1966 nb_ostreams += os->nb_streams;
1968 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1969 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1970 ret = AVERROR(EINVAL);
1974 /* Sanity check the mapping args -- do the input files & streams exist? */
1975 for(i=0;i<nb_stream_maps;i++) {
1976 int fi = stream_maps[i].file_index;
1977 int si = stream_maps[i].stream_index;
1979 if (fi < 0 || fi > nb_input_files - 1 ||
1980 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1981 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1982 ret = AVERROR(EINVAL);
1985 fi = stream_maps[i].sync_file_index;
1986 si = stream_maps[i].sync_stream_index;
1987 if (fi < 0 || fi > nb_input_files - 1 ||
1988 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1989 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1990 ret = AVERROR(EINVAL);
1995 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1999 for(k=0;k<nb_output_files;k++) {
2000 os = output_files[k];
2001 for(i=0;i<os->nb_streams;i++,n++) {
2003 ost = ost_table[n] = output_streams_for_file[k][i];
2004 ost->st = os->streams[i];
2005 if (nb_stream_maps > 0) {
2006 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2007 stream_maps[n].stream_index;
2009 /* Sanity check that the stream types match */
2010 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2011 int i= ost->file_index;
2012 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2013 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2014 stream_maps[n].file_index, stream_maps[n].stream_index,
2015 ost->file_index, ost->index);
2020 int best_nb_frames=-1;
2021 /* get corresponding input stream index : we select the first one with the right type */
2023 for (j = 0; j < nb_input_streams; j++) {
2025 ist = &input_streams[j];
2028 AVFormatContext *f = input_files[ist->file_index].ctx;
2030 for(pi=0; pi<f->nb_programs; pi++){
2031 AVProgram *p= f->programs[pi];
2032 if(p->id == opt_programid)
2033 for(si=0; si<p->nb_stream_indexes; si++){
2034 if(f->streams[ p->stream_index[si] ] == ist->st)
2039 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2040 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2041 if(best_nb_frames < ist->st->codec_info_nb_frames){
2042 best_nb_frames= ist->st->codec_info_nb_frames;
2043 ost->source_index = j;
2050 if(! opt_programid) {
2051 /* try again and reuse existing stream */
2052 for (j = 0; j < nb_input_streams; j++) {
2053 ist = &input_streams[j];
2054 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2055 && ist->st->discard != AVDISCARD_ALL) {
2056 ost->source_index = j;
2062 int i= ost->file_index;
2063 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2064 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2065 ost->file_index, ost->index);
2070 ist = &input_streams[ost->source_index];
2072 ost->sync_ist = (nb_stream_maps > 0) ?
2073 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2074 stream_maps[n].sync_stream_index] : ist;
2078 /* for each output stream, we compute the right encoding parameters */
2079 for(i=0;i<nb_ostreams;i++) {
2081 os = output_files[ost->file_index];
2082 ist = &input_streams[ost->source_index];
2084 codec = ost->st->codec;
2085 icodec = ist->st->codec;
2087 if (metadata_streams_autocopy)
2088 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2089 AV_DICT_DONT_OVERWRITE);
2091 ost->st->disposition = ist->st->disposition;
2092 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2093 codec->chroma_sample_location = icodec->chroma_sample_location;
2095 if (ost->st->stream_copy) {
2096 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2098 if (extra_size > INT_MAX)
2101 /* if stream_copy is selected, no need to decode or encode */
2102 codec->codec_id = icodec->codec_id;
2103 codec->codec_type = icodec->codec_type;
2105 if(!codec->codec_tag){
2106 if( !os->oformat->codec_tag
2107 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2108 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2109 codec->codec_tag = icodec->codec_tag;
2112 codec->bit_rate = icodec->bit_rate;
2113 codec->rc_max_rate = icodec->rc_max_rate;
2114 codec->rc_buffer_size = icodec->rc_buffer_size;
2115 codec->extradata= av_mallocz(extra_size);
2116 if (!codec->extradata)
2118 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2119 codec->extradata_size= icodec->extradata_size;
2120 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){
2121 codec->time_base = icodec->time_base;
2122 codec->time_base.num *= icodec->ticks_per_frame;
2123 av_reduce(&codec->time_base.num, &codec->time_base.den,
2124 codec->time_base.num, codec->time_base.den, INT_MAX);
2126 codec->time_base = ist->st->time_base;
2127 switch(codec->codec_type) {
2128 case AVMEDIA_TYPE_AUDIO:
2129 if(audio_volume != 256) {
2130 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2133 codec->channel_layout = icodec->channel_layout;
2134 codec->sample_rate = icodec->sample_rate;
2135 codec->channels = icodec->channels;
2136 codec->frame_size = icodec->frame_size;
2137 codec->audio_service_type = icodec->audio_service_type;
2138 codec->block_align= icodec->block_align;
2139 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2140 codec->block_align= 0;
2141 if(codec->codec_id == CODEC_ID_AC3)
2142 codec->block_align= 0;
2144 case AVMEDIA_TYPE_VIDEO:
2145 codec->pix_fmt = icodec->pix_fmt;
2146 codec->width = icodec->width;
2147 codec->height = icodec->height;
2148 codec->has_b_frames = icodec->has_b_frames;
2149 if (!codec->sample_aspect_ratio.num) {
2150 codec->sample_aspect_ratio =
2151 ost->st->sample_aspect_ratio =
2152 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2153 ist->st->codec->sample_aspect_ratio.num ?
2154 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2157 case AVMEDIA_TYPE_SUBTITLE:
2158 codec->width = icodec->width;
2159 codec->height = icodec->height;
2161 case AVMEDIA_TYPE_DATA:
2168 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2169 switch(codec->codec_type) {
2170 case AVMEDIA_TYPE_AUDIO:
2171 ost->fifo= av_fifo_alloc(1024);
2174 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2175 if (!codec->sample_rate) {
2176 codec->sample_rate = icodec->sample_rate;
2178 codec->sample_rate >>= icodec->lowres;
2180 choose_sample_rate(ost->st, ost->enc);
2181 codec->time_base = (AVRational){1, codec->sample_rate};
2182 if (!codec->channels)
2183 codec->channels = icodec->channels;
2184 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2185 codec->channel_layout = 0;
2186 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2187 icodec->request_channels = codec->channels;
2188 ist->decoding_needed = 1;
2189 ost->encoding_needed = 1;
2190 ost->resample_sample_fmt = icodec->sample_fmt;
2191 ost->resample_sample_rate = icodec->sample_rate;
2192 ost->resample_channels = icodec->channels;
2194 case AVMEDIA_TYPE_VIDEO:
2195 if (codec->pix_fmt == PIX_FMT_NONE)
2196 codec->pix_fmt = icodec->pix_fmt;
2197 choose_pixel_fmt(ost->st, ost->enc);
2199 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2200 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2203 ost->video_resample = codec->width != icodec->width ||
2204 codec->height != icodec->height ||
2205 codec->pix_fmt != icodec->pix_fmt;
2206 if (ost->video_resample) {
2207 #if !CONFIG_AVFILTER
2208 avcodec_get_frame_defaults(&ost->pict_tmp);
2209 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2210 codec->width, codec->height)) {
2211 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2214 ost->img_resample_ctx = sws_getContext(
2221 ost->sws_flags, NULL, NULL, NULL);
2222 if (ost->img_resample_ctx == NULL) {
2223 fprintf(stderr, "Cannot get resampling context\n");
2227 codec->bits_per_raw_sample= 0;
2229 ost->resample_height = icodec->height;
2230 ost->resample_width = icodec->width;
2231 ost->resample_pix_fmt= icodec->pix_fmt;
2232 ost->encoding_needed = 1;
2233 ist->decoding_needed = 1;
2235 if (!ost->frame_rate.num)
2236 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2237 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2238 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2239 ost->frame_rate = ost->enc->supported_framerates[idx];
2241 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2244 if (configure_video_filters(ist, ost)) {
2245 fprintf(stderr, "Error opening filters!\n");
2250 case AVMEDIA_TYPE_SUBTITLE:
2251 ost->encoding_needed = 1;
2252 ist->decoding_needed = 1;
2259 if (ost->encoding_needed &&
2260 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2261 char logfilename[1024];
2264 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2265 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2267 if (codec->flags & CODEC_FLAG_PASS1) {
2268 f = fopen(logfilename, "wb");
2270 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2276 size_t logbuffer_size;
2277 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2278 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2281 codec->stats_in = logbuffer;
2285 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2286 int size= codec->width * codec->height;
2287 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2292 bit_buffer = av_malloc(bit_buffer_size);
2294 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2296 ret = AVERROR(ENOMEM);
2300 /* open each encoder */
2301 for(i=0;i<nb_ostreams;i++) {
2303 if (ost->encoding_needed) {
2304 AVCodec *codec = ost->enc;
2305 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2307 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2308 ost->st->codec->codec_id, ost->file_index, ost->index);
2309 ret = AVERROR(EINVAL);
2312 if (dec->subtitle_header) {
2313 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2314 if (!ost->st->codec->subtitle_header) {
2315 ret = AVERROR(ENOMEM);
2318 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2319 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2321 if (avcodec_open(ost->st->codec, codec) < 0) {
2322 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2323 ost->file_index, ost->index);
2324 ret = AVERROR(EINVAL);
2327 extra_size += ost->st->codec->extradata_size;
2331 /* open each decoder */
2332 for (i = 0; i < nb_input_streams; i++) {
2333 ist = &input_streams[i];
2334 if (ist->decoding_needed) {
2335 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2337 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2339 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2340 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2341 ret = AVERROR(EINVAL);
2345 /* update requested sample format for the decoder based on the
2346 corresponding encoder sample format */
2347 for (j = 0; j < nb_ostreams; j++) {
2349 if (ost->source_index == i) {
2350 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2355 if (avcodec_open(ist->st->codec, codec) < 0) {
2356 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2357 ist->file_index, ist->st->index);
2358 ret = AVERROR(EINVAL);
2361 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2362 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2367 for (i = 0; i < nb_input_streams; i++) {
2369 ist = &input_streams[i];
2371 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2372 ist->next_pts = AV_NOPTS_VALUE;
2373 init_pts_correction(&ist->pts_ctx);
2377 /* set meta data information from input file if required */
2378 for (i=0;i<nb_meta_data_maps;i++) {
2379 AVFormatContext *files[2];
2380 AVDictionary **meta[2];
2383 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2384 if ((index) < 0 || (index) >= (nb_elems)) {\
2385 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2387 ret = AVERROR(EINVAL);\
2391 int out_file_index = meta_data_maps[i][0].file;
2392 int in_file_index = meta_data_maps[i][1].file;
2393 if (in_file_index < 0 || out_file_index < 0)
2395 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2396 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2398 files[0] = output_files[out_file_index];
2399 files[1] = input_files[in_file_index].ctx;
2401 for (j = 0; j < 2; j++) {
2402 AVMetaDataMap *map = &meta_data_maps[i][j];
2404 switch (map->type) {
2406 meta[j] = &files[j]->metadata;
2409 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2410 meta[j] = &files[j]->streams[map->index]->metadata;
2413 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2414 meta[j] = &files[j]->chapters[map->index]->metadata;
2417 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2418 meta[j] = &files[j]->programs[map->index]->metadata;
2423 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2426 /* copy global metadata by default */
2427 if (metadata_global_autocopy) {
2429 for (i = 0; i < nb_output_files; i++)
2430 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2431 AV_DICT_DONT_OVERWRITE);
2434 /* copy chapters according to chapter maps */
2435 for (i = 0; i < nb_chapter_maps; i++) {
2436 int infile = chapter_maps[i].in_file;
2437 int outfile = chapter_maps[i].out_file;
2439 if (infile < 0 || outfile < 0)
2441 if (infile >= nb_input_files) {
2442 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2443 ret = AVERROR(EINVAL);
2446 if (outfile >= nb_output_files) {
2447 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2448 ret = AVERROR(EINVAL);
2451 copy_chapters(infile, outfile);
2454 /* copy chapters from the first input file that has them*/
2455 if (!nb_chapter_maps)
2456 for (i = 0; i < nb_input_files; i++) {
2457 if (!input_files[i].ctx->nb_chapters)
2460 for (j = 0; j < nb_output_files; j++)
2461 if ((ret = copy_chapters(i, j)) < 0)
2466 /* open files and write file headers */
2467 for(i=0;i<nb_output_files;i++) {
2468 os = output_files[i];
2469 if (av_write_header(os) < 0) {
2470 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2471 ret = AVERROR(EINVAL);
2474 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2480 /* dump the file output parameters - cannot be done before in case
2482 for(i=0;i<nb_output_files;i++) {
2483 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2486 /* dump the stream mapping */
2488 fprintf(stderr, "Stream mapping:\n");
2489 for(i=0;i<nb_ostreams;i++) {
2491 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2492 input_streams[ost->source_index].file_index,
2493 input_streams[ost->source_index].st->index,
2496 if (ost->sync_ist != &input_streams[ost->source_index])
2497 fprintf(stderr, " [sync #%d.%d]",
2498 ost->sync_ist->file_index,
2499 ost->sync_ist->st->index);
2500 fprintf(stderr, "\n");
2505 fprintf(stderr, "%s\n", error);
2510 print_sdp(output_files, nb_output_files);
2514 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2517 timer_start = av_gettime();
2519 for(; received_sigterm == 0;) {
2520 int file_index, ist_index;
2529 /* select the stream that we must read now by looking at the
2530 smallest output pts */
2532 for(i=0;i<nb_ostreams;i++) {
2535 os = output_files[ost->file_index];
2536 ist = &input_streams[ost->source_index];
2537 if(ist->is_past_recording_time || no_packet[ist->file_index])
2539 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2540 ipts = (double)ist->pts;
2541 if (!input_files[ist->file_index].eof_reached){
2542 if(ipts < ipts_min) {
2544 if(input_sync ) file_index = ist->file_index;
2546 if(opts < opts_min) {
2548 if(!input_sync) file_index = ist->file_index;
2551 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2556 /* if none, if is finished */
2557 if (file_index < 0) {
2558 if(no_packet_count){
2560 memset(no_packet, 0, sizeof(no_packet));
2567 /* finish if limit size exhausted */
2568 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2571 /* read a frame from it and output it in the fifo */
2572 is = input_files[file_index].ctx;
2573 ret= av_read_frame(is, &pkt);
2574 if(ret == AVERROR(EAGAIN)){
2575 no_packet[file_index]=1;
2580 input_files[file_index].eof_reached = 1;
2588 memset(no_packet, 0, sizeof(no_packet));
2591 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2592 is->streams[pkt.stream_index]);
2594 /* the following test is needed in case new streams appear
2595 dynamically in stream : we ignore them */
2596 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2597 goto discard_packet;
2598 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2599 ist = &input_streams[ist_index];
2601 goto discard_packet;
2603 if (pkt.dts != AV_NOPTS_VALUE)
2604 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2605 if (pkt.pts != AV_NOPTS_VALUE)
2606 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2608 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2609 && input_files_ts_scale[file_index][pkt.stream_index]){
2610 if(pkt.pts != AV_NOPTS_VALUE)
2611 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2612 if(pkt.dts != AV_NOPTS_VALUE)
2613 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2616 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2617 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2618 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2619 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2620 int64_t delta= pkt_dts - ist->next_pts;
2621 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2622 input_files_ts_offset[ist->file_index]-= delta;
2624 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2625 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2626 if(pkt.pts != AV_NOPTS_VALUE)
2627 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2631 /* finish if recording time exhausted */
2632 if (recording_time != INT64_MAX &&
2633 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2634 ist->is_past_recording_time = 1;
2635 goto discard_packet;
2638 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2639 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2642 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2643 ist->file_index, ist->st->index);
2646 av_free_packet(&pkt);
2651 av_free_packet(&pkt);
2653 /* dump report by using the output first video and audio streams */
2654 print_report(output_files, ost_table, nb_ostreams, 0);
2657 /* at the end of stream, we must flush the decoder buffers */
2658 for (i = 0; i < nb_input_streams; i++) {
2659 ist = &input_streams[i];
2660 if (ist->decoding_needed) {
2661 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2667 /* write the trailer if needed and close file */
2668 for(i=0;i<nb_output_files;i++) {
2669 os = output_files[i];
2670 av_write_trailer(os);
2673 /* dump report by using the first video and audio streams */
2674 print_report(output_files, ost_table, nb_ostreams, 1);
2676 /* close each encoder */
2677 for(i=0;i<nb_ostreams;i++) {
2679 if (ost->encoding_needed) {
2680 av_freep(&ost->st->codec->stats_in);
2681 avcodec_close(ost->st->codec);
2684 avfilter_graph_free(&ost->graph);
2688 /* close each decoder */
2689 for (i = 0; i < nb_input_streams; i++) {
2690 ist = &input_streams[i];
2691 if (ist->decoding_needed) {
2692 avcodec_close(ist->st->codec);
2700 av_freep(&bit_buffer);
2703 for(i=0;i<nb_ostreams;i++) {
2706 if (ost->st->stream_copy)
2707 av_freep(&ost->st->codec->extradata);
2709 fclose(ost->logfile);
2710 ost->logfile = NULL;
2712 av_fifo_free(ost->fifo); /* works even if fifo is not
2713 initialized but set to zero */
2714 av_freep(&ost->st->codec->subtitle_header);
2715 av_free(ost->pict_tmp.data[0]);
2716 av_free(ost->forced_kf_pts);
2717 if (ost->video_resample)
2718 sws_freeContext(ost->img_resample_ctx);
2720 audio_resample_close(ost->resample);
2721 if (ost->reformat_ctx)
2722 av_audio_convert_free(ost->reformat_ctx);
2731 static int opt_format(const char *opt, const char *arg)
2733 last_asked_format = arg;
2737 static int opt_video_rc_override_string(const char *opt, const char *arg)
2739 video_rc_override_string = arg;
2743 static int opt_me_threshold(const char *opt, const char *arg)
2745 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2749 static int opt_verbose(const char *opt, const char *arg)
2751 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2755 static int opt_frame_rate(const char *opt, const char *arg)
2757 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2758 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2764 static int opt_bitrate(const char *opt, const char *arg)
2766 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2768 opt_default(opt, arg);
2770 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2771 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2776 static int opt_frame_crop(const char *opt, const char *arg)
2778 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2779 return AVERROR(EINVAL);
2782 static int opt_frame_size(const char *opt, const char *arg)
2784 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2785 fprintf(stderr, "Incorrect frame size\n");
2786 return AVERROR(EINVAL);
2791 static int opt_pad(const char *opt, const char *arg) {
2792 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2796 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2798 if (strcmp(arg, "list")) {
2799 frame_pix_fmt = av_get_pix_fmt(arg);
2800 if (frame_pix_fmt == PIX_FMT_NONE) {
2801 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2802 return AVERROR(EINVAL);
2811 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2818 p = strchr(arg, ':');
2820 x = strtol(arg, &end, 10);
2822 y = strtol(end+1, &end, 10);
2824 ar = (double)x / (double)y;
2826 ar = strtod(arg, NULL);
2829 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2830 return AVERROR(EINVAL);
2832 frame_aspect_ratio = ar;
2836 static int opt_metadata(const char *opt, const char *arg)
2838 char *mid= strchr(arg, '=');
2841 fprintf(stderr, "Missing =\n");
2846 av_dict_set(&metadata, arg, mid, 0);
2851 static int opt_qscale(const char *opt, const char *arg)
2853 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2854 if (video_qscale == 0) {
2855 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2856 return AVERROR(EINVAL);
2861 static int opt_top_field_first(const char *opt, const char *arg)
2863 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2867 static int opt_thread_count(const char *opt, const char *arg)
2869 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2872 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2877 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2879 if (strcmp(arg, "list")) {
2880 audio_sample_fmt = av_get_sample_fmt(arg);
2881 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2882 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2883 return AVERROR(EINVAL);
2888 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2889 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2895 static int opt_audio_rate(const char *opt, const char *arg)
2897 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2901 static int opt_audio_channels(const char *opt, const char *arg)
2903 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2907 static int opt_video_channel(const char *opt, const char *arg)
2909 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2913 static int opt_video_standard(const char *opt, const char *arg)
2915 video_standard = av_strdup(arg);
2919 static int opt_codec(int *pstream_copy, char **pcodec_name,
2920 int codec_type, const char *arg)
2922 av_freep(pcodec_name);
2923 if (!strcmp(arg, "copy")) {
2926 *pcodec_name = av_strdup(arg);
2931 static int opt_audio_codec(const char *opt, const char *arg)
2933 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2936 static int opt_video_codec(const char *opt, const char *arg)
2938 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2941 static int opt_subtitle_codec(const char *opt, const char *arg)
2943 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2946 static int opt_data_codec(const char *opt, const char *arg)
2948 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2951 static int opt_codec_tag(const char *opt, const char *arg)
2954 uint32_t *codec_tag;
2956 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2957 !strcmp(opt, "vtag") ? &video_codec_tag :
2958 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2962 *codec_tag = strtol(arg, &tail, 0);
2964 *codec_tag = AV_RL32(arg);
2969 static int opt_map(const char *opt, const char *arg)
2974 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2975 m = &stream_maps[nb_stream_maps-1];
2977 m->file_index = strtol(arg, &p, 0);
2981 m->stream_index = strtol(p, &p, 0);
2984 m->sync_file_index = strtol(p, &p, 0);
2987 m->sync_stream_index = strtol(p, &p, 0);
2989 m->sync_file_index = m->file_index;
2990 m->sync_stream_index = m->stream_index;
2995 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3006 *index = strtol(++arg, endptr, 0);
3009 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3016 static int opt_map_metadata(const char *opt, const char *arg)
3018 AVMetaDataMap *m, *m1;
3021 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3022 &nb_meta_data_maps, nb_meta_data_maps + 1);
3024 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3025 m->file = strtol(arg, &p, 0);
3026 parse_meta_type(p, &m->type, &m->index, &p);
3030 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3031 m1->file = strtol(p, &p, 0);
3032 parse_meta_type(p, &m1->type, &m1->index, &p);
3034 if (m->type == 'g' || m1->type == 'g')
3035 metadata_global_autocopy = 0;
3036 if (m->type == 's' || m1->type == 's')
3037 metadata_streams_autocopy = 0;
3038 if (m->type == 'c' || m1->type == 'c')
3039 metadata_chapters_autocopy = 0;
3044 static int opt_map_meta_data(const char *opt, const char *arg)
3046 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3047 "Use -map_metadata instead.\n");
3048 return opt_map_metadata(opt, arg);
3051 static int opt_map_chapters(const char *opt, const char *arg)
3056 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3057 nb_chapter_maps + 1);
3058 c = &chapter_maps[nb_chapter_maps - 1];
3059 c->out_file = strtol(arg, &p, 0);
3063 c->in_file = strtol(p, &p, 0);
3067 static int opt_input_ts_scale(const char *opt, const char *arg)
3069 unsigned int stream;
3073 stream = strtol(arg, &p, 0);
3076 scale= strtod(p, &p);
3078 if(stream >= MAX_STREAMS)
3081 input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3082 input_files_ts_scale[nb_input_files][stream]= scale;
3086 static int opt_recording_time(const char *opt, const char *arg)
3088 recording_time = parse_time_or_die(opt, arg, 1);
3092 static int opt_start_time(const char *opt, const char *arg)
3094 start_time = parse_time_or_die(opt, arg, 1);
3098 static int opt_recording_timestamp(const char *opt, const char *arg)
3100 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3104 static int opt_input_ts_offset(const char *opt, const char *arg)
3106 input_ts_offset = parse_time_or_die(opt, arg, 1);
3110 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3112 const char *codec_string = encoder ? "encoder" : "decoder";
3116 return CODEC_ID_NONE;
3118 avcodec_find_encoder_by_name(name) :
3119 avcodec_find_decoder_by_name(name);
3121 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3124 if(codec->type != type) {
3125 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3128 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3129 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3130 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3131 "results.\nAdd '-strict experimental' if you want to use it.\n",
3132 codec_string, codec->name);
3134 avcodec_find_encoder(codec->id) :
3135 avcodec_find_decoder(codec->id);
3136 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3137 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3138 codec_string, codec->name);
3144 static int opt_input_file(const char *opt, const char *filename)
3146 AVFormatContext *ic;
3147 AVFormatParameters params, *ap = ¶ms;
3148 AVInputFormat *file_iformat = NULL;
3149 int err, i, ret, rfps, rfps_base;
3152 if (last_asked_format) {
3153 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3154 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3157 last_asked_format = NULL;
3160 if (!strcmp(filename, "-"))
3163 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3164 !strcmp(filename, "/dev/stdin");
3166 /* get default parameters from command line */
3167 ic = avformat_alloc_context();
3169 print_error(filename, AVERROR(ENOMEM));
3173 memset(ap, 0, sizeof(*ap));
3174 ap->prealloced_context = 1;
3175 ap->sample_rate = audio_sample_rate;
3176 ap->channels = audio_channels;
3177 ap->time_base.den = frame_rate.num;
3178 ap->time_base.num = frame_rate.den;
3179 ap->width = frame_width;
3180 ap->height = frame_height;
3181 ap->pix_fmt = frame_pix_fmt;
3182 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3183 ap->channel = video_channel;
3184 ap->standard = video_standard;
3186 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3188 ic->video_codec_id =
3189 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3190 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3191 ic->audio_codec_id =
3192 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3193 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3194 ic->subtitle_codec_id=
3195 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3196 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3197 ic->flags |= AVFMT_FLAG_NONBLOCK;
3199 /* open the input file with generic libav function */
3200 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3202 print_error(filename, err);
3208 for(i=0; i<ic->nb_streams; i++){
3209 ic->streams[i]->discard= AVDISCARD_ALL;
3211 for(i=0; i<ic->nb_programs; i++){
3212 AVProgram *p= ic->programs[i];
3213 if(p->id != opt_programid){
3214 p->discard = AVDISCARD_ALL;
3217 for(j=0; j<p->nb_stream_indexes; j++){
3218 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3223 fprintf(stderr, "Specified program id not found\n");
3229 ic->loop_input = loop_input;
3231 /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3232 for (i = 0; i < ic->nb_streams; i++) {
3233 AVCodecContext *dec = ic->streams[i]->codec;
3234 switch (dec->codec_type) {
3235 case AVMEDIA_TYPE_AUDIO:
3236 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3237 AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3240 case AVMEDIA_TYPE_VIDEO:
3241 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3242 AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3248 /* If not enough info to get the stream parameters, we decode the
3249 first frames to get it. (used in mpeg case for example) */
3250 ret = av_find_stream_info(ic);
3251 if (ret < 0 && verbose >= 0) {
3252 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3253 av_close_input_file(ic);
3257 timestamp = start_time;
3258 /* add the stream start time */
3259 if (ic->start_time != AV_NOPTS_VALUE)
3260 timestamp += ic->start_time;
3262 /* if seeking requested, we execute it */
3263 if (start_time != 0) {
3264 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3266 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3267 filename, (double)timestamp / AV_TIME_BASE);
3269 /* reset seek info */
3273 /* update the current parameters so that they match the one of the input stream */
3274 for(i=0;i<ic->nb_streams;i++) {
3275 AVStream *st = ic->streams[i];
3276 AVCodecContext *dec = st->codec;
3279 dec->thread_count = thread_count;
3280 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3282 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3283 ist = &input_streams[nb_input_streams - 1];
3285 ist->file_index = nb_input_files;
3288 switch (dec->codec_type) {
3289 case AVMEDIA_TYPE_AUDIO:
3290 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3291 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3292 channel_layout = dec->channel_layout;
3293 audio_sample_fmt = dec->sample_fmt;
3295 st->discard= AVDISCARD_ALL;
3297 case AVMEDIA_TYPE_VIDEO:
3298 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3299 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3300 frame_height = dec->height;
3301 frame_width = dec->width;
3302 rfps = ic->streams[i]->r_frame_rate.num;
3303 rfps_base = ic->streams[i]->r_frame_rate.den;
3305 dec->flags |= CODEC_FLAG_EMU_EDGE;
3306 frame_height >>= dec->lowres;
3307 frame_width >>= dec->lowres;
3308 dec->height = frame_height;
3309 dec->width = frame_width;
3312 dec->debug |= FF_DEBUG_MV;
3314 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3317 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3318 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3320 (float)rfps / rfps_base, rfps, rfps_base);
3324 st->discard= AVDISCARD_ALL;
3325 else if(video_discard)
3326 st->discard= video_discard;
3328 case AVMEDIA_TYPE_DATA:
3330 case AVMEDIA_TYPE_SUBTITLE:
3331 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3332 if(subtitle_disable)
3333 st->discard = AVDISCARD_ALL;
3335 case AVMEDIA_TYPE_ATTACHMENT:
3336 case AVMEDIA_TYPE_UNKNOWN:
3343 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3344 /* dump the file content */
3346 av_dump_format(ic, nb_input_files, filename, 0);
3348 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3349 input_files[nb_input_files - 1].ctx = ic;
3350 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3353 frame_rate = (AVRational){0, 0};
3354 frame_pix_fmt = PIX_FMT_NONE;
3355 audio_sample_rate = 0;
3358 av_freep(&video_codec_name);
3359 av_freep(&audio_codec_name);
3360 av_freep(&subtitle_codec_name);
3366 static void check_inputs(int *has_video_ptr,
3368 int *has_subtitle_ptr,
3371 int has_video, has_audio, has_subtitle, has_data, i, j;
3372 AVFormatContext *ic;
3379 for(j=0;j<nb_input_files;j++) {
3380 ic = input_files[j].ctx;
3381 for(i=0;i<ic->nb_streams;i++) {
3382 AVCodecContext *enc = ic->streams[i]->codec;
3383 switch(enc->codec_type) {
3384 case AVMEDIA_TYPE_AUDIO:
3387 case AVMEDIA_TYPE_VIDEO:
3390 case AVMEDIA_TYPE_SUBTITLE:
3393 case AVMEDIA_TYPE_DATA:
3394 case AVMEDIA_TYPE_ATTACHMENT:
3395 case AVMEDIA_TYPE_UNKNOWN:
3403 *has_video_ptr = has_video;
3404 *has_audio_ptr = has_audio;
3405 *has_subtitle_ptr = has_subtitle;
3406 *has_data_ptr = has_data;
3409 static void new_video_stream(AVFormatContext *oc, int file_idx)
3412 AVOutputStream *ost;
3413 AVCodecContext *video_enc;
3414 enum CodecID codec_id = CODEC_ID_NONE;
3415 AVCodec *codec= NULL;
3417 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3419 fprintf(stderr, "Could not alloc stream\n");
3422 ost = new_output_stream(oc, file_idx);
3424 if(!video_stream_copy){
3425 if (video_codec_name) {
3426 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3427 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3428 codec = avcodec_find_encoder_by_name(video_codec_name);
3431 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3432 codec = avcodec_find_encoder(codec_id);
3435 ost->frame_aspect_ratio = frame_aspect_ratio;
3436 frame_aspect_ratio = 0;
3438 ost->avfilter= vfilters;
3443 avcodec_get_context_defaults3(st->codec, codec);
3444 ost->bitstream_filters = video_bitstream_filters;
3445 video_bitstream_filters= NULL;
3447 st->codec->thread_count= thread_count;
3449 video_enc = st->codec;
3452 video_enc->codec_tag= video_codec_tag;
3454 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3455 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3456 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3459 if (video_stream_copy) {
3460 st->stream_copy = 1;
3461 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3462 video_enc->sample_aspect_ratio =
3463 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3469 ost->frame_rate = frame_rate;
3470 video_enc->codec_id = codec_id;
3471 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3473 video_enc->width = frame_width;
3474 video_enc->height = frame_height;
3475 video_enc->pix_fmt = frame_pix_fmt;
3476 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3479 video_enc->gop_size = 0;
3480 if (video_qscale || same_quality) {
3481 video_enc->flags |= CODEC_FLAG_QSCALE;
3482 video_enc->global_quality=
3483 st->quality = FF_QP2LAMBDA * video_qscale;
3487 video_enc->intra_matrix = intra_matrix;
3489 video_enc->inter_matrix = inter_matrix;
3491 p= video_rc_override_string;
3494 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3496 fprintf(stderr, "error parsing rc_override\n");
3499 video_enc->rc_override=
3500 av_realloc(video_enc->rc_override,
3501 sizeof(RcOverride)*(i+1));
3502 video_enc->rc_override[i].start_frame= start;
3503 video_enc->rc_override[i].end_frame = end;
3505 video_enc->rc_override[i].qscale= q;
3506 video_enc->rc_override[i].quality_factor= 1.0;
3509 video_enc->rc_override[i].qscale= 0;
3510 video_enc->rc_override[i].quality_factor= -q/100.0;
3515 video_enc->rc_override_count=i;
3516 if (!video_enc->rc_initial_buffer_occupancy)
3517 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3518 video_enc->me_threshold= me_threshold;
3519 video_enc->intra_dc_precision= intra_dc_precision - 8;
3522 video_enc->flags|= CODEC_FLAG_PSNR;
3527 video_enc->flags |= CODEC_FLAG_PASS1;
3529 video_enc->flags |= CODEC_FLAG_PASS2;
3533 if (forced_key_frames)
3534 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3536 if (video_language) {
3537 av_dict_set(&st->metadata, "language", video_language, 0);
3538 av_freep(&video_language);
3541 /* reset some key parameters */
3543 av_freep(&video_codec_name);
3544 av_freep(&forced_key_frames);
3545 video_stream_copy = 0;
3546 frame_pix_fmt = PIX_FMT_NONE;
3549 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3552 AVOutputStream *ost;
3553 AVCodec *codec= NULL;
3554 AVCodecContext *audio_enc;
3555 enum CodecID codec_id = CODEC_ID_NONE;
3557 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3559 fprintf(stderr, "Could not alloc stream\n");
3562 ost = new_output_stream(oc, file_idx);
3564 if(!audio_stream_copy){
3565 if (audio_codec_name) {
3566 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3567 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3568 codec = avcodec_find_encoder_by_name(audio_codec_name);
3571 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3572 codec = avcodec_find_encoder(codec_id);
3576 avcodec_get_context_defaults3(st->codec, codec);
3578 ost->bitstream_filters = audio_bitstream_filters;
3579 audio_bitstream_filters= NULL;
3581 st->codec->thread_count= thread_count;
3583 audio_enc = st->codec;
3584 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3587 audio_enc->codec_tag= audio_codec_tag;
3589 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3590 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3591 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3593 if (audio_stream_copy) {
3594 st->stream_copy = 1;
3596 audio_enc->codec_id = codec_id;
3597 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3599 if (audio_qscale > QSCALE_NONE) {
3600 audio_enc->flags |= CODEC_FLAG_QSCALE;
3601 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3604 audio_enc->channels = audio_channels;
3605 audio_enc->sample_fmt = audio_sample_fmt;
3606 if (audio_sample_rate)
3607 audio_enc->sample_rate = audio_sample_rate;
3608 audio_enc->channel_layout = channel_layout;
3609 choose_sample_fmt(st, codec);
3611 if (audio_language) {
3612 av_dict_set(&st->metadata, "language", audio_language, 0);
3613 av_freep(&audio_language);
3616 /* reset some key parameters */
3618 av_freep(&audio_codec_name);
3619 audio_stream_copy = 0;
3622 static void new_data_stream(AVFormatContext *oc, int file_idx)
3625 AVCodec *codec=NULL;
3626 AVCodecContext *data_enc;
3628 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3630 fprintf(stderr, "Could not alloc stream\n");
3633 new_output_stream(oc, file_idx);
3634 data_enc = st->codec;
3635 if (!data_stream_copy) {
3636 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3639 avcodec_get_context_defaults3(st->codec, codec);
3641 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3644 data_enc->codec_tag= data_codec_tag;
3646 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3647 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3648 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3650 if (data_stream_copy) {
3651 st->stream_copy = 1;
3655 av_freep(&data_codec_name);
3656 data_stream_copy = 0;
3659 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3662 AVOutputStream *ost;
3663 AVCodec *codec=NULL;
3664 AVCodecContext *subtitle_enc;
3665 enum CodecID codec_id = CODEC_ID_NONE;
3667 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3669 fprintf(stderr, "Could not alloc stream\n");
3672 ost = new_output_stream(oc, file_idx);
3673 subtitle_enc = st->codec;
3674 if(!subtitle_stream_copy){
3675 if (subtitle_codec_name) {
3676 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3677 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3678 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3681 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3682 codec = avcodec_find_encoder(codec_id);
3685 avcodec_get_context_defaults3(st->codec, codec);
3687 ost->bitstream_filters = subtitle_bitstream_filters;
3688 subtitle_bitstream_filters= NULL;
3690 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3692 if(subtitle_codec_tag)
3693 subtitle_enc->codec_tag= subtitle_codec_tag;
3695 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3696 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3697 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3699 if (subtitle_stream_copy) {
3700 st->stream_copy = 1;
3702 subtitle_enc->codec_id = codec_id;
3703 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3706 if (subtitle_language) {
3707 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3708 av_freep(&subtitle_language);
3711 subtitle_disable = 0;
3712 av_freep(&subtitle_codec_name);
3713 subtitle_stream_copy = 0;
3716 static int opt_new_stream(const char *opt, const char *arg)
3718 AVFormatContext *oc;
3719 int file_idx = nb_output_files - 1;
3720 if (nb_output_files <= 0) {
3721 fprintf(stderr, "At least one output file must be specified\n");
3724 oc = output_files[file_idx];
3726 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3727 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3728 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3729 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3734 /* arg format is "output-stream-index:streamid-value". */
3735 static int opt_streamid(const char *opt, const char *arg)
3741 av_strlcpy(idx_str, arg, sizeof(idx_str));
3742 p = strchr(idx_str, ':');
3745 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3750 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3751 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3752 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3756 static void opt_output_file(const char *filename)
3758 AVFormatContext *oc;
3759 int err, use_video, use_audio, use_subtitle, use_data;
3760 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3761 AVFormatParameters params, *ap = ¶ms;
3762 AVOutputFormat *file_oformat;
3764 if (!strcmp(filename, "-"))
3767 oc = avformat_alloc_context();
3769 print_error(filename, AVERROR(ENOMEM));
3773 if (last_asked_format) {
3774 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3775 if (!file_oformat) {
3776 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3779 last_asked_format = NULL;
3781 file_oformat = av_guess_format(NULL, filename, NULL);
3782 if (!file_oformat) {
3783 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3789 oc->oformat = file_oformat;
3790 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3792 if (!strcmp(file_oformat->name, "ffm") &&
3793 av_strstart(filename, "http:", NULL)) {
3794 /* special case for files sent to ffserver: we get the stream
3795 parameters from ffserver */
3796 int err = read_ffserver_streams(oc, filename);
3798 print_error(filename, err);
3802 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3803 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3804 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3805 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 */
3807 /* disable if no corresponding type found and at least one
3809 if (nb_input_files > 0) {
3810 check_inputs(&input_has_video,
3812 &input_has_subtitle,
3815 if (!input_has_video)
3817 if (!input_has_audio)
3819 if (!input_has_subtitle)
3821 if (!input_has_data)
3825 /* manual disable */
3826 if (audio_disable) use_audio = 0;
3827 if (video_disable) use_video = 0;
3828 if (subtitle_disable) use_subtitle = 0;
3829 if (data_disable) use_data = 0;
3831 if (use_video) new_video_stream(oc, nb_output_files);
3832 if (use_audio) new_audio_stream(oc, nb_output_files);
3833 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3834 if (use_data) new_data_stream(oc, nb_output_files);
3836 oc->timestamp = recording_timestamp;
3838 av_dict_copy(&oc->metadata, metadata, 0);
3839 av_dict_free(&metadata);
3842 output_files[nb_output_files++] = oc;
3844 /* check filename in case of an image number is expected */
3845 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3846 if (!av_filename_number_test(oc->filename)) {
3847 print_error(oc->filename, AVERROR(EINVAL));
3852 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3853 /* test if it already exists to avoid loosing precious files */
3854 if (!file_overwrite &&
3855 (strchr(filename, ':') == NULL ||
3856 filename[1] == ':' ||
3857 av_strstart(filename, "file:", NULL))) {
3858 if (avio_check(filename, 0) == 0) {
3860 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3862 if (!read_yesno()) {
3863 fprintf(stderr, "Not overwriting - exiting\n");
3868 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3875 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3876 print_error(filename, err);
3881 memset(ap, 0, sizeof(*ap));
3882 if (av_set_parameters(oc, ap) < 0) {
3883 fprintf(stderr, "%s: Invalid encoding parameters\n",
3888 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3889 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3890 oc->loop_output = loop_output;
3891 oc->flags |= AVFMT_FLAG_NONBLOCK;
3893 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3895 frame_rate = (AVRational){0, 0};
3896 audio_sample_rate = 0;
3899 av_freep(&forced_key_frames);
3904 /* same option as mencoder */
3905 static int opt_pass(const char *opt, const char *arg)
3907 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3911 static int64_t getutime(void)
3914 struct rusage rusage;
3916 getrusage(RUSAGE_SELF, &rusage);
3917 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3918 #elif HAVE_GETPROCESSTIMES
3920 FILETIME c, e, k, u;
3921 proc = GetCurrentProcess();
3922 GetProcessTimes(proc, &c, &e, &k, &u);
3923 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3925 return av_gettime();
3929 static int64_t getmaxrss(void)
3931 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3932 struct rusage rusage;
3933 getrusage(RUSAGE_SELF, &rusage);
3934 return (int64_t)rusage.ru_maxrss * 1024;
3935 #elif HAVE_GETPROCESSMEMORYINFO
3937 PROCESS_MEMORY_COUNTERS memcounters;
3938 proc = GetCurrentProcess();
3939 memcounters.cb = sizeof(memcounters);
3940 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3941 return memcounters.PeakPagefileUsage;
3947 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3950 const char *p = str;
3957 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3964 static void opt_inter_matrix(const char *arg)
3966 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3967 parse_matrix_coeffs(inter_matrix, arg);
3970 static void opt_intra_matrix(const char *arg)
3972 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3973 parse_matrix_coeffs(intra_matrix, arg);
3976 static void show_usage(void)
3978 printf("Hyper fast Audio and Video encoder\n");
3979 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3983 static void show_help(void)
3986 AVOutputFormat *oformat = NULL;
3988 av_log_set_callback(log_callback_help);
3990 show_help_options(options, "Main options:\n",
3991 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3992 show_help_options(options, "\nAdvanced options:\n",
3993 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3995 show_help_options(options, "\nVideo options:\n",
3996 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3998 show_help_options(options, "\nAdvanced Video options:\n",
3999 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4000 OPT_VIDEO | OPT_EXPERT);
4001 show_help_options(options, "\nAudio options:\n",
4002 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4004 show_help_options(options, "\nAdvanced Audio options:\n",
4005 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4006 OPT_AUDIO | OPT_EXPERT);
4007 show_help_options(options, "\nSubtitle options:\n",
4008 OPT_SUBTITLE | OPT_GRAB,
4010 show_help_options(options, "\nAudio/Video grab options:\n",
4014 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4017 /* individual codec options */
4019 while ((c = av_codec_next(c))) {
4020 if (c->priv_class) {
4021 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4026 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4029 /* individual muxer options */
4030 while ((oformat = av_oformat_next(oformat))) {
4031 if (oformat->priv_class) {
4032 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4037 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4040 static int opt_target(const char *opt, const char *arg)
4042 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4043 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4045 if(!strncmp(arg, "pal-", 4)) {
4048 } else if(!strncmp(arg, "ntsc-", 5)) {
4051 } else if(!strncmp(arg, "film-", 5)) {
4056 /* Calculate FR via float to avoid int overflow */
4057 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4060 } else if((fr == 29970) || (fr == 23976)) {
4063 /* Try to determine PAL/NTSC by peeking in the input files */
4064 if(nb_input_files) {
4066 for (j = 0; j < nb_input_files; j++) {
4067 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4068 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4069 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4071 fr = c->time_base.den * 1000 / c->time_base.num;
4075 } else if((fr == 29970) || (fr == 23976)) {
4085 if(verbose > 0 && norm != UNKNOWN)
4086 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4089 if(norm == UNKNOWN) {
4090 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4091 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4092 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4096 if(!strcmp(arg, "vcd")) {
4097 opt_video_codec("vcodec", "mpeg1video");
4098 opt_audio_codec("vcodec", "mp2");
4099 opt_format("f", "vcd");
4101 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4102 opt_frame_rate("r", frame_rates[norm]);
4103 opt_default("g", norm == PAL ? "15" : "18");
4105 opt_default("b", "1150000");
4106 opt_default("maxrate", "1150000");
4107 opt_default("minrate", "1150000");
4108 opt_default("bufsize", "327680"); // 40*1024*8;
4110 opt_default("ab", "224000");
4111 audio_sample_rate = 44100;
4114 opt_default("packetsize", "2324");
4115 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4117 /* We have to offset the PTS, so that it is consistent with the SCR.
4118 SCR starts at 36000, but the first two packs contain only padding
4119 and the first pack from the other stream, respectively, may also have
4120 been written before.
4121 So the real data starts at SCR 36000+3*1200. */
4122 mux_preload= (36000+3*1200) / 90000.0; //0.44
4123 } else if(!strcmp(arg, "svcd")) {
4125 opt_video_codec("vcodec", "mpeg2video");
4126 opt_audio_codec("acodec", "mp2");
4127 opt_format("f", "svcd");
4129 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4130 opt_frame_rate("r", frame_rates[norm]);
4131 opt_default("g", norm == PAL ? "15" : "18");
4133 opt_default("b", "2040000");
4134 opt_default("maxrate", "2516000");
4135 opt_default("minrate", "0"); //1145000;
4136 opt_default("bufsize", "1835008"); //224*1024*8;
4137 opt_default("flags", "+scan_offset");
4140 opt_default("ab", "224000");
4141 audio_sample_rate = 44100;
4143 opt_default("packetsize", "2324");
4145 } else if(!strcmp(arg, "dvd")) {
4147 opt_video_codec("vcodec", "mpeg2video");
4148 opt_audio_codec("vcodec", "ac3");
4149 opt_format("f", "dvd");
4151 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4152 opt_frame_rate("r", frame_rates[norm]);
4153 opt_default("g", norm == PAL ? "15" : "18");
4155 opt_default("b", "6000000");
4156 opt_default("maxrate", "9000000");
4157 opt_default("minrate", "0"); //1500000;
4158 opt_default("bufsize", "1835008"); //224*1024*8;
4160 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4161 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4163 opt_default("ab", "448000");
4164 audio_sample_rate = 48000;
4166 } else if(!strncmp(arg, "dv", 2)) {
4168 opt_format("f", "dv");
4170 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4171 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4172 norm == PAL ? "yuv420p" : "yuv411p");
4173 opt_frame_rate("r", frame_rates[norm]);
4175 audio_sample_rate = 48000;
4179 fprintf(stderr, "Unknown target: %s\n", arg);
4180 return AVERROR(EINVAL);
4185 static int opt_vstats_file(const char *opt, const char *arg)
4187 av_free (vstats_filename);
4188 vstats_filename=av_strdup (arg);
4192 static int opt_vstats(const char *opt, const char *arg)
4195 time_t today2 = time(NULL);
4196 struct tm *today = localtime(&today2);
4198 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4200 return opt_vstats_file(opt, filename);
4203 static int opt_bsf(const char *opt, const char *arg)
4205 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4206 AVBitStreamFilterContext **bsfp;
4209 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4213 bsfp= *opt == 'v' ? &video_bitstream_filters :
4214 *opt == 'a' ? &audio_bitstream_filters :
4215 &subtitle_bitstream_filters;
4217 bsfp= &(*bsfp)->next;
4224 static int opt_preset(const char *opt, const char *arg)
4227 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4228 char *codec_name = *opt == 'v' ? video_codec_name :
4229 *opt == 'a' ? audio_codec_name :
4230 subtitle_codec_name;
4232 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4233 fprintf(stderr, "File for preset '%s' not found\n", arg);
4238 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4239 if(line[0] == '#' && !e)
4241 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4243 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4246 if(!strcmp(tmp, "acodec")){
4247 opt_audio_codec(tmp, tmp2);
4248 }else if(!strcmp(tmp, "vcodec")){
4249 opt_video_codec(tmp, tmp2);
4250 }else if(!strcmp(tmp, "scodec")){
4251 opt_subtitle_codec(tmp, tmp2);
4252 }else if(!strcmp(tmp, "dcodec")){
4253 opt_data_codec(tmp, tmp2);
4254 }else if(opt_default(tmp, tmp2) < 0){
4255 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4265 static const OptionDef options[] = {
4267 #include "cmdutils_common_opts.h"
4268 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4269 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4270 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4271 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4272 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4273 "outfile[,metadata]:infile[,metadata]" },
4274 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4275 "outfile[,metadata]:infile[,metadata]" },
4276 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4277 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4278 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4279 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4280 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4281 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4282 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4283 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4284 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4285 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4286 "add timings for benchmarking" },
4287 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4288 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4289 "dump each input packet" },
4290 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4291 "when dumping packets, also dump the payload" },
4292 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4293 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4294 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4295 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4296 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4297 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4298 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4299 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4300 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4301 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4302 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4303 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4304 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4305 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4306 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4307 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4310 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4311 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4312 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4313 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4314 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4315 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4316 { "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" },
4317 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4318 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4319 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4320 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4321 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4322 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4323 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4324 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4325 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4326 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4327 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4328 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4329 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4330 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4331 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4332 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4333 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4334 "use same quantizer as source (implies VBR)" },
4335 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4336 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4337 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4338 "deinterlace pictures" },
4339 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4340 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4341 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4343 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4345 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4346 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4347 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4348 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4349 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4350 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4351 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4352 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4353 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4354 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4355 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4358 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4359 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4360 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4361 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4362 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4363 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4364 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4365 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4366 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4367 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4368 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4369 { "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" },
4371 /* subtitle options */
4372 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4373 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4374 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4375 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4376 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4379 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4380 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4381 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4384 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4385 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4387 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4388 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4389 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4391 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4392 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4393 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4394 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4395 /* data codec support */
4396 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4398 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4402 int main(int argc, char **argv)
4406 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4408 avcodec_register_all();
4410 avdevice_register_all();
4413 avfilter_register_all();
4417 avio_set_interrupt_cb(decode_interrupt_cb);
4424 parse_options(argc, argv, options, opt_output_file);
4426 if(nb_output_files <= 0 && nb_input_files == 0) {
4428 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4432 /* file converter / grab */
4433 if (nb_output_files <= 0) {
4434 fprintf(stderr, "At least one output file must be specified\n");
4438 if (nb_input_files == 0) {
4439 fprintf(stderr, "At least one input file must be specified\n");
4444 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4445 stream_maps, nb_stream_maps) < 0)
4447 ti = getutime() - ti;
4449 int maxrss = getmaxrss() / 1024;
4450 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4453 return ffmpeg_exit(0);