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
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavutil/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavutil/audioconvert.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/libm.h"
48 #include "libavformat/os_support.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
79 #include "libavutil/avassert.h"
81 const char program_name[] = "ffmpeg";
82 const int program_birth_year = 2000;
84 /* select an input stream for an output stream */
85 typedef struct AVStreamMap {
89 int sync_stream_index;
93 * select an input file for an output file
95 typedef struct AVMetaDataMap {
96 int file; //< file index
97 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
98 int index; //< stream/chapter/program number
101 typedef struct AVChapterMap {
106 static const OptionDef options[];
108 #define MAX_FILES 100
109 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
111 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
113 static const char *last_asked_format = NULL;
114 static AVFormatContext *input_files[MAX_FILES];
115 static int64_t input_files_ts_offset[MAX_FILES];
116 static double *input_files_ts_scale[MAX_FILES] = {NULL};
117 static AVCodec **input_codecs = NULL;
118 static int nb_input_files = 0;
119 static int nb_input_codecs = 0;
120 static int nb_input_files_ts_scale[MAX_FILES] = {0};
122 static AVFormatContext *output_files[MAX_FILES];
123 static AVCodec **output_codecs = NULL;
124 static int nb_output_files = 0;
125 static int nb_output_codecs = 0;
127 static AVStreamMap *stream_maps = NULL;
128 static int nb_stream_maps;
130 /* first item specifies output metadata, second is input */
131 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
132 static int nb_meta_data_maps;
133 static int metadata_global_autocopy = 1;
134 static int metadata_streams_autocopy = 1;
135 static int metadata_chapters_autocopy = 1;
137 static AVChapterMap *chapter_maps = NULL;
138 static int nb_chapter_maps;
140 /* indexed by output file stream index */
141 static int *streamid_map = NULL;
142 static int nb_streamid_map = 0;
144 static int frame_width = 0;
145 static int frame_height = 0;
146 static float frame_aspect_ratio = 0;
147 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
148 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
149 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
150 static AVRational frame_rate;
151 static float video_qscale = 0;
152 static uint16_t *intra_matrix = NULL;
153 static uint16_t *inter_matrix = NULL;
154 static const char *video_rc_override_string=NULL;
155 static int video_disable = 0;
156 static int video_discard = 0;
157 static char *video_codec_name = NULL;
158 static unsigned int video_codec_tag = 0;
159 static char *video_language = NULL;
160 static int same_quality = 0;
161 static int do_deinterlace = 0;
162 static int top_field_first = -1;
163 static int me_threshold = 0;
164 static int intra_dc_precision = 8;
165 static int loop_input = 0;
166 static int loop_output = AVFMT_NOOUTPUTLOOP;
167 static int qp_hist = 0;
169 static char *vfilters = NULL;
170 static AVFilterGraph *graph = NULL;
173 static int intra_only = 0;
174 static int audio_sample_rate = 44100;
175 static int64_t channel_layout = 0;
176 #define QSCALE_NONE -99999
177 static float audio_qscale = QSCALE_NONE;
178 static int audio_disable = 0;
179 static int audio_channels = 1;
180 static char *audio_codec_name = NULL;
181 static unsigned int audio_codec_tag = 0;
182 static char *audio_language = NULL;
184 static int subtitle_disable = 0;
185 static char *subtitle_codec_name = NULL;
186 static char *subtitle_language = NULL;
187 static unsigned int subtitle_codec_tag = 0;
189 static int data_disable = 0;
190 static char *data_codec_name = NULL;
191 static unsigned int data_codec_tag = 0;
193 static float mux_preload= 0.5;
194 static float mux_max_delay= 0.7;
196 static int64_t recording_time = INT64_MAX;
197 static int64_t start_time = 0;
198 static int64_t recording_timestamp = 0;
199 static int64_t input_ts_offset = 0;
200 static int file_overwrite = 0;
201 static AVMetadata *metadata;
202 static int do_benchmark = 0;
203 static int do_hex_dump = 0;
204 static int do_pkt_dump = 0;
205 static int do_psnr = 0;
206 static int do_pass = 0;
207 static char *pass_logfilename_prefix = NULL;
208 static int audio_stream_copy = 0;
209 static int video_stream_copy = 0;
210 static int subtitle_stream_copy = 0;
211 static int data_stream_copy = 0;
212 static int video_sync_method= -1;
213 static int audio_sync_method= 0;
214 static float audio_drift_threshold= 0.1;
215 static int copy_ts= 0;
217 static int opt_shortest = 0;
218 static int video_global_header = 0;
219 static char *vstats_filename;
220 static FILE *vstats_file;
221 static int opt_programid = 0;
222 static int copy_initial_nonkeyframes = 0;
224 static int rate_emu = 0;
226 static int video_channel = 0;
227 static char *video_standard;
229 static int audio_volume = 256;
231 static int exit_on_error = 0;
232 static int using_stdin = 0;
233 static int verbose = 1;
234 static int thread_count= 1;
235 static int q_pressed = 0;
236 static int64_t video_size = 0;
237 static int64_t audio_size = 0;
238 static int64_t extra_size = 0;
239 static int nb_frames_dup = 0;
240 static int nb_frames_drop = 0;
241 static int input_sync;
242 static uint64_t limit_filesize = 0;
243 static int force_fps = 0;
244 static char *forced_key_frames = NULL;
246 static float dts_delta_threshold = 10;
248 static int64_t timer_start;
250 static uint8_t *audio_buf;
251 static uint8_t *audio_out;
252 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
254 static short *samples;
256 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
257 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
258 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
260 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
262 struct AVInputStream;
264 typedef struct AVOutputStream {
265 int file_index; /* file index */
266 int index; /* stream index in the output file */
267 int source_index; /* AVInputStream index */
268 AVStream *st; /* stream in the output file */
269 int encoding_needed; /* true if encoding needed for this stream */
271 /* input pts and corresponding output pts
273 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
274 struct AVInputStream *sync_ist; /* input stream to sync against */
275 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
276 AVBitStreamFilterContext *bitstream_filters;
279 AVFrame pict_tmp; /* temporary image for resampling */
280 struct SwsContext *img_resample_ctx; /* for image resampling */
283 int resample_pix_fmt;
285 /* forced key frames */
286 int64_t *forced_kf_pts;
292 ReSampleContext *resample; /* for audio resampling */
293 int resample_sample_fmt;
294 int resample_channels;
295 int resample_sample_rate;
297 AVAudioConvert *reformat_ctx;
298 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
304 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
305 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
307 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 AVFilterContext *output_video_filter;
325 AVFilterContext *input_video_filter;
326 AVFrame *filter_frame;
327 int has_filter_frame;
328 AVFilterBufferRef *picref;
332 typedef struct AVInputFile {
333 int eof_reached; /* true if eof reached */
334 int ist_index; /* index of first stream in ist_table */
335 int buffer_size; /* current total buffer size */
336 int nb_streams; /* nb streams we are aware of */
341 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
343 AVFilterContext *last_filter, *filter;
344 /** filter graph containing all filters including input & output */
345 AVCodecContext *codec = ost->st->codec;
346 AVCodecContext *icodec = ist->st->codec;
347 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
348 AVRational sample_aspect_ratio;
352 graph = avfilter_graph_alloc();
354 if (ist->st->sample_aspect_ratio.num){
355 sample_aspect_ratio = ist->st->sample_aspect_ratio;
357 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
359 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
360 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
361 sample_aspect_ratio.num, sample_aspect_ratio.den);
363 ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
364 "src", args, NULL, graph);
367 ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
368 "out", NULL, &ffsink_ctx, graph);
371 last_filter = ist->input_video_filter;
373 if (codec->width != icodec->width || codec->height != icodec->height) {
374 snprintf(args, 255, "%d:%d:flags=0x%X",
378 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
379 NULL, args, NULL, graph)) < 0)
381 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
383 last_filter = filter;
386 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
387 graph->scale_sws_opts = av_strdup(args);
390 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
391 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
393 outputs->name = av_strdup("in");
394 outputs->filter_ctx = last_filter;
395 outputs->pad_idx = 0;
396 outputs->next = NULL;
398 inputs->name = av_strdup("out");
399 inputs->filter_ctx = ist->output_video_filter;
403 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
407 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
411 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
414 codec->width = ist->output_video_filter->inputs[0]->w;
415 codec->height = ist->output_video_filter->inputs[0]->h;
416 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
417 ist->output_video_filter->inputs[0]->sample_aspect_ratio;
421 #endif /* CONFIG_AVFILTER */
423 static void term_exit(void)
425 av_log(NULL, AV_LOG_QUIET, "");
428 static volatile int received_sigterm = 0;
431 sigterm_handler(int sig)
433 received_sigterm = sig;
437 static void term_init(void)
439 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
440 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
442 signal(SIGXCPU, sigterm_handler);
446 /* read a key without blocking */
447 static int read_key(void)
456 static int decode_interrupt_cb(void)
458 return q_pressed || (q_pressed = read_key() == 'q');
461 static int ffmpeg_exit(int ret)
466 for(i=0;i<nb_output_files;i++) {
467 AVFormatContext *s = output_files[i];
468 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
470 avformat_free_context(s);
471 av_free(output_streams_for_file[i]);
473 for(i=0;i<nb_input_files;i++) {
474 av_close_input_file(input_files[i]);
475 av_free(input_files_ts_scale[i]);
478 av_free(intra_matrix);
479 av_free(inter_matrix);
483 av_free(vstats_filename);
485 av_free(streamid_map);
486 av_free(input_codecs);
487 av_free(output_codecs);
488 av_free(stream_maps);
489 av_free(meta_data_maps);
491 av_free(video_codec_name);
492 av_free(audio_codec_name);
493 av_free(subtitle_codec_name);
494 av_free(data_codec_name);
496 av_free(video_standard);
501 allocated_audio_buf_size= allocated_audio_out_size= 0;
508 if (received_sigterm) {
510 "Received signal %d: terminating.\n",
511 (int) received_sigterm);
515 exit(ret); /* not all OS-es handle main() return value */
519 /* similar to ff_dynarray_add() and av_fast_realloc() */
520 static void *grow_array(void *array, int elem_size, int *size, int new_size)
522 if (new_size >= INT_MAX / elem_size) {
523 fprintf(stderr, "Array too big.\n");
526 if (*size < new_size) {
527 uint8_t *tmp = av_realloc(array, new_size*elem_size);
529 fprintf(stderr, "Could not alloc buffer.\n");
532 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
539 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
541 if(codec && codec->sample_fmts){
542 const enum AVSampleFormat *p= codec->sample_fmts;
544 if(*p == st->codec->sample_fmt)
548 av_log(NULL, AV_LOG_WARNING,
549 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
550 av_get_sample_fmt_name(st->codec->sample_fmt),
552 av_get_sample_fmt_name(codec->sample_fmts[0]));
553 st->codec->sample_fmt = codec->sample_fmts[0];
558 static void choose_sample_rate(AVStream *st, AVCodec *codec)
560 if(codec && codec->supported_samplerates){
561 const int *p= codec->supported_samplerates;
563 int best_dist=INT_MAX;
565 int dist= abs(st->codec->sample_rate - *p);
566 if(dist < best_dist){
572 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
574 st->codec->sample_rate= best;
578 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
580 if(codec && codec->pix_fmts){
581 const enum PixelFormat *p= codec->pix_fmts;
582 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
583 if(st->codec->codec_id==CODEC_ID_MJPEG){
584 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
585 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
586 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};
590 if(*p == st->codec->pix_fmt)
594 if(st->codec->pix_fmt != PIX_FMT_NONE)
595 av_log(NULL, AV_LOG_WARNING,
596 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
597 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
599 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
600 st->codec->pix_fmt = codec->pix_fmts[0];
605 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
607 int idx = oc->nb_streams - 1;
610 output_streams_for_file[file_idx] =
611 grow_array(output_streams_for_file[file_idx],
612 sizeof(*output_streams_for_file[file_idx]),
613 &nb_output_streams_for_file[file_idx],
615 ost = output_streams_for_file[file_idx][idx] =
616 av_mallocz(sizeof(AVOutputStream));
618 fprintf(stderr, "Could not alloc output stream\n");
621 ost->file_index = file_idx;
624 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
628 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
634 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
637 /* copy stream format */
639 for(i=0;i<ic->nb_streams;i++) {
645 // FIXME: a more elegant solution is needed
646 st = av_mallocz(sizeof(AVStream));
647 memcpy(st, ic->streams[i], sizeof(AVStream));
648 st->codec = avcodec_alloc_context();
650 print_error(filename, AVERROR(ENOMEM));
653 avcodec_copy_context(st->codec, ic->streams[i]->codec);
656 codec = avcodec_find_encoder(st->codec->codec_id);
657 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
658 if (audio_stream_copy) {
661 choose_sample_fmt(st, codec);
662 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
663 if (video_stream_copy) {
666 choose_pixel_fmt(st, codec);
669 if(st->codec->flags & CODEC_FLAG_BITEXACT)
672 new_output_stream(s, nb_output_files);
676 s->timestamp = av_gettime();
678 av_close_input_file(ic);
683 get_sync_ipts(const AVOutputStream *ost)
685 const AVInputStream *ist = ost->sync_ist;
686 return (double)(ist->pts - start_time)/AV_TIME_BASE;
689 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
693 AVPacket new_pkt= *pkt;
694 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
695 &new_pkt.data, &new_pkt.size,
696 pkt->data, pkt->size,
697 pkt->flags & AV_PKT_FLAG_KEY);
700 new_pkt.destruct= av_destruct_packet;
702 fprintf(stderr, "%s failed for stream %d, codec %s",
703 bsfc->filter->name, pkt->stream_index,
704 avctx->codec ? avctx->codec->name : "copy");
714 ret= av_interleaved_write_frame(s, pkt);
716 print_error("av_interleaved_write_frame()", ret);
721 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
723 static void do_audio_out(AVFormatContext *s,
726 unsigned char *buf, int size)
729 int64_t audio_out_size, audio_buf_size;
730 int64_t allocated_for_size= size;
732 int size_out, frame_bytes, ret, resample_changed;
733 AVCodecContext *enc= ost->st->codec;
734 AVCodecContext *dec= ist->st->codec;
735 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
736 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
737 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
740 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
741 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
742 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
743 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
744 audio_buf_size*= osize*enc->channels;
746 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
747 if(coded_bps > 8*osize)
748 audio_out_size= audio_out_size * coded_bps / (8*osize);
749 audio_out_size += FF_MIN_BUFFER_SIZE;
751 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
752 fprintf(stderr, "Buffer sizes too large\n");
756 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
757 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
758 if (!audio_buf || !audio_out){
759 fprintf(stderr, "Out of memory in do_audio_out\n");
763 if (enc->channels != dec->channels)
764 ost->audio_resample = 1;
766 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
767 ost->resample_channels != dec->channels ||
768 ost->resample_sample_rate != dec->sample_rate;
770 if ((ost->audio_resample && !ost->resample) || resample_changed) {
771 if (resample_changed) {
772 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",
773 ist->file_index, ist->index,
774 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
775 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
776 ost->resample_sample_fmt = dec->sample_fmt;
777 ost->resample_channels = dec->channels;
778 ost->resample_sample_rate = dec->sample_rate;
780 audio_resample_close(ost->resample);
782 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
783 if (audio_sync_method <= 1 &&
784 ost->resample_sample_fmt == enc->sample_fmt &&
785 ost->resample_channels == enc->channels &&
786 ost->resample_sample_rate == enc->sample_rate) {
787 ost->resample = NULL;
788 ost->audio_resample = 0;
790 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
791 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
792 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
793 enc->sample_rate, dec->sample_rate,
794 enc->sample_fmt, dec->sample_fmt,
796 if (!ost->resample) {
797 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
798 dec->channels, dec->sample_rate,
799 enc->channels, enc->sample_rate);
805 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
806 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
807 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
808 if (ost->reformat_ctx)
809 av_audio_convert_free(ost->reformat_ctx);
810 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
811 dec->sample_fmt, 1, NULL, 0);
812 if (!ost->reformat_ctx) {
813 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
814 av_get_sample_fmt_name(dec->sample_fmt),
815 av_get_sample_fmt_name(enc->sample_fmt));
818 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
821 if(audio_sync_method){
822 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
823 - av_fifo_size(ost->fifo)/(enc->channels * 2);
824 double idelta= delta*dec->sample_rate / enc->sample_rate;
825 int byte_delta= ((int)idelta)*2*dec->channels;
827 //FIXME resample delay
828 if(fabs(delta) > 50){
829 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
831 byte_delta= FFMAX(byte_delta, -size);
835 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
840 static uint8_t *input_tmp= NULL;
841 input_tmp= av_realloc(input_tmp, byte_delta + size);
843 if(byte_delta > allocated_for_size - size){
844 allocated_for_size= byte_delta + (int64_t)size;
849 memset(input_tmp, 0, byte_delta);
850 memcpy(input_tmp + byte_delta, buf, size);
854 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
856 }else if(audio_sync_method>1){
857 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
858 av_assert0(ost->audio_resample);
860 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
861 // 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));
862 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
866 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
867 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
869 if (ost->audio_resample) {
871 size_out = audio_resample(ost->resample,
872 (short *)buftmp, (short *)buf,
873 size / (dec->channels * isize));
874 size_out = size_out * enc->channels * osize;
880 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
881 const void *ibuf[6]= {buftmp};
882 void *obuf[6]= {audio_buf};
883 int istride[6]= {isize};
884 int ostride[6]= {osize};
885 int len= size_out/istride[0];
886 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
887 printf("av_audio_convert() failed\n");
893 size_out = len*osize;
896 /* now encode as many frames as possible */
897 if (enc->frame_size > 1) {
898 /* output resampled raw samples */
899 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
900 fprintf(stderr, "av_fifo_realloc2() failed\n");
903 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
905 frame_bytes = enc->frame_size * osize * enc->channels;
907 while (av_fifo_size(ost->fifo) >= frame_bytes) {
909 av_init_packet(&pkt);
911 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
913 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
915 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
918 fprintf(stderr, "Audio encoding failed\n");
922 pkt.stream_index= ost->index;
925 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
926 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
927 pkt.flags |= AV_PKT_FLAG_KEY;
928 write_frame(s, &pkt, enc, ost->bitstream_filters);
930 ost->sync_opts += enc->frame_size;
934 av_init_packet(&pkt);
936 ost->sync_opts += size_out / (osize * enc->channels);
938 /* output a pcm frame */
939 /* determine the size of the coded buffer */
942 size_out = size_out*coded_bps/8;
944 if(size_out > audio_out_size){
945 fprintf(stderr, "Internal error, buffer size too small\n");
949 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
950 ret = avcodec_encode_audio(enc, audio_out, size_out,
953 fprintf(stderr, "Audio encoding failed\n");
957 pkt.stream_index= ost->index;
960 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
961 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
962 pkt.flags |= AV_PKT_FLAG_KEY;
963 write_frame(s, &pkt, enc, ost->bitstream_filters);
967 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
971 AVPicture picture_tmp;
974 dec = ist->st->codec;
976 /* deinterlace : must be done before any resize */
977 if (do_deinterlace) {
980 /* create temporary picture */
981 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
982 buf = av_malloc(size);
986 picture2 = &picture_tmp;
987 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
989 if(avpicture_deinterlace(picture2, picture,
990 dec->pix_fmt, dec->width, dec->height) < 0) {
991 /* if error, do not deinterlace */
992 fprintf(stderr, "Deinterlacing failed\n");
1001 if (picture != picture2)
1002 *picture = *picture2;
1006 /* we begin to correct av delay at this threshold */
1007 #define AV_DELAY_MAX 0.100
1009 static void do_subtitle_out(AVFormatContext *s,
1010 AVOutputStream *ost,
1015 static uint8_t *subtitle_out = NULL;
1016 int subtitle_out_max_size = 1024 * 1024;
1017 int subtitle_out_size, nb, i;
1018 AVCodecContext *enc;
1021 if (pts == AV_NOPTS_VALUE) {
1022 fprintf(stderr, "Subtitle packets must have a pts\n");
1028 enc = ost->st->codec;
1030 if (!subtitle_out) {
1031 subtitle_out = av_malloc(subtitle_out_max_size);
1034 /* Note: DVB subtitle need one packet to draw them and one other
1035 packet to clear them */
1036 /* XXX: signal it in the codec context ? */
1037 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1042 for(i = 0; i < nb; i++) {
1043 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1044 // start_display_time is required to be 0
1045 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1046 sub->end_display_time -= sub->start_display_time;
1047 sub->start_display_time = 0;
1048 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1049 subtitle_out_max_size, sub);
1050 if (subtitle_out_size < 0) {
1051 fprintf(stderr, "Subtitle encoding failed\n");
1055 av_init_packet(&pkt);
1056 pkt.stream_index = ost->index;
1057 pkt.data = subtitle_out;
1058 pkt.size = subtitle_out_size;
1059 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1060 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1061 /* XXX: the pts correction is handled here. Maybe handling
1062 it in the codec would be better */
1064 pkt.pts += 90 * sub->start_display_time;
1066 pkt.pts += 90 * sub->end_display_time;
1068 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1072 static int bit_buffer_size= 1024*256;
1073 static uint8_t *bit_buffer= NULL;
1075 static void do_video_out(AVFormatContext *s,
1076 AVOutputStream *ost,
1078 AVFrame *in_picture,
1081 int nb_frames, i, ret, resample_changed;
1082 AVFrame *final_picture, *formatted_picture, *resampling_dst;
1083 AVCodecContext *enc, *dec;
1086 enc = ost->st->codec;
1087 dec = ist->st->codec;
1089 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1091 /* by default, we output a single frame */
1096 if(video_sync_method){
1097 double vdelta = sync_ipts - ost->sync_opts;
1098 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1101 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1104 }else if(vdelta>0.6)
1105 ost->sync_opts= lrintf(sync_ipts);
1106 }else if (vdelta > 1.1)
1107 nb_frames = lrintf(vdelta);
1108 //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);
1109 if (nb_frames == 0){
1112 fprintf(stderr, "*** drop!\n");
1113 }else if (nb_frames > 1) {
1114 nb_frames_dup += nb_frames - 1;
1116 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1119 ost->sync_opts= lrintf(sync_ipts);
1121 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1125 formatted_picture = in_picture;
1126 final_picture = formatted_picture;
1127 resampling_dst = &ost->pict_tmp;
1129 resample_changed = ost->resample_width != dec->width ||
1130 ost->resample_height != dec->height ||
1131 ost->resample_pix_fmt != dec->pix_fmt;
1133 if (resample_changed) {
1134 av_log(NULL, AV_LOG_INFO,
1135 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1136 ist->file_index, ist->index,
1137 ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1138 dec->width , dec->height , avcodec_get_pix_fmt_name(dec->pix_fmt));
1139 if(!ost->video_resample)
1143 #if !CONFIG_AVFILTER
1144 if (ost->video_resample) {
1145 final_picture = &ost->pict_tmp;
1146 if (resample_changed) {
1147 /* initialize a new scaler context */
1148 sws_freeContext(ost->img_resample_ctx);
1149 ost->img_resample_ctx = sws_getContext(
1150 ist->st->codec->width,
1151 ist->st->codec->height,
1152 ist->st->codec->pix_fmt,
1153 ost->st->codec->width,
1154 ost->st->codec->height,
1155 ost->st->codec->pix_fmt,
1156 ost->sws_flags, NULL, NULL, NULL);
1157 if (ost->img_resample_ctx == NULL) {
1158 fprintf(stderr, "Cannot get resampling context\n");
1162 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1163 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1167 /* duplicates frame if needed */
1168 for(i=0;i<nb_frames;i++) {
1170 av_init_packet(&pkt);
1171 pkt.stream_index= ost->index;
1173 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1174 /* raw pictures are written as AVPicture structure to
1175 avoid any copies. We support temorarily the older
1177 AVFrame* old_frame = enc->coded_frame;
1178 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1179 pkt.data= (uint8_t *)final_picture;
1180 pkt.size= sizeof(AVPicture);
1181 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1182 pkt.flags |= AV_PKT_FLAG_KEY;
1184 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1185 enc->coded_frame = old_frame;
1187 AVFrame big_picture;
1189 big_picture= *final_picture;
1190 /* better than nothing: use input picture interlaced
1192 big_picture.interlaced_frame = in_picture->interlaced_frame;
1193 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1194 if(top_field_first == -1)
1195 big_picture.top_field_first = in_picture->top_field_first;
1197 big_picture.top_field_first = top_field_first;
1200 /* handles sameq here. This is not correct because it may
1201 not be a global option */
1202 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1204 big_picture.pict_type = 0;
1205 // big_picture.pts = AV_NOPTS_VALUE;
1206 big_picture.pts= ost->sync_opts;
1207 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1208 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1209 if (ost->forced_kf_index < ost->forced_kf_count &&
1210 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1211 big_picture.pict_type = AV_PICTURE_TYPE_I;
1212 ost->forced_kf_index++;
1214 ret = avcodec_encode_video(enc,
1215 bit_buffer, bit_buffer_size,
1218 fprintf(stderr, "Video encoding failed\n");
1223 pkt.data= bit_buffer;
1225 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1226 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1227 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1228 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1229 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1231 if(enc->coded_frame->key_frame)
1232 pkt.flags |= AV_PKT_FLAG_KEY;
1233 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1236 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1237 // enc->frame_number-1, ret, enc->pict_type);
1238 /* if two pass, output log */
1239 if (ost->logfile && enc->stats_out) {
1240 fprintf(ost->logfile, "%s", enc->stats_out);
1245 ost->frame_number++;
1249 static double psnr(double d){
1250 return -10.0*log(d)/log(10.0);
1253 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1256 AVCodecContext *enc;
1258 double ti1, bitrate, avg_bitrate;
1260 /* this is executed just the first time do_video_stats is called */
1262 vstats_file = fopen(vstats_filename, "w");
1269 enc = ost->st->codec;
1270 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1271 frame_number = ost->frame_number;
1272 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1273 if (enc->flags&CODEC_FLAG_PSNR)
1274 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1276 fprintf(vstats_file,"f_size= %6d ", frame_size);
1277 /* compute pts value */
1278 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1282 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1283 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1284 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1285 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1286 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1290 static void print_report(AVFormatContext **output_files,
1291 AVOutputStream **ost_table, int nb_ostreams,
1295 AVOutputStream *ost;
1296 AVFormatContext *oc;
1298 AVCodecContext *enc;
1299 int frame_number, vid, i;
1300 double bitrate, ti1, pts;
1301 static int64_t last_time = -1;
1302 static int qp_histogram[52];
1304 if (!is_last_report) {
1306 /* display the report every 0.5 seconds */
1307 cur_time = av_gettime();
1308 if (last_time == -1) {
1309 last_time = cur_time;
1312 if ((cur_time - last_time) < 500000)
1314 last_time = cur_time;
1318 oc = output_files[0];
1320 total_size = avio_size(oc->pb);
1321 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1322 total_size= avio_tell(oc->pb);
1327 for(i=0;i<nb_ostreams;i++) {
1329 enc = ost->st->codec;
1330 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1331 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1332 !ost->st->stream_copy ?
1333 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1335 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1336 float t = (av_gettime()-timer_start) / 1000000.0;
1338 frame_number = ost->frame_number;
1339 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1340 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1341 !ost->st->stream_copy ?
1342 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1344 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1347 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1348 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1351 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1353 if (enc->flags&CODEC_FLAG_PSNR){
1355 double error, error_sum=0;
1356 double scale, scale_sum=0;
1357 char type[3]= {'Y','U','V'};
1358 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1361 error= enc->error[j];
1362 scale= enc->width*enc->height*255.0*255.0*frame_number;
1364 error= enc->coded_frame->error[j];
1365 scale= enc->width*enc->height*255.0*255.0;
1370 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1376 /* compute min output value */
1377 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1378 if ((pts < ti1) && (pts > 0))
1384 if (verbose > 0 || is_last_report) {
1385 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1388 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1389 (double)total_size / 1024, ti1, bitrate);
1391 if (nb_frames_dup || nb_frames_drop)
1392 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1393 nb_frames_dup, nb_frames_drop);
1396 fprintf(stderr, "%s \r", buf);
1401 if (is_last_report && verbose >= 0){
1402 int64_t raw= audio_size + video_size + extra_size;
1403 fprintf(stderr, "\n");
1404 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1408 100.0*(total_size - raw)/raw
1413 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1415 int fill_char = 0x00;
1416 if (sample_fmt == AV_SAMPLE_FMT_U8)
1418 memset(buf, fill_char, size);
1421 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1422 static int output_packet(AVInputStream *ist, int ist_index,
1423 AVOutputStream **ost_table, int nb_ostreams,
1424 const AVPacket *pkt)
1426 AVFormatContext *os;
1427 AVOutputStream *ost;
1431 void *buffer_to_free;
1432 static unsigned int samples_size= 0;
1433 AVSubtitle subtitle, *subtitle_to_free;
1434 int64_t pkt_pts = AV_NOPTS_VALUE;
1436 int frame_available;
1440 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1442 if(ist->next_pts == AV_NOPTS_VALUE)
1443 ist->next_pts= ist->pts;
1447 av_init_packet(&avpkt);
1455 if(pkt->dts != AV_NOPTS_VALUE)
1456 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1457 if(pkt->pts != AV_NOPTS_VALUE)
1458 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1460 //while we have more to decode or while the decoder did output something on EOF
1461 while (avpkt.size > 0 || (!pkt && got_output)) {
1462 uint8_t *data_buf, *decoded_data_buf;
1463 int data_size, decoded_data_size;
1465 ist->pts= ist->next_pts;
1467 if(avpkt.size && avpkt.size != pkt->size &&
1468 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1469 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1470 ist->showed_multi_packet_warning=1;
1473 /* decode the packet if needed */
1474 decoded_data_buf = NULL; /* fail safe */
1475 decoded_data_size= 0;
1476 data_buf = avpkt.data;
1477 data_size = avpkt.size;
1478 subtitle_to_free = NULL;
1479 if (ist->decoding_needed) {
1480 switch(ist->st->codec->codec_type) {
1481 case AVMEDIA_TYPE_AUDIO:{
1482 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1483 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1485 samples= av_malloc(samples_size);
1487 decoded_data_size= samples_size;
1488 /* XXX: could avoid copy if PCM 16 bits with same
1489 endianness as CPU */
1490 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1497 got_output = decoded_data_size > 0;
1498 /* Some bug in mpeg audio decoder gives */
1499 /* decoded_data_size < 0, it seems they are overflows */
1501 /* no audio frame */
1504 decoded_data_buf = (uint8_t *)samples;
1505 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1506 (ist->st->codec->sample_rate * ist->st->codec->channels);
1508 case AVMEDIA_TYPE_VIDEO:
1509 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1510 /* XXX: allocate picture correctly */
1511 avcodec_get_frame_defaults(&picture);
1512 avpkt.pts = pkt_pts;
1513 avpkt.dts = ist->pts;
1514 pkt_pts = AV_NOPTS_VALUE;
1516 ret = avcodec_decode_video2(ist->st->codec,
1517 &picture, &got_output, &avpkt);
1518 ist->st->quality= picture.quality;
1522 /* no picture yet */
1523 goto discard_packet;
1525 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1526 if (ist->st->codec->time_base.num != 0) {
1527 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1528 ist->next_pts += ((int64_t)AV_TIME_BASE *
1529 ist->st->codec->time_base.num * ticks) /
1530 ist->st->codec->time_base.den;
1534 case AVMEDIA_TYPE_SUBTITLE:
1535 ret = avcodec_decode_subtitle2(ist->st->codec,
1536 &subtitle, &got_output, &avpkt);
1540 goto discard_packet;
1542 subtitle_to_free = &subtitle;
1549 switch(ist->st->codec->codec_type) {
1550 case AVMEDIA_TYPE_AUDIO:
1551 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1552 ist->st->codec->sample_rate;
1554 case AVMEDIA_TYPE_VIDEO:
1555 if (ist->st->codec->time_base.num != 0) {
1556 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1557 ist->next_pts += ((int64_t)AV_TIME_BASE *
1558 ist->st->codec->time_base.num * ticks) /
1559 ist->st->codec->time_base.den;
1567 buffer_to_free = NULL;
1568 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1569 pre_process_video_frame(ist, (AVPicture *)&picture,
1574 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1576 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1577 else sar = ist->st->codec->sample_aspect_ratio;
1578 // add it to be filtered
1579 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1585 // preprocess audio (volume)
1586 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1587 if (audio_volume != 256) {
1590 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1591 int v = ((*volp) * audio_volume + 128) >> 8;
1592 if (v < -32768) v = -32768;
1593 if (v > 32767) v = 32767;
1599 /* frame rate emulation */
1601 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1602 int64_t now = av_gettime() - ist->start;
1607 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1608 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1610 /* if output time reached then transcode raw format,
1611 encode packets and output them */
1612 if (start_time == 0 || ist->pts >= start_time)
1614 while (frame_available) {
1615 AVRational ist_pts_tb;
1616 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1617 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1619 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1621 for(i=0;i<nb_ostreams;i++) {
1625 if (ost->source_index == ist_index) {
1626 os = output_files[ost->file_index];
1628 /* set the input output pts pairs */
1629 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1631 if (ost->encoding_needed) {
1632 av_assert0(ist->decoding_needed);
1633 switch(ost->st->codec->codec_type) {
1634 case AVMEDIA_TYPE_AUDIO:
1635 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1637 case AVMEDIA_TYPE_VIDEO:
1639 if (ist->picref->video)
1640 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1642 do_video_out(os, ost, ist, &picture, &frame_size);
1643 if (vstats_filename && frame_size)
1644 do_video_stats(os, ost, frame_size);
1646 case AVMEDIA_TYPE_SUBTITLE:
1647 do_subtitle_out(os, ost, ist, &subtitle,
1654 AVFrame avframe; //FIXME/XXX remove this
1656 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1658 av_init_packet(&opkt);
1660 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1663 /* no reencoding needed : output the packet directly */
1664 /* force the input stream PTS */
1666 avcodec_get_frame_defaults(&avframe);
1667 ost->st->codec->coded_frame= &avframe;
1668 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1670 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1671 audio_size += data_size;
1672 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1673 video_size += data_size;
1677 opkt.stream_index= ost->index;
1678 if(pkt->pts != AV_NOPTS_VALUE)
1679 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1681 opkt.pts= AV_NOPTS_VALUE;
1683 if (pkt->dts == AV_NOPTS_VALUE)
1684 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1686 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1687 opkt.dts -= ost_tb_start_time;
1689 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1690 opkt.flags= pkt->flags;
1692 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1693 if( ost->st->codec->codec_id != CODEC_ID_H264
1694 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1695 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1697 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1698 opkt.destruct= av_destruct_packet;
1700 opkt.data = data_buf;
1701 opkt.size = data_size;
1704 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1705 ost->st->codec->frame_number++;
1706 ost->frame_number++;
1707 av_free_packet(&opkt);
1713 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1714 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1716 avfilter_unref_buffer(ist->picref);
1719 av_free(buffer_to_free);
1720 /* XXX: allocate the subtitles in the codec ? */
1721 if (subtitle_to_free) {
1722 avsubtitle_free(subtitle_to_free);
1723 subtitle_to_free = NULL;
1730 for(i=0;i<nb_ostreams;i++) {
1732 if (ost->source_index == ist_index) {
1733 AVCodecContext *enc= ost->st->codec;
1734 os = output_files[ost->file_index];
1736 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1738 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1741 if (ost->encoding_needed) {
1745 av_init_packet(&pkt);
1746 pkt.stream_index= ost->index;
1748 switch(ost->st->codec->codec_type) {
1749 case AVMEDIA_TYPE_AUDIO:
1750 fifo_bytes = av_fifo_size(ost->fifo);
1752 /* encode any samples remaining in fifo */
1753 if (fifo_bytes > 0) {
1754 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1755 int fs_tmp = enc->frame_size;
1757 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1758 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1759 enc->frame_size = fifo_bytes / (osize * enc->channels);
1761 int frame_bytes = enc->frame_size*osize*enc->channels;
1762 if (allocated_audio_buf_size < frame_bytes)
1764 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1767 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1768 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1769 ost->st->time_base.num, enc->sample_rate);
1770 enc->frame_size = fs_tmp;
1773 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1776 fprintf(stderr, "Audio encoding failed\n");
1780 pkt.flags |= AV_PKT_FLAG_KEY;
1782 case AVMEDIA_TYPE_VIDEO:
1783 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1785 fprintf(stderr, "Video encoding failed\n");
1789 if(enc->coded_frame && enc->coded_frame->key_frame)
1790 pkt.flags |= AV_PKT_FLAG_KEY;
1791 if (ost->logfile && enc->stats_out) {
1792 fprintf(ost->logfile, "%s", enc->stats_out);
1801 pkt.data= bit_buffer;
1803 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1804 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1805 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1817 static void print_sdp(AVFormatContext **avc, int n)
1821 av_sdp_create(avc, n, sdp, sizeof(sdp));
1822 printf("SDP:\n%s\n", sdp);
1826 static int copy_chapters(int infile, int outfile)
1828 AVFormatContext *is = input_files[infile];
1829 AVFormatContext *os = output_files[outfile];
1832 for (i = 0; i < is->nb_chapters; i++) {
1833 AVChapter *in_ch = is->chapters[i], *out_ch;
1834 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1835 AV_TIME_BASE_Q, in_ch->time_base);
1836 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1837 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1840 if (in_ch->end < ts_off)
1842 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1845 out_ch = av_mallocz(sizeof(AVChapter));
1847 return AVERROR(ENOMEM);
1849 out_ch->id = in_ch->id;
1850 out_ch->time_base = in_ch->time_base;
1851 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1852 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1854 if (metadata_chapters_autocopy)
1855 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1858 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1860 return AVERROR(ENOMEM);
1861 os->chapters[os->nb_chapters - 1] = out_ch;
1866 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1867 AVCodecContext *avctx)
1873 for (p = kf; *p; p++)
1876 ost->forced_kf_count = n;
1877 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1878 if (!ost->forced_kf_pts) {
1879 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1882 for (i = 0; i < n; i++) {
1883 p = i ? strchr(p, ',') + 1 : kf;
1884 t = parse_time_or_die("force_key_frames", p, 1);
1885 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1890 * The following code is the main loop of the file converter
1892 static int transcode(AVFormatContext **output_files,
1893 int nb_output_files,
1894 AVFormatContext **input_files,
1896 AVStreamMap *stream_maps, int nb_stream_maps)
1898 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1899 AVFormatContext *is, *os;
1900 AVCodecContext *codec, *icodec;
1901 AVOutputStream *ost, **ost_table = NULL;
1902 AVInputStream *ist, **ist_table = NULL;
1903 AVInputFile *file_table;
1907 uint8_t no_packet[MAX_FILES]={0};
1908 int no_packet_count=0;
1910 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1914 /* input stream init */
1916 for(i=0;i<nb_input_files;i++) {
1917 is = input_files[i];
1918 file_table[i].ist_index = j;
1919 file_table[i].nb_streams = is->nb_streams;
1920 j += is->nb_streams;
1924 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1928 for(i=0;i<nb_istreams;i++) {
1929 ist = av_mallocz(sizeof(AVInputStream));
1935 for(i=0;i<nb_input_files;i++) {
1936 is = input_files[i];
1937 for(k=0;k<is->nb_streams;k++) {
1938 ist = ist_table[j++];
1939 ist->st = is->streams[k];
1940 ist->file_index = i;
1942 ist->discard = 1; /* the stream is discarded by default
1946 ist->start = av_gettime();
1951 /* output stream init */
1953 for(i=0;i<nb_output_files;i++) {
1954 os = output_files[i];
1955 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1956 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1957 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1958 ret = AVERROR(EINVAL);
1961 nb_ostreams += os->nb_streams;
1963 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1964 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1965 ret = AVERROR(EINVAL);
1969 /* Sanity check the mapping args -- do the input files & streams exist? */
1970 for(i=0;i<nb_stream_maps;i++) {
1971 int fi = stream_maps[i].file_index;
1972 int si = stream_maps[i].stream_index;
1974 if (fi < 0 || fi > nb_input_files - 1 ||
1975 si < 0 || si > file_table[fi].nb_streams - 1) {
1976 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1977 ret = AVERROR(EINVAL);
1980 fi = stream_maps[i].sync_file_index;
1981 si = stream_maps[i].sync_stream_index;
1982 if (fi < 0 || fi > nb_input_files - 1 ||
1983 si < 0 || si > file_table[fi].nb_streams - 1) {
1984 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1985 ret = AVERROR(EINVAL);
1990 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1994 for(k=0;k<nb_output_files;k++) {
1995 os = output_files[k];
1996 for(i=0;i<os->nb_streams;i++,n++) {
1998 ost = ost_table[n] = output_streams_for_file[k][i];
1999 ost->st = os->streams[i];
2000 if (nb_stream_maps > 0) {
2001 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2002 stream_maps[n].stream_index;
2004 /* Sanity check that the stream types match */
2005 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2006 int i= ost->file_index;
2007 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2008 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2009 stream_maps[n].file_index, stream_maps[n].stream_index,
2010 ost->file_index, ost->index);
2015 int best_nb_frames=-1;
2016 /* get corresponding input stream index : we select the first one with the right type */
2018 for(j=0;j<nb_istreams;j++) {
2023 AVFormatContext *f= input_files[ ist->file_index ];
2025 for(pi=0; pi<f->nb_programs; pi++){
2026 AVProgram *p= f->programs[pi];
2027 if(p->id == opt_programid)
2028 for(si=0; si<p->nb_stream_indexes; si++){
2029 if(f->streams[ p->stream_index[si] ] == ist->st)
2034 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2035 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2036 if(best_nb_frames < ist->st->codec_info_nb_frames){
2037 best_nb_frames= ist->st->codec_info_nb_frames;
2038 ost->source_index = j;
2045 if(! opt_programid) {
2046 /* try again and reuse existing stream */
2047 for(j=0;j<nb_istreams;j++) {
2049 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2050 && ist->st->discard != AVDISCARD_ALL) {
2051 ost->source_index = j;
2057 int i= ost->file_index;
2058 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2059 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2060 ost->file_index, ost->index);
2065 ist = ist_table[ost->source_index];
2067 ost->sync_ist = (nb_stream_maps > 0) ?
2068 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2069 stream_maps[n].sync_stream_index] : ist;
2073 /* for each output stream, we compute the right encoding parameters */
2074 for(i=0;i<nb_ostreams;i++) {
2076 os = output_files[ost->file_index];
2077 ist = ist_table[ost->source_index];
2079 codec = ost->st->codec;
2080 icodec = ist->st->codec;
2082 if (metadata_streams_autocopy)
2083 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2084 AV_METADATA_DONT_OVERWRITE);
2086 ost->st->disposition = ist->st->disposition;
2087 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2088 codec->chroma_sample_location = icodec->chroma_sample_location;
2090 if (ost->st->stream_copy) {
2091 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2093 if (extra_size > INT_MAX)
2096 /* if stream_copy is selected, no need to decode or encode */
2097 codec->codec_id = icodec->codec_id;
2098 codec->codec_type = icodec->codec_type;
2100 if(!codec->codec_tag){
2101 if( !os->oformat->codec_tag
2102 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2103 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2104 codec->codec_tag = icodec->codec_tag;
2107 codec->bit_rate = icodec->bit_rate;
2108 codec->rc_max_rate = icodec->rc_max_rate;
2109 codec->rc_buffer_size = icodec->rc_buffer_size;
2110 codec->extradata= av_mallocz(extra_size);
2111 if (!codec->extradata)
2113 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2114 codec->extradata_size= icodec->extradata_size;
2115 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){
2116 codec->time_base = icodec->time_base;
2117 codec->time_base.num *= icodec->ticks_per_frame;
2118 av_reduce(&codec->time_base.num, &codec->time_base.den,
2119 codec->time_base.num, codec->time_base.den, INT_MAX);
2121 codec->time_base = ist->st->time_base;
2122 switch(codec->codec_type) {
2123 case AVMEDIA_TYPE_AUDIO:
2124 if(audio_volume != 256) {
2125 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2128 codec->channel_layout = icodec->channel_layout;
2129 codec->sample_rate = icodec->sample_rate;
2130 codec->channels = icodec->channels;
2131 codec->frame_size = icodec->frame_size;
2132 codec->audio_service_type = icodec->audio_service_type;
2133 codec->block_align= icodec->block_align;
2134 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2135 codec->block_align= 0;
2136 if(codec->codec_id == CODEC_ID_AC3)
2137 codec->block_align= 0;
2139 case AVMEDIA_TYPE_VIDEO:
2140 codec->pix_fmt = icodec->pix_fmt;
2141 codec->width = icodec->width;
2142 codec->height = icodec->height;
2143 codec->has_b_frames = icodec->has_b_frames;
2145 case AVMEDIA_TYPE_SUBTITLE:
2146 codec->width = icodec->width;
2147 codec->height = icodec->height;
2149 case AVMEDIA_TYPE_DATA:
2155 switch(codec->codec_type) {
2156 case AVMEDIA_TYPE_AUDIO:
2157 ost->fifo= av_fifo_alloc(1024);
2160 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2161 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2162 icodec->request_channels = codec->channels;
2163 ist->decoding_needed = 1;
2164 ost->encoding_needed = 1;
2165 ost->resample_sample_fmt = icodec->sample_fmt;
2166 ost->resample_sample_rate = icodec->sample_rate;
2167 ost->resample_channels = icodec->channels;
2169 case AVMEDIA_TYPE_VIDEO:
2170 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2171 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2174 ost->video_resample = (codec->width != icodec->width ||
2175 codec->height != icodec->height ||
2176 (codec->pix_fmt != icodec->pix_fmt));
2177 if (ost->video_resample) {
2178 #if !CONFIG_AVFILTER
2179 avcodec_get_frame_defaults(&ost->pict_tmp);
2180 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2181 codec->width, codec->height)) {
2182 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2185 ost->img_resample_ctx = sws_getContext(
2192 ost->sws_flags, NULL, NULL, NULL);
2193 if (ost->img_resample_ctx == NULL) {
2194 fprintf(stderr, "Cannot get resampling context\n");
2198 codec->bits_per_raw_sample= 0;
2200 ost->resample_height = icodec->height;
2201 ost->resample_width = icodec->width;
2202 ost->resample_pix_fmt= icodec->pix_fmt;
2203 ost->encoding_needed = 1;
2204 ist->decoding_needed = 1;
2207 if (configure_video_filters(ist, ost)) {
2208 fprintf(stderr, "Error opening filters!\n");
2213 case AVMEDIA_TYPE_SUBTITLE:
2214 ost->encoding_needed = 1;
2215 ist->decoding_needed = 1;
2222 if (ost->encoding_needed &&
2223 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2224 char logfilename[1024];
2227 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2228 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2230 if (codec->flags & CODEC_FLAG_PASS1) {
2231 f = fopen(logfilename, "wb");
2233 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2239 size_t logbuffer_size;
2240 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2241 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2244 codec->stats_in = logbuffer;
2248 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2249 int size= codec->width * codec->height;
2250 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2255 bit_buffer = av_malloc(bit_buffer_size);
2257 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2259 ret = AVERROR(ENOMEM);
2263 /* open each encoder */
2264 for(i=0;i<nb_ostreams;i++) {
2266 if (ost->encoding_needed) {
2267 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2268 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2270 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2272 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2273 ost->st->codec->codec_id, ost->file_index, ost->index);
2274 ret = AVERROR(EINVAL);
2277 if (dec->subtitle_header) {
2278 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2279 if (!ost->st->codec->subtitle_header) {
2280 ret = AVERROR(ENOMEM);
2283 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2284 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2286 if (avcodec_open(ost->st->codec, codec) < 0) {
2287 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2288 ost->file_index, ost->index);
2289 ret = AVERROR(EINVAL);
2292 extra_size += ost->st->codec->extradata_size;
2296 /* open each decoder */
2297 for(i=0;i<nb_istreams;i++) {
2299 if (ist->decoding_needed) {
2300 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2302 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2304 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2305 ist->st->codec->codec_id, ist->file_index, ist->index);
2306 ret = AVERROR(EINVAL);
2309 if (avcodec_open(ist->st->codec, codec) < 0) {
2310 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2311 ist->file_index, ist->index);
2312 ret = AVERROR(EINVAL);
2315 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2316 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2321 for(i=0;i<nb_istreams;i++) {
2325 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2326 ist->next_pts = AV_NOPTS_VALUE;
2327 init_pts_correction(&ist->pts_ctx);
2331 /* set meta data information from input file if required */
2332 for (i=0;i<nb_meta_data_maps;i++) {
2333 AVFormatContext *files[2];
2334 AVMetadata **meta[2];
2337 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2338 if ((index) < 0 || (index) >= (nb_elems)) {\
2339 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2341 ret = AVERROR(EINVAL);\
2345 int out_file_index = meta_data_maps[i][0].file;
2346 int in_file_index = meta_data_maps[i][1].file;
2347 if (in_file_index < 0 || out_file_index < 0)
2349 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2350 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2352 files[0] = output_files[out_file_index];
2353 files[1] = input_files[in_file_index];
2355 for (j = 0; j < 2; j++) {
2356 AVMetaDataMap *map = &meta_data_maps[i][j];
2358 switch (map->type) {
2360 meta[j] = &files[j]->metadata;
2363 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2364 meta[j] = &files[j]->streams[map->index]->metadata;
2367 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2368 meta[j] = &files[j]->chapters[map->index]->metadata;
2371 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2372 meta[j] = &files[j]->programs[map->index]->metadata;
2377 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2380 /* copy global metadata by default */
2381 if (metadata_global_autocopy) {
2383 for (i = 0; i < nb_output_files; i++)
2384 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2385 AV_METADATA_DONT_OVERWRITE);
2388 /* copy chapters according to chapter maps */
2389 for (i = 0; i < nb_chapter_maps; i++) {
2390 int infile = chapter_maps[i].in_file;
2391 int outfile = chapter_maps[i].out_file;
2393 if (infile < 0 || outfile < 0)
2395 if (infile >= nb_input_files) {
2396 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2397 ret = AVERROR(EINVAL);
2400 if (outfile >= nb_output_files) {
2401 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2402 ret = AVERROR(EINVAL);
2405 copy_chapters(infile, outfile);
2408 /* copy chapters from the first input file that has them*/
2409 if (!nb_chapter_maps)
2410 for (i = 0; i < nb_input_files; i++) {
2411 if (!input_files[i]->nb_chapters)
2414 for (j = 0; j < nb_output_files; j++)
2415 if ((ret = copy_chapters(i, j)) < 0)
2420 /* open files and write file headers */
2421 for(i=0;i<nb_output_files;i++) {
2422 os = output_files[i];
2423 if (av_write_header(os) < 0) {
2424 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2425 ret = AVERROR(EINVAL);
2428 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2434 /* dump the file output parameters - cannot be done before in case
2436 for(i=0;i<nb_output_files;i++) {
2437 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2440 /* dump the stream mapping */
2442 fprintf(stderr, "Stream mapping:\n");
2443 for(i=0;i<nb_ostreams;i++) {
2445 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2446 ist_table[ost->source_index]->file_index,
2447 ist_table[ost->source_index]->index,
2450 if (ost->sync_ist != ist_table[ost->source_index])
2451 fprintf(stderr, " [sync #%d.%d]",
2452 ost->sync_ist->file_index,
2453 ost->sync_ist->index);
2454 fprintf(stderr, "\n");
2459 fprintf(stderr, "%s\n", error);
2464 print_sdp(output_files, nb_output_files);
2467 if (!using_stdin && verbose >= 0) {
2469 fprintf(stderr, "Press [q] to stop encoding\n");
2471 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2473 avio_set_interrupt_cb(decode_interrupt_cb);
2477 timer_start = av_gettime();
2479 for(; received_sigterm == 0;) {
2480 int file_index, ist_index;
2488 /* if 'q' pressed, exits */
2492 /* read_key() returns 0 on EOF */
2498 /* select the stream that we must read now by looking at the
2499 smallest output pts */
2501 for(i=0;i<nb_ostreams;i++) {
2504 os = output_files[ost->file_index];
2505 ist = ist_table[ost->source_index];
2506 if(ist->is_past_recording_time || no_packet[ist->file_index])
2508 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2509 ipts = (double)ist->pts;
2510 if (!file_table[ist->file_index].eof_reached){
2511 if(ipts < ipts_min) {
2513 if(input_sync ) file_index = ist->file_index;
2515 if(opts < opts_min) {
2517 if(!input_sync) file_index = ist->file_index;
2520 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2525 /* if none, if is finished */
2526 if (file_index < 0) {
2527 if(no_packet_count){
2529 memset(no_packet, 0, sizeof(no_packet));
2536 /* finish if limit size exhausted */
2537 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2540 /* read a frame from it and output it in the fifo */
2541 is = input_files[file_index];
2542 ret= av_read_frame(is, &pkt);
2543 if(ret == AVERROR(EAGAIN)){
2544 no_packet[file_index]=1;
2549 file_table[file_index].eof_reached = 1;
2557 memset(no_packet, 0, sizeof(no_packet));
2560 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2561 is->streams[pkt.stream_index]);
2563 /* the following test is needed in case new streams appear
2564 dynamically in stream : we ignore them */
2565 if (pkt.stream_index >= file_table[file_index].nb_streams)
2566 goto discard_packet;
2567 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2568 ist = ist_table[ist_index];
2570 goto discard_packet;
2572 if (pkt.dts != AV_NOPTS_VALUE)
2573 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2574 if (pkt.pts != AV_NOPTS_VALUE)
2575 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2577 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2578 && input_files_ts_scale[file_index][pkt.stream_index]){
2579 if(pkt.pts != AV_NOPTS_VALUE)
2580 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2581 if(pkt.dts != AV_NOPTS_VALUE)
2582 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2585 // 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);
2586 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2587 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2588 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2589 int64_t delta= pkt_dts - ist->next_pts;
2590 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2591 input_files_ts_offset[ist->file_index]-= delta;
2593 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2594 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2595 if(pkt.pts != AV_NOPTS_VALUE)
2596 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2600 /* finish if recording time exhausted */
2601 if (recording_time != INT64_MAX &&
2602 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2603 ist->is_past_recording_time = 1;
2604 goto discard_packet;
2607 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2608 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2611 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2612 ist->file_index, ist->index);
2615 av_free_packet(&pkt);
2620 av_free_packet(&pkt);
2622 /* dump report by using the output first video and audio streams */
2623 print_report(output_files, ost_table, nb_ostreams, 0);
2626 /* at the end of stream, we must flush the decoder buffers */
2627 for(i=0;i<nb_istreams;i++) {
2629 if (ist->decoding_needed) {
2630 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2636 /* write the trailer if needed and close file */
2637 for(i=0;i<nb_output_files;i++) {
2638 os = output_files[i];
2639 av_write_trailer(os);
2642 /* dump report by using the first video and audio streams */
2643 print_report(output_files, ost_table, nb_ostreams, 1);
2645 /* close each encoder */
2646 for(i=0;i<nb_ostreams;i++) {
2648 if (ost->encoding_needed) {
2649 av_freep(&ost->st->codec->stats_in);
2650 avcodec_close(ost->st->codec);
2654 /* close each decoder */
2655 for(i=0;i<nb_istreams;i++) {
2657 if (ist->decoding_needed) {
2658 avcodec_close(ist->st->codec);
2662 avfilter_graph_free(&graph);
2669 av_freep(&bit_buffer);
2670 av_free(file_table);
2673 for(i=0;i<nb_istreams;i++) {
2680 for(i=0;i<nb_ostreams;i++) {
2683 if (ost->st->stream_copy)
2684 av_freep(&ost->st->codec->extradata);
2686 fclose(ost->logfile);
2687 ost->logfile = NULL;
2689 av_fifo_free(ost->fifo); /* works even if fifo is not
2690 initialized but set to zero */
2691 av_freep(&ost->st->codec->subtitle_header);
2692 av_free(ost->pict_tmp.data[0]);
2693 av_free(ost->forced_kf_pts);
2694 if (ost->video_resample)
2695 sws_freeContext(ost->img_resample_ctx);
2697 audio_resample_close(ost->resample);
2698 if (ost->reformat_ctx)
2699 av_audio_convert_free(ost->reformat_ctx);
2708 static void opt_format(const char *arg)
2710 last_asked_format = arg;
2713 static void opt_video_rc_override_string(const char *arg)
2715 video_rc_override_string = arg;
2718 static int opt_me_threshold(const char *opt, const char *arg)
2720 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2724 static int opt_verbose(const char *opt, const char *arg)
2726 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2730 static int opt_frame_rate(const char *opt, const char *arg)
2732 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2733 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2739 static int opt_bitrate(const char *opt, const char *arg)
2741 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2743 opt_default(opt, arg);
2745 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2746 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2751 static int opt_frame_crop(const char *opt, const char *arg)
2753 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2754 return AVERROR(EINVAL);
2757 static void opt_frame_size(const char *arg)
2759 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2760 fprintf(stderr, "Incorrect frame size\n");
2765 static int opt_pad(const char *opt, const char *arg) {
2766 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2770 static void opt_frame_pix_fmt(const char *arg)
2772 if (strcmp(arg, "list")) {
2773 frame_pix_fmt = av_get_pix_fmt(arg);
2774 if (frame_pix_fmt == PIX_FMT_NONE) {
2775 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2784 static void opt_frame_aspect_ratio(const char *arg)
2791 p = strchr(arg, ':');
2793 x = strtol(arg, &end, 10);
2795 y = strtol(end+1, &end, 10);
2797 ar = (double)x / (double)y;
2799 ar = strtod(arg, NULL);
2802 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2805 frame_aspect_ratio = ar;
2808 x = vfilters ? strlen(vfilters) : 0;
2809 vfilters = av_realloc(vfilters, x+100);
2810 snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2814 static int opt_metadata(const char *opt, const char *arg)
2816 char *mid= strchr(arg, '=');
2819 fprintf(stderr, "Missing =\n");
2824 av_metadata_set2(&metadata, arg, mid, 0);
2829 static void opt_qscale(const char *arg)
2831 video_qscale = atof(arg);
2832 if (video_qscale <= 0 ||
2833 video_qscale > 255) {
2834 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2839 static void opt_top_field_first(const char *arg)
2841 top_field_first= atoi(arg);
2844 static int opt_thread_count(const char *opt, const char *arg)
2846 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2849 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2854 static void opt_audio_sample_fmt(const char *arg)
2856 if (strcmp(arg, "list")) {
2857 audio_sample_fmt = av_get_sample_fmt(arg);
2858 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2859 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2865 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2866 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2871 static int opt_audio_rate(const char *opt, const char *arg)
2873 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2877 static int opt_audio_channels(const char *opt, const char *arg)
2879 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2883 static void opt_video_channel(const char *arg)
2885 video_channel = strtol(arg, NULL, 0);
2888 static void opt_video_standard(const char *arg)
2890 video_standard = av_strdup(arg);
2893 static void opt_codec(int *pstream_copy, char **pcodec_name,
2894 int codec_type, const char *arg)
2896 av_freep(pcodec_name);
2897 if (!strcmp(arg, "copy")) {
2900 *pcodec_name = av_strdup(arg);
2904 static void opt_audio_codec(const char *arg)
2906 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2909 static void opt_video_codec(const char *arg)
2911 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2914 static void opt_subtitle_codec(const char *arg)
2916 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2919 static void opt_data_codec(const char *arg)
2921 opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2924 static int opt_codec_tag(const char *opt, const char *arg)
2927 uint32_t *codec_tag;
2929 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2930 !strcmp(opt, "vtag") ? &video_codec_tag :
2931 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2935 *codec_tag = strtol(arg, &tail, 0);
2937 *codec_tag = AV_RL32(arg);
2942 static void opt_map(const char *arg)
2947 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2948 m = &stream_maps[nb_stream_maps-1];
2950 m->file_index = strtol(arg, &p, 0);
2954 m->stream_index = strtol(p, &p, 0);
2957 m->sync_file_index = strtol(p, &p, 0);
2960 m->sync_stream_index = strtol(p, &p, 0);
2962 m->sync_file_index = m->file_index;
2963 m->sync_stream_index = m->stream_index;
2967 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2978 *index = strtol(++arg, endptr, 0);
2981 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2988 static void opt_map_metadata(const char *arg)
2990 AVMetaDataMap *m, *m1;
2993 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2994 &nb_meta_data_maps, nb_meta_data_maps + 1);
2996 m = &meta_data_maps[nb_meta_data_maps - 1][0];
2997 m->file = strtol(arg, &p, 0);
2998 parse_meta_type(p, &m->type, &m->index, &p);
3002 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3003 m1->file = strtol(p, &p, 0);
3004 parse_meta_type(p, &m1->type, &m1->index, &p);
3006 if (m->type == 'g' || m1->type == 'g')
3007 metadata_global_autocopy = 0;
3008 if (m->type == 's' || m1->type == 's')
3009 metadata_streams_autocopy = 0;
3010 if (m->type == 'c' || m1->type == 'c')
3011 metadata_chapters_autocopy = 0;
3014 static void opt_map_meta_data(const char *arg)
3016 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3017 "Use -map_metadata instead.\n");
3018 opt_map_metadata(arg);
3021 static void opt_map_chapters(const char *arg)
3026 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3027 nb_chapter_maps + 1);
3028 c = &chapter_maps[nb_chapter_maps - 1];
3029 c->out_file = strtol(arg, &p, 0);
3033 c->in_file = strtol(p, &p, 0);
3036 static void opt_input_ts_scale(const char *arg)
3038 unsigned int stream;
3042 stream = strtol(arg, &p, 0);
3045 scale= strtod(p, &p);
3047 if(stream >= MAX_STREAMS)
3050 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);
3051 input_files_ts_scale[nb_input_files][stream]= scale;
3054 static int opt_recording_time(const char *opt, const char *arg)
3056 recording_time = parse_time_or_die(opt, arg, 1);
3060 static int opt_start_time(const char *opt, const char *arg)
3062 start_time = parse_time_or_die(opt, arg, 1);
3066 static int opt_recording_timestamp(const char *opt, const char *arg)
3068 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3072 static int opt_input_ts_offset(const char *opt, const char *arg)
3074 input_ts_offset = parse_time_or_die(opt, arg, 1);
3078 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3080 const char *codec_string = encoder ? "encoder" : "decoder";
3084 return CODEC_ID_NONE;
3086 avcodec_find_encoder_by_name(name) :
3087 avcodec_find_decoder_by_name(name);
3089 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3092 if(codec->type != type) {
3093 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3096 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3097 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3098 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3099 "results.\nAdd '-strict experimental' if you want to use it.\n",
3100 codec_string, codec->name);
3102 avcodec_find_encoder(codec->id) :
3103 avcodec_find_decoder(codec->id);
3104 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3105 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3106 codec_string, codec->name);
3112 static void opt_input_file(const char *filename)
3114 AVFormatContext *ic;
3115 AVFormatParameters params, *ap = ¶ms;
3116 AVInputFormat *file_iformat = NULL;
3117 int err, i, ret, rfps, rfps_base;
3120 if (last_asked_format) {
3121 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3122 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3125 last_asked_format = NULL;
3128 if (!strcmp(filename, "-"))
3131 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3132 !strcmp(filename, "/dev/stdin");
3134 /* get default parameters from command line */
3135 ic = avformat_alloc_context();
3137 print_error(filename, AVERROR(ENOMEM));
3141 memset(ap, 0, sizeof(*ap));
3142 ap->prealloced_context = 1;
3143 ap->sample_rate = audio_sample_rate;
3144 ap->channels = audio_channels;
3145 ap->time_base.den = frame_rate.num;
3146 ap->time_base.num = frame_rate.den;
3147 ap->width = frame_width;
3148 ap->height = frame_height;
3149 ap->pix_fmt = frame_pix_fmt;
3150 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3151 ap->channel = video_channel;
3152 ap->standard = video_standard;
3154 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3156 ic->video_codec_id =
3157 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3158 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3159 ic->audio_codec_id =
3160 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3161 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3162 ic->subtitle_codec_id=
3163 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3164 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3165 ic->flags |= AVFMT_FLAG_NONBLOCK;
3167 /* open the input file with generic libav function */
3168 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3170 print_error(filename, err);
3176 for(i=0; i<ic->nb_streams; i++){
3177 ic->streams[i]->discard= AVDISCARD_ALL;
3179 for(i=0; i<ic->nb_programs; i++){
3180 AVProgram *p= ic->programs[i];
3181 if(p->id != opt_programid){
3182 p->discard = AVDISCARD_ALL;
3185 for(j=0; j<p->nb_stream_indexes; j++){
3186 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3191 fprintf(stderr, "Specified program id not found\n");
3197 ic->loop_input = loop_input;
3199 /* If not enough info to get the stream parameters, we decode the
3200 first frames to get it. (used in mpeg case for example) */
3201 ret = av_find_stream_info(ic);
3202 if (ret < 0 && verbose >= 0) {
3203 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3204 av_close_input_file(ic);
3208 timestamp = start_time;
3209 /* add the stream start time */
3210 if (ic->start_time != AV_NOPTS_VALUE)
3211 timestamp += ic->start_time;
3213 /* if seeking requested, we execute it */
3214 if (start_time != 0) {
3215 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3217 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3218 filename, (double)timestamp / AV_TIME_BASE);
3220 /* reset seek info */
3224 /* update the current parameters so that they match the one of the input stream */
3225 for(i=0;i<ic->nb_streams;i++) {
3226 AVStream *st = ic->streams[i];
3227 AVCodecContext *dec = st->codec;
3228 dec->thread_count = thread_count;
3229 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3230 switch (dec->codec_type) {
3231 case AVMEDIA_TYPE_AUDIO:
3232 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3233 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]);
3234 channel_layout = dec->channel_layout;
3235 audio_channels = dec->channels;
3236 audio_sample_rate = dec->sample_rate;
3237 audio_sample_fmt = dec->sample_fmt;
3239 st->discard= AVDISCARD_ALL;
3240 /* Note that av_find_stream_info can add more streams, and we
3241 * currently have no chance of setting up lowres decoding
3242 * early enough for them. */
3244 audio_sample_rate >>= dec->lowres;
3246 case AVMEDIA_TYPE_VIDEO:
3247 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3248 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]);
3249 frame_height = dec->height;
3250 frame_width = dec->width;
3251 if(ic->streams[i]->sample_aspect_ratio.num)
3252 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3254 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3255 frame_aspect_ratio *= (float) dec->width / dec->height;
3256 frame_pix_fmt = dec->pix_fmt;
3257 rfps = ic->streams[i]->r_frame_rate.num;
3258 rfps_base = ic->streams[i]->r_frame_rate.den;
3260 dec->flags |= CODEC_FLAG_EMU_EDGE;
3261 frame_height >>= dec->lowres;
3262 frame_width >>= dec->lowres;
3263 dec->height = frame_height;
3264 dec->width = frame_width;
3267 dec->debug |= FF_DEBUG_MV;
3269 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3272 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3273 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3275 (float)rfps / rfps_base, rfps, rfps_base);
3277 /* update the current frame rate to match the stream frame rate */
3278 frame_rate.num = rfps;
3279 frame_rate.den = rfps_base;
3282 st->discard= AVDISCARD_ALL;
3283 else if(video_discard)
3284 st->discard= video_discard;
3286 case AVMEDIA_TYPE_DATA:
3288 case AVMEDIA_TYPE_SUBTITLE:
3289 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3290 if(subtitle_disable)
3291 st->discard = AVDISCARD_ALL;
3293 case AVMEDIA_TYPE_ATTACHMENT:
3294 case AVMEDIA_TYPE_UNKNOWN:
3301 input_files[nb_input_files] = ic;
3302 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3303 /* dump the file content */
3305 av_dump_format(ic, nb_input_files, filename, 0);
3311 av_freep(&video_codec_name);
3312 av_freep(&audio_codec_name);
3313 av_freep(&subtitle_codec_name);
3318 static void check_inputs(int *has_video_ptr,
3320 int *has_subtitle_ptr,
3323 int has_video, has_audio, has_subtitle, has_data, i, j;
3324 AVFormatContext *ic;
3331 for(j=0;j<nb_input_files;j++) {
3332 ic = input_files[j];
3333 for(i=0;i<ic->nb_streams;i++) {
3334 AVCodecContext *enc = ic->streams[i]->codec;
3335 switch(enc->codec_type) {
3336 case AVMEDIA_TYPE_AUDIO:
3339 case AVMEDIA_TYPE_VIDEO:
3342 case AVMEDIA_TYPE_SUBTITLE:
3345 case AVMEDIA_TYPE_DATA:
3346 case AVMEDIA_TYPE_ATTACHMENT:
3347 case AVMEDIA_TYPE_UNKNOWN:
3355 *has_video_ptr = has_video;
3356 *has_audio_ptr = has_audio;
3357 *has_subtitle_ptr = has_subtitle;
3358 *has_data_ptr = has_data;
3361 static void new_video_stream(AVFormatContext *oc, int file_idx)
3364 AVOutputStream *ost;
3365 AVCodecContext *video_enc;
3366 enum CodecID codec_id = CODEC_ID_NONE;
3367 AVCodec *codec= NULL;
3369 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3371 fprintf(stderr, "Could not alloc stream\n");
3374 ost = new_output_stream(oc, file_idx);
3376 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3377 if(!video_stream_copy){
3378 if (video_codec_name) {
3379 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3380 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3381 codec = avcodec_find_encoder_by_name(video_codec_name);
3382 output_codecs[nb_output_codecs-1] = codec;
3384 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3385 codec = avcodec_find_encoder(codec_id);
3389 avcodec_get_context_defaults3(st->codec, codec);
3390 ost->bitstream_filters = video_bitstream_filters;
3391 video_bitstream_filters= NULL;
3393 st->codec->thread_count= thread_count;
3395 video_enc = st->codec;
3398 video_enc->codec_tag= video_codec_tag;
3400 if( (video_global_header&1)
3401 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3402 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3403 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3405 if(video_global_header&2){
3406 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3407 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3410 if (video_stream_copy) {
3411 st->stream_copy = 1;
3412 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3413 video_enc->sample_aspect_ratio =
3414 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3418 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3420 video_enc->codec_id = codec_id;
3421 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3423 if (codec && codec->supported_framerates && !force_fps)
3424 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3425 video_enc->time_base.den = fps.num;
3426 video_enc->time_base.num = fps.den;
3428 video_enc->width = frame_width;
3429 video_enc->height = frame_height;
3430 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3431 video_enc->pix_fmt = frame_pix_fmt;
3432 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3434 choose_pixel_fmt(st, codec);
3437 video_enc->gop_size = 0;
3438 if (video_qscale || same_quality) {
3439 video_enc->flags |= CODEC_FLAG_QSCALE;
3440 video_enc->global_quality=
3441 st->quality = FF_QP2LAMBDA * video_qscale;
3445 video_enc->intra_matrix = intra_matrix;
3447 video_enc->inter_matrix = inter_matrix;
3449 p= video_rc_override_string;
3452 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3454 fprintf(stderr, "error parsing rc_override\n");
3457 video_enc->rc_override=
3458 av_realloc(video_enc->rc_override,
3459 sizeof(RcOverride)*(i+1));
3460 video_enc->rc_override[i].start_frame= start;
3461 video_enc->rc_override[i].end_frame = end;
3463 video_enc->rc_override[i].qscale= q;
3464 video_enc->rc_override[i].quality_factor= 1.0;
3467 video_enc->rc_override[i].qscale= 0;
3468 video_enc->rc_override[i].quality_factor= -q/100.0;
3473 video_enc->rc_override_count=i;
3474 if (!video_enc->rc_initial_buffer_occupancy)
3475 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3476 video_enc->me_threshold= me_threshold;
3477 video_enc->intra_dc_precision= intra_dc_precision - 8;
3480 video_enc->flags|= CODEC_FLAG_PSNR;
3485 video_enc->flags |= CODEC_FLAG_PASS1;
3487 video_enc->flags |= CODEC_FLAG_PASS2;
3491 if (forced_key_frames)
3492 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3494 if (video_language) {
3495 av_metadata_set2(&st->metadata, "language", video_language, 0);
3496 av_freep(&video_language);
3499 /* reset some key parameters */
3501 av_freep(&video_codec_name);
3502 av_freep(&forced_key_frames);
3503 video_stream_copy = 0;
3504 frame_pix_fmt = PIX_FMT_NONE;
3507 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3510 AVOutputStream *ost;
3511 AVCodec *codec= NULL;
3512 AVCodecContext *audio_enc;
3513 enum CodecID codec_id = CODEC_ID_NONE;
3515 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3517 fprintf(stderr, "Could not alloc stream\n");
3520 ost = new_output_stream(oc, file_idx);
3522 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3523 if(!audio_stream_copy){
3524 if (audio_codec_name) {
3525 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3526 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3527 codec = avcodec_find_encoder_by_name(audio_codec_name);
3528 output_codecs[nb_output_codecs-1] = codec;
3530 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3531 codec = avcodec_find_encoder(codec_id);
3535 avcodec_get_context_defaults3(st->codec, codec);
3537 ost->bitstream_filters = audio_bitstream_filters;
3538 audio_bitstream_filters= NULL;
3540 st->codec->thread_count= thread_count;
3542 audio_enc = st->codec;
3543 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3546 audio_enc->codec_tag= audio_codec_tag;
3548 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3549 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3550 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3552 if (audio_stream_copy) {
3553 st->stream_copy = 1;
3554 audio_enc->channels = audio_channels;
3555 audio_enc->sample_rate = audio_sample_rate;
3557 audio_enc->codec_id = codec_id;
3558 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3560 if (audio_qscale > QSCALE_NONE) {
3561 audio_enc->flags |= CODEC_FLAG_QSCALE;
3562 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3564 audio_enc->channels = audio_channels;
3565 audio_enc->sample_fmt = audio_sample_fmt;
3566 audio_enc->sample_rate = audio_sample_rate;
3567 audio_enc->channel_layout = channel_layout;
3568 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3569 audio_enc->channel_layout = 0;
3570 choose_sample_fmt(st, codec);
3571 choose_sample_rate(st, codec);
3573 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3574 if (audio_language) {
3575 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3576 av_freep(&audio_language);
3579 /* reset some key parameters */
3581 av_freep(&audio_codec_name);
3582 audio_stream_copy = 0;
3585 static void new_data_stream(AVFormatContext *oc, int file_idx)
3588 AVOutputStream *ost;
3589 AVCodec *codec=NULL;
3590 AVCodecContext *data_enc;
3592 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3594 fprintf(stderr, "Could not alloc stream\n");
3597 ost = new_output_stream(oc, file_idx);
3598 data_enc = st->codec;
3599 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3600 if (!data_stream_copy) {
3601 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3604 avcodec_get_context_defaults3(st->codec, codec);
3606 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3609 data_enc->codec_tag= data_codec_tag;
3611 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3612 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3613 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3615 if (data_stream_copy) {
3616 st->stream_copy = 1;
3620 av_freep(&data_codec_name);
3621 data_stream_copy = 0;
3624 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3627 AVOutputStream *ost;
3628 AVCodec *codec=NULL;
3629 AVCodecContext *subtitle_enc;
3630 enum CodecID codec_id = CODEC_ID_NONE;
3632 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3634 fprintf(stderr, "Could not alloc stream\n");
3637 ost = new_output_stream(oc, file_idx);
3638 subtitle_enc = st->codec;
3639 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3640 if(!subtitle_stream_copy){
3641 if (subtitle_codec_name) {
3642 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3643 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3644 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3646 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3647 codec = avcodec_find_encoder(codec_id);
3650 avcodec_get_context_defaults3(st->codec, codec);
3652 ost->bitstream_filters = subtitle_bitstream_filters;
3653 subtitle_bitstream_filters= NULL;
3655 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3657 if(subtitle_codec_tag)
3658 subtitle_enc->codec_tag= subtitle_codec_tag;
3660 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3661 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3662 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3664 if (subtitle_stream_copy) {
3665 st->stream_copy = 1;
3667 subtitle_enc->codec_id = codec_id;
3668 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3671 if (subtitle_language) {
3672 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3673 av_freep(&subtitle_language);
3676 subtitle_disable = 0;
3677 av_freep(&subtitle_codec_name);
3678 subtitle_stream_copy = 0;
3681 static int opt_new_stream(const char *opt, const char *arg)
3683 AVFormatContext *oc;
3684 int file_idx = nb_output_files - 1;
3685 if (nb_output_files <= 0) {
3686 fprintf(stderr, "At least one output file must be specified\n");
3689 oc = output_files[file_idx];
3691 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3692 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3693 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3694 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3699 /* arg format is "output-stream-index:streamid-value". */
3700 static int opt_streamid(const char *opt, const char *arg)
3706 av_strlcpy(idx_str, arg, sizeof(idx_str));
3707 p = strchr(idx_str, ':');
3710 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3715 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3716 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3717 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3721 static void opt_output_file(const char *filename)
3723 AVFormatContext *oc;
3724 int err, use_video, use_audio, use_subtitle, use_data;
3725 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3726 AVFormatParameters params, *ap = ¶ms;
3727 AVOutputFormat *file_oformat;
3729 if (!strcmp(filename, "-"))
3732 oc = avformat_alloc_context();
3734 print_error(filename, AVERROR(ENOMEM));
3738 if (last_asked_format) {
3739 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3740 if (!file_oformat) {
3741 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3744 last_asked_format = NULL;
3746 file_oformat = av_guess_format(NULL, filename, NULL);
3747 if (!file_oformat) {
3748 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3754 oc->oformat = file_oformat;
3755 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3757 if (!strcmp(file_oformat->name, "ffm") &&
3758 av_strstart(filename, "http:", NULL)) {
3759 /* special case for files sent to ffserver: we get the stream
3760 parameters from ffserver */
3761 int err = read_ffserver_streams(oc, filename);
3763 print_error(filename, err);
3767 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3768 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3769 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3770 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 */
3772 /* disable if no corresponding type found and at least one
3774 if (nb_input_files > 0) {
3775 check_inputs(&input_has_video,
3777 &input_has_subtitle,
3780 if (!input_has_video)
3782 if (!input_has_audio)
3784 if (!input_has_subtitle)
3786 if (!input_has_data)
3790 /* manual disable */
3791 if (audio_disable) use_audio = 0;
3792 if (video_disable) use_video = 0;
3793 if (subtitle_disable) use_subtitle = 0;
3794 if (data_disable) use_data = 0;
3796 if (use_video) new_video_stream(oc, nb_output_files);
3797 if (use_audio) new_audio_stream(oc, nb_output_files);
3798 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3799 if (use_data) new_data_stream(oc, nb_output_files);
3801 oc->timestamp = recording_timestamp;
3803 av_metadata_copy(&oc->metadata, metadata, 0);
3804 av_metadata_free(&metadata);
3807 output_files[nb_output_files++] = oc;
3809 /* check filename in case of an image number is expected */
3810 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3811 if (!av_filename_number_test(oc->filename)) {
3812 print_error(oc->filename, AVERROR(EINVAL));
3817 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3818 /* test if it already exists to avoid loosing precious files */
3819 if (!file_overwrite &&
3820 (strchr(filename, ':') == NULL ||
3821 filename[1] == ':' ||
3822 av_strstart(filename, "file:", NULL))) {
3823 if (avio_check(filename, 0) == 0) {
3825 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3827 if (!read_yesno()) {
3828 fprintf(stderr, "Not overwriting - exiting\n");
3833 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3840 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3841 print_error(filename, err);
3846 memset(ap, 0, sizeof(*ap));
3847 if (av_set_parameters(oc, ap) < 0) {
3848 fprintf(stderr, "%s: Invalid encoding parameters\n",
3853 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3854 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3855 oc->loop_output = loop_output;
3856 oc->flags |= AVFMT_FLAG_NONBLOCK;
3858 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3860 av_freep(&forced_key_frames);
3865 /* same option as mencoder */
3866 static void opt_pass(const char *pass_str)
3869 pass = atoi(pass_str);
3870 if (pass != 1 && pass != 2) {
3871 fprintf(stderr, "pass number can be only 1 or 2\n");
3877 static int64_t getutime(void)
3880 struct rusage rusage;
3882 getrusage(RUSAGE_SELF, &rusage);
3883 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3884 #elif HAVE_GETPROCESSTIMES
3886 FILETIME c, e, k, u;
3887 proc = GetCurrentProcess();
3888 GetProcessTimes(proc, &c, &e, &k, &u);
3889 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3891 return av_gettime();
3895 static int64_t getmaxrss(void)
3897 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3898 struct rusage rusage;
3899 getrusage(RUSAGE_SELF, &rusage);
3900 return (int64_t)rusage.ru_maxrss * 1024;
3901 #elif HAVE_GETPROCESSMEMORYINFO
3903 PROCESS_MEMORY_COUNTERS memcounters;
3904 proc = GetCurrentProcess();
3905 memcounters.cb = sizeof(memcounters);
3906 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3907 return memcounters.PeakPagefileUsage;
3913 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3916 const char *p = str;
3923 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3930 static void opt_inter_matrix(const char *arg)
3932 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3933 parse_matrix_coeffs(inter_matrix, arg);
3936 static void opt_intra_matrix(const char *arg)
3938 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3939 parse_matrix_coeffs(intra_matrix, arg);
3942 static void show_usage(void)
3944 printf("Hyper fast Audio and Video encoder\n");
3945 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3949 static void show_help(void)
3952 AVOutputFormat *oformat = NULL;
3954 av_log_set_callback(log_callback_help);
3956 show_help_options(options, "Main options:\n",
3957 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3958 show_help_options(options, "\nAdvanced options:\n",
3959 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3961 show_help_options(options, "\nVideo options:\n",
3962 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3964 show_help_options(options, "\nAdvanced Video options:\n",
3965 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3966 OPT_VIDEO | OPT_EXPERT);
3967 show_help_options(options, "\nAudio options:\n",
3968 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3970 show_help_options(options, "\nAdvanced Audio options:\n",
3971 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3972 OPT_AUDIO | OPT_EXPERT);
3973 show_help_options(options, "\nSubtitle options:\n",
3974 OPT_SUBTITLE | OPT_GRAB,
3976 show_help_options(options, "\nAudio/Video grab options:\n",
3980 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3983 /* individual codec options */
3985 while ((c = av_codec_next(c))) {
3986 if (c->priv_class) {
3987 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3992 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3995 /* individual muxer options */
3996 while ((oformat = av_oformat_next(oformat))) {
3997 if (oformat->priv_class) {
3998 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4003 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4006 static void opt_target(const char *arg)
4008 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4009 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4011 if(!strncmp(arg, "pal-", 4)) {
4014 } else if(!strncmp(arg, "ntsc-", 5)) {
4017 } else if(!strncmp(arg, "film-", 5)) {
4022 /* Calculate FR via float to avoid int overflow */
4023 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4026 } else if((fr == 29970) || (fr == 23976)) {
4029 /* Try to determine PAL/NTSC by peeking in the input files */
4030 if(nb_input_files) {
4032 for(j = 0; j < nb_input_files; j++) {
4033 for(i = 0; i < input_files[j]->nb_streams; i++) {
4034 AVCodecContext *c = input_files[j]->streams[i]->codec;
4035 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4037 fr = c->time_base.den * 1000 / c->time_base.num;
4041 } else if((fr == 29970) || (fr == 23976)) {
4051 if(verbose > 0 && norm != UNKNOWN)
4052 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4055 if(norm == UNKNOWN) {
4056 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4057 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4058 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4062 if(!strcmp(arg, "vcd")) {
4064 opt_video_codec("mpeg1video");
4065 opt_audio_codec("mp2");
4068 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4069 opt_frame_rate(NULL, frame_rates[norm]);
4070 opt_default("g", norm == PAL ? "15" : "18");
4072 opt_default("b", "1150000");
4073 opt_default("maxrate", "1150000");
4074 opt_default("minrate", "1150000");
4075 opt_default("bufsize", "327680"); // 40*1024*8;
4077 opt_default("ab", "224000");
4078 audio_sample_rate = 44100;
4081 opt_default("packetsize", "2324");
4082 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4084 /* We have to offset the PTS, so that it is consistent with the SCR.
4085 SCR starts at 36000, but the first two packs contain only padding
4086 and the first pack from the other stream, respectively, may also have
4087 been written before.
4088 So the real data starts at SCR 36000+3*1200. */
4089 mux_preload= (36000+3*1200) / 90000.0; //0.44
4090 } else if(!strcmp(arg, "svcd")) {
4092 opt_video_codec("mpeg2video");
4093 opt_audio_codec("mp2");
4096 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4097 opt_frame_rate(NULL, frame_rates[norm]);
4098 opt_default("g", norm == PAL ? "15" : "18");
4100 opt_default("b", "2040000");
4101 opt_default("maxrate", "2516000");
4102 opt_default("minrate", "0"); //1145000;
4103 opt_default("bufsize", "1835008"); //224*1024*8;
4104 opt_default("flags", "+scan_offset");
4107 opt_default("ab", "224000");
4108 audio_sample_rate = 44100;
4110 opt_default("packetsize", "2324");
4112 } else if(!strcmp(arg, "dvd")) {
4114 opt_video_codec("mpeg2video");
4115 opt_audio_codec("ac3");
4118 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4119 opt_frame_rate(NULL, frame_rates[norm]);
4120 opt_default("g", norm == PAL ? "15" : "18");
4122 opt_default("b", "6000000");
4123 opt_default("maxrate", "9000000");
4124 opt_default("minrate", "0"); //1500000;
4125 opt_default("bufsize", "1835008"); //224*1024*8;
4127 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4128 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4130 opt_default("ab", "448000");
4131 audio_sample_rate = 48000;
4133 } else if(!strncmp(arg, "dv", 2)) {
4137 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4138 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4139 (norm == PAL ? "yuv420p" : "yuv411p"));
4140 opt_frame_rate(NULL, frame_rates[norm]);
4142 audio_sample_rate = 48000;
4146 fprintf(stderr, "Unknown target: %s\n", arg);
4151 static void opt_vstats_file (const char *arg)
4153 av_free (vstats_filename);
4154 vstats_filename=av_strdup (arg);
4157 static void opt_vstats (void)
4160 time_t today2 = time(NULL);
4161 struct tm *today = localtime(&today2);
4163 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4165 opt_vstats_file(filename);
4168 static int opt_bsf(const char *opt, const char *arg)
4170 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4171 AVBitStreamFilterContext **bsfp;
4174 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4178 bsfp= *opt == 'v' ? &video_bitstream_filters :
4179 *opt == 'a' ? &audio_bitstream_filters :
4180 &subtitle_bitstream_filters;
4182 bsfp= &(*bsfp)->next;
4189 static int opt_preset(const char *opt, const char *arg)
4192 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4193 char *codec_name = *opt == 'v' ? video_codec_name :
4194 *opt == 'a' ? audio_codec_name :
4195 subtitle_codec_name;
4197 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4198 fprintf(stderr, "File for preset '%s' not found\n", arg);
4203 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4204 if(line[0] == '#' && !e)
4206 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4208 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4211 if(!strcmp(tmp, "acodec")){
4212 opt_audio_codec(tmp2);
4213 }else if(!strcmp(tmp, "vcodec")){
4214 opt_video_codec(tmp2);
4215 }else if(!strcmp(tmp, "scodec")){
4216 opt_subtitle_codec(tmp2);
4217 }else if(!strcmp(tmp, "dcodec")){
4218 opt_data_codec(tmp2);
4219 }else if(opt_default(tmp, tmp2) < 0){
4220 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4230 static const OptionDef options[] = {
4232 #include "cmdutils_common_opts.h"
4233 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4234 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4235 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4236 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4237 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4238 "outfile[,metadata]:infile[,metadata]" },
4239 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4240 "outfile[,metadata]:infile[,metadata]" },
4241 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4242 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4243 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4244 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4245 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4246 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4247 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4248 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4249 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4250 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4251 "add timings for benchmarking" },
4252 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4253 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4254 "dump each input packet" },
4255 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4256 "when dumping packets, also dump the payload" },
4257 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4258 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4259 { "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)", "" },
4260 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4261 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4262 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4263 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4264 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4265 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4266 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4267 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4268 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4269 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4270 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4271 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4272 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4273 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4276 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4277 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4278 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4279 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4280 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4281 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4282 { "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" },
4283 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4284 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4285 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4286 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4287 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4288 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4289 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4290 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4291 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4292 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4293 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4294 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4295 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4296 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4297 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4298 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4299 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4300 "use same quantizer as source (implies VBR)" },
4301 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4302 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4303 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4304 "deinterlace pictures" },
4305 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4306 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4307 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4309 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4311 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4312 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4313 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4314 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4315 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4316 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4317 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4318 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4319 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4320 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4321 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4324 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4325 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4326 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4327 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4328 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4329 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4330 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4331 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4332 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4333 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4334 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4335 { "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" },
4337 /* subtitle options */
4338 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4339 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4340 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4341 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4342 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4345 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4346 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4347 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4350 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4351 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4353 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4354 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4355 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4357 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4358 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4359 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4360 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4361 /* data codec support */
4362 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4364 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4368 int main(int argc, char **argv)
4372 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4374 avcodec_register_all();
4376 avdevice_register_all();
4379 avfilter_register_all();
4384 if(isatty(STDIN_FILENO))
4385 avio_set_interrupt_cb(decode_interrupt_cb);
4393 parse_options(argc, argv, options, opt_output_file);
4395 if(nb_output_files <= 0 && nb_input_files == 0) {
4397 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4401 /* file converter / grab */
4402 if (nb_output_files <= 0) {
4403 fprintf(stderr, "At least one output file must be specified\n");
4407 if (nb_input_files == 0) {
4408 fprintf(stderr, "At least one input file must be specified\n");
4413 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4414 stream_maps, nb_stream_maps) < 0)
4416 ti = getutime() - ti;
4418 int maxrss = getmaxrss() / 1024;
4419 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4422 return ffmpeg_exit(0);