3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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 "libavcore/audioconvert.h"
40 #include "libavcore/parseutils.h"
41 #include "libavcore/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>
74 #include <sys/ioctl.h>
84 #include "libavutil/avassert.h"
86 const char program_name[] = "FFmpeg";
87 const int program_birth_year = 2000;
89 /* select an input stream for an output stream */
90 typedef struct AVStreamMap {
94 int sync_stream_index;
98 * select an input file for an output file
100 typedef struct AVMetaDataMap {
101 int file; //< file index
102 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103 int index; //< stream/chapter/program number
106 typedef struct AVChapterMap {
111 static const OptionDef options[];
113 #define MAX_FILES 100
114 #if !FF_API_MAX_STREAMS
115 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static AVFormatContext *input_files[MAX_FILES];
120 static int64_t input_files_ts_offset[MAX_FILES];
121 static double *input_files_ts_scale[MAX_FILES] = {NULL};
122 static AVCodec **input_codecs = NULL;
123 static int nb_input_files = 0;
124 static int nb_input_codecs = 0;
125 static int nb_input_files_ts_scale[MAX_FILES] = {0};
127 static AVFormatContext *output_files[MAX_FILES];
128 static AVCodec **output_codecs = NULL;
129 static int nb_output_files = 0;
130 static int nb_output_codecs = 0;
132 static AVStreamMap *stream_maps = NULL;
133 static int nb_stream_maps;
135 /* first item specifies output metadata, second is input */
136 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137 static int nb_meta_data_maps;
138 static int metadata_global_autocopy = 1;
139 static int metadata_streams_autocopy = 1;
140 static int metadata_chapters_autocopy = 1;
142 static AVChapterMap *chapter_maps = NULL;
143 static int nb_chapter_maps;
145 /* indexed by output file stream index */
146 static int *streamid_map = NULL;
147 static int nb_streamid_map = 0;
149 static int frame_width = 0;
150 static int frame_height = 0;
151 static float frame_aspect_ratio = 0;
152 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155 static AVRational frame_rate;
156 static float video_qscale = 0;
157 static uint16_t *intra_matrix = NULL;
158 static uint16_t *inter_matrix = NULL;
159 static const char *video_rc_override_string=NULL;
160 static int video_disable = 0;
161 static int video_discard = 0;
162 static char *video_codec_name = NULL;
163 static unsigned int video_codec_tag = 0;
164 static char *video_language = NULL;
165 static int same_quality = 0;
166 static int do_deinterlace = 0;
167 static int top_field_first = -1;
168 static int me_threshold = 0;
169 static int intra_dc_precision = 8;
170 static int loop_input = 0;
171 static int loop_output = AVFMT_NOOUTPUTLOOP;
172 static int qp_hist = 0;
174 static char *vfilters = NULL;
175 static AVFilterGraph *graph = NULL;
178 static int intra_only = 0;
179 static int audio_sample_rate = 44100;
180 static int64_t channel_layout = 0;
181 #define QSCALE_NONE -99999
182 static float audio_qscale = QSCALE_NONE;
183 static int audio_disable = 0;
184 static int audio_channels = 1;
185 static char *audio_codec_name = NULL;
186 static unsigned int audio_codec_tag = 0;
187 static char *audio_language = NULL;
189 static int subtitle_disable = 0;
190 static char *subtitle_codec_name = NULL;
191 static char *subtitle_language = NULL;
192 static unsigned int subtitle_codec_tag = 0;
194 static float mux_preload= 0.5;
195 static float mux_max_delay= 0.7;
197 static int64_t recording_time = INT64_MAX;
198 static int64_t start_time = 0;
199 static int64_t recording_timestamp = 0;
200 static int64_t input_ts_offset = 0;
201 static int file_overwrite = 0;
202 static AVMetadata *metadata;
203 static int do_benchmark = 0;
204 static int do_hex_dump = 0;
205 static int do_pkt_dump = 0;
206 static int do_psnr = 0;
207 static int do_pass = 0;
208 static char *pass_logfilename_prefix = NULL;
209 static int audio_stream_copy = 0;
210 static int video_stream_copy = 0;
211 static int subtitle_stream_copy = 0;
212 static int video_sync_method= -1;
213 static int audio_sync_method= 0;
214 static float audio_drift_threshold= 0.1;
215 static int copy_ts= 0;
217 static int opt_shortest = 0;
218 static int video_global_header = 0;
219 static char *vstats_filename;
220 static FILE *vstats_file;
221 static int opt_programid = 0;
222 static int copy_initial_nonkeyframes = 0;
224 static int rate_emu = 0;
226 static int video_channel = 0;
227 static char *video_standard;
229 static int audio_volume = 256;
231 static int exit_on_error = 0;
232 static int using_stdin = 0;
233 static int verbose = 1;
234 static int thread_count= 1;
235 static int q_pressed = 0;
236 static int64_t video_size = 0;
237 static int64_t audio_size = 0;
238 static int64_t extra_size = 0;
239 static int nb_frames_dup = 0;
240 static int nb_frames_drop = 0;
241 static int input_sync;
242 static uint64_t limit_filesize = 0;
243 static int force_fps = 0;
244 static char *forced_key_frames = NULL;
246 static float dts_delta_threshold = 10;
248 static unsigned int sws_flags = SWS_BICUBIC;
250 static int64_t timer_start;
252 static uint8_t *audio_buf;
253 static uint8_t *audio_out;
254 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
256 static short *samples;
258 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
260 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
262 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
264 struct AVInputStream;
266 typedef struct AVOutputStream {
267 int file_index; /* file index */
268 int index; /* stream index in the output file */
269 int source_index; /* AVInputStream index */
270 AVStream *st; /* stream in the output file */
271 int encoding_needed; /* true if encoding needed for this stream */
273 /* input pts and corresponding output pts
275 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
276 struct AVInputStream *sync_ist; /* input stream to sync against */
277 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
278 AVBitStreamFilterContext *bitstream_filters;
281 AVFrame pict_tmp; /* temporary image for resampling */
282 struct SwsContext *img_resample_ctx; /* for image resampling */
285 int resample_pix_fmt;
287 /* full frame size of first frame */
291 /* forced key frames */
292 int64_t *forced_kf_pts;
298 ReSampleContext *resample; /* for audio resampling */
299 int resample_sample_fmt;
300 int resample_channels;
301 int resample_sample_rate;
303 AVAudioConvert *reformat_ctx;
304 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
308 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
311 typedef struct AVInputStream {
315 int discard; /* true if stream data should be discarded */
316 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
317 int64_t sample_index; /* current sample */
319 int64_t start; /* time when read started */
320 int64_t next_pts; /* synthetic pts for cases where pkt.pts
322 int64_t pts; /* current pts */
323 PtsCorrectionContext pts_ctx;
324 int is_start; /* is 1 at the start and after a discontinuity */
325 int showed_multi_packet_warning;
326 int is_past_recording_time;
328 AVFilterContext *output_video_filter;
329 AVFilterContext *input_video_filter;
330 AVFrame *filter_frame;
331 int has_filter_frame;
332 AVFilterBufferRef *picref;
336 typedef struct AVInputFile {
337 int eof_reached; /* true if eof reached */
338 int ist_index; /* index of first stream in ist_table */
339 int buffer_size; /* current total buffer size */
340 int nb_streams; /* nb streams we are aware of */
345 /* init terminal so that we can grab keys */
346 static struct termios oldtty;
351 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
353 AVFilterContext *last_filter, *filter;
354 /** filter graph containing all filters including input & output */
355 AVCodecContext *codec = ost->st->codec;
356 AVCodecContext *icodec = ist->st->codec;
357 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
358 AVRational sample_aspect_ratio;
362 graph = avfilter_graph_alloc();
364 if (ist->st->sample_aspect_ratio.num){
365 sample_aspect_ratio = ist->st->sample_aspect_ratio;
367 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
369 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
370 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
371 sample_aspect_ratio.num, sample_aspect_ratio.den);
373 ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
374 "src", args, NULL, graph);
377 ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
378 "out", NULL, &ffsink_ctx, graph);
381 last_filter = ist->input_video_filter;
383 if (codec->width != icodec->width || codec->height != icodec->height) {
384 snprintf(args, 255, "%d:%d:flags=0x%X",
387 (int)av_get_int(sws_opts, "sws_flags", NULL));
388 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
389 NULL, args, NULL, graph)) < 0)
391 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
393 last_filter = filter;
396 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
397 graph->scale_sws_opts = av_strdup(args);
400 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
401 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
403 outputs->name = av_strdup("in");
404 outputs->filter_ctx = last_filter;
405 outputs->pad_idx = 0;
406 outputs->next = NULL;
408 inputs->name = av_strdup("out");
409 inputs->filter_ctx = ist->output_video_filter;
413 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
417 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
421 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
424 codec->width = ist->output_video_filter->inputs[0]->w;
425 codec->height = ist->output_video_filter->inputs[0]->h;
426 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
427 ist->output_video_filter->inputs[0]->sample_aspect_ratio;
431 #endif /* CONFIG_AVFILTER */
433 static void term_exit(void)
435 av_log(NULL, AV_LOG_QUIET, "");
437 tcsetattr (0, TCSANOW, &oldtty);
441 static volatile int received_sigterm = 0;
444 sigterm_handler(int sig)
446 received_sigterm = sig;
450 static void term_init(void)
459 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
460 |INLCR|IGNCR|ICRNL|IXON);
461 tty.c_oflag |= OPOST;
462 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
463 tty.c_cflag &= ~(CSIZE|PARENB);
468 tcsetattr (0, TCSANOW, &tty);
469 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
472 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
473 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
475 signal(SIGXCPU, sigterm_handler);
479 /* read a key without blocking */
480 static int read_key(void)
492 n = select(1, &rfds, NULL, NULL, &tv);
507 static int decode_interrupt_cb(void)
509 return q_pressed || (q_pressed = read_key() == 'q');
512 static int ffmpeg_exit(int ret)
517 for(i=0;i<nb_output_files;i++) {
518 AVFormatContext *s = output_files[i];
520 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
522 avformat_free_context(s);
523 av_free(output_streams_for_file[i]);
525 for(i=0;i<nb_input_files;i++) {
526 av_close_input_file(input_files[i]);
527 av_free(input_files_ts_scale[i]);
530 av_free(intra_matrix);
531 av_free(inter_matrix);
535 av_free(vstats_filename);
537 av_free(streamid_map);
538 av_free(input_codecs);
539 av_free(output_codecs);
540 av_free(stream_maps);
541 av_free(meta_data_maps);
543 av_free(video_codec_name);
544 av_free(audio_codec_name);
545 av_free(subtitle_codec_name);
547 av_free(video_standard);
552 allocated_audio_buf_size= allocated_audio_out_size= 0;
559 if (received_sigterm) {
561 "Received signal %d: terminating.\n",
562 (int) received_sigterm);
566 exit(ret); /* not all OS-es handle main() return value */
570 /* similar to ff_dynarray_add() and av_fast_realloc() */
571 static void *grow_array(void *array, int elem_size, int *size, int new_size)
573 if (new_size >= INT_MAX / elem_size) {
574 fprintf(stderr, "Array too big.\n");
577 if (*size < new_size) {
578 uint8_t *tmp = av_realloc(array, new_size*elem_size);
580 fprintf(stderr, "Could not alloc buffer.\n");
583 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
590 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
592 if(codec && codec->sample_fmts){
593 const enum AVSampleFormat *p= codec->sample_fmts;
595 if(*p == st->codec->sample_fmt)
599 av_log(NULL, AV_LOG_WARNING,
600 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
601 av_get_sample_fmt_name(st->codec->sample_fmt),
603 av_get_sample_fmt_name(codec->sample_fmts[0]));
604 st->codec->sample_fmt = codec->sample_fmts[0];
609 static void choose_sample_rate(AVStream *st, AVCodec *codec)
611 if(codec && codec->supported_samplerates){
612 const int *p= codec->supported_samplerates;
614 int best_dist=INT_MAX;
616 int dist= abs(st->codec->sample_rate - *p);
617 if(dist < best_dist){
623 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
625 st->codec->sample_rate= best;
629 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
631 if(codec && codec->pix_fmts){
632 const enum PixelFormat *p= codec->pix_fmts;
633 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
634 if(st->codec->codec_id==CODEC_ID_MJPEG){
635 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
636 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
637 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};
641 if(*p == st->codec->pix_fmt)
645 st->codec->pix_fmt = codec->pix_fmts[0];
649 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
651 int idx = oc->nb_streams - 1;
654 output_streams_for_file[file_idx] =
655 grow_array(output_streams_for_file[file_idx],
656 sizeof(*output_streams_for_file[file_idx]),
657 &nb_output_streams_for_file[file_idx],
659 ost = output_streams_for_file[file_idx][idx] =
660 av_mallocz(sizeof(AVOutputStream));
662 fprintf(stderr, "Could not alloc output stream\n");
665 ost->file_index = file_idx;
670 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
676 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
679 /* copy stream format */
681 for(i=0;i<ic->nb_streams;i++) {
687 // FIXME: a more elegant solution is needed
688 st = av_mallocz(sizeof(AVStream));
689 memcpy(st, ic->streams[i], sizeof(AVStream));
690 st->codec = avcodec_alloc_context();
692 print_error(filename, AVERROR(ENOMEM));
695 avcodec_copy_context(st->codec, ic->streams[i]->codec);
698 codec = avcodec_find_encoder(st->codec->codec_id);
699 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
700 if (audio_stream_copy) {
703 choose_sample_fmt(st, codec);
704 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
705 if (video_stream_copy) {
708 choose_pixel_fmt(st, codec);
711 if(!st->codec->thread_count)
712 st->codec->thread_count = 1;
713 if(st->codec->thread_count>1)
714 avcodec_thread_init(st->codec, st->codec->thread_count);
716 if(st->codec->flags & CODEC_FLAG_BITEXACT)
719 new_output_stream(s, nb_output_files);
723 s->timestamp = av_gettime();
725 av_close_input_file(ic);
730 get_sync_ipts(const AVOutputStream *ost)
732 const AVInputStream *ist = ost->sync_ist;
733 return (double)(ist->pts - start_time)/AV_TIME_BASE;
736 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
740 AVPacket new_pkt= *pkt;
741 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
742 &new_pkt.data, &new_pkt.size,
743 pkt->data, pkt->size,
744 pkt->flags & AV_PKT_FLAG_KEY);
747 new_pkt.destruct= av_destruct_packet;
749 fprintf(stderr, "%s failed for stream %d, codec %s",
750 bsfc->filter->name, pkt->stream_index,
751 avctx->codec ? avctx->codec->name : "copy");
761 ret= av_interleaved_write_frame(s, pkt);
763 print_error("av_interleaved_write_frame()", ret);
768 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
770 static void do_audio_out(AVFormatContext *s,
773 unsigned char *buf, int size)
776 int64_t audio_out_size, audio_buf_size;
777 int64_t allocated_for_size= size;
779 int size_out, frame_bytes, ret, resample_changed;
780 AVCodecContext *enc= ost->st->codec;
781 AVCodecContext *dec= ist->st->codec;
782 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
783 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
784 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
787 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
788 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
789 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
790 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
791 audio_buf_size*= osize*enc->channels;
793 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
794 if(coded_bps > 8*osize)
795 audio_out_size= audio_out_size * coded_bps / (8*osize);
796 audio_out_size += FF_MIN_BUFFER_SIZE;
798 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
799 fprintf(stderr, "Buffer sizes too large\n");
803 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
804 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
805 if (!audio_buf || !audio_out){
806 fprintf(stderr, "Out of memory in do_audio_out\n");
810 if (enc->channels != dec->channels)
811 ost->audio_resample = 1;
813 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
814 ost->resample_channels != dec->channels ||
815 ost->resample_sample_rate != dec->sample_rate;
817 if ((ost->audio_resample && !ost->resample) || resample_changed) {
818 if (resample_changed) {
819 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",
820 ist->file_index, ist->index,
821 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
822 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
823 ost->resample_sample_fmt = dec->sample_fmt;
824 ost->resample_channels = dec->channels;
825 ost->resample_sample_rate = dec->sample_rate;
827 audio_resample_close(ost->resample);
829 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
830 if (audio_sync_method <= 1 &&
831 ost->resample_sample_fmt == enc->sample_fmt &&
832 ost->resample_channels == enc->channels &&
833 ost->resample_sample_rate == enc->sample_rate) {
834 ost->resample = NULL;
835 ost->audio_resample = 0;
837 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
838 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
839 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
840 enc->sample_rate, dec->sample_rate,
841 enc->sample_fmt, dec->sample_fmt,
843 if (!ost->resample) {
844 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
845 dec->channels, dec->sample_rate,
846 enc->channels, enc->sample_rate);
852 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
853 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
854 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
855 if (ost->reformat_ctx)
856 av_audio_convert_free(ost->reformat_ctx);
857 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
858 dec->sample_fmt, 1, NULL, 0);
859 if (!ost->reformat_ctx) {
860 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
861 av_get_sample_fmt_name(dec->sample_fmt),
862 av_get_sample_fmt_name(enc->sample_fmt));
865 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
868 if(audio_sync_method){
869 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
870 - av_fifo_size(ost->fifo)/(enc->channels * 2);
871 double idelta= delta*dec->sample_rate / enc->sample_rate;
872 int byte_delta= ((int)idelta)*2*dec->channels;
874 //FIXME resample delay
875 if(fabs(delta) > 50){
876 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
878 byte_delta= FFMAX(byte_delta, -size);
882 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
887 static uint8_t *input_tmp= NULL;
888 input_tmp= av_realloc(input_tmp, byte_delta + size);
890 if(byte_delta > allocated_for_size - size){
891 allocated_for_size= byte_delta + (int64_t)size;
896 memset(input_tmp, 0, byte_delta);
897 memcpy(input_tmp + byte_delta, buf, size);
901 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
903 }else if(audio_sync_method>1){
904 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
905 av_assert0(ost->audio_resample);
907 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
908 // 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));
909 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
913 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
914 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
916 if (ost->audio_resample) {
918 size_out = audio_resample(ost->resample,
919 (short *)buftmp, (short *)buf,
920 size / (dec->channels * isize));
921 size_out = size_out * enc->channels * osize;
927 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
928 const void *ibuf[6]= {buftmp};
929 void *obuf[6]= {audio_buf};
930 int istride[6]= {isize};
931 int ostride[6]= {osize};
932 int len= size_out/istride[0];
933 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
934 printf("av_audio_convert() failed\n");
940 size_out = len*osize;
943 /* now encode as many frames as possible */
944 if (enc->frame_size > 1) {
945 /* output resampled raw samples */
946 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
947 fprintf(stderr, "av_fifo_realloc2() failed\n");
950 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
952 frame_bytes = enc->frame_size * osize * enc->channels;
954 while (av_fifo_size(ost->fifo) >= frame_bytes) {
956 av_init_packet(&pkt);
958 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
960 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
962 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
965 fprintf(stderr, "Audio encoding failed\n");
969 pkt.stream_index= ost->index;
972 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
973 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
974 pkt.flags |= AV_PKT_FLAG_KEY;
975 write_frame(s, &pkt, enc, ost->bitstream_filters);
977 ost->sync_opts += enc->frame_size;
981 av_init_packet(&pkt);
983 ost->sync_opts += size_out / (osize * enc->channels);
985 /* output a pcm frame */
986 /* determine the size of the coded buffer */
989 size_out = size_out*coded_bps/8;
991 if(size_out > audio_out_size){
992 fprintf(stderr, "Internal error, buffer size too small\n");
996 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
997 ret = avcodec_encode_audio(enc, audio_out, size_out,
1000 fprintf(stderr, "Audio encoding failed\n");
1004 pkt.stream_index= ost->index;
1005 pkt.data= audio_out;
1007 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1008 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1009 pkt.flags |= AV_PKT_FLAG_KEY;
1010 write_frame(s, &pkt, enc, ost->bitstream_filters);
1014 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1016 AVCodecContext *dec;
1017 AVPicture *picture2;
1018 AVPicture picture_tmp;
1021 dec = ist->st->codec;
1023 /* deinterlace : must be done before any resize */
1024 if (do_deinterlace) {
1027 /* create temporary picture */
1028 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1029 buf = av_malloc(size);
1033 picture2 = &picture_tmp;
1034 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1036 if(avpicture_deinterlace(picture2, picture,
1037 dec->pix_fmt, dec->width, dec->height) < 0) {
1038 /* if error, do not deinterlace */
1039 fprintf(stderr, "Deinterlacing failed\n");
1048 if (picture != picture2)
1049 *picture = *picture2;
1053 /* we begin to correct av delay at this threshold */
1054 #define AV_DELAY_MAX 0.100
1056 static void do_subtitle_out(AVFormatContext *s,
1057 AVOutputStream *ost,
1062 static uint8_t *subtitle_out = NULL;
1063 int subtitle_out_max_size = 1024 * 1024;
1064 int subtitle_out_size, nb, i;
1065 AVCodecContext *enc;
1068 if (pts == AV_NOPTS_VALUE) {
1069 fprintf(stderr, "Subtitle packets must have a pts\n");
1075 enc = ost->st->codec;
1077 if (!subtitle_out) {
1078 subtitle_out = av_malloc(subtitle_out_max_size);
1081 /* Note: DVB subtitle need one packet to draw them and one other
1082 packet to clear them */
1083 /* XXX: signal it in the codec context ? */
1084 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1089 for(i = 0; i < nb; i++) {
1090 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1091 // start_display_time is required to be 0
1092 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1093 sub->end_display_time -= sub->start_display_time;
1094 sub->start_display_time = 0;
1095 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1096 subtitle_out_max_size, sub);
1097 if (subtitle_out_size < 0) {
1098 fprintf(stderr, "Subtitle encoding failed\n");
1102 av_init_packet(&pkt);
1103 pkt.stream_index = ost->index;
1104 pkt.data = subtitle_out;
1105 pkt.size = subtitle_out_size;
1106 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1107 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1108 /* XXX: the pts correction is handled here. Maybe handling
1109 it in the codec would be better */
1111 pkt.pts += 90 * sub->start_display_time;
1113 pkt.pts += 90 * sub->end_display_time;
1115 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1119 static int bit_buffer_size= 1024*256;
1120 static uint8_t *bit_buffer= NULL;
1122 static void do_video_out(AVFormatContext *s,
1123 AVOutputStream *ost,
1125 AVFrame *in_picture,
1128 int nb_frames, i, ret;
1129 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1130 AVCodecContext *enc, *dec;
1133 enc = ost->st->codec;
1134 dec = ist->st->codec;
1136 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1138 /* by default, we output a single frame */
1143 if(video_sync_method){
1144 double vdelta = sync_ipts - ost->sync_opts;
1145 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1148 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1151 }else if(vdelta>0.6)
1152 ost->sync_opts= lrintf(sync_ipts);
1153 }else if (vdelta > 1.1)
1154 nb_frames = lrintf(vdelta);
1155 //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);
1156 if (nb_frames == 0){
1159 fprintf(stderr, "*** drop!\n");
1160 }else if (nb_frames > 1) {
1161 nb_frames_dup += nb_frames - 1;
1163 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1166 ost->sync_opts= lrintf(sync_ipts);
1168 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1172 formatted_picture = in_picture;
1173 final_picture = formatted_picture;
1174 padding_src = formatted_picture;
1175 resampling_dst = &ost->pict_tmp;
1177 if ( ost->resample_height != ist->st->codec->height
1178 || ost->resample_width != ist->st->codec->width
1179 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1181 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));
1182 if(!ost->video_resample)
1186 #if !CONFIG_AVFILTER
1187 if (ost->video_resample) {
1189 final_picture = &ost->pict_tmp;
1190 if( ost->resample_height != ist->st->codec->height
1191 || ost->resample_width != ist->st->codec->width
1192 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1194 /* initialize a new scaler context */
1195 sws_freeContext(ost->img_resample_ctx);
1196 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1197 ost->img_resample_ctx = sws_getContext(
1198 ist->st->codec->width,
1199 ist->st->codec->height,
1200 ist->st->codec->pix_fmt,
1201 ost->st->codec->width,
1202 ost->st->codec->height,
1203 ost->st->codec->pix_fmt,
1204 sws_flags, NULL, NULL, NULL);
1205 if (ost->img_resample_ctx == NULL) {
1206 fprintf(stderr, "Cannot get resampling context\n");
1210 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1211 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1215 /* duplicates frame if needed */
1216 for(i=0;i<nb_frames;i++) {
1218 av_init_packet(&pkt);
1219 pkt.stream_index= ost->index;
1221 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1222 /* raw pictures are written as AVPicture structure to
1223 avoid any copies. We support temorarily the older
1225 AVFrame* old_frame = enc->coded_frame;
1226 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1227 pkt.data= (uint8_t *)final_picture;
1228 pkt.size= sizeof(AVPicture);
1229 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1230 pkt.flags |= AV_PKT_FLAG_KEY;
1232 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1233 enc->coded_frame = old_frame;
1235 AVFrame big_picture;
1237 big_picture= *final_picture;
1238 /* better than nothing: use input picture interlaced
1240 big_picture.interlaced_frame = in_picture->interlaced_frame;
1241 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1242 if(top_field_first == -1)
1243 big_picture.top_field_first = in_picture->top_field_first;
1245 big_picture.top_field_first = top_field_first;
1248 /* handles sameq here. This is not correct because it may
1249 not be a global option */
1250 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1252 big_picture.pict_type = 0;
1253 // big_picture.pts = AV_NOPTS_VALUE;
1254 big_picture.pts= ost->sync_opts;
1255 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1256 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1257 if (ost->forced_kf_index < ost->forced_kf_count &&
1258 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1259 big_picture.pict_type = FF_I_TYPE;
1260 ost->forced_kf_index++;
1262 ret = avcodec_encode_video(enc,
1263 bit_buffer, bit_buffer_size,
1266 fprintf(stderr, "Video encoding failed\n");
1271 pkt.data= bit_buffer;
1273 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1274 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1275 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1276 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1277 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1279 if(enc->coded_frame->key_frame)
1280 pkt.flags |= AV_PKT_FLAG_KEY;
1281 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1284 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1285 // enc->frame_number-1, ret, enc->pict_type);
1286 /* if two pass, output log */
1287 if (ost->logfile && enc->stats_out) {
1288 fprintf(ost->logfile, "%s", enc->stats_out);
1293 ost->frame_number++;
1297 static double psnr(double d){
1298 return -10.0*log(d)/log(10.0);
1301 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1304 AVCodecContext *enc;
1306 double ti1, bitrate, avg_bitrate;
1308 /* this is executed just the first time do_video_stats is called */
1310 vstats_file = fopen(vstats_filename, "w");
1317 enc = ost->st->codec;
1318 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1319 frame_number = ost->frame_number;
1320 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1321 if (enc->flags&CODEC_FLAG_PSNR)
1322 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1324 fprintf(vstats_file,"f_size= %6d ", frame_size);
1325 /* compute pts value */
1326 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1330 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1331 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1332 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1333 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1334 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1338 static void print_report(AVFormatContext **output_files,
1339 AVOutputStream **ost_table, int nb_ostreams,
1343 AVOutputStream *ost;
1344 AVFormatContext *oc;
1346 AVCodecContext *enc;
1347 int frame_number, vid, i;
1348 double bitrate, ti1, pts;
1349 static int64_t last_time = -1;
1350 static int qp_histogram[52];
1352 if (!is_last_report) {
1354 /* display the report every 0.5 seconds */
1355 cur_time = av_gettime();
1356 if (last_time == -1) {
1357 last_time = cur_time;
1360 if ((cur_time - last_time) < 500000)
1362 last_time = cur_time;
1366 oc = output_files[0];
1368 total_size = url_fsize(oc->pb);
1369 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1370 total_size= url_ftell(oc->pb);
1375 for(i=0;i<nb_ostreams;i++) {
1377 enc = ost->st->codec;
1378 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1379 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1380 !ost->st->stream_copy ?
1381 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1383 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1384 float t = (av_gettime()-timer_start) / 1000000.0;
1386 frame_number = ost->frame_number;
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1388 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1389 !ost->st->stream_copy ?
1390 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1392 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1395 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1396 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1399 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1401 if (enc->flags&CODEC_FLAG_PSNR){
1403 double error, error_sum=0;
1404 double scale, scale_sum=0;
1405 char type[3]= {'Y','U','V'};
1406 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1409 error= enc->error[j];
1410 scale= enc->width*enc->height*255.0*255.0*frame_number;
1412 error= enc->coded_frame->error[j];
1413 scale= enc->width*enc->height*255.0*255.0;
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1424 /* compute min output value */
1425 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1426 if ((pts < ti1) && (pts > 0))
1432 if (verbose || is_last_report) {
1433 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1435 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1436 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1437 (double)total_size / 1024, ti1, bitrate);
1439 if (nb_frames_dup || nb_frames_drop)
1440 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1441 nb_frames_dup, nb_frames_drop);
1444 fprintf(stderr, "%s \r", buf);
1449 if (is_last_report && verbose >= 0){
1450 int64_t raw= audio_size + video_size + extra_size;
1451 fprintf(stderr, "\n");
1452 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1456 100.0*(total_size - raw)/raw
1461 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1462 static int output_packet(AVInputStream *ist, int ist_index,
1463 AVOutputStream **ost_table, int nb_ostreams,
1464 const AVPacket *pkt)
1466 AVFormatContext *os;
1467 AVOutputStream *ost;
1471 void *buffer_to_free;
1472 static unsigned int samples_size= 0;
1473 AVSubtitle subtitle, *subtitle_to_free;
1474 int64_t pkt_pts = AV_NOPTS_VALUE;
1476 int frame_available;
1480 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1482 if(ist->next_pts == AV_NOPTS_VALUE)
1483 ist->next_pts= ist->pts;
1487 av_init_packet(&avpkt);
1495 if(pkt->dts != AV_NOPTS_VALUE)
1496 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1497 if(pkt->pts != AV_NOPTS_VALUE)
1498 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1500 //while we have more to decode or while the decoder did output something on EOF
1501 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1502 uint8_t *data_buf, *decoded_data_buf;
1503 int data_size, decoded_data_size;
1505 ist->pts= ist->next_pts;
1507 if(avpkt.size && avpkt.size != pkt->size &&
1508 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1509 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1510 ist->showed_multi_packet_warning=1;
1513 /* decode the packet if needed */
1514 decoded_data_buf = NULL; /* fail safe */
1515 decoded_data_size= 0;
1516 data_buf = avpkt.data;
1517 data_size = avpkt.size;
1518 subtitle_to_free = NULL;
1519 if (ist->decoding_needed) {
1520 switch(ist->st->codec->codec_type) {
1521 case AVMEDIA_TYPE_AUDIO:{
1522 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1523 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1525 samples= av_malloc(samples_size);
1527 decoded_data_size= samples_size;
1528 /* XXX: could avoid copy if PCM 16 bits with same
1529 endianness as CPU */
1530 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1537 /* Some bug in mpeg audio decoder gives */
1538 /* decoded_data_size < 0, it seems they are overflows */
1539 if (decoded_data_size <= 0) {
1540 /* no audio frame */
1543 decoded_data_buf = (uint8_t *)samples;
1544 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1545 (ist->st->codec->sample_rate * ist->st->codec->channels);
1547 case AVMEDIA_TYPE_VIDEO:
1548 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1549 /* XXX: allocate picture correctly */
1550 avcodec_get_frame_defaults(&picture);
1551 avpkt.pts = pkt_pts;
1552 avpkt.dts = ist->pts;
1553 pkt_pts = AV_NOPTS_VALUE;
1555 ret = avcodec_decode_video2(ist->st->codec,
1556 &picture, &got_picture, &avpkt);
1557 ist->st->quality= picture.quality;
1561 /* no picture yet */
1562 goto discard_packet;
1564 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1565 if (ist->st->codec->time_base.num != 0) {
1566 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1567 ist->next_pts += ((int64_t)AV_TIME_BASE *
1568 ist->st->codec->time_base.num * ticks) /
1569 ist->st->codec->time_base.den;
1573 case AVMEDIA_TYPE_SUBTITLE:
1574 ret = avcodec_decode_subtitle2(ist->st->codec,
1575 &subtitle, &got_picture, &avpkt);
1579 goto discard_packet;
1581 subtitle_to_free = &subtitle;
1588 switch(ist->st->codec->codec_type) {
1589 case AVMEDIA_TYPE_AUDIO:
1590 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1591 ist->st->codec->sample_rate;
1593 case AVMEDIA_TYPE_VIDEO:
1594 if (ist->st->codec->time_base.num != 0) {
1595 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1596 ist->next_pts += ((int64_t)AV_TIME_BASE *
1597 ist->st->codec->time_base.num * ticks) /
1598 ist->st->codec->time_base.den;
1606 buffer_to_free = NULL;
1607 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1608 pre_process_video_frame(ist, (AVPicture *)&picture,
1613 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1615 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1616 else sar = ist->st->codec->sample_aspect_ratio;
1617 // add it to be filtered
1618 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1624 // preprocess audio (volume)
1625 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1626 if (audio_volume != 256) {
1629 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1630 int v = ((*volp) * audio_volume + 128) >> 8;
1631 if (v < -32768) v = -32768;
1632 if (v > 32767) v = 32767;
1638 /* frame rate emulation */
1640 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1641 int64_t now = av_gettime() - ist->start;
1646 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1647 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1649 /* if output time reached then transcode raw format,
1650 encode packets and output them */
1651 if (start_time == 0 || ist->pts >= start_time)
1653 while (frame_available) {
1654 AVRational ist_pts_tb;
1655 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1656 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1658 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1660 for(i=0;i<nb_ostreams;i++) {
1664 if (ost->source_index == ist_index) {
1665 os = output_files[ost->file_index];
1667 /* set the input output pts pairs */
1668 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1670 if (ost->encoding_needed) {
1671 av_assert0(ist->decoding_needed);
1672 switch(ost->st->codec->codec_type) {
1673 case AVMEDIA_TYPE_AUDIO:
1674 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1676 case AVMEDIA_TYPE_VIDEO:
1678 if (ist->picref->video)
1679 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1681 do_video_out(os, ost, ist, &picture, &frame_size);
1682 if (vstats_filename && frame_size)
1683 do_video_stats(os, ost, frame_size);
1685 case AVMEDIA_TYPE_SUBTITLE:
1686 do_subtitle_out(os, ost, ist, &subtitle,
1693 AVFrame avframe; //FIXME/XXX remove this
1695 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1697 av_init_packet(&opkt);
1699 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1702 /* no reencoding needed : output the packet directly */
1703 /* force the input stream PTS */
1705 avcodec_get_frame_defaults(&avframe);
1706 ost->st->codec->coded_frame= &avframe;
1707 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1709 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1710 audio_size += data_size;
1711 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1712 video_size += data_size;
1716 opkt.stream_index= ost->index;
1717 if(pkt->pts != AV_NOPTS_VALUE)
1718 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1720 opkt.pts= AV_NOPTS_VALUE;
1722 if (pkt->dts == AV_NOPTS_VALUE)
1723 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1725 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1726 opkt.dts -= ost_tb_start_time;
1728 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1729 opkt.flags= pkt->flags;
1731 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1732 if( ost->st->codec->codec_id != CODEC_ID_H264
1733 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1734 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1736 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1737 opkt.destruct= av_destruct_packet;
1739 opkt.data = data_buf;
1740 opkt.size = data_size;
1743 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1744 ost->st->codec->frame_number++;
1745 ost->frame_number++;
1746 av_free_packet(&opkt);
1752 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1753 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1755 avfilter_unref_buffer(ist->picref);
1758 av_free(buffer_to_free);
1759 /* XXX: allocate the subtitles in the codec ? */
1760 if (subtitle_to_free) {
1761 avsubtitle_free(subtitle_to_free);
1762 subtitle_to_free = NULL;
1769 for(i=0;i<nb_ostreams;i++) {
1771 if (ost->source_index == ist_index) {
1772 AVCodecContext *enc= ost->st->codec;
1773 os = output_files[ost->file_index];
1775 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1777 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1780 if (ost->encoding_needed) {
1784 av_init_packet(&pkt);
1785 pkt.stream_index= ost->index;
1787 switch(ost->st->codec->codec_type) {
1788 case AVMEDIA_TYPE_AUDIO:
1789 fifo_bytes = av_fifo_size(ost->fifo);
1791 /* encode any samples remaining in fifo */
1792 if (fifo_bytes > 0) {
1793 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1794 int fs_tmp = enc->frame_size;
1796 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1797 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1798 enc->frame_size = fifo_bytes / (osize * enc->channels);
1800 int frame_bytes = enc->frame_size*osize*enc->channels;
1801 if (allocated_audio_buf_size < frame_bytes)
1803 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1806 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1807 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1808 ost->st->time_base.num, enc->sample_rate);
1809 enc->frame_size = fs_tmp;
1812 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1815 fprintf(stderr, "Audio encoding failed\n");
1819 pkt.flags |= AV_PKT_FLAG_KEY;
1821 case AVMEDIA_TYPE_VIDEO:
1822 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1824 fprintf(stderr, "Video encoding failed\n");
1828 if(enc->coded_frame && enc->coded_frame->key_frame)
1829 pkt.flags |= AV_PKT_FLAG_KEY;
1830 if (ost->logfile && enc->stats_out) {
1831 fprintf(ost->logfile, "%s", enc->stats_out);
1840 pkt.data= bit_buffer;
1842 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1843 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1844 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1856 static void print_sdp(AVFormatContext **avc, int n)
1860 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1861 printf("SDP:\n%s\n", sdp);
1865 static int copy_chapters(int infile, int outfile)
1867 AVFormatContext *is = input_files[infile];
1868 AVFormatContext *os = output_files[outfile];
1871 for (i = 0; i < is->nb_chapters; i++) {
1872 AVChapter *in_ch = is->chapters[i], *out_ch;
1873 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1874 AV_TIME_BASE_Q, in_ch->time_base);
1875 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1876 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1879 if (in_ch->end < ts_off)
1881 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1884 out_ch = av_mallocz(sizeof(AVChapter));
1886 return AVERROR(ENOMEM);
1888 out_ch->id = in_ch->id;
1889 out_ch->time_base = in_ch->time_base;
1890 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1891 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1893 if (metadata_chapters_autocopy)
1894 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1897 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1899 return AVERROR(ENOMEM);
1900 os->chapters[os->nb_chapters - 1] = out_ch;
1905 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1906 AVCodecContext *avctx)
1912 for (p = kf; *p; p++)
1915 ost->forced_kf_count = n;
1916 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1917 if (!ost->forced_kf_pts) {
1918 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1921 for (i = 0; i < n; i++) {
1922 p = i ? strchr(p, ',') + 1 : kf;
1923 t = parse_time_or_die("force_key_frames", p, 1);
1924 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1929 * The following code is the main loop of the file converter
1931 static int transcode(AVFormatContext **output_files,
1932 int nb_output_files,
1933 AVFormatContext **input_files,
1935 AVStreamMap *stream_maps, int nb_stream_maps)
1937 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1938 AVFormatContext *is, *os;
1939 AVCodecContext *codec, *icodec;
1940 AVOutputStream *ost, **ost_table = NULL;
1941 AVInputStream *ist, **ist_table = NULL;
1942 AVInputFile *file_table;
1946 uint8_t no_packet[MAX_FILES]={0};
1947 int no_packet_count=0;
1949 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1953 /* input stream init */
1955 for(i=0;i<nb_input_files;i++) {
1956 is = input_files[i];
1957 file_table[i].ist_index = j;
1958 file_table[i].nb_streams = is->nb_streams;
1959 j += is->nb_streams;
1963 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1967 for(i=0;i<nb_istreams;i++) {
1968 ist = av_mallocz(sizeof(AVInputStream));
1974 for(i=0;i<nb_input_files;i++) {
1975 is = input_files[i];
1976 for(k=0;k<is->nb_streams;k++) {
1977 ist = ist_table[j++];
1978 ist->st = is->streams[k];
1979 ist->file_index = i;
1981 ist->discard = 1; /* the stream is discarded by default
1985 ist->start = av_gettime();
1990 /* output stream init */
1992 for(i=0;i<nb_output_files;i++) {
1993 os = output_files[i];
1994 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1995 dump_format(output_files[i], i, output_files[i]->filename, 1);
1996 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1997 ret = AVERROR(EINVAL);
2000 nb_ostreams += os->nb_streams;
2002 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2003 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2004 ret = AVERROR(EINVAL);
2008 /* Sanity check the mapping args -- do the input files & streams exist? */
2009 for(i=0;i<nb_stream_maps;i++) {
2010 int fi = stream_maps[i].file_index;
2011 int si = stream_maps[i].stream_index;
2013 if (fi < 0 || fi > nb_input_files - 1 ||
2014 si < 0 || si > file_table[fi].nb_streams - 1) {
2015 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2016 ret = AVERROR(EINVAL);
2019 fi = stream_maps[i].sync_file_index;
2020 si = stream_maps[i].sync_stream_index;
2021 if (fi < 0 || fi > nb_input_files - 1 ||
2022 si < 0 || si > file_table[fi].nb_streams - 1) {
2023 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2024 ret = AVERROR(EINVAL);
2029 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2033 for(k=0;k<nb_output_files;k++) {
2034 os = output_files[k];
2035 for(i=0;i<os->nb_streams;i++,n++) {
2037 ost = ost_table[n] = output_streams_for_file[k][i];
2038 ost->st = os->streams[i];
2039 if (nb_stream_maps > 0) {
2040 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2041 stream_maps[n].stream_index;
2043 /* Sanity check that the stream types match */
2044 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2045 int i= ost->file_index;
2046 dump_format(output_files[i], i, output_files[i]->filename, 1);
2047 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2048 stream_maps[n].file_index, stream_maps[n].stream_index,
2049 ost->file_index, ost->index);
2054 int best_nb_frames=-1;
2055 /* get corresponding input stream index : we select the first one with the right type */
2057 for(j=0;j<nb_istreams;j++) {
2062 AVFormatContext *f= input_files[ ist->file_index ];
2064 for(pi=0; pi<f->nb_programs; pi++){
2065 AVProgram *p= f->programs[pi];
2066 if(p->id == opt_programid)
2067 for(si=0; si<p->nb_stream_indexes; si++){
2068 if(f->streams[ p->stream_index[si] ] == ist->st)
2073 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2074 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2075 if(best_nb_frames < ist->st->codec_info_nb_frames){
2076 best_nb_frames= ist->st->codec_info_nb_frames;
2077 ost->source_index = j;
2084 if(! opt_programid) {
2085 /* try again and reuse existing stream */
2086 for(j=0;j<nb_istreams;j++) {
2088 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2089 && ist->st->discard != AVDISCARD_ALL) {
2090 ost->source_index = j;
2096 int i= ost->file_index;
2097 dump_format(output_files[i], i, output_files[i]->filename, 1);
2098 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2099 ost->file_index, ost->index);
2104 ist = ist_table[ost->source_index];
2106 ost->sync_ist = (nb_stream_maps > 0) ?
2107 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2108 stream_maps[n].sync_stream_index] : ist;
2112 /* for each output stream, we compute the right encoding parameters */
2113 for(i=0;i<nb_ostreams;i++) {
2115 os = output_files[ost->file_index];
2116 ist = ist_table[ost->source_index];
2118 codec = ost->st->codec;
2119 icodec = ist->st->codec;
2121 if (metadata_streams_autocopy)
2122 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2123 AV_METADATA_DONT_OVERWRITE);
2125 ost->st->disposition = ist->st->disposition;
2126 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2127 codec->chroma_sample_location = icodec->chroma_sample_location;
2129 if (ost->st->stream_copy) {
2130 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2132 if (extra_size > INT_MAX)
2135 /* if stream_copy is selected, no need to decode or encode */
2136 codec->codec_id = icodec->codec_id;
2137 codec->codec_type = icodec->codec_type;
2139 if(!codec->codec_tag){
2140 if( !os->oformat->codec_tag
2141 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2142 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2143 codec->codec_tag = icodec->codec_tag;
2146 codec->bit_rate = icodec->bit_rate;
2147 codec->rc_max_rate = icodec->rc_max_rate;
2148 codec->rc_buffer_size = icodec->rc_buffer_size;
2149 codec->extradata= av_mallocz(extra_size);
2150 if (!codec->extradata)
2152 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2153 codec->extradata_size= icodec->extradata_size;
2154 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){
2155 codec->time_base = icodec->time_base;
2156 codec->time_base.num *= icodec->ticks_per_frame;
2157 av_reduce(&codec->time_base.num, &codec->time_base.den,
2158 codec->time_base.num, codec->time_base.den, INT_MAX);
2160 codec->time_base = ist->st->time_base;
2161 switch(codec->codec_type) {
2162 case AVMEDIA_TYPE_AUDIO:
2163 if(audio_volume != 256) {
2164 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2167 codec->channel_layout = icodec->channel_layout;
2168 codec->sample_rate = icodec->sample_rate;
2169 codec->channels = icodec->channels;
2170 codec->frame_size = icodec->frame_size;
2171 codec->block_align= icodec->block_align;
2172 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2173 codec->block_align= 0;
2174 if(codec->codec_id == CODEC_ID_AC3)
2175 codec->block_align= 0;
2177 case AVMEDIA_TYPE_VIDEO:
2178 codec->pix_fmt = icodec->pix_fmt;
2179 codec->width = icodec->width;
2180 codec->height = icodec->height;
2181 codec->has_b_frames = icodec->has_b_frames;
2183 case AVMEDIA_TYPE_SUBTITLE:
2184 codec->width = icodec->width;
2185 codec->height = icodec->height;
2191 switch(codec->codec_type) {
2192 case AVMEDIA_TYPE_AUDIO:
2193 ost->fifo= av_fifo_alloc(1024);
2196 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2197 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2198 icodec->request_channels = codec->channels;
2199 ist->decoding_needed = 1;
2200 ost->encoding_needed = 1;
2201 ost->resample_sample_fmt = icodec->sample_fmt;
2202 ost->resample_sample_rate = icodec->sample_rate;
2203 ost->resample_channels = icodec->channels;
2205 case AVMEDIA_TYPE_VIDEO:
2206 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2207 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2210 ost->video_resample = (codec->width != icodec->width ||
2211 codec->height != icodec->height ||
2212 (codec->pix_fmt != icodec->pix_fmt));
2213 if (ost->video_resample) {
2214 #if !CONFIG_AVFILTER
2215 avcodec_get_frame_defaults(&ost->pict_tmp);
2216 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2217 codec->width, codec->height)) {
2218 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2221 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2222 ost->img_resample_ctx = sws_getContext(
2229 sws_flags, NULL, NULL, NULL);
2230 if (ost->img_resample_ctx == NULL) {
2231 fprintf(stderr, "Cannot get resampling context\n");
2235 ost->original_height = icodec->height;
2236 ost->original_width = icodec->width;
2238 codec->bits_per_raw_sample= 0;
2240 ost->resample_height = icodec->height;
2241 ost->resample_width = icodec->width;
2242 ost->resample_pix_fmt= icodec->pix_fmt;
2243 ost->encoding_needed = 1;
2244 ist->decoding_needed = 1;
2247 if (configure_filters(ist, ost)) {
2248 fprintf(stderr, "Error opening filters!\n");
2253 case AVMEDIA_TYPE_SUBTITLE:
2254 ost->encoding_needed = 1;
2255 ist->decoding_needed = 1;
2262 if (ost->encoding_needed &&
2263 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2264 char logfilename[1024];
2267 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2268 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2270 if (codec->flags & CODEC_FLAG_PASS1) {
2271 f = fopen(logfilename, "wb");
2273 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2279 size_t logbuffer_size;
2280 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2281 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2284 codec->stats_in = logbuffer;
2288 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2289 int size= codec->width * codec->height;
2290 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2295 bit_buffer = av_malloc(bit_buffer_size);
2297 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2299 ret = AVERROR(ENOMEM);
2303 /* open each encoder */
2304 for(i=0;i<nb_ostreams;i++) {
2306 if (ost->encoding_needed) {
2307 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2308 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2310 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2312 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2313 ost->st->codec->codec_id, ost->file_index, ost->index);
2314 ret = AVERROR(EINVAL);
2317 if (dec->subtitle_header) {
2318 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2319 if (!ost->st->codec->subtitle_header) {
2320 ret = AVERROR(ENOMEM);
2323 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2324 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2326 if (avcodec_open(ost->st->codec, codec) < 0) {
2327 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2328 ost->file_index, ost->index);
2329 ret = AVERROR(EINVAL);
2332 extra_size += ost->st->codec->extradata_size;
2336 /* open each decoder */
2337 for(i=0;i<nb_istreams;i++) {
2339 if (ist->decoding_needed) {
2340 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2342 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2344 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2345 ist->st->codec->codec_id, ist->file_index, ist->index);
2346 ret = AVERROR(EINVAL);
2349 if (avcodec_open(ist->st->codec, codec) < 0) {
2350 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2351 ist->file_index, ist->index);
2352 ret = AVERROR(EINVAL);
2355 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2356 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2361 for(i=0;i<nb_istreams;i++) {
2365 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2366 ist->next_pts = AV_NOPTS_VALUE;
2367 init_pts_correction(&ist->pts_ctx);
2371 /* set meta data information from input file if required */
2372 for (i=0;i<nb_meta_data_maps;i++) {
2373 AVFormatContext *files[2];
2374 AVMetadata **meta[2];
2377 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2378 if ((index) < 0 || (index) >= (nb_elems)) {\
2379 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2381 ret = AVERROR(EINVAL);\
2385 int out_file_index = meta_data_maps[i][0].file;
2386 int in_file_index = meta_data_maps[i][1].file;
2387 if (in_file_index < 0 || out_file_index < 0)
2389 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2390 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2392 files[0] = output_files[out_file_index];
2393 files[1] = input_files[in_file_index];
2395 for (j = 0; j < 2; j++) {
2396 AVMetaDataMap *map = &meta_data_maps[i][j];
2398 switch (map->type) {
2400 meta[j] = &files[j]->metadata;
2403 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2404 meta[j] = &files[j]->streams[map->index]->metadata;
2407 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2408 meta[j] = &files[j]->chapters[map->index]->metadata;
2411 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2412 meta[j] = &files[j]->programs[map->index]->metadata;
2417 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2420 /* copy global metadata by default */
2421 if (metadata_global_autocopy) {
2423 for (i = 0; i < nb_output_files; i++)
2424 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2425 AV_METADATA_DONT_OVERWRITE);
2428 /* copy chapters according to chapter maps */
2429 for (i = 0; i < nb_chapter_maps; i++) {
2430 int infile = chapter_maps[i].in_file;
2431 int outfile = chapter_maps[i].out_file;
2433 if (infile < 0 || outfile < 0)
2435 if (infile >= nb_input_files) {
2436 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2437 ret = AVERROR(EINVAL);
2440 if (outfile >= nb_output_files) {
2441 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2442 ret = AVERROR(EINVAL);
2445 copy_chapters(infile, outfile);
2448 /* copy chapters from the first input file that has them*/
2449 if (!nb_chapter_maps)
2450 for (i = 0; i < nb_input_files; i++) {
2451 if (!input_files[i]->nb_chapters)
2454 for (j = 0; j < nb_output_files; j++)
2455 if ((ret = copy_chapters(i, j)) < 0)
2460 /* open files and write file headers */
2461 for(i=0;i<nb_output_files;i++) {
2462 os = output_files[i];
2463 if (av_write_header(os) < 0) {
2464 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2465 ret = AVERROR(EINVAL);
2468 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2474 /* dump the file output parameters - cannot be done before in case
2476 for(i=0;i<nb_output_files;i++) {
2477 dump_format(output_files[i], i, output_files[i]->filename, 1);
2480 /* dump the stream mapping */
2482 fprintf(stderr, "Stream mapping:\n");
2483 for(i=0;i<nb_ostreams;i++) {
2485 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2486 ist_table[ost->source_index]->file_index,
2487 ist_table[ost->source_index]->index,
2490 if (ost->sync_ist != ist_table[ost->source_index])
2491 fprintf(stderr, " [sync #%d.%d]",
2492 ost->sync_ist->file_index,
2493 ost->sync_ist->index);
2494 fprintf(stderr, "\n");
2499 fprintf(stderr, "%s\n", error);
2504 print_sdp(output_files, nb_output_files);
2507 if (!using_stdin && verbose >= 0) {
2508 fprintf(stderr, "Press [q] to stop encoding\n");
2509 url_set_interrupt_cb(decode_interrupt_cb);
2513 timer_start = av_gettime();
2515 for(; received_sigterm == 0;) {
2516 int file_index, ist_index;
2524 /* if 'q' pressed, exits */
2528 /* read_key() returns 0 on EOF */
2534 /* select the stream that we must read now by looking at the
2535 smallest output pts */
2537 for(i=0;i<nb_ostreams;i++) {
2540 os = output_files[ost->file_index];
2541 ist = ist_table[ost->source_index];
2542 if(ist->is_past_recording_time || no_packet[ist->file_index])
2544 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2545 ipts = (double)ist->pts;
2546 if (!file_table[ist->file_index].eof_reached){
2547 if(ipts < ipts_min) {
2549 if(input_sync ) file_index = ist->file_index;
2551 if(opts < opts_min) {
2553 if(!input_sync) file_index = ist->file_index;
2556 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2561 /* if none, if is finished */
2562 if (file_index < 0) {
2563 if(no_packet_count){
2565 memset(no_packet, 0, sizeof(no_packet));
2572 /* finish if limit size exhausted */
2573 if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2576 /* read a frame from it and output it in the fifo */
2577 is = input_files[file_index];
2578 ret= av_read_frame(is, &pkt);
2579 if(ret == AVERROR(EAGAIN)){
2580 no_packet[file_index]=1;
2585 file_table[file_index].eof_reached = 1;
2593 memset(no_packet, 0, sizeof(no_packet));
2596 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2598 /* the following test is needed in case new streams appear
2599 dynamically in stream : we ignore them */
2600 if (pkt.stream_index >= file_table[file_index].nb_streams)
2601 goto discard_packet;
2602 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2603 ist = ist_table[ist_index];
2605 goto discard_packet;
2607 if (pkt.dts != AV_NOPTS_VALUE)
2608 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2609 if (pkt.pts != AV_NOPTS_VALUE)
2610 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2612 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2613 && input_files_ts_scale[file_index][pkt.stream_index]){
2614 if(pkt.pts != AV_NOPTS_VALUE)
2615 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2616 if(pkt.dts != AV_NOPTS_VALUE)
2617 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2620 // 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);
2621 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2622 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2623 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2624 int64_t delta= pkt_dts - ist->next_pts;
2625 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2626 input_files_ts_offset[ist->file_index]-= delta;
2628 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2629 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2630 if(pkt.pts != AV_NOPTS_VALUE)
2631 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2635 /* finish if recording time exhausted */
2636 if (recording_time != INT64_MAX &&
2637 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2638 ist->is_past_recording_time = 1;
2639 goto discard_packet;
2642 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2643 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2646 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2647 ist->file_index, ist->index);
2650 av_free_packet(&pkt);
2655 av_free_packet(&pkt);
2657 /* dump report by using the output first video and audio streams */
2658 print_report(output_files, ost_table, nb_ostreams, 0);
2661 /* at the end of stream, we must flush the decoder buffers */
2662 for(i=0;i<nb_istreams;i++) {
2664 if (ist->decoding_needed) {
2665 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2671 /* write the trailer if needed and close file */
2672 for(i=0;i<nb_output_files;i++) {
2673 os = output_files[i];
2674 av_write_trailer(os);
2677 /* dump report by using the first video and audio streams */
2678 print_report(output_files, ost_table, nb_ostreams, 1);
2680 /* close each encoder */
2681 for(i=0;i<nb_ostreams;i++) {
2683 if (ost->encoding_needed) {
2684 av_freep(&ost->st->codec->stats_in);
2685 avcodec_close(ost->st->codec);
2689 /* close each decoder */
2690 for(i=0;i<nb_istreams;i++) {
2692 if (ist->decoding_needed) {
2693 avcodec_close(ist->st->codec);
2697 avfilter_graph_free(&graph);
2704 av_freep(&bit_buffer);
2705 av_free(file_table);
2708 for(i=0;i<nb_istreams;i++) {
2715 for(i=0;i<nb_ostreams;i++) {
2718 if (ost->st->stream_copy)
2719 av_freep(&ost->st->codec->extradata);
2721 fclose(ost->logfile);
2722 ost->logfile = NULL;
2724 av_fifo_free(ost->fifo); /* works even if fifo is not
2725 initialized but set to zero */
2726 av_freep(&ost->st->codec->subtitle_header);
2727 av_free(ost->pict_tmp.data[0]);
2728 av_free(ost->forced_kf_pts);
2729 if (ost->video_resample)
2730 sws_freeContext(ost->img_resample_ctx);
2732 audio_resample_close(ost->resample);
2733 if (ost->reformat_ctx)
2734 av_audio_convert_free(ost->reformat_ctx);
2743 static void opt_format(const char *arg)
2745 last_asked_format = arg;
2748 static void opt_video_rc_override_string(const char *arg)
2750 video_rc_override_string = arg;
2753 static int opt_me_threshold(const char *opt, const char *arg)
2755 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2759 static int opt_verbose(const char *opt, const char *arg)
2761 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2765 static int opt_frame_rate(const char *opt, const char *arg)
2767 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2768 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2774 static int opt_bitrate(const char *opt, const char *arg)
2776 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2778 opt_default(opt, arg);
2780 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2781 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2786 static int opt_frame_crop(const char *opt, const char *arg)
2788 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2789 return AVERROR(EINVAL);
2792 static void opt_frame_size(const char *arg)
2794 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2795 fprintf(stderr, "Incorrect frame size\n");
2800 static int opt_pad(const char *opt, const char *arg) {
2801 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2805 static void opt_frame_pix_fmt(const char *arg)
2807 if (strcmp(arg, "list")) {
2808 frame_pix_fmt = av_get_pix_fmt(arg);
2809 if (frame_pix_fmt == PIX_FMT_NONE) {
2810 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2819 static void opt_frame_aspect_ratio(const char *arg)
2826 p = strchr(arg, ':');
2828 x = strtol(arg, &end, 10);
2830 y = strtol(end+1, &end, 10);
2832 ar = (double)x / (double)y;
2834 ar = strtod(arg, NULL);
2837 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2840 frame_aspect_ratio = ar;
2842 x = vfilters ? strlen(vfilters) : 0;
2843 vfilters = av_realloc(vfilters, x+100);
2844 snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2847 static int opt_metadata(const char *opt, const char *arg)
2849 char *mid= strchr(arg, '=');
2852 fprintf(stderr, "Missing =\n");
2857 av_metadata_set2(&metadata, arg, mid, 0);
2862 static void opt_qscale(const char *arg)
2864 video_qscale = atof(arg);
2865 if (video_qscale <= 0 ||
2866 video_qscale > 255) {
2867 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2872 static void opt_top_field_first(const char *arg)
2874 top_field_first= atoi(arg);
2877 static int opt_thread_count(const char *opt, const char *arg)
2879 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2882 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2887 static void opt_audio_sample_fmt(const char *arg)
2889 if (strcmp(arg, "list")) {
2890 audio_sample_fmt = av_get_sample_fmt(arg);
2891 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2892 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2896 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2901 static int opt_audio_rate(const char *opt, const char *arg)
2903 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2907 static int opt_audio_channels(const char *opt, const char *arg)
2909 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2913 static void opt_video_channel(const char *arg)
2915 video_channel = strtol(arg, NULL, 0);
2918 static void opt_video_standard(const char *arg)
2920 video_standard = av_strdup(arg);
2923 static void opt_codec(int *pstream_copy, char **pcodec_name,
2924 int codec_type, const char *arg)
2926 av_freep(pcodec_name);
2927 if (!strcmp(arg, "copy")) {
2930 *pcodec_name = av_strdup(arg);
2934 static void opt_audio_codec(const char *arg)
2936 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2939 static void opt_video_codec(const char *arg)
2941 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2944 static void opt_subtitle_codec(const char *arg)
2946 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2949 static int opt_codec_tag(const char *opt, const char *arg)
2952 uint32_t *codec_tag;
2954 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2955 !strcmp(opt, "vtag") ? &video_codec_tag :
2956 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2960 *codec_tag = strtol(arg, &tail, 0);
2962 *codec_tag = AV_RL32(arg);
2967 static void opt_map(const char *arg)
2972 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2973 m = &stream_maps[nb_stream_maps-1];
2975 m->file_index = strtol(arg, &p, 0);
2979 m->stream_index = strtol(p, &p, 0);
2982 m->sync_file_index = strtol(p, &p, 0);
2985 m->sync_stream_index = strtol(p, &p, 0);
2987 m->sync_file_index = m->file_index;
2988 m->sync_stream_index = m->stream_index;
2992 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3003 *index = strtol(++arg, endptr, 0);
3006 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3013 static void opt_map_metadata(const char *arg)
3015 AVMetaDataMap *m, *m1;
3018 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3019 &nb_meta_data_maps, nb_meta_data_maps + 1);
3021 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3022 m->file = strtol(arg, &p, 0);
3023 parse_meta_type(p, &m->type, &m->index, &p);
3027 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3028 m1->file = strtol(p, &p, 0);
3029 parse_meta_type(p, &m1->type, &m1->index, &p);
3031 if (m->type == 'g' || m1->type == 'g')
3032 metadata_global_autocopy = 0;
3033 if (m->type == 's' || m1->type == 's')
3034 metadata_streams_autocopy = 0;
3035 if (m->type == 'c' || m1->type == 'c')
3036 metadata_chapters_autocopy = 0;
3039 static void opt_map_meta_data(const char *arg)
3041 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3042 "Use -map_metadata instead.\n");
3043 opt_map_metadata(arg);
3046 static void opt_map_chapters(const char *arg)
3051 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3052 nb_chapter_maps + 1);
3053 c = &chapter_maps[nb_chapter_maps - 1];
3054 c->out_file = strtol(arg, &p, 0);
3058 c->in_file = strtol(p, &p, 0);
3061 static void opt_input_ts_scale(const char *arg)
3063 unsigned int stream;
3067 stream = strtol(arg, &p, 0);
3070 scale= strtod(p, &p);
3072 if(stream >= MAX_STREAMS)
3075 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);
3076 input_files_ts_scale[nb_input_files][stream]= scale;
3079 static int opt_recording_time(const char *opt, const char *arg)
3081 recording_time = parse_time_or_die(opt, arg, 1);
3085 static int opt_start_time(const char *opt, const char *arg)
3087 start_time = parse_time_or_die(opt, arg, 1);
3091 static int opt_recording_timestamp(const char *opt, const char *arg)
3093 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3097 static int opt_input_ts_offset(const char *opt, const char *arg)
3099 input_ts_offset = parse_time_or_die(opt, arg, 1);
3103 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3105 const char *codec_string = encoder ? "encoder" : "decoder";
3109 return CODEC_ID_NONE;
3111 avcodec_find_encoder_by_name(name) :
3112 avcodec_find_decoder_by_name(name);
3114 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3117 if(codec->type != type) {
3118 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3121 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3122 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3123 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3124 "results.\nAdd '-strict experimental' if you want to use it.\n",
3125 codec_string, codec->name);
3127 avcodec_find_encoder(codec->id) :
3128 avcodec_find_decoder(codec->id);
3129 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3130 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3131 codec_string, codec->name);
3137 static void opt_input_file(const char *filename)
3139 AVFormatContext *ic;
3140 AVFormatParameters params, *ap = ¶ms;
3141 AVInputFormat *file_iformat = NULL;
3142 int err, i, ret, rfps, rfps_base;
3145 if (last_asked_format) {
3146 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3147 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3150 last_asked_format = NULL;
3153 if (!strcmp(filename, "-"))
3156 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3157 !strcmp(filename, "/dev/stdin");
3159 /* get default parameters from command line */
3160 ic = avformat_alloc_context();
3162 print_error(filename, AVERROR(ENOMEM));
3166 memset(ap, 0, sizeof(*ap));
3167 ap->prealloced_context = 1;
3168 ap->sample_rate = audio_sample_rate;
3169 ap->channels = audio_channels;
3170 ap->time_base.den = frame_rate.num;
3171 ap->time_base.num = frame_rate.den;
3172 ap->width = frame_width;
3173 ap->height = frame_height;
3174 ap->pix_fmt = frame_pix_fmt;
3175 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3176 ap->channel = video_channel;
3177 ap->standard = video_standard;
3179 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3181 ic->video_codec_id =
3182 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3183 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3184 ic->audio_codec_id =
3185 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3186 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3187 ic->subtitle_codec_id=
3188 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3189 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3190 ic->flags |= AVFMT_FLAG_NONBLOCK;
3192 /* open the input file with generic libav function */
3193 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3195 print_error(filename, err);
3201 for(i=0; i<ic->nb_streams; i++){
3202 ic->streams[i]->discard= AVDISCARD_ALL;
3204 for(i=0; i<ic->nb_programs; i++){
3205 AVProgram *p= ic->programs[i];
3206 if(p->id != opt_programid){
3207 p->discard = AVDISCARD_ALL;
3210 for(j=0; j<p->nb_stream_indexes; j++){
3211 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3216 fprintf(stderr, "Specified program id not found\n");
3222 ic->loop_input = loop_input;
3224 /* If not enough info to get the stream parameters, we decode the
3225 first frames to get it. (used in mpeg case for example) */
3226 ret = av_find_stream_info(ic);
3227 if (ret < 0 && verbose >= 0) {
3228 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3229 av_close_input_file(ic);
3233 timestamp = start_time;
3234 /* add the stream start time */
3235 if (ic->start_time != AV_NOPTS_VALUE)
3236 timestamp += ic->start_time;
3238 /* if seeking requested, we execute it */
3239 if (start_time != 0) {
3240 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3242 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3243 filename, (double)timestamp / AV_TIME_BASE);
3245 /* reset seek info */
3249 /* update the current parameters so that they match the one of the input stream */
3250 for(i=0;i<ic->nb_streams;i++) {
3251 AVStream *st = ic->streams[i];
3252 AVCodecContext *dec = st->codec;
3253 avcodec_thread_init(dec, thread_count);
3254 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3255 switch (dec->codec_type) {
3256 case AVMEDIA_TYPE_AUDIO:
3257 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3258 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]);
3259 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3260 channel_layout = dec->channel_layout;
3261 audio_channels = dec->channels;
3262 audio_sample_rate = dec->sample_rate;
3263 audio_sample_fmt = dec->sample_fmt;
3265 st->discard= AVDISCARD_ALL;
3266 /* Note that av_find_stream_info can add more streams, and we
3267 * currently have no chance of setting up lowres decoding
3268 * early enough for them. */
3270 audio_sample_rate >>= dec->lowres;
3272 case AVMEDIA_TYPE_VIDEO:
3273 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3274 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]);
3275 frame_height = dec->height;
3276 frame_width = dec->width;
3277 if(ic->streams[i]->sample_aspect_ratio.num)
3278 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3280 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3281 frame_aspect_ratio *= (float) dec->width / dec->height;
3282 frame_pix_fmt = dec->pix_fmt;
3283 rfps = ic->streams[i]->r_frame_rate.num;
3284 rfps_base = ic->streams[i]->r_frame_rate.den;
3286 dec->flags |= CODEC_FLAG_EMU_EDGE;
3287 frame_height >>= dec->lowres;
3288 frame_width >>= dec->lowres;
3289 dec->height = frame_height;
3290 dec->width = frame_width;
3293 dec->debug |= FF_DEBUG_MV;
3295 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3298 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3299 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3301 (float)rfps / rfps_base, rfps, rfps_base);
3303 /* update the current frame rate to match the stream frame rate */
3304 frame_rate.num = rfps;
3305 frame_rate.den = rfps_base;
3308 st->discard= AVDISCARD_ALL;
3309 else if(video_discard)
3310 st->discard= video_discard;
3312 case AVMEDIA_TYPE_DATA:
3314 case AVMEDIA_TYPE_SUBTITLE:
3315 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3316 if(subtitle_disable)
3317 st->discard = AVDISCARD_ALL;
3319 case AVMEDIA_TYPE_ATTACHMENT:
3320 case AVMEDIA_TYPE_UNKNOWN:
3327 input_files[nb_input_files] = ic;
3328 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3329 /* dump the file content */
3331 dump_format(ic, nb_input_files, filename, 0);
3337 av_freep(&video_codec_name);
3338 av_freep(&audio_codec_name);
3339 av_freep(&subtitle_codec_name);
3342 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3343 int *has_subtitle_ptr)
3345 int has_video, has_audio, has_subtitle, i, j;
3346 AVFormatContext *ic;
3351 for(j=0;j<nb_input_files;j++) {
3352 ic = input_files[j];
3353 for(i=0;i<ic->nb_streams;i++) {
3354 AVCodecContext *enc = ic->streams[i]->codec;
3355 switch(enc->codec_type) {
3356 case AVMEDIA_TYPE_AUDIO:
3359 case AVMEDIA_TYPE_VIDEO:
3362 case AVMEDIA_TYPE_SUBTITLE:
3365 case AVMEDIA_TYPE_DATA:
3366 case AVMEDIA_TYPE_ATTACHMENT:
3367 case AVMEDIA_TYPE_UNKNOWN:
3374 *has_video_ptr = has_video;
3375 *has_audio_ptr = has_audio;
3376 *has_subtitle_ptr = has_subtitle;
3379 static void new_video_stream(AVFormatContext *oc, int file_idx)
3382 AVOutputStream *ost;
3383 AVCodecContext *video_enc;
3384 enum CodecID codec_id = CODEC_ID_NONE;
3385 AVCodec *codec= NULL;
3387 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3389 fprintf(stderr, "Could not alloc stream\n");
3392 ost = new_output_stream(oc, file_idx);
3394 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3395 if(!video_stream_copy){
3396 if (video_codec_name) {
3397 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3398 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3399 codec = avcodec_find_encoder_by_name(video_codec_name);
3400 output_codecs[nb_output_codecs-1] = codec;
3402 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3403 codec = avcodec_find_encoder(codec_id);
3407 avcodec_get_context_defaults3(st->codec, codec);
3408 ost->bitstream_filters = video_bitstream_filters;
3409 video_bitstream_filters= NULL;
3411 avcodec_thread_init(st->codec, thread_count);
3413 video_enc = st->codec;
3416 video_enc->codec_tag= video_codec_tag;
3418 if( (video_global_header&1)
3419 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3420 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3421 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3423 if(video_global_header&2){
3424 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3425 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3428 if (video_stream_copy) {
3429 st->stream_copy = 1;
3430 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3431 video_enc->sample_aspect_ratio =
3432 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3436 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3438 video_enc->codec_id = codec_id;
3439 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3441 if (codec && codec->supported_framerates && !force_fps)
3442 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3443 video_enc->time_base.den = fps.num;
3444 video_enc->time_base.num = fps.den;
3446 video_enc->width = frame_width;
3447 video_enc->height = frame_height;
3448 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3449 video_enc->pix_fmt = frame_pix_fmt;
3450 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3452 choose_pixel_fmt(st, codec);
3455 video_enc->gop_size = 0;
3456 if (video_qscale || same_quality) {
3457 video_enc->flags |= CODEC_FLAG_QSCALE;
3458 video_enc->global_quality=
3459 st->quality = FF_QP2LAMBDA * video_qscale;
3463 video_enc->intra_matrix = intra_matrix;
3465 video_enc->inter_matrix = inter_matrix;
3467 p= video_rc_override_string;
3470 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3472 fprintf(stderr, "error parsing rc_override\n");
3475 video_enc->rc_override=
3476 av_realloc(video_enc->rc_override,
3477 sizeof(RcOverride)*(i+1));
3478 video_enc->rc_override[i].start_frame= start;
3479 video_enc->rc_override[i].end_frame = end;
3481 video_enc->rc_override[i].qscale= q;
3482 video_enc->rc_override[i].quality_factor= 1.0;
3485 video_enc->rc_override[i].qscale= 0;
3486 video_enc->rc_override[i].quality_factor= -q/100.0;
3491 video_enc->rc_override_count=i;
3492 if (!video_enc->rc_initial_buffer_occupancy)
3493 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3494 video_enc->me_threshold= me_threshold;
3495 video_enc->intra_dc_precision= intra_dc_precision - 8;
3498 video_enc->flags|= CODEC_FLAG_PSNR;
3503 video_enc->flags |= CODEC_FLAG_PASS1;
3505 video_enc->flags |= CODEC_FLAG_PASS2;
3509 if (forced_key_frames)
3510 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3512 if (video_language) {
3513 av_metadata_set2(&st->metadata, "language", video_language, 0);
3514 av_freep(&video_language);
3517 /* reset some key parameters */
3519 av_freep(&video_codec_name);
3520 av_freep(&forced_key_frames);
3521 video_stream_copy = 0;
3522 frame_pix_fmt = PIX_FMT_NONE;
3525 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3528 AVOutputStream *ost;
3529 AVCodec *codec= NULL;
3530 AVCodecContext *audio_enc;
3531 enum CodecID codec_id = CODEC_ID_NONE;
3533 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3535 fprintf(stderr, "Could not alloc stream\n");
3538 ost = new_output_stream(oc, file_idx);
3540 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3541 if(!audio_stream_copy){
3542 if (audio_codec_name) {
3543 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3544 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3545 codec = avcodec_find_encoder_by_name(audio_codec_name);
3546 output_codecs[nb_output_codecs-1] = codec;
3548 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3549 codec = avcodec_find_encoder(codec_id);
3553 avcodec_get_context_defaults3(st->codec, codec);
3555 ost->bitstream_filters = audio_bitstream_filters;
3556 audio_bitstream_filters= NULL;
3558 avcodec_thread_init(st->codec, thread_count);
3560 audio_enc = st->codec;
3561 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3564 audio_enc->codec_tag= audio_codec_tag;
3566 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3567 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3568 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3570 if (audio_stream_copy) {
3571 st->stream_copy = 1;
3572 audio_enc->channels = audio_channels;
3573 audio_enc->sample_rate = audio_sample_rate;
3575 audio_enc->codec_id = codec_id;
3576 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3578 if (audio_qscale > QSCALE_NONE) {
3579 audio_enc->flags |= CODEC_FLAG_QSCALE;
3580 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3582 audio_enc->channels = audio_channels;
3583 audio_enc->sample_fmt = audio_sample_fmt;
3584 audio_enc->sample_rate = audio_sample_rate;
3585 audio_enc->channel_layout = channel_layout;
3586 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3587 audio_enc->channel_layout = 0;
3588 choose_sample_fmt(st, codec);
3589 choose_sample_rate(st, codec);
3591 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3592 if (audio_language) {
3593 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3594 av_freep(&audio_language);
3597 /* reset some key parameters */
3599 av_freep(&audio_codec_name);
3600 audio_stream_copy = 0;
3603 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3606 AVOutputStream *ost;
3607 AVCodec *codec=NULL;
3608 AVCodecContext *subtitle_enc;
3609 enum CodecID codec_id = CODEC_ID_NONE;
3611 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3613 fprintf(stderr, "Could not alloc stream\n");
3616 ost = new_output_stream(oc, file_idx);
3617 subtitle_enc = st->codec;
3618 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3619 if(!subtitle_stream_copy){
3620 if (subtitle_codec_name) {
3621 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3622 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3623 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3625 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3626 codec = avcodec_find_encoder(codec_id);
3629 avcodec_get_context_defaults3(st->codec, codec);
3631 ost->bitstream_filters = subtitle_bitstream_filters;
3632 subtitle_bitstream_filters= NULL;
3634 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3636 if(subtitle_codec_tag)
3637 subtitle_enc->codec_tag= subtitle_codec_tag;
3639 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3640 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3641 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3643 if (subtitle_stream_copy) {
3644 st->stream_copy = 1;
3646 subtitle_enc->codec_id = codec_id;
3647 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3650 if (subtitle_language) {
3651 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3652 av_freep(&subtitle_language);
3655 subtitle_disable = 0;
3656 av_freep(&subtitle_codec_name);
3657 subtitle_stream_copy = 0;
3660 static int opt_new_stream(const char *opt, const char *arg)
3662 AVFormatContext *oc;
3663 int file_idx = nb_output_files - 1;
3664 if (nb_output_files <= 0) {
3665 fprintf(stderr, "At least one output file must be specified\n");
3668 oc = output_files[file_idx];
3670 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3671 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3672 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3677 /* arg format is "output-stream-index:streamid-value". */
3678 static int opt_streamid(const char *opt, const char *arg)
3684 strncpy(idx_str, arg, sizeof(idx_str));
3685 idx_str[sizeof(idx_str)-1] = '\0';
3686 p = strchr(idx_str, ':');
3689 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3694 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3695 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3696 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3700 static void opt_output_file(const char *filename)
3702 AVFormatContext *oc;
3703 int err, use_video, use_audio, use_subtitle;
3704 int input_has_video, input_has_audio, input_has_subtitle;
3705 AVFormatParameters params, *ap = ¶ms;
3706 AVOutputFormat *file_oformat;
3708 if (!strcmp(filename, "-"))
3711 oc = avformat_alloc_context();
3713 print_error(filename, AVERROR(ENOMEM));
3717 if (last_asked_format) {
3718 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3719 if (!file_oformat) {
3720 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3723 last_asked_format = NULL;
3725 file_oformat = av_guess_format(NULL, filename, NULL);
3726 if (!file_oformat) {
3727 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3733 oc->oformat = file_oformat;
3734 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3736 if (!strcmp(file_oformat->name, "ffm") &&
3737 av_strstart(filename, "http:", NULL)) {
3738 /* special case for files sent to ffserver: we get the stream
3739 parameters from ffserver */
3740 int err = read_ffserver_streams(oc, filename);
3742 print_error(filename, err);
3746 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3747 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3748 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3750 /* disable if no corresponding type found and at least one
3752 if (nb_input_files > 0) {
3753 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3754 &input_has_subtitle);
3755 if (!input_has_video)
3757 if (!input_has_audio)
3759 if (!input_has_subtitle)
3763 /* manual disable */
3764 if (audio_disable) use_audio = 0;
3765 if (video_disable) use_video = 0;
3766 if (subtitle_disable) use_subtitle = 0;
3768 if (use_video) new_video_stream(oc, nb_output_files);
3769 if (use_audio) new_audio_stream(oc, nb_output_files);
3770 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3772 oc->timestamp = recording_timestamp;
3774 av_metadata_copy(&oc->metadata, metadata, 0);
3775 av_metadata_free(&metadata);
3778 output_files[nb_output_files++] = oc;
3780 /* check filename in case of an image number is expected */
3781 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3782 if (!av_filename_number_test(oc->filename)) {
3783 print_error(oc->filename, AVERROR_NUMEXPECTED);
3788 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3789 /* test if it already exists to avoid loosing precious files */
3790 if (!file_overwrite &&
3791 (strchr(filename, ':') == NULL ||
3792 filename[1] == ':' ||
3793 av_strstart(filename, "file:", NULL))) {
3794 if (url_exist(filename)) {
3796 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3798 if (!read_yesno()) {
3799 fprintf(stderr, "Not overwriting - exiting\n");
3804 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3811 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3812 print_error(filename, err);
3817 memset(ap, 0, sizeof(*ap));
3818 if (av_set_parameters(oc, ap) < 0) {
3819 fprintf(stderr, "%s: Invalid encoding parameters\n",
3824 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3825 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3826 oc->loop_output = loop_output;
3827 oc->flags |= AVFMT_FLAG_NONBLOCK;
3829 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3831 av_freep(&forced_key_frames);
3834 /* same option as mencoder */
3835 static void opt_pass(const char *pass_str)
3838 pass = atoi(pass_str);
3839 if (pass != 1 && pass != 2) {
3840 fprintf(stderr, "pass number can be only 1 or 2\n");
3846 static int64_t getutime(void)
3849 struct rusage rusage;
3851 getrusage(RUSAGE_SELF, &rusage);
3852 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3853 #elif HAVE_GETPROCESSTIMES
3855 FILETIME c, e, k, u;
3856 proc = GetCurrentProcess();
3857 GetProcessTimes(proc, &c, &e, &k, &u);
3858 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3860 return av_gettime();
3864 static int64_t getmaxrss(void)
3866 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3867 struct rusage rusage;
3868 getrusage(RUSAGE_SELF, &rusage);
3869 return (int64_t)rusage.ru_maxrss * 1024;
3870 #elif HAVE_GETPROCESSMEMORYINFO
3872 PROCESS_MEMORY_COUNTERS memcounters;
3873 proc = GetCurrentProcess();
3874 memcounters.cb = sizeof(memcounters);
3875 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3876 return memcounters.PeakPagefileUsage;
3882 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3885 const char *p = str;
3892 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3899 static void opt_inter_matrix(const char *arg)
3901 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3902 parse_matrix_coeffs(inter_matrix, arg);
3905 static void opt_intra_matrix(const char *arg)
3907 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3908 parse_matrix_coeffs(intra_matrix, arg);
3911 static void show_usage(void)
3913 printf("Hyper fast Audio and Video encoder\n");
3914 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3918 static void show_help(void)
3921 AVOutputFormat *oformat = NULL;
3923 av_log_set_callback(log_callback_help);
3925 show_help_options(options, "Main options:\n",
3926 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3927 show_help_options(options, "\nAdvanced options:\n",
3928 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3930 show_help_options(options, "\nVideo options:\n",
3931 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3933 show_help_options(options, "\nAdvanced Video options:\n",
3934 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3935 OPT_VIDEO | OPT_EXPERT);
3936 show_help_options(options, "\nAudio options:\n",
3937 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3939 show_help_options(options, "\nAdvanced Audio options:\n",
3940 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3941 OPT_AUDIO | OPT_EXPERT);
3942 show_help_options(options, "\nSubtitle options:\n",
3943 OPT_SUBTITLE | OPT_GRAB,
3945 show_help_options(options, "\nAudio/Video grab options:\n",
3949 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3952 /* individual codec options */
3954 while ((c = av_codec_next(c))) {
3955 if (c->priv_class) {
3956 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3961 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3964 /* individual muxer options */
3965 while ((oformat = av_oformat_next(oformat))) {
3966 if (oformat->priv_class) {
3967 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3972 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3975 static void opt_target(const char *arg)
3977 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3978 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3980 if(!strncmp(arg, "pal-", 4)) {
3983 } else if(!strncmp(arg, "ntsc-", 5)) {
3986 } else if(!strncmp(arg, "film-", 5)) {
3991 /* Calculate FR via float to avoid int overflow */
3992 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3995 } else if((fr == 29970) || (fr == 23976)) {
3998 /* Try to determine PAL/NTSC by peeking in the input files */
3999 if(nb_input_files) {
4001 for(j = 0; j < nb_input_files; j++) {
4002 for(i = 0; i < input_files[j]->nb_streams; i++) {
4003 AVCodecContext *c = input_files[j]->streams[i]->codec;
4004 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4006 fr = c->time_base.den * 1000 / c->time_base.num;
4010 } else if((fr == 29970) || (fr == 23976)) {
4020 if(verbose && norm != UNKNOWN)
4021 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4024 if(norm == UNKNOWN) {
4025 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4026 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4027 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4031 if(!strcmp(arg, "vcd")) {
4033 opt_video_codec("mpeg1video");
4034 opt_audio_codec("mp2");
4037 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4038 opt_frame_rate(NULL, frame_rates[norm]);
4039 opt_default("g", norm == PAL ? "15" : "18");
4041 opt_default("b", "1150000");
4042 opt_default("maxrate", "1150000");
4043 opt_default("minrate", "1150000");
4044 opt_default("bufsize", "327680"); // 40*1024*8;
4046 opt_default("ab", "224000");
4047 audio_sample_rate = 44100;
4050 opt_default("packetsize", "2324");
4051 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4053 /* We have to offset the PTS, so that it is consistent with the SCR.
4054 SCR starts at 36000, but the first two packs contain only padding
4055 and the first pack from the other stream, respectively, may also have
4056 been written before.
4057 So the real data starts at SCR 36000+3*1200. */
4058 mux_preload= (36000+3*1200) / 90000.0; //0.44
4059 } else if(!strcmp(arg, "svcd")) {
4061 opt_video_codec("mpeg2video");
4062 opt_audio_codec("mp2");
4065 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4066 opt_frame_rate(NULL, frame_rates[norm]);
4067 opt_default("g", norm == PAL ? "15" : "18");
4069 opt_default("b", "2040000");
4070 opt_default("maxrate", "2516000");
4071 opt_default("minrate", "0"); //1145000;
4072 opt_default("bufsize", "1835008"); //224*1024*8;
4073 opt_default("flags", "+scan_offset");
4076 opt_default("ab", "224000");
4077 audio_sample_rate = 44100;
4079 opt_default("packetsize", "2324");
4081 } else if(!strcmp(arg, "dvd")) {
4083 opt_video_codec("mpeg2video");
4084 opt_audio_codec("ac3");
4087 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4088 opt_frame_rate(NULL, frame_rates[norm]);
4089 opt_default("g", norm == PAL ? "15" : "18");
4091 opt_default("b", "6000000");
4092 opt_default("maxrate", "9000000");
4093 opt_default("minrate", "0"); //1500000;
4094 opt_default("bufsize", "1835008"); //224*1024*8;
4096 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4097 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4099 opt_default("ab", "448000");
4100 audio_sample_rate = 48000;
4102 } else if(!strncmp(arg, "dv", 2)) {
4106 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4107 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4108 (norm == PAL ? "yuv420p" : "yuv411p"));
4109 opt_frame_rate(NULL, frame_rates[norm]);
4111 audio_sample_rate = 48000;
4115 fprintf(stderr, "Unknown target: %s\n", arg);
4120 static void opt_vstats_file (const char *arg)
4122 av_free (vstats_filename);
4123 vstats_filename=av_strdup (arg);
4126 static void opt_vstats (void)
4129 time_t today2 = time(NULL);
4130 struct tm *today = localtime(&today2);
4132 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4134 opt_vstats_file(filename);
4137 static int opt_bsf(const char *opt, const char *arg)
4139 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4140 AVBitStreamFilterContext **bsfp;
4143 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4147 bsfp= *opt == 'v' ? &video_bitstream_filters :
4148 *opt == 'a' ? &audio_bitstream_filters :
4149 &subtitle_bitstream_filters;
4151 bsfp= &(*bsfp)->next;
4158 static int opt_preset(const char *opt, const char *arg)
4161 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4162 char *codec_name = *opt == 'v' ? video_codec_name :
4163 *opt == 'a' ? audio_codec_name :
4164 subtitle_codec_name;
4166 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4167 fprintf(stderr, "File for preset '%s' not found\n", arg);
4172 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4173 if(line[0] == '#' && !e)
4175 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4177 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4180 if(!strcmp(tmp, "acodec")){
4181 opt_audio_codec(tmp2);
4182 }else if(!strcmp(tmp, "vcodec")){
4183 opt_video_codec(tmp2);
4184 }else if(!strcmp(tmp, "scodec")){
4185 opt_subtitle_codec(tmp2);
4186 }else if(opt_default(tmp, tmp2) < 0){
4187 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4197 static const OptionDef options[] = {
4199 #include "cmdutils_common_opts.h"
4200 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4201 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4202 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4203 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4204 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4205 "outfile[,metadata]:infile[,metadata]" },
4206 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4207 "outfile[,metadata]:infile[,metadata]" },
4208 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4209 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4210 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4211 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4212 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4213 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4214 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4215 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4216 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4217 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4218 "add timings for benchmarking" },
4219 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4220 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4221 "dump each input packet" },
4222 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4223 "when dumping packets, also dump the payload" },
4224 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4225 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4226 { "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)", "" },
4227 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4228 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4229 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4230 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4231 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4232 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4233 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4234 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4235 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4236 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4237 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4238 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4239 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4240 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4243 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4244 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4245 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4246 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4247 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4248 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4249 { "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" },
4250 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4251 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4252 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4253 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4254 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4255 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4256 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4257 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4258 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4259 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4260 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4261 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4262 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4263 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4264 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4265 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4266 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4267 "use same video quality as source (implies VBR)" },
4268 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4269 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4270 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4271 "deinterlace pictures" },
4272 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4273 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4274 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4276 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4278 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4279 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4280 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4281 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4282 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4283 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4284 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4285 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4286 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4287 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4288 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4291 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4292 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4293 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4294 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4295 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4296 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4297 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4298 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4299 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4300 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4301 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4302 { "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" },
4304 /* subtitle options */
4305 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4306 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4307 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4308 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4309 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4312 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4313 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4314 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4317 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4318 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4320 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4321 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4322 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4324 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4325 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4326 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4327 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4329 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4333 int main(int argc, char **argv)
4337 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4339 avcodec_register_all();
4341 avdevice_register_all();
4344 avfilter_register_all();
4349 if(isatty(STDIN_FILENO))
4350 url_set_interrupt_cb(decode_interrupt_cb);
4358 parse_options(argc, argv, options, opt_output_file);
4360 if(nb_output_files <= 0 && nb_input_files == 0) {
4362 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4366 /* file converter / grab */
4367 if (nb_output_files <= 0) {
4368 fprintf(stderr, "At least one output file must be specified\n");
4372 if (nb_input_files == 0) {
4373 fprintf(stderr, "At least one input file must be specified\n");
4378 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4379 stream_maps, nb_stream_maps) < 0)
4381 ti = getutime() - ti;
4383 int maxrss = getmaxrss() / 1024;
4384 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4387 return ffmpeg_exit(0);