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 "libavcodec/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 #if !FF_API_MAX_STREAMS
110 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
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 float mux_preload= 0.5;
190 static float mux_max_delay= 0.7;
192 static int64_t recording_time = INT64_MAX;
193 static int64_t start_time = 0;
194 static int64_t recording_timestamp = 0;
195 static int64_t input_ts_offset = 0;
196 static int file_overwrite = 0;
197 static AVMetadata *metadata;
198 static int do_benchmark = 0;
199 static int do_hex_dump = 0;
200 static int do_pkt_dump = 0;
201 static int do_psnr = 0;
202 static int do_pass = 0;
203 static char *pass_logfilename_prefix = NULL;
204 static int audio_stream_copy = 0;
205 static int video_stream_copy = 0;
206 static int subtitle_stream_copy = 0;
207 static int video_sync_method= -1;
208 static int audio_sync_method= 0;
209 static float audio_drift_threshold= 0.1;
210 static int copy_ts= 0;
212 static int opt_shortest = 0;
213 static int video_global_header = 0;
214 static char *vstats_filename;
215 static FILE *vstats_file;
216 static int opt_programid = 0;
217 static int copy_initial_nonkeyframes = 0;
219 static int rate_emu = 0;
221 static int video_channel = 0;
222 static char *video_standard;
224 static int audio_volume = 256;
226 static int exit_on_error = 0;
227 static int using_stdin = 0;
228 static int verbose = 1;
229 static int thread_count= 1;
230 static int q_pressed = 0;
231 static int64_t video_size = 0;
232 static int64_t audio_size = 0;
233 static int64_t extra_size = 0;
234 static int nb_frames_dup = 0;
235 static int nb_frames_drop = 0;
236 static int input_sync;
237 static uint64_t limit_filesize = 0;
238 static int force_fps = 0;
239 static char *forced_key_frames = NULL;
241 static float dts_delta_threshold = 10;
243 static unsigned int sws_flags = SWS_BICUBIC;
245 static int64_t timer_start;
247 static uint8_t *audio_buf;
248 static uint8_t *audio_out;
249 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
251 static short *samples;
253 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
254 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
255 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
257 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
259 struct AVInputStream;
261 typedef struct AVOutputStream {
262 int file_index; /* file index */
263 int index; /* stream index in the output file */
264 int source_index; /* AVInputStream index */
265 AVStream *st; /* stream in the output file */
266 int encoding_needed; /* true if encoding needed for this stream */
268 /* input pts and corresponding output pts
270 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
271 struct AVInputStream *sync_ist; /* input stream to sync against */
272 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
273 AVBitStreamFilterContext *bitstream_filters;
276 AVFrame pict_tmp; /* temporary image for resampling */
277 struct SwsContext *img_resample_ctx; /* for image resampling */
280 int resample_pix_fmt;
282 /* full frame size of first frame */
286 /* forced key frames */
287 int64_t *forced_kf_pts;
293 ReSampleContext *resample; /* for audio resampling */
294 int resample_sample_fmt;
295 int resample_channels;
296 int resample_sample_rate;
298 AVAudioConvert *reformat_ctx;
299 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
303 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
304 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
306 typedef struct AVInputStream {
310 int discard; /* true if stream data should be discarded */
311 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
312 int64_t sample_index; /* current sample */
314 int64_t start; /* time when read started */
315 int64_t next_pts; /* synthetic pts for cases where pkt.pts
317 int64_t pts; /* current pts */
318 PtsCorrectionContext pts_ctx;
319 int is_start; /* is 1 at the start and after a discontinuity */
320 int showed_multi_packet_warning;
321 int is_past_recording_time;
323 AVFilterContext *output_video_filter;
324 AVFilterContext *input_video_filter;
325 AVFrame *filter_frame;
326 int has_filter_frame;
327 AVFilterBufferRef *picref;
331 typedef struct AVInputFile {
332 int eof_reached; /* true if eof reached */
333 int ist_index; /* index of first stream in ist_table */
334 int buffer_size; /* current total buffer size */
335 int nb_streams; /* nb streams we are aware of */
340 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
342 AVFilterContext *last_filter, *filter;
343 /** filter graph containing all filters including input & output */
344 AVCodecContext *codec = ost->st->codec;
345 AVCodecContext *icodec = ist->st->codec;
346 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
350 graph = avfilter_graph_alloc();
352 snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
353 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
354 ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
355 "src", args, NULL, graph);
358 ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
359 "out", NULL, &ffsink_ctx, graph);
362 last_filter = ist->input_video_filter;
364 if (codec->width != icodec->width || codec->height != icodec->height) {
365 snprintf(args, 255, "%d:%d:flags=0x%X",
368 (int)av_get_int(sws_opts, "sws_flags", NULL));
369 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
370 NULL, args, NULL, graph)) < 0)
372 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
374 last_filter = filter;
377 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
378 graph->scale_sws_opts = av_strdup(args);
381 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
382 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
384 outputs->name = av_strdup("in");
385 outputs->filter_ctx = last_filter;
386 outputs->pad_idx = 0;
387 outputs->next = NULL;
389 inputs->name = av_strdup("out");
390 inputs->filter_ctx = ist->output_video_filter;
394 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
398 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
402 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
405 codec->width = ist->output_video_filter->inputs[0]->w;
406 codec->height = ist->output_video_filter->inputs[0]->h;
410 #endif /* CONFIG_AVFILTER */
412 static void term_exit(void)
414 av_log(NULL, AV_LOG_QUIET, "");
417 static volatile int received_sigterm = 0;
420 sigterm_handler(int sig)
422 received_sigterm = sig;
426 static void term_init(void)
428 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
429 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
431 signal(SIGXCPU, sigterm_handler);
435 /* read a key without blocking */
436 static int read_key(void)
445 static int decode_interrupt_cb(void)
447 return q_pressed || (q_pressed = read_key() == 'q');
450 static int ffmpeg_exit(int ret)
455 for(i=0;i<nb_output_files;i++) {
456 AVFormatContext *s = output_files[i];
457 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
459 avformat_free_context(s);
460 av_free(output_streams_for_file[i]);
462 for(i=0;i<nb_input_files;i++) {
463 av_close_input_file(input_files[i]);
464 av_free(input_files_ts_scale[i]);
467 av_free(intra_matrix);
468 av_free(inter_matrix);
472 av_free(vstats_filename);
474 av_free(streamid_map);
475 av_free(input_codecs);
476 av_free(output_codecs);
477 av_free(stream_maps);
478 av_free(meta_data_maps);
480 av_free(video_codec_name);
481 av_free(audio_codec_name);
482 av_free(subtitle_codec_name);
484 av_free(video_standard);
489 allocated_audio_buf_size= allocated_audio_out_size= 0;
496 if (received_sigterm) {
498 "Received signal %d: terminating.\n",
499 (int) received_sigterm);
503 exit(ret); /* not all OS-es handle main() return value */
507 /* similar to ff_dynarray_add() and av_fast_realloc() */
508 static void *grow_array(void *array, int elem_size, int *size, int new_size)
510 if (new_size >= INT_MAX / elem_size) {
511 fprintf(stderr, "Array too big.\n");
514 if (*size < new_size) {
515 uint8_t *tmp = av_realloc(array, new_size*elem_size);
517 fprintf(stderr, "Could not alloc buffer.\n");
520 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
527 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
529 if(codec && codec->sample_fmts){
530 const enum AVSampleFormat *p= codec->sample_fmts;
532 if(*p == st->codec->sample_fmt)
536 av_log(NULL, AV_LOG_WARNING,
537 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
538 av_get_sample_fmt_name(st->codec->sample_fmt),
540 av_get_sample_fmt_name(codec->sample_fmts[0]));
541 st->codec->sample_fmt = codec->sample_fmts[0];
546 static void choose_sample_rate(AVStream *st, AVCodec *codec)
548 if(codec && codec->supported_samplerates){
549 const int *p= codec->supported_samplerates;
551 int best_dist=INT_MAX;
553 int dist= abs(st->codec->sample_rate - *p);
554 if(dist < best_dist){
560 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
562 st->codec->sample_rate= best;
566 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
568 if(codec && codec->pix_fmts){
569 const enum PixelFormat *p= codec->pix_fmts;
570 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
571 if(st->codec->codec_id==CODEC_ID_MJPEG){
572 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
573 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
574 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};
578 if(*p == st->codec->pix_fmt)
582 st->codec->pix_fmt = codec->pix_fmts[0];
586 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
588 int idx = oc->nb_streams - 1;
591 output_streams_for_file[file_idx] =
592 grow_array(output_streams_for_file[file_idx],
593 sizeof(*output_streams_for_file[file_idx]),
594 &nb_output_streams_for_file[file_idx],
596 ost = output_streams_for_file[file_idx][idx] =
597 av_mallocz(sizeof(AVOutputStream));
599 fprintf(stderr, "Could not alloc output stream\n");
602 ost->file_index = file_idx;
607 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
613 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
616 /* copy stream format */
618 for(i=0;i<ic->nb_streams;i++) {
624 // FIXME: a more elegant solution is needed
625 st = av_mallocz(sizeof(AVStream));
626 memcpy(st, ic->streams[i], sizeof(AVStream));
627 st->codec = avcodec_alloc_context();
629 print_error(filename, AVERROR(ENOMEM));
632 avcodec_copy_context(st->codec, ic->streams[i]->codec);
635 codec = avcodec_find_encoder(st->codec->codec_id);
636 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
637 if (audio_stream_copy) {
640 choose_sample_fmt(st, codec);
641 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
642 if (video_stream_copy) {
645 choose_pixel_fmt(st, codec);
648 if(st->codec->flags & CODEC_FLAG_BITEXACT)
651 new_output_stream(s, nb_output_files);
655 s->timestamp = av_gettime();
657 av_close_input_file(ic);
662 get_sync_ipts(const AVOutputStream *ost)
664 const AVInputStream *ist = ost->sync_ist;
665 return (double)(ist->pts - start_time)/AV_TIME_BASE;
668 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
672 AVPacket new_pkt= *pkt;
673 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
674 &new_pkt.data, &new_pkt.size,
675 pkt->data, pkt->size,
676 pkt->flags & AV_PKT_FLAG_KEY);
679 new_pkt.destruct= av_destruct_packet;
681 fprintf(stderr, "%s failed for stream %d, codec %s",
682 bsfc->filter->name, pkt->stream_index,
683 avctx->codec ? avctx->codec->name : "copy");
693 ret= av_interleaved_write_frame(s, pkt);
695 print_error("av_interleaved_write_frame()", ret);
700 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
702 static void do_audio_out(AVFormatContext *s,
705 unsigned char *buf, int size)
708 int64_t audio_out_size, audio_buf_size;
709 int64_t allocated_for_size= size;
711 int size_out, frame_bytes, ret, resample_changed;
712 AVCodecContext *enc= ost->st->codec;
713 AVCodecContext *dec= ist->st->codec;
714 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
715 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
716 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
719 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
720 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
721 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
722 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
723 audio_buf_size*= osize*enc->channels;
725 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
726 if(coded_bps > 8*osize)
727 audio_out_size= audio_out_size * coded_bps / (8*osize);
728 audio_out_size += FF_MIN_BUFFER_SIZE;
730 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
731 fprintf(stderr, "Buffer sizes too large\n");
735 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
736 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
737 if (!audio_buf || !audio_out){
738 fprintf(stderr, "Out of memory in do_audio_out\n");
742 if (enc->channels != dec->channels)
743 ost->audio_resample = 1;
745 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
746 ost->resample_channels != dec->channels ||
747 ost->resample_sample_rate != dec->sample_rate;
749 if ((ost->audio_resample && !ost->resample) || resample_changed) {
750 if (resample_changed) {
751 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",
752 ist->file_index, ist->index,
753 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
754 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
755 ost->resample_sample_fmt = dec->sample_fmt;
756 ost->resample_channels = dec->channels;
757 ost->resample_sample_rate = dec->sample_rate;
759 audio_resample_close(ost->resample);
761 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
762 if (audio_sync_method <= 1 &&
763 ost->resample_sample_fmt == enc->sample_fmt &&
764 ost->resample_channels == enc->channels &&
765 ost->resample_sample_rate == enc->sample_rate) {
766 ost->resample = NULL;
767 ost->audio_resample = 0;
769 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
770 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
771 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
772 enc->sample_rate, dec->sample_rate,
773 enc->sample_fmt, dec->sample_fmt,
775 if (!ost->resample) {
776 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
777 dec->channels, dec->sample_rate,
778 enc->channels, enc->sample_rate);
784 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
785 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
786 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
787 if (ost->reformat_ctx)
788 av_audio_convert_free(ost->reformat_ctx);
789 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
790 dec->sample_fmt, 1, NULL, 0);
791 if (!ost->reformat_ctx) {
792 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
793 av_get_sample_fmt_name(dec->sample_fmt),
794 av_get_sample_fmt_name(enc->sample_fmt));
797 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
800 if(audio_sync_method){
801 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
802 - av_fifo_size(ost->fifo)/(enc->channels * 2);
803 double idelta= delta*dec->sample_rate / enc->sample_rate;
804 int byte_delta= ((int)idelta)*2*dec->channels;
806 //FIXME resample delay
807 if(fabs(delta) > 50){
808 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
810 byte_delta= FFMAX(byte_delta, -size);
814 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
819 static uint8_t *input_tmp= NULL;
820 input_tmp= av_realloc(input_tmp, byte_delta + size);
822 if(byte_delta > allocated_for_size - size){
823 allocated_for_size= byte_delta + (int64_t)size;
828 memset(input_tmp, 0, byte_delta);
829 memcpy(input_tmp + byte_delta, buf, size);
833 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
835 }else if(audio_sync_method>1){
836 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
837 av_assert0(ost->audio_resample);
839 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
840 // 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));
841 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
845 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
846 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
848 if (ost->audio_resample) {
850 size_out = audio_resample(ost->resample,
851 (short *)buftmp, (short *)buf,
852 size / (dec->channels * isize));
853 size_out = size_out * enc->channels * osize;
859 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
860 const void *ibuf[6]= {buftmp};
861 void *obuf[6]= {audio_buf};
862 int istride[6]= {isize};
863 int ostride[6]= {osize};
864 int len= size_out/istride[0];
865 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
866 printf("av_audio_convert() failed\n");
872 size_out = len*osize;
875 /* now encode as many frames as possible */
876 if (enc->frame_size > 1) {
877 /* output resampled raw samples */
878 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
879 fprintf(stderr, "av_fifo_realloc2() failed\n");
882 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
884 frame_bytes = enc->frame_size * osize * enc->channels;
886 while (av_fifo_size(ost->fifo) >= frame_bytes) {
888 av_init_packet(&pkt);
890 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
892 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
894 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
897 fprintf(stderr, "Audio encoding failed\n");
901 pkt.stream_index= ost->index;
904 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
905 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
906 pkt.flags |= AV_PKT_FLAG_KEY;
907 write_frame(s, &pkt, enc, ost->bitstream_filters);
909 ost->sync_opts += enc->frame_size;
913 av_init_packet(&pkt);
915 ost->sync_opts += size_out / (osize * enc->channels);
917 /* output a pcm frame */
918 /* determine the size of the coded buffer */
921 size_out = size_out*coded_bps/8;
923 if(size_out > audio_out_size){
924 fprintf(stderr, "Internal error, buffer size too small\n");
928 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
929 ret = avcodec_encode_audio(enc, audio_out, size_out,
932 fprintf(stderr, "Audio encoding failed\n");
936 pkt.stream_index= ost->index;
939 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
940 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
941 pkt.flags |= AV_PKT_FLAG_KEY;
942 write_frame(s, &pkt, enc, ost->bitstream_filters);
946 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
950 AVPicture picture_tmp;
953 dec = ist->st->codec;
955 /* deinterlace : must be done before any resize */
956 if (do_deinterlace) {
959 /* create temporary picture */
960 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
961 buf = av_malloc(size);
965 picture2 = &picture_tmp;
966 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
968 if(avpicture_deinterlace(picture2, picture,
969 dec->pix_fmt, dec->width, dec->height) < 0) {
970 /* if error, do not deinterlace */
971 fprintf(stderr, "Deinterlacing failed\n");
980 if (picture != picture2)
981 *picture = *picture2;
985 /* we begin to correct av delay at this threshold */
986 #define AV_DELAY_MAX 0.100
988 static void do_subtitle_out(AVFormatContext *s,
994 static uint8_t *subtitle_out = NULL;
995 int subtitle_out_max_size = 1024 * 1024;
996 int subtitle_out_size, nb, i;
1000 if (pts == AV_NOPTS_VALUE) {
1001 fprintf(stderr, "Subtitle packets must have a pts\n");
1007 enc = ost->st->codec;
1009 if (!subtitle_out) {
1010 subtitle_out = av_malloc(subtitle_out_max_size);
1013 /* Note: DVB subtitle need one packet to draw them and one other
1014 packet to clear them */
1015 /* XXX: signal it in the codec context ? */
1016 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1021 for(i = 0; i < nb; i++) {
1022 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1023 // start_display_time is required to be 0
1024 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1025 sub->end_display_time -= sub->start_display_time;
1026 sub->start_display_time = 0;
1027 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1028 subtitle_out_max_size, sub);
1029 if (subtitle_out_size < 0) {
1030 fprintf(stderr, "Subtitle encoding failed\n");
1034 av_init_packet(&pkt);
1035 pkt.stream_index = ost->index;
1036 pkt.data = subtitle_out;
1037 pkt.size = subtitle_out_size;
1038 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1039 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1040 /* XXX: the pts correction is handled here. Maybe handling
1041 it in the codec would be better */
1043 pkt.pts += 90 * sub->start_display_time;
1045 pkt.pts += 90 * sub->end_display_time;
1047 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1051 static int bit_buffer_size= 1024*256;
1052 static uint8_t *bit_buffer= NULL;
1054 static void do_video_out(AVFormatContext *s,
1055 AVOutputStream *ost,
1057 AVFrame *in_picture,
1060 int nb_frames, i, ret;
1061 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1062 AVCodecContext *enc, *dec;
1065 enc = ost->st->codec;
1066 dec = ist->st->codec;
1068 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1070 /* by default, we output a single frame */
1075 if(video_sync_method){
1076 double vdelta = sync_ipts - ost->sync_opts;
1077 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1080 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1083 }else if(vdelta>0.6)
1084 ost->sync_opts= lrintf(sync_ipts);
1085 }else if (vdelta > 1.1)
1086 nb_frames = lrintf(vdelta);
1087 //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);
1088 if (nb_frames == 0){
1091 fprintf(stderr, "*** drop!\n");
1092 }else if (nb_frames > 1) {
1093 nb_frames_dup += nb_frames - 1;
1095 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1098 ost->sync_opts= lrintf(sync_ipts);
1100 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1104 formatted_picture = in_picture;
1105 final_picture = formatted_picture;
1106 padding_src = formatted_picture;
1107 resampling_dst = &ost->pict_tmp;
1109 if ( ost->resample_height != ist->st->codec->height
1110 || ost->resample_width != ist->st->codec->width
1111 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1113 fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1114 if(!ost->video_resample)
1118 #if !CONFIG_AVFILTER
1119 if (ost->video_resample) {
1121 final_picture = &ost->pict_tmp;
1122 if( ost->resample_height != ist->st->codec->height
1123 || ost->resample_width != ist->st->codec->width
1124 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1126 /* initialize a new scaler context */
1127 sws_freeContext(ost->img_resample_ctx);
1128 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1129 ost->img_resample_ctx = sws_getContext(
1130 ist->st->codec->width,
1131 ist->st->codec->height,
1132 ist->st->codec->pix_fmt,
1133 ost->st->codec->width,
1134 ost->st->codec->height,
1135 ost->st->codec->pix_fmt,
1136 sws_flags, NULL, NULL, NULL);
1137 if (ost->img_resample_ctx == NULL) {
1138 fprintf(stderr, "Cannot get resampling context\n");
1142 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1143 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1147 /* duplicates frame if needed */
1148 for(i=0;i<nb_frames;i++) {
1150 av_init_packet(&pkt);
1151 pkt.stream_index= ost->index;
1153 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1154 /* raw pictures are written as AVPicture structure to
1155 avoid any copies. We support temorarily the older
1157 AVFrame* old_frame = enc->coded_frame;
1158 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1159 pkt.data= (uint8_t *)final_picture;
1160 pkt.size= sizeof(AVPicture);
1161 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1162 pkt.flags |= AV_PKT_FLAG_KEY;
1164 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1165 enc->coded_frame = old_frame;
1167 AVFrame big_picture;
1169 big_picture= *final_picture;
1170 /* better than nothing: use input picture interlaced
1172 big_picture.interlaced_frame = in_picture->interlaced_frame;
1173 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1174 if(top_field_first == -1)
1175 big_picture.top_field_first = in_picture->top_field_first;
1177 big_picture.top_field_first = top_field_first;
1180 /* handles sameq here. This is not correct because it may
1181 not be a global option */
1182 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1184 big_picture.pict_type = 0;
1185 // big_picture.pts = AV_NOPTS_VALUE;
1186 big_picture.pts= ost->sync_opts;
1187 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1188 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1189 if (ost->forced_kf_index < ost->forced_kf_count &&
1190 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1191 big_picture.pict_type = FF_I_TYPE;
1192 ost->forced_kf_index++;
1194 ret = avcodec_encode_video(enc,
1195 bit_buffer, bit_buffer_size,
1198 fprintf(stderr, "Video encoding failed\n");
1203 pkt.data= bit_buffer;
1205 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1206 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1207 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1208 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1209 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1211 if(enc->coded_frame->key_frame)
1212 pkt.flags |= AV_PKT_FLAG_KEY;
1213 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1216 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1217 // enc->frame_number-1, ret, enc->pict_type);
1218 /* if two pass, output log */
1219 if (ost->logfile && enc->stats_out) {
1220 fprintf(ost->logfile, "%s", enc->stats_out);
1225 ost->frame_number++;
1229 static double psnr(double d){
1230 return -10.0*log(d)/log(10.0);
1233 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1236 AVCodecContext *enc;
1238 double ti1, bitrate, avg_bitrate;
1240 /* this is executed just the first time do_video_stats is called */
1242 vstats_file = fopen(vstats_filename, "w");
1249 enc = ost->st->codec;
1250 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1251 frame_number = ost->frame_number;
1252 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1253 if (enc->flags&CODEC_FLAG_PSNR)
1254 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1256 fprintf(vstats_file,"f_size= %6d ", frame_size);
1257 /* compute pts value */
1258 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1262 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1263 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1264 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1265 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1266 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1270 static void print_report(AVFormatContext **output_files,
1271 AVOutputStream **ost_table, int nb_ostreams,
1275 AVOutputStream *ost;
1276 AVFormatContext *oc;
1278 AVCodecContext *enc;
1279 int frame_number, vid, i;
1280 double bitrate, ti1, pts;
1281 static int64_t last_time = -1;
1282 static int qp_histogram[52];
1284 if (!is_last_report) {
1286 /* display the report every 0.5 seconds */
1287 cur_time = av_gettime();
1288 if (last_time == -1) {
1289 last_time = cur_time;
1292 if ((cur_time - last_time) < 500000)
1294 last_time = cur_time;
1298 oc = output_files[0];
1300 total_size = avio_size(oc->pb);
1301 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1302 total_size= avio_tell(oc->pb);
1307 for(i=0;i<nb_ostreams;i++) {
1309 enc = ost->st->codec;
1310 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1311 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1312 !ost->st->stream_copy ?
1313 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1315 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1316 float t = (av_gettime()-timer_start) / 1000000.0;
1318 frame_number = ost->frame_number;
1319 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1320 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1321 !ost->st->stream_copy ?
1322 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1324 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1327 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1328 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1331 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1333 if (enc->flags&CODEC_FLAG_PSNR){
1335 double error, error_sum=0;
1336 double scale, scale_sum=0;
1337 char type[3]= {'Y','U','V'};
1338 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1341 error= enc->error[j];
1342 scale= enc->width*enc->height*255.0*255.0*frame_number;
1344 error= enc->coded_frame->error[j];
1345 scale= enc->width*enc->height*255.0*255.0;
1350 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1352 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1356 /* compute min output value */
1357 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1358 if ((pts < ti1) && (pts > 0))
1364 if (verbose || is_last_report) {
1365 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1367 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1368 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1369 (double)total_size / 1024, ti1, bitrate);
1371 if (nb_frames_dup || nb_frames_drop)
1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1373 nb_frames_dup, nb_frames_drop);
1376 fprintf(stderr, "%s \r", buf);
1381 if (is_last_report && verbose >= 0){
1382 int64_t raw= audio_size + video_size + extra_size;
1383 fprintf(stderr, "\n");
1384 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1388 100.0*(total_size - raw)/raw
1393 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1394 static int output_packet(AVInputStream *ist, int ist_index,
1395 AVOutputStream **ost_table, int nb_ostreams,
1396 const AVPacket *pkt)
1398 AVFormatContext *os;
1399 AVOutputStream *ost;
1403 void *buffer_to_free;
1404 static unsigned int samples_size= 0;
1405 AVSubtitle subtitle, *subtitle_to_free;
1406 int64_t pkt_pts = AV_NOPTS_VALUE;
1408 int frame_available;
1412 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1414 if(ist->next_pts == AV_NOPTS_VALUE)
1415 ist->next_pts= ist->pts;
1419 av_init_packet(&avpkt);
1427 if(pkt->dts != AV_NOPTS_VALUE)
1428 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1429 if(pkt->pts != AV_NOPTS_VALUE)
1430 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1432 //while we have more to decode or while the decoder did output something on EOF
1433 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1434 uint8_t *data_buf, *decoded_data_buf;
1435 int data_size, decoded_data_size;
1437 ist->pts= ist->next_pts;
1439 if(avpkt.size && avpkt.size != pkt->size &&
1440 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1441 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1442 ist->showed_multi_packet_warning=1;
1445 /* decode the packet if needed */
1446 decoded_data_buf = NULL; /* fail safe */
1447 decoded_data_size= 0;
1448 data_buf = avpkt.data;
1449 data_size = avpkt.size;
1450 subtitle_to_free = NULL;
1451 if (ist->decoding_needed) {
1452 switch(ist->st->codec->codec_type) {
1453 case AVMEDIA_TYPE_AUDIO:{
1454 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1455 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1457 samples= av_malloc(samples_size);
1459 decoded_data_size= samples_size;
1460 /* XXX: could avoid copy if PCM 16 bits with same
1461 endianness as CPU */
1462 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1469 /* Some bug in mpeg audio decoder gives */
1470 /* decoded_data_size < 0, it seems they are overflows */
1471 if (decoded_data_size <= 0) {
1472 /* no audio frame */
1475 decoded_data_buf = (uint8_t *)samples;
1476 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1477 (ist->st->codec->sample_rate * ist->st->codec->channels);
1479 case AVMEDIA_TYPE_VIDEO:
1480 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1481 /* XXX: allocate picture correctly */
1482 avcodec_get_frame_defaults(&picture);
1483 avpkt.pts = pkt_pts;
1484 avpkt.dts = ist->pts;
1485 pkt_pts = AV_NOPTS_VALUE;
1487 ret = avcodec_decode_video2(ist->st->codec,
1488 &picture, &got_picture, &avpkt);
1489 ist->st->quality= picture.quality;
1493 /* no picture yet */
1494 goto discard_packet;
1496 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1497 if (ist->st->codec->time_base.num != 0) {
1498 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1499 ist->next_pts += ((int64_t)AV_TIME_BASE *
1500 ist->st->codec->time_base.num * ticks) /
1501 ist->st->codec->time_base.den;
1505 case AVMEDIA_TYPE_SUBTITLE:
1506 ret = avcodec_decode_subtitle2(ist->st->codec,
1507 &subtitle, &got_picture, &avpkt);
1511 goto discard_packet;
1513 subtitle_to_free = &subtitle;
1520 switch(ist->st->codec->codec_type) {
1521 case AVMEDIA_TYPE_AUDIO:
1522 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1523 ist->st->codec->sample_rate;
1525 case AVMEDIA_TYPE_VIDEO:
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;
1538 buffer_to_free = NULL;
1539 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1540 pre_process_video_frame(ist, (AVPicture *)&picture,
1545 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1547 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1548 else sar = ist->st->codec->sample_aspect_ratio;
1549 // add it to be filtered
1550 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1556 // preprocess audio (volume)
1557 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1558 if (audio_volume != 256) {
1561 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1562 int v = ((*volp) * audio_volume + 128) >> 8;
1563 if (v < -32768) v = -32768;
1564 if (v > 32767) v = 32767;
1570 /* frame rate emulation */
1572 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1573 int64_t now = av_gettime() - ist->start;
1578 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1579 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1581 /* if output time reached then transcode raw format,
1582 encode packets and output them */
1583 if (start_time == 0 || ist->pts >= start_time)
1585 while (frame_available) {
1586 AVRational ist_pts_tb;
1587 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1588 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1590 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1592 for(i=0;i<nb_ostreams;i++) {
1596 if (ost->source_index == ist_index) {
1597 os = output_files[ost->file_index];
1599 /* set the input output pts pairs */
1600 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1602 if (ost->encoding_needed) {
1603 av_assert0(ist->decoding_needed);
1604 switch(ost->st->codec->codec_type) {
1605 case AVMEDIA_TYPE_AUDIO:
1606 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1608 case AVMEDIA_TYPE_VIDEO:
1610 if (ist->picref->video)
1611 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1613 do_video_out(os, ost, ist, &picture, &frame_size);
1614 if (vstats_filename && frame_size)
1615 do_video_stats(os, ost, frame_size);
1617 case AVMEDIA_TYPE_SUBTITLE:
1618 do_subtitle_out(os, ost, ist, &subtitle,
1625 AVFrame avframe; //FIXME/XXX remove this
1627 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1629 av_init_packet(&opkt);
1631 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1634 /* no reencoding needed : output the packet directly */
1635 /* force the input stream PTS */
1637 avcodec_get_frame_defaults(&avframe);
1638 ost->st->codec->coded_frame= &avframe;
1639 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1641 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1642 audio_size += data_size;
1643 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1644 video_size += data_size;
1648 opkt.stream_index= ost->index;
1649 if(pkt->pts != AV_NOPTS_VALUE)
1650 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1652 opkt.pts= AV_NOPTS_VALUE;
1654 if (pkt->dts == AV_NOPTS_VALUE)
1655 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1657 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1658 opkt.dts -= ost_tb_start_time;
1660 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1661 opkt.flags= pkt->flags;
1663 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1664 if( ost->st->codec->codec_id != CODEC_ID_H264
1665 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1666 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1668 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1669 opkt.destruct= av_destruct_packet;
1671 opkt.data = data_buf;
1672 opkt.size = data_size;
1675 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1676 ost->st->codec->frame_number++;
1677 ost->frame_number++;
1678 av_free_packet(&opkt);
1684 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1685 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1687 avfilter_unref_buffer(ist->picref);
1690 av_free(buffer_to_free);
1691 /* XXX: allocate the subtitles in the codec ? */
1692 if (subtitle_to_free) {
1693 avsubtitle_free(subtitle_to_free);
1694 subtitle_to_free = NULL;
1701 for(i=0;i<nb_ostreams;i++) {
1703 if (ost->source_index == ist_index) {
1704 AVCodecContext *enc= ost->st->codec;
1705 os = output_files[ost->file_index];
1707 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1709 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1712 if (ost->encoding_needed) {
1716 av_init_packet(&pkt);
1717 pkt.stream_index= ost->index;
1719 switch(ost->st->codec->codec_type) {
1720 case AVMEDIA_TYPE_AUDIO:
1721 fifo_bytes = av_fifo_size(ost->fifo);
1723 /* encode any samples remaining in fifo */
1724 if (fifo_bytes > 0) {
1725 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1726 int fs_tmp = enc->frame_size;
1728 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1729 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1730 enc->frame_size = fifo_bytes / (osize * enc->channels);
1732 int frame_bytes = enc->frame_size*osize*enc->channels;
1733 if (allocated_audio_buf_size < frame_bytes)
1735 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1738 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1739 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1740 ost->st->time_base.num, enc->sample_rate);
1741 enc->frame_size = fs_tmp;
1744 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1747 fprintf(stderr, "Audio encoding failed\n");
1751 pkt.flags |= AV_PKT_FLAG_KEY;
1753 case AVMEDIA_TYPE_VIDEO:
1754 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1756 fprintf(stderr, "Video encoding failed\n");
1760 if(enc->coded_frame && enc->coded_frame->key_frame)
1761 pkt.flags |= AV_PKT_FLAG_KEY;
1762 if (ost->logfile && enc->stats_out) {
1763 fprintf(ost->logfile, "%s", enc->stats_out);
1772 pkt.data= bit_buffer;
1774 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1775 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1776 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1788 static void print_sdp(AVFormatContext **avc, int n)
1792 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1793 printf("SDP:\n%s\n", sdp);
1797 static int copy_chapters(int infile, int outfile)
1799 AVFormatContext *is = input_files[infile];
1800 AVFormatContext *os = output_files[outfile];
1803 for (i = 0; i < is->nb_chapters; i++) {
1804 AVChapter *in_ch = is->chapters[i], *out_ch;
1805 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1806 AV_TIME_BASE_Q, in_ch->time_base);
1807 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1808 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1811 if (in_ch->end < ts_off)
1813 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1816 out_ch = av_mallocz(sizeof(AVChapter));
1818 return AVERROR(ENOMEM);
1820 out_ch->id = in_ch->id;
1821 out_ch->time_base = in_ch->time_base;
1822 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1823 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1825 if (metadata_chapters_autocopy)
1826 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1829 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1831 return AVERROR(ENOMEM);
1832 os->chapters[os->nb_chapters - 1] = out_ch;
1837 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1838 AVCodecContext *avctx)
1844 for (p = kf; *p; p++)
1847 ost->forced_kf_count = n;
1848 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1849 if (!ost->forced_kf_pts) {
1850 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1853 for (i = 0; i < n; i++) {
1854 p = i ? strchr(p, ',') + 1 : kf;
1855 t = parse_time_or_die("force_key_frames", p, 1);
1856 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1861 * The following code is the main loop of the file converter
1863 static int transcode(AVFormatContext **output_files,
1864 int nb_output_files,
1865 AVFormatContext **input_files,
1867 AVStreamMap *stream_maps, int nb_stream_maps)
1869 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1870 AVFormatContext *is, *os;
1871 AVCodecContext *codec, *icodec;
1872 AVOutputStream *ost, **ost_table = NULL;
1873 AVInputStream *ist, **ist_table = NULL;
1874 AVInputFile *file_table;
1878 uint8_t no_packet[MAX_FILES]={0};
1879 int no_packet_count=0;
1881 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1885 /* input stream init */
1887 for(i=0;i<nb_input_files;i++) {
1888 is = input_files[i];
1889 file_table[i].ist_index = j;
1890 file_table[i].nb_streams = is->nb_streams;
1891 j += is->nb_streams;
1895 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1899 for(i=0;i<nb_istreams;i++) {
1900 ist = av_mallocz(sizeof(AVInputStream));
1906 for(i=0;i<nb_input_files;i++) {
1907 is = input_files[i];
1908 for(k=0;k<is->nb_streams;k++) {
1909 ist = ist_table[j++];
1910 ist->st = is->streams[k];
1911 ist->file_index = i;
1913 ist->discard = 1; /* the stream is discarded by default
1917 ist->start = av_gettime();
1922 /* output stream init */
1924 for(i=0;i<nb_output_files;i++) {
1925 os = output_files[i];
1926 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1927 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1928 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1929 ret = AVERROR(EINVAL);
1932 nb_ostreams += os->nb_streams;
1934 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1935 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1936 ret = AVERROR(EINVAL);
1940 /* Sanity check the mapping args -- do the input files & streams exist? */
1941 for(i=0;i<nb_stream_maps;i++) {
1942 int fi = stream_maps[i].file_index;
1943 int si = stream_maps[i].stream_index;
1945 if (fi < 0 || fi > nb_input_files - 1 ||
1946 si < 0 || si > file_table[fi].nb_streams - 1) {
1947 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1948 ret = AVERROR(EINVAL);
1951 fi = stream_maps[i].sync_file_index;
1952 si = stream_maps[i].sync_stream_index;
1953 if (fi < 0 || fi > nb_input_files - 1 ||
1954 si < 0 || si > file_table[fi].nb_streams - 1) {
1955 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1956 ret = AVERROR(EINVAL);
1961 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1965 for(k=0;k<nb_output_files;k++) {
1966 os = output_files[k];
1967 for(i=0;i<os->nb_streams;i++,n++) {
1969 ost = ost_table[n] = output_streams_for_file[k][i];
1970 ost->st = os->streams[i];
1971 if (nb_stream_maps > 0) {
1972 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1973 stream_maps[n].stream_index;
1975 /* Sanity check that the stream types match */
1976 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1977 int i= ost->file_index;
1978 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1979 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1980 stream_maps[n].file_index, stream_maps[n].stream_index,
1981 ost->file_index, ost->index);
1986 int best_nb_frames=-1;
1987 /* get corresponding input stream index : we select the first one with the right type */
1989 for(j=0;j<nb_istreams;j++) {
1994 AVFormatContext *f= input_files[ ist->file_index ];
1996 for(pi=0; pi<f->nb_programs; pi++){
1997 AVProgram *p= f->programs[pi];
1998 if(p->id == opt_programid)
1999 for(si=0; si<p->nb_stream_indexes; si++){
2000 if(f->streams[ p->stream_index[si] ] == ist->st)
2005 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2006 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2007 if(best_nb_frames < ist->st->codec_info_nb_frames){
2008 best_nb_frames= ist->st->codec_info_nb_frames;
2009 ost->source_index = j;
2016 if(! opt_programid) {
2017 /* try again and reuse existing stream */
2018 for(j=0;j<nb_istreams;j++) {
2020 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2021 && ist->st->discard != AVDISCARD_ALL) {
2022 ost->source_index = j;
2028 int i= ost->file_index;
2029 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2030 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2031 ost->file_index, ost->index);
2036 ist = ist_table[ost->source_index];
2038 ost->sync_ist = (nb_stream_maps > 0) ?
2039 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2040 stream_maps[n].sync_stream_index] : ist;
2044 /* for each output stream, we compute the right encoding parameters */
2045 for(i=0;i<nb_ostreams;i++) {
2047 os = output_files[ost->file_index];
2048 ist = ist_table[ost->source_index];
2050 codec = ost->st->codec;
2051 icodec = ist->st->codec;
2053 if (metadata_streams_autocopy)
2054 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2055 AV_METADATA_DONT_OVERWRITE);
2057 ost->st->disposition = ist->st->disposition;
2058 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2059 codec->chroma_sample_location = icodec->chroma_sample_location;
2061 if (ost->st->stream_copy) {
2062 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2064 if (extra_size > INT_MAX)
2067 /* if stream_copy is selected, no need to decode or encode */
2068 codec->codec_id = icodec->codec_id;
2069 codec->codec_type = icodec->codec_type;
2071 if(!codec->codec_tag){
2072 if( !os->oformat->codec_tag
2073 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2074 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2075 codec->codec_tag = icodec->codec_tag;
2078 codec->bit_rate = icodec->bit_rate;
2079 codec->rc_max_rate = icodec->rc_max_rate;
2080 codec->rc_buffer_size = icodec->rc_buffer_size;
2081 codec->extradata= av_mallocz(extra_size);
2082 if (!codec->extradata)
2084 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2085 codec->extradata_size= icodec->extradata_size;
2086 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){
2087 codec->time_base = icodec->time_base;
2088 codec->time_base.num *= icodec->ticks_per_frame;
2089 av_reduce(&codec->time_base.num, &codec->time_base.den,
2090 codec->time_base.num, codec->time_base.den, INT_MAX);
2092 codec->time_base = ist->st->time_base;
2093 switch(codec->codec_type) {
2094 case AVMEDIA_TYPE_AUDIO:
2095 if(audio_volume != 256) {
2096 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2099 codec->channel_layout = icodec->channel_layout;
2100 codec->sample_rate = icodec->sample_rate;
2101 codec->channels = icodec->channels;
2102 codec->frame_size = icodec->frame_size;
2103 codec->audio_service_type = icodec->audio_service_type;
2104 codec->block_align= icodec->block_align;
2105 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2106 codec->block_align= 0;
2107 if(codec->codec_id == CODEC_ID_AC3)
2108 codec->block_align= 0;
2110 case AVMEDIA_TYPE_VIDEO:
2111 codec->pix_fmt = icodec->pix_fmt;
2112 codec->width = icodec->width;
2113 codec->height = icodec->height;
2114 codec->has_b_frames = icodec->has_b_frames;
2116 case AVMEDIA_TYPE_SUBTITLE:
2117 codec->width = icodec->width;
2118 codec->height = icodec->height;
2124 switch(codec->codec_type) {
2125 case AVMEDIA_TYPE_AUDIO:
2126 ost->fifo= av_fifo_alloc(1024);
2129 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2130 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2131 icodec->request_channels = codec->channels;
2132 ist->decoding_needed = 1;
2133 ost->encoding_needed = 1;
2134 ost->resample_sample_fmt = icodec->sample_fmt;
2135 ost->resample_sample_rate = icodec->sample_rate;
2136 ost->resample_channels = icodec->channels;
2138 case AVMEDIA_TYPE_VIDEO:
2139 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2140 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2143 ost->video_resample = (codec->width != icodec->width ||
2144 codec->height != icodec->height ||
2145 (codec->pix_fmt != icodec->pix_fmt));
2146 if (ost->video_resample) {
2147 #if !CONFIG_AVFILTER
2148 avcodec_get_frame_defaults(&ost->pict_tmp);
2149 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2150 codec->width, codec->height)) {
2151 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2154 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2155 ost->img_resample_ctx = sws_getContext(
2162 sws_flags, NULL, NULL, NULL);
2163 if (ost->img_resample_ctx == NULL) {
2164 fprintf(stderr, "Cannot get resampling context\n");
2168 ost->original_height = icodec->height;
2169 ost->original_width = icodec->width;
2171 codec->bits_per_raw_sample= 0;
2173 ost->resample_height = icodec->height;
2174 ost->resample_width = icodec->width;
2175 ost->resample_pix_fmt= icodec->pix_fmt;
2176 ost->encoding_needed = 1;
2177 ist->decoding_needed = 1;
2180 if (configure_filters(ist, ost)) {
2181 fprintf(stderr, "Error opening filters!\n");
2186 case AVMEDIA_TYPE_SUBTITLE:
2187 ost->encoding_needed = 1;
2188 ist->decoding_needed = 1;
2195 if (ost->encoding_needed &&
2196 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2197 char logfilename[1024];
2200 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2201 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2203 if (codec->flags & CODEC_FLAG_PASS1) {
2204 f = fopen(logfilename, "wb");
2206 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2212 size_t logbuffer_size;
2213 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2214 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2217 codec->stats_in = logbuffer;
2221 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2222 int size= codec->width * codec->height;
2223 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2228 bit_buffer = av_malloc(bit_buffer_size);
2230 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2232 ret = AVERROR(ENOMEM);
2236 /* open each encoder */
2237 for(i=0;i<nb_ostreams;i++) {
2239 if (ost->encoding_needed) {
2240 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2241 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2243 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2245 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2246 ost->st->codec->codec_id, ost->file_index, ost->index);
2247 ret = AVERROR(EINVAL);
2250 if (dec->subtitle_header) {
2251 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2252 if (!ost->st->codec->subtitle_header) {
2253 ret = AVERROR(ENOMEM);
2256 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2257 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2259 if (avcodec_open(ost->st->codec, codec) < 0) {
2260 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2261 ost->file_index, ost->index);
2262 ret = AVERROR(EINVAL);
2265 extra_size += ost->st->codec->extradata_size;
2269 /* open each decoder */
2270 for(i=0;i<nb_istreams;i++) {
2272 if (ist->decoding_needed) {
2273 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2275 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2277 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2278 ist->st->codec->codec_id, ist->file_index, ist->index);
2279 ret = AVERROR(EINVAL);
2282 if (avcodec_open(ist->st->codec, codec) < 0) {
2283 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2284 ist->file_index, ist->index);
2285 ret = AVERROR(EINVAL);
2288 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2289 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2294 for(i=0;i<nb_istreams;i++) {
2298 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2299 ist->next_pts = AV_NOPTS_VALUE;
2300 init_pts_correction(&ist->pts_ctx);
2304 /* set meta data information from input file if required */
2305 for (i=0;i<nb_meta_data_maps;i++) {
2306 AVFormatContext *files[2];
2307 AVMetadata **meta[2];
2310 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2311 if ((index) < 0 || (index) >= (nb_elems)) {\
2312 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2314 ret = AVERROR(EINVAL);\
2318 int out_file_index = meta_data_maps[i][0].file;
2319 int in_file_index = meta_data_maps[i][1].file;
2320 if (in_file_index < 0 || out_file_index < 0)
2322 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2323 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2325 files[0] = output_files[out_file_index];
2326 files[1] = input_files[in_file_index];
2328 for (j = 0; j < 2; j++) {
2329 AVMetaDataMap *map = &meta_data_maps[i][j];
2331 switch (map->type) {
2333 meta[j] = &files[j]->metadata;
2336 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2337 meta[j] = &files[j]->streams[map->index]->metadata;
2340 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2341 meta[j] = &files[j]->chapters[map->index]->metadata;
2344 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2345 meta[j] = &files[j]->programs[map->index]->metadata;
2350 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2353 /* copy global metadata by default */
2354 if (metadata_global_autocopy) {
2356 for (i = 0; i < nb_output_files; i++)
2357 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2358 AV_METADATA_DONT_OVERWRITE);
2361 /* copy chapters according to chapter maps */
2362 for (i = 0; i < nb_chapter_maps; i++) {
2363 int infile = chapter_maps[i].in_file;
2364 int outfile = chapter_maps[i].out_file;
2366 if (infile < 0 || outfile < 0)
2368 if (infile >= nb_input_files) {
2369 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2370 ret = AVERROR(EINVAL);
2373 if (outfile >= nb_output_files) {
2374 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2375 ret = AVERROR(EINVAL);
2378 copy_chapters(infile, outfile);
2381 /* copy chapters from the first input file that has them*/
2382 if (!nb_chapter_maps)
2383 for (i = 0; i < nb_input_files; i++) {
2384 if (!input_files[i]->nb_chapters)
2387 for (j = 0; j < nb_output_files; j++)
2388 if ((ret = copy_chapters(i, j)) < 0)
2393 /* open files and write file headers */
2394 for(i=0;i<nb_output_files;i++) {
2395 os = output_files[i];
2396 if (av_write_header(os) < 0) {
2397 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2398 ret = AVERROR(EINVAL);
2401 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2407 /* dump the file output parameters - cannot be done before in case
2409 for(i=0;i<nb_output_files;i++) {
2410 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2413 /* dump the stream mapping */
2415 fprintf(stderr, "Stream mapping:\n");
2416 for(i=0;i<nb_ostreams;i++) {
2418 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2419 ist_table[ost->source_index]->file_index,
2420 ist_table[ost->source_index]->index,
2423 if (ost->sync_ist != ist_table[ost->source_index])
2424 fprintf(stderr, " [sync #%d.%d]",
2425 ost->sync_ist->file_index,
2426 ost->sync_ist->index);
2427 fprintf(stderr, "\n");
2432 fprintf(stderr, "%s\n", error);
2437 print_sdp(output_files, nb_output_files);
2440 if (!using_stdin && verbose >= 0) {
2442 fprintf(stderr, "Press [q] to stop encoding\n");
2444 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2446 url_set_interrupt_cb(decode_interrupt_cb);
2450 timer_start = av_gettime();
2452 for(; received_sigterm == 0;) {
2453 int file_index, ist_index;
2461 /* if 'q' pressed, exits */
2465 /* read_key() returns 0 on EOF */
2471 /* select the stream that we must read now by looking at the
2472 smallest output pts */
2474 for(i=0;i<nb_ostreams;i++) {
2477 os = output_files[ost->file_index];
2478 ist = ist_table[ost->source_index];
2479 if(ist->is_past_recording_time || no_packet[ist->file_index])
2481 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2482 ipts = (double)ist->pts;
2483 if (!file_table[ist->file_index].eof_reached){
2484 if(ipts < ipts_min) {
2486 if(input_sync ) file_index = ist->file_index;
2488 if(opts < opts_min) {
2490 if(!input_sync) file_index = ist->file_index;
2493 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2498 /* if none, if is finished */
2499 if (file_index < 0) {
2500 if(no_packet_count){
2502 memset(no_packet, 0, sizeof(no_packet));
2509 /* finish if limit size exhausted */
2510 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2513 /* read a frame from it and output it in the fifo */
2514 is = input_files[file_index];
2515 ret= av_read_frame(is, &pkt);
2516 if(ret == AVERROR(EAGAIN)){
2517 no_packet[file_index]=1;
2522 file_table[file_index].eof_reached = 1;
2530 memset(no_packet, 0, sizeof(no_packet));
2533 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2534 is->streams[pkt.stream_index]);
2536 /* the following test is needed in case new streams appear
2537 dynamically in stream : we ignore them */
2538 if (pkt.stream_index >= file_table[file_index].nb_streams)
2539 goto discard_packet;
2540 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2541 ist = ist_table[ist_index];
2543 goto discard_packet;
2545 if (pkt.dts != AV_NOPTS_VALUE)
2546 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2547 if (pkt.pts != AV_NOPTS_VALUE)
2548 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2550 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2551 && input_files_ts_scale[file_index][pkt.stream_index]){
2552 if(pkt.pts != AV_NOPTS_VALUE)
2553 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2554 if(pkt.dts != AV_NOPTS_VALUE)
2555 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2558 // 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);
2559 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2560 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2561 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2562 int64_t delta= pkt_dts - ist->next_pts;
2563 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2564 input_files_ts_offset[ist->file_index]-= delta;
2566 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2567 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2568 if(pkt.pts != AV_NOPTS_VALUE)
2569 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2573 /* finish if recording time exhausted */
2574 if (recording_time != INT64_MAX &&
2575 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2576 ist->is_past_recording_time = 1;
2577 goto discard_packet;
2580 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2581 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2584 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2585 ist->file_index, ist->index);
2588 av_free_packet(&pkt);
2593 av_free_packet(&pkt);
2595 /* dump report by using the output first video and audio streams */
2596 print_report(output_files, ost_table, nb_ostreams, 0);
2599 /* at the end of stream, we must flush the decoder buffers */
2600 for(i=0;i<nb_istreams;i++) {
2602 if (ist->decoding_needed) {
2603 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2609 /* write the trailer if needed and close file */
2610 for(i=0;i<nb_output_files;i++) {
2611 os = output_files[i];
2612 av_write_trailer(os);
2615 /* dump report by using the first video and audio streams */
2616 print_report(output_files, ost_table, nb_ostreams, 1);
2618 /* close each encoder */
2619 for(i=0;i<nb_ostreams;i++) {
2621 if (ost->encoding_needed) {
2622 av_freep(&ost->st->codec->stats_in);
2623 avcodec_close(ost->st->codec);
2627 /* close each decoder */
2628 for(i=0;i<nb_istreams;i++) {
2630 if (ist->decoding_needed) {
2631 avcodec_close(ist->st->codec);
2635 avfilter_graph_free(&graph);
2642 av_freep(&bit_buffer);
2643 av_free(file_table);
2646 for(i=0;i<nb_istreams;i++) {
2653 for(i=0;i<nb_ostreams;i++) {
2656 if (ost->st->stream_copy)
2657 av_freep(&ost->st->codec->extradata);
2659 fclose(ost->logfile);
2660 ost->logfile = NULL;
2662 av_fifo_free(ost->fifo); /* works even if fifo is not
2663 initialized but set to zero */
2664 av_freep(&ost->st->codec->subtitle_header);
2665 av_free(ost->pict_tmp.data[0]);
2666 av_free(ost->forced_kf_pts);
2667 if (ost->video_resample)
2668 sws_freeContext(ost->img_resample_ctx);
2670 audio_resample_close(ost->resample);
2671 if (ost->reformat_ctx)
2672 av_audio_convert_free(ost->reformat_ctx);
2681 static void opt_format(const char *arg)
2683 last_asked_format = arg;
2686 static void opt_video_rc_override_string(const char *arg)
2688 video_rc_override_string = arg;
2691 static int opt_me_threshold(const char *opt, const char *arg)
2693 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2697 static int opt_verbose(const char *opt, const char *arg)
2699 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2703 static int opt_frame_rate(const char *opt, const char *arg)
2705 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2706 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2712 static int opt_bitrate(const char *opt, const char *arg)
2714 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2716 opt_default(opt, arg);
2718 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2719 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2724 static int opt_frame_crop(const char *opt, const char *arg)
2726 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2727 return AVERROR(EINVAL);
2730 static void opt_frame_size(const char *arg)
2732 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2733 fprintf(stderr, "Incorrect frame size\n");
2738 static int opt_pad(const char *opt, const char *arg) {
2739 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2743 static void opt_frame_pix_fmt(const char *arg)
2745 if (strcmp(arg, "list")) {
2746 frame_pix_fmt = av_get_pix_fmt(arg);
2747 if (frame_pix_fmt == PIX_FMT_NONE) {
2748 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2757 static void opt_frame_aspect_ratio(const char *arg)
2764 p = strchr(arg, ':');
2766 x = strtol(arg, &end, 10);
2768 y = strtol(end+1, &end, 10);
2770 ar = (double)x / (double)y;
2772 ar = strtod(arg, NULL);
2775 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2778 frame_aspect_ratio = ar;
2781 static int opt_metadata(const char *opt, const char *arg)
2783 char *mid= strchr(arg, '=');
2786 fprintf(stderr, "Missing =\n");
2791 av_metadata_set2(&metadata, arg, mid, 0);
2796 static void opt_qscale(const char *arg)
2798 video_qscale = atof(arg);
2799 if (video_qscale <= 0 ||
2800 video_qscale > 255) {
2801 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2806 static void opt_top_field_first(const char *arg)
2808 top_field_first= atoi(arg);
2811 static int opt_thread_count(const char *opt, const char *arg)
2813 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2816 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2821 static void opt_audio_sample_fmt(const char *arg)
2823 if (strcmp(arg, "list")) {
2824 audio_sample_fmt = av_get_sample_fmt(arg);
2825 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2826 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2830 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2835 static int opt_audio_rate(const char *opt, const char *arg)
2837 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2841 static int opt_audio_channels(const char *opt, const char *arg)
2843 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2847 static void opt_video_channel(const char *arg)
2849 video_channel = strtol(arg, NULL, 0);
2852 static void opt_video_standard(const char *arg)
2854 video_standard = av_strdup(arg);
2857 static void opt_codec(int *pstream_copy, char **pcodec_name,
2858 int codec_type, const char *arg)
2860 av_freep(pcodec_name);
2861 if (!strcmp(arg, "copy")) {
2864 *pcodec_name = av_strdup(arg);
2868 static void opt_audio_codec(const char *arg)
2870 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2873 static void opt_video_codec(const char *arg)
2875 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2878 static void opt_subtitle_codec(const char *arg)
2880 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2883 static int opt_codec_tag(const char *opt, const char *arg)
2886 uint32_t *codec_tag;
2888 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2889 !strcmp(opt, "vtag") ? &video_codec_tag :
2890 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2894 *codec_tag = strtol(arg, &tail, 0);
2896 *codec_tag = AV_RL32(arg);
2901 static void opt_map(const char *arg)
2906 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2907 m = &stream_maps[nb_stream_maps-1];
2909 m->file_index = strtol(arg, &p, 0);
2913 m->stream_index = strtol(p, &p, 0);
2916 m->sync_file_index = strtol(p, &p, 0);
2919 m->sync_stream_index = strtol(p, &p, 0);
2921 m->sync_file_index = m->file_index;
2922 m->sync_stream_index = m->stream_index;
2926 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2937 *index = strtol(++arg, endptr, 0);
2940 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2947 static void opt_map_metadata(const char *arg)
2949 AVMetaDataMap *m, *m1;
2952 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2953 &nb_meta_data_maps, nb_meta_data_maps + 1);
2955 m = &meta_data_maps[nb_meta_data_maps - 1][0];
2956 m->file = strtol(arg, &p, 0);
2957 parse_meta_type(p, &m->type, &m->index, &p);
2961 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2962 m1->file = strtol(p, &p, 0);
2963 parse_meta_type(p, &m1->type, &m1->index, &p);
2965 if (m->type == 'g' || m1->type == 'g')
2966 metadata_global_autocopy = 0;
2967 if (m->type == 's' || m1->type == 's')
2968 metadata_streams_autocopy = 0;
2969 if (m->type == 'c' || m1->type == 'c')
2970 metadata_chapters_autocopy = 0;
2973 static void opt_map_meta_data(const char *arg)
2975 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2976 "Use -map_metadata instead.\n");
2977 opt_map_metadata(arg);
2980 static void opt_map_chapters(const char *arg)
2985 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2986 nb_chapter_maps + 1);
2987 c = &chapter_maps[nb_chapter_maps - 1];
2988 c->out_file = strtol(arg, &p, 0);
2992 c->in_file = strtol(p, &p, 0);
2995 static void opt_input_ts_scale(const char *arg)
2997 unsigned int stream;
3001 stream = strtol(arg, &p, 0);
3004 scale= strtod(p, &p);
3006 if(stream >= MAX_STREAMS)
3009 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);
3010 input_files_ts_scale[nb_input_files][stream]= scale;
3013 static int opt_recording_time(const char *opt, const char *arg)
3015 recording_time = parse_time_or_die(opt, arg, 1);
3019 static int opt_start_time(const char *opt, const char *arg)
3021 start_time = parse_time_or_die(opt, arg, 1);
3025 static int opt_recording_timestamp(const char *opt, const char *arg)
3027 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3031 static int opt_input_ts_offset(const char *opt, const char *arg)
3033 input_ts_offset = parse_time_or_die(opt, arg, 1);
3037 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3039 const char *codec_string = encoder ? "encoder" : "decoder";
3043 return CODEC_ID_NONE;
3045 avcodec_find_encoder_by_name(name) :
3046 avcodec_find_decoder_by_name(name);
3048 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3051 if(codec->type != type) {
3052 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3055 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3056 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3057 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3058 "results.\nAdd '-strict experimental' if you want to use it.\n",
3059 codec_string, codec->name);
3061 avcodec_find_encoder(codec->id) :
3062 avcodec_find_decoder(codec->id);
3063 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3064 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3065 codec_string, codec->name);
3071 static void opt_input_file(const char *filename)
3073 AVFormatContext *ic;
3074 AVFormatParameters params, *ap = ¶ms;
3075 AVInputFormat *file_iformat = NULL;
3076 int err, i, ret, rfps, rfps_base;
3079 if (last_asked_format) {
3080 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3081 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3084 last_asked_format = NULL;
3087 if (!strcmp(filename, "-"))
3090 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3091 !strcmp(filename, "/dev/stdin");
3093 /* get default parameters from command line */
3094 ic = avformat_alloc_context();
3096 print_error(filename, AVERROR(ENOMEM));
3100 memset(ap, 0, sizeof(*ap));
3101 ap->prealloced_context = 1;
3102 ap->sample_rate = audio_sample_rate;
3103 ap->channels = audio_channels;
3104 ap->time_base.den = frame_rate.num;
3105 ap->time_base.num = frame_rate.den;
3106 ap->width = frame_width;
3107 ap->height = frame_height;
3108 ap->pix_fmt = frame_pix_fmt;
3109 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3110 ap->channel = video_channel;
3111 ap->standard = video_standard;
3113 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3115 ic->video_codec_id =
3116 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3117 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3118 ic->audio_codec_id =
3119 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3120 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3121 ic->subtitle_codec_id=
3122 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3123 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3124 ic->flags |= AVFMT_FLAG_NONBLOCK;
3126 /* open the input file with generic libav function */
3127 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3129 print_error(filename, err);
3135 for(i=0; i<ic->nb_streams; i++){
3136 ic->streams[i]->discard= AVDISCARD_ALL;
3138 for(i=0; i<ic->nb_programs; i++){
3139 AVProgram *p= ic->programs[i];
3140 if(p->id != opt_programid){
3141 p->discard = AVDISCARD_ALL;
3144 for(j=0; j<p->nb_stream_indexes; j++){
3145 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3150 fprintf(stderr, "Specified program id not found\n");
3156 ic->loop_input = loop_input;
3158 /* If not enough info to get the stream parameters, we decode the
3159 first frames to get it. (used in mpeg case for example) */
3160 ret = av_find_stream_info(ic);
3161 if (ret < 0 && verbose >= 0) {
3162 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3163 av_close_input_file(ic);
3167 timestamp = start_time;
3168 /* add the stream start time */
3169 if (ic->start_time != AV_NOPTS_VALUE)
3170 timestamp += ic->start_time;
3172 /* if seeking requested, we execute it */
3173 if (start_time != 0) {
3174 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3176 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3177 filename, (double)timestamp / AV_TIME_BASE);
3179 /* reset seek info */
3183 /* update the current parameters so that they match the one of the input stream */
3184 for(i=0;i<ic->nb_streams;i++) {
3185 AVStream *st = ic->streams[i];
3186 AVCodecContext *dec = st->codec;
3187 dec->thread_count = thread_count;
3188 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3189 switch (dec->codec_type) {
3190 case AVMEDIA_TYPE_AUDIO:
3191 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3192 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]);
3193 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3194 channel_layout = dec->channel_layout;
3195 audio_channels = dec->channels;
3196 audio_sample_rate = dec->sample_rate;
3197 audio_sample_fmt = dec->sample_fmt;
3199 st->discard= AVDISCARD_ALL;
3200 /* Note that av_find_stream_info can add more streams, and we
3201 * currently have no chance of setting up lowres decoding
3202 * early enough for them. */
3204 audio_sample_rate >>= dec->lowres;
3206 case AVMEDIA_TYPE_VIDEO:
3207 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3208 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]);
3209 frame_height = dec->height;
3210 frame_width = dec->width;
3211 if(ic->streams[i]->sample_aspect_ratio.num)
3212 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3214 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3215 frame_aspect_ratio *= (float) dec->width / dec->height;
3216 frame_pix_fmt = dec->pix_fmt;
3217 rfps = ic->streams[i]->r_frame_rate.num;
3218 rfps_base = ic->streams[i]->r_frame_rate.den;
3220 dec->flags |= CODEC_FLAG_EMU_EDGE;
3221 frame_height >>= dec->lowres;
3222 frame_width >>= dec->lowres;
3223 dec->height = frame_height;
3224 dec->width = frame_width;
3227 dec->debug |= FF_DEBUG_MV;
3229 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3232 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3233 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3235 (float)rfps / rfps_base, rfps, rfps_base);
3237 /* update the current frame rate to match the stream frame rate */
3238 frame_rate.num = rfps;
3239 frame_rate.den = rfps_base;
3242 st->discard= AVDISCARD_ALL;
3243 else if(video_discard)
3244 st->discard= video_discard;
3246 case AVMEDIA_TYPE_DATA:
3248 case AVMEDIA_TYPE_SUBTITLE:
3249 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3250 if(subtitle_disable)
3251 st->discard = AVDISCARD_ALL;
3253 case AVMEDIA_TYPE_ATTACHMENT:
3254 case AVMEDIA_TYPE_UNKNOWN:
3261 input_files[nb_input_files] = ic;
3262 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3263 /* dump the file content */
3265 av_dump_format(ic, nb_input_files, filename, 0);
3271 av_freep(&video_codec_name);
3272 av_freep(&audio_codec_name);
3273 av_freep(&subtitle_codec_name);
3276 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3277 int *has_subtitle_ptr)
3279 int has_video, has_audio, has_subtitle, i, j;
3280 AVFormatContext *ic;
3285 for(j=0;j<nb_input_files;j++) {
3286 ic = input_files[j];
3287 for(i=0;i<ic->nb_streams;i++) {
3288 AVCodecContext *enc = ic->streams[i]->codec;
3289 switch(enc->codec_type) {
3290 case AVMEDIA_TYPE_AUDIO:
3293 case AVMEDIA_TYPE_VIDEO:
3296 case AVMEDIA_TYPE_SUBTITLE:
3299 case AVMEDIA_TYPE_DATA:
3300 case AVMEDIA_TYPE_ATTACHMENT:
3301 case AVMEDIA_TYPE_UNKNOWN:
3308 *has_video_ptr = has_video;
3309 *has_audio_ptr = has_audio;
3310 *has_subtitle_ptr = has_subtitle;
3313 static void new_video_stream(AVFormatContext *oc, int file_idx)
3316 AVOutputStream *ost;
3317 AVCodecContext *video_enc;
3318 enum CodecID codec_id = CODEC_ID_NONE;
3319 AVCodec *codec= NULL;
3321 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3323 fprintf(stderr, "Could not alloc stream\n");
3326 ost = new_output_stream(oc, file_idx);
3328 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3329 if(!video_stream_copy){
3330 if (video_codec_name) {
3331 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3332 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3333 codec = avcodec_find_encoder_by_name(video_codec_name);
3334 output_codecs[nb_output_codecs-1] = codec;
3336 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3337 codec = avcodec_find_encoder(codec_id);
3341 avcodec_get_context_defaults3(st->codec, codec);
3342 ost->bitstream_filters = video_bitstream_filters;
3343 video_bitstream_filters= NULL;
3345 st->codec->thread_count= thread_count;
3347 video_enc = st->codec;
3350 video_enc->codec_tag= video_codec_tag;
3352 if( (video_global_header&1)
3353 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3354 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3355 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3357 if(video_global_header&2){
3358 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3359 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3362 if (video_stream_copy) {
3363 st->stream_copy = 1;
3364 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3365 video_enc->sample_aspect_ratio =
3366 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3370 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3372 video_enc->codec_id = codec_id;
3373 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3375 if (codec && codec->supported_framerates && !force_fps)
3376 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3377 video_enc->time_base.den = fps.num;
3378 video_enc->time_base.num = fps.den;
3380 video_enc->width = frame_width;
3381 video_enc->height = frame_height;
3382 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3383 video_enc->pix_fmt = frame_pix_fmt;
3384 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3386 choose_pixel_fmt(st, codec);
3389 video_enc->gop_size = 0;
3390 if (video_qscale || same_quality) {
3391 video_enc->flags |= CODEC_FLAG_QSCALE;
3392 video_enc->global_quality=
3393 st->quality = FF_QP2LAMBDA * video_qscale;
3397 video_enc->intra_matrix = intra_matrix;
3399 video_enc->inter_matrix = inter_matrix;
3401 p= video_rc_override_string;
3404 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3406 fprintf(stderr, "error parsing rc_override\n");
3409 video_enc->rc_override=
3410 av_realloc(video_enc->rc_override,
3411 sizeof(RcOverride)*(i+1));
3412 video_enc->rc_override[i].start_frame= start;
3413 video_enc->rc_override[i].end_frame = end;
3415 video_enc->rc_override[i].qscale= q;
3416 video_enc->rc_override[i].quality_factor= 1.0;
3419 video_enc->rc_override[i].qscale= 0;
3420 video_enc->rc_override[i].quality_factor= -q/100.0;
3425 video_enc->rc_override_count=i;
3426 if (!video_enc->rc_initial_buffer_occupancy)
3427 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3428 video_enc->me_threshold= me_threshold;
3429 video_enc->intra_dc_precision= intra_dc_precision - 8;
3432 video_enc->flags|= CODEC_FLAG_PSNR;
3437 video_enc->flags |= CODEC_FLAG_PASS1;
3439 video_enc->flags |= CODEC_FLAG_PASS2;
3443 if (forced_key_frames)
3444 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3446 if (video_language) {
3447 av_metadata_set2(&st->metadata, "language", video_language, 0);
3448 av_freep(&video_language);
3451 /* reset some key parameters */
3453 av_freep(&video_codec_name);
3454 av_freep(&forced_key_frames);
3455 video_stream_copy = 0;
3456 frame_pix_fmt = PIX_FMT_NONE;
3459 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3462 AVOutputStream *ost;
3463 AVCodec *codec= NULL;
3464 AVCodecContext *audio_enc;
3465 enum CodecID codec_id = CODEC_ID_NONE;
3467 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3469 fprintf(stderr, "Could not alloc stream\n");
3472 ost = new_output_stream(oc, file_idx);
3474 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3475 if(!audio_stream_copy){
3476 if (audio_codec_name) {
3477 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3478 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3479 codec = avcodec_find_encoder_by_name(audio_codec_name);
3480 output_codecs[nb_output_codecs-1] = codec;
3482 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3483 codec = avcodec_find_encoder(codec_id);
3487 avcodec_get_context_defaults3(st->codec, codec);
3489 ost->bitstream_filters = audio_bitstream_filters;
3490 audio_bitstream_filters= NULL;
3492 st->codec->thread_count= thread_count;
3494 audio_enc = st->codec;
3495 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3498 audio_enc->codec_tag= audio_codec_tag;
3500 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3501 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3502 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3504 if (audio_stream_copy) {
3505 st->stream_copy = 1;
3506 audio_enc->channels = audio_channels;
3507 audio_enc->sample_rate = audio_sample_rate;
3509 audio_enc->codec_id = codec_id;
3510 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3512 if (audio_qscale > QSCALE_NONE) {
3513 audio_enc->flags |= CODEC_FLAG_QSCALE;
3514 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3516 audio_enc->channels = audio_channels;
3517 audio_enc->sample_fmt = audio_sample_fmt;
3518 audio_enc->sample_rate = audio_sample_rate;
3519 audio_enc->channel_layout = channel_layout;
3520 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3521 audio_enc->channel_layout = 0;
3522 choose_sample_fmt(st, codec);
3523 choose_sample_rate(st, codec);
3525 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3526 if (audio_language) {
3527 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3528 av_freep(&audio_language);
3531 /* reset some key parameters */
3533 av_freep(&audio_codec_name);
3534 audio_stream_copy = 0;
3537 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3540 AVOutputStream *ost;
3541 AVCodec *codec=NULL;
3542 AVCodecContext *subtitle_enc;
3543 enum CodecID codec_id = CODEC_ID_NONE;
3545 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3547 fprintf(stderr, "Could not alloc stream\n");
3550 ost = new_output_stream(oc, file_idx);
3551 subtitle_enc = st->codec;
3552 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3553 if(!subtitle_stream_copy){
3554 if (subtitle_codec_name) {
3555 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3556 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3557 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3559 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3560 codec = avcodec_find_encoder(codec_id);
3563 avcodec_get_context_defaults3(st->codec, codec);
3565 ost->bitstream_filters = subtitle_bitstream_filters;
3566 subtitle_bitstream_filters= NULL;
3568 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3570 if(subtitle_codec_tag)
3571 subtitle_enc->codec_tag= subtitle_codec_tag;
3573 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3574 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3577 if (subtitle_stream_copy) {
3578 st->stream_copy = 1;
3580 subtitle_enc->codec_id = codec_id;
3581 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3584 if (subtitle_language) {
3585 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3586 av_freep(&subtitle_language);
3589 subtitle_disable = 0;
3590 av_freep(&subtitle_codec_name);
3591 subtitle_stream_copy = 0;
3594 static int opt_new_stream(const char *opt, const char *arg)
3596 AVFormatContext *oc;
3597 int file_idx = nb_output_files - 1;
3598 if (nb_output_files <= 0) {
3599 fprintf(stderr, "At least one output file must be specified\n");
3602 oc = output_files[file_idx];
3604 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3605 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3606 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3611 /* arg format is "output-stream-index:streamid-value". */
3612 static int opt_streamid(const char *opt, const char *arg)
3618 strncpy(idx_str, arg, sizeof(idx_str));
3619 idx_str[sizeof(idx_str)-1] = '\0';
3620 p = strchr(idx_str, ':');
3623 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3628 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3629 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3630 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3634 static void opt_output_file(const char *filename)
3636 AVFormatContext *oc;
3637 int err, use_video, use_audio, use_subtitle;
3638 int input_has_video, input_has_audio, input_has_subtitle;
3639 AVFormatParameters params, *ap = ¶ms;
3640 AVOutputFormat *file_oformat;
3642 if (!strcmp(filename, "-"))
3645 oc = avformat_alloc_context();
3647 print_error(filename, AVERROR(ENOMEM));
3651 if (last_asked_format) {
3652 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3653 if (!file_oformat) {
3654 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3657 last_asked_format = NULL;
3659 file_oformat = av_guess_format(NULL, filename, NULL);
3660 if (!file_oformat) {
3661 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3667 oc->oformat = file_oformat;
3668 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3670 if (!strcmp(file_oformat->name, "ffm") &&
3671 av_strstart(filename, "http:", NULL)) {
3672 /* special case for files sent to ffserver: we get the stream
3673 parameters from ffserver */
3674 int err = read_ffserver_streams(oc, filename);
3676 print_error(filename, err);
3680 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3681 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3682 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3684 /* disable if no corresponding type found and at least one
3686 if (nb_input_files > 0) {
3687 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3688 &input_has_subtitle);
3689 if (!input_has_video)
3691 if (!input_has_audio)
3693 if (!input_has_subtitle)
3697 /* manual disable */
3698 if (audio_disable) use_audio = 0;
3699 if (video_disable) use_video = 0;
3700 if (subtitle_disable) use_subtitle = 0;
3702 if (use_video) new_video_stream(oc, nb_output_files);
3703 if (use_audio) new_audio_stream(oc, nb_output_files);
3704 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3706 oc->timestamp = recording_timestamp;
3708 av_metadata_copy(&oc->metadata, metadata, 0);
3709 av_metadata_free(&metadata);
3712 output_files[nb_output_files++] = oc;
3714 /* check filename in case of an image number is expected */
3715 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3716 if (!av_filename_number_test(oc->filename)) {
3717 print_error(oc->filename, AVERROR_NUMEXPECTED);
3722 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3723 /* test if it already exists to avoid loosing precious files */
3724 if (!file_overwrite &&
3725 (strchr(filename, ':') == NULL ||
3726 filename[1] == ':' ||
3727 av_strstart(filename, "file:", NULL))) {
3728 if (url_exist(filename)) {
3730 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3732 if (!read_yesno()) {
3733 fprintf(stderr, "Not overwriting - exiting\n");
3738 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3745 if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3746 print_error(filename, err);
3751 memset(ap, 0, sizeof(*ap));
3752 if (av_set_parameters(oc, ap) < 0) {
3753 fprintf(stderr, "%s: Invalid encoding parameters\n",
3758 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3759 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3760 oc->loop_output = loop_output;
3761 oc->flags |= AVFMT_FLAG_NONBLOCK;
3763 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3765 av_freep(&forced_key_frames);
3768 /* same option as mencoder */
3769 static void opt_pass(const char *pass_str)
3772 pass = atoi(pass_str);
3773 if (pass != 1 && pass != 2) {
3774 fprintf(stderr, "pass number can be only 1 or 2\n");
3780 static int64_t getutime(void)
3783 struct rusage rusage;
3785 getrusage(RUSAGE_SELF, &rusage);
3786 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3787 #elif HAVE_GETPROCESSTIMES
3789 FILETIME c, e, k, u;
3790 proc = GetCurrentProcess();
3791 GetProcessTimes(proc, &c, &e, &k, &u);
3792 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3794 return av_gettime();
3798 static int64_t getmaxrss(void)
3800 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3801 struct rusage rusage;
3802 getrusage(RUSAGE_SELF, &rusage);
3803 return (int64_t)rusage.ru_maxrss * 1024;
3804 #elif HAVE_GETPROCESSMEMORYINFO
3806 PROCESS_MEMORY_COUNTERS memcounters;
3807 proc = GetCurrentProcess();
3808 memcounters.cb = sizeof(memcounters);
3809 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3810 return memcounters.PeakPagefileUsage;
3816 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3819 const char *p = str;
3826 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3833 static void opt_inter_matrix(const char *arg)
3835 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3836 parse_matrix_coeffs(inter_matrix, arg);
3839 static void opt_intra_matrix(const char *arg)
3841 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3842 parse_matrix_coeffs(intra_matrix, arg);
3845 static void show_usage(void)
3847 printf("Hyper fast Audio and Video encoder\n");
3848 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3852 static void show_help(void)
3855 AVOutputFormat *oformat = NULL;
3857 av_log_set_callback(log_callback_help);
3859 show_help_options(options, "Main options:\n",
3860 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3861 show_help_options(options, "\nAdvanced options:\n",
3862 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3864 show_help_options(options, "\nVideo options:\n",
3865 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3867 show_help_options(options, "\nAdvanced Video options:\n",
3868 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3869 OPT_VIDEO | OPT_EXPERT);
3870 show_help_options(options, "\nAudio options:\n",
3871 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3873 show_help_options(options, "\nAdvanced Audio options:\n",
3874 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3875 OPT_AUDIO | OPT_EXPERT);
3876 show_help_options(options, "\nSubtitle options:\n",
3877 OPT_SUBTITLE | OPT_GRAB,
3879 show_help_options(options, "\nAudio/Video grab options:\n",
3883 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3886 /* individual codec options */
3888 while ((c = av_codec_next(c))) {
3889 if (c->priv_class) {
3890 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3895 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3898 /* individual muxer options */
3899 while ((oformat = av_oformat_next(oformat))) {
3900 if (oformat->priv_class) {
3901 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3906 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3909 static void opt_target(const char *arg)
3911 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3912 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3914 if(!strncmp(arg, "pal-", 4)) {
3917 } else if(!strncmp(arg, "ntsc-", 5)) {
3920 } else if(!strncmp(arg, "film-", 5)) {
3925 /* Calculate FR via float to avoid int overflow */
3926 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3929 } else if((fr == 29970) || (fr == 23976)) {
3932 /* Try to determine PAL/NTSC by peeking in the input files */
3933 if(nb_input_files) {
3935 for(j = 0; j < nb_input_files; j++) {
3936 for(i = 0; i < input_files[j]->nb_streams; i++) {
3937 AVCodecContext *c = input_files[j]->streams[i]->codec;
3938 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3940 fr = c->time_base.den * 1000 / c->time_base.num;
3944 } else if((fr == 29970) || (fr == 23976)) {
3954 if(verbose && norm != UNKNOWN)
3955 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3958 if(norm == UNKNOWN) {
3959 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3960 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3961 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3965 if(!strcmp(arg, "vcd")) {
3967 opt_video_codec("mpeg1video");
3968 opt_audio_codec("mp2");
3971 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3972 opt_frame_rate(NULL, frame_rates[norm]);
3973 opt_default("g", norm == PAL ? "15" : "18");
3975 opt_default("b", "1150000");
3976 opt_default("maxrate", "1150000");
3977 opt_default("minrate", "1150000");
3978 opt_default("bufsize", "327680"); // 40*1024*8;
3980 opt_default("ab", "224000");
3981 audio_sample_rate = 44100;
3984 opt_default("packetsize", "2324");
3985 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3987 /* We have to offset the PTS, so that it is consistent with the SCR.
3988 SCR starts at 36000, but the first two packs contain only padding
3989 and the first pack from the other stream, respectively, may also have
3990 been written before.
3991 So the real data starts at SCR 36000+3*1200. */
3992 mux_preload= (36000+3*1200) / 90000.0; //0.44
3993 } else if(!strcmp(arg, "svcd")) {
3995 opt_video_codec("mpeg2video");
3996 opt_audio_codec("mp2");
3999 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4000 opt_frame_rate(NULL, frame_rates[norm]);
4001 opt_default("g", norm == PAL ? "15" : "18");
4003 opt_default("b", "2040000");
4004 opt_default("maxrate", "2516000");
4005 opt_default("minrate", "0"); //1145000;
4006 opt_default("bufsize", "1835008"); //224*1024*8;
4007 opt_default("flags", "+scan_offset");
4010 opt_default("ab", "224000");
4011 audio_sample_rate = 44100;
4013 opt_default("packetsize", "2324");
4015 } else if(!strcmp(arg, "dvd")) {
4017 opt_video_codec("mpeg2video");
4018 opt_audio_codec("ac3");
4021 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4022 opt_frame_rate(NULL, frame_rates[norm]);
4023 opt_default("g", norm == PAL ? "15" : "18");
4025 opt_default("b", "6000000");
4026 opt_default("maxrate", "9000000");
4027 opt_default("minrate", "0"); //1500000;
4028 opt_default("bufsize", "1835008"); //224*1024*8;
4030 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4031 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4033 opt_default("ab", "448000");
4034 audio_sample_rate = 48000;
4036 } else if(!strncmp(arg, "dv", 2)) {
4040 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4041 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4042 (norm == PAL ? "yuv420p" : "yuv411p"));
4043 opt_frame_rate(NULL, frame_rates[norm]);
4045 audio_sample_rate = 48000;
4049 fprintf(stderr, "Unknown target: %s\n", arg);
4054 static void opt_vstats_file (const char *arg)
4056 av_free (vstats_filename);
4057 vstats_filename=av_strdup (arg);
4060 static void opt_vstats (void)
4063 time_t today2 = time(NULL);
4064 struct tm *today = localtime(&today2);
4066 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4068 opt_vstats_file(filename);
4071 static int opt_bsf(const char *opt, const char *arg)
4073 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4074 AVBitStreamFilterContext **bsfp;
4077 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4081 bsfp= *opt == 'v' ? &video_bitstream_filters :
4082 *opt == 'a' ? &audio_bitstream_filters :
4083 &subtitle_bitstream_filters;
4085 bsfp= &(*bsfp)->next;
4092 static int opt_preset(const char *opt, const char *arg)
4095 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4096 char *codec_name = *opt == 'v' ? video_codec_name :
4097 *opt == 'a' ? audio_codec_name :
4098 subtitle_codec_name;
4100 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4101 fprintf(stderr, "File for preset '%s' not found\n", arg);
4106 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4107 if(line[0] == '#' && !e)
4109 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4111 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4114 if(!strcmp(tmp, "acodec")){
4115 opt_audio_codec(tmp2);
4116 }else if(!strcmp(tmp, "vcodec")){
4117 opt_video_codec(tmp2);
4118 }else if(!strcmp(tmp, "scodec")){
4119 opt_subtitle_codec(tmp2);
4120 }else if(opt_default(tmp, tmp2) < 0){
4121 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4131 static const OptionDef options[] = {
4133 #include "cmdutils_common_opts.h"
4134 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4135 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4136 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4137 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4138 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4139 "outfile[,metadata]:infile[,metadata]" },
4140 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4141 "outfile[,metadata]:infile[,metadata]" },
4142 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4143 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4144 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4145 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4146 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4147 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4148 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4149 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4150 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4151 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4152 "add timings for benchmarking" },
4153 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4154 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4155 "dump each input packet" },
4156 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4157 "when dumping packets, also dump the payload" },
4158 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4159 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4160 { "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)", "" },
4161 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4162 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4163 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4164 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4165 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4166 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4167 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4168 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4169 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4170 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4171 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4172 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4173 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4174 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4177 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4178 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4179 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4180 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4181 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4182 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4183 { "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" },
4184 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4185 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4186 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4187 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4188 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4189 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4190 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4191 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4192 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4193 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4194 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4195 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4196 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4197 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4198 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4199 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4200 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4201 "use same video quality as source (implies VBR)" },
4202 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4203 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4204 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4205 "deinterlace pictures" },
4206 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4207 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4208 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4210 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4212 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4213 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4214 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4215 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4216 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4217 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4218 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4219 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4220 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4221 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4222 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4225 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4226 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4227 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4228 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4229 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4230 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4231 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4232 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4233 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4234 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4235 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4236 { "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" },
4238 /* subtitle options */
4239 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4240 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4241 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4242 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4243 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4246 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4247 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4248 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4251 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4252 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4254 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4255 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4256 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4258 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4259 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4260 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4261 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4263 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4267 int main(int argc, char **argv)
4271 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4273 avcodec_register_all();
4275 avdevice_register_all();
4278 avfilter_register_all();
4283 if(isatty(STDIN_FILENO))
4284 url_set_interrupt_cb(decode_interrupt_cb);
4292 parse_options(argc, argv, options, opt_output_file);
4294 if(nb_output_files <= 0 && nb_input_files == 0) {
4296 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4300 /* file converter / grab */
4301 if (nb_output_files <= 0) {
4302 fprintf(stderr, "At least one output file must be specified\n");
4306 if (nb_input_files == 0) {
4307 fprintf(stderr, "At least one input file must be specified\n");
4312 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4313 stream_maps, nb_stream_maps) < 0)
4315 ti = getutime() - ti;
4317 int maxrss = getmaxrss() / 1024;
4318 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4321 return ffmpeg_exit(0);