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 "libavutil/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavutil/audioconvert.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/libm.h"
48 #include "libavformat/os_support.h"
50 #include "libavformat/ffm.h" // not public API
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/vsrc_buffer.h"
58 #if HAVE_SYS_RESOURCE_H
59 #include <sys/types.h>
61 #include <sys/resource.h>
62 #elif HAVE_GETPROCESSTIMES
65 #if HAVE_GETPROCESSMEMORYINFO
71 #include <sys/select.h>
76 #include <sys/ioctl.h>
86 #include "libavutil/avassert.h"
88 const char program_name[] = "ffmpeg";
89 const int program_birth_year = 2000;
91 /* select an input stream for an output stream */
92 typedef struct AVStreamMap {
96 int sync_stream_index;
100 * select an input file for an output file
102 typedef struct AVMetaDataMap {
103 int file; //< file index
104 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
105 int index; //< stream/chapter/program number
108 typedef struct AVChapterMap {
113 static const OptionDef options[];
115 #define MAX_FILES 100
116 #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 int frame_bits_per_raw_sample = 0;
154 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
155 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
156 static AVRational frame_rate;
157 static float video_qscale = 0;
158 static uint16_t *intra_matrix = NULL;
159 static uint16_t *inter_matrix = NULL;
160 static const char *video_rc_override_string=NULL;
161 static int video_disable = 0;
162 static int video_discard = 0;
163 static char *video_codec_name = NULL;
164 static unsigned int video_codec_tag = 0;
165 static char *video_language = NULL;
166 static int same_quality = 0;
167 static int do_deinterlace = 0;
168 static int top_field_first = -1;
169 static int me_threshold = 0;
170 static int intra_dc_precision = 8;
171 static int loop_input = 0;
172 static int loop_output = AVFMT_NOOUTPUTLOOP;
173 static int qp_hist = 0;
175 static char *vfilters = NULL;
177 static unsigned int sws_flags = SWS_BICUBIC;
180 static int intra_only = 0;
181 static int audio_sample_rate = 44100;
182 static int64_t channel_layout = 0;
183 #define QSCALE_NONE -99999
184 static float audio_qscale = QSCALE_NONE;
185 static int audio_disable = 0;
186 static int audio_channels = 1;
187 static char *audio_codec_name = NULL;
188 static unsigned int audio_codec_tag = 0;
189 static char *audio_language = NULL;
191 static int subtitle_disable = 0;
192 static char *subtitle_codec_name = NULL;
193 static char *subtitle_language = NULL;
194 static unsigned int subtitle_codec_tag = 0;
196 static float mux_preload= 0.5;
197 static float mux_max_delay= 0.7;
199 static int64_t recording_time = INT64_MAX;
200 static int64_t start_time = 0;
201 static int64_t recording_timestamp = 0;
202 static int64_t input_ts_offset = 0;
203 static int file_overwrite = 0;
204 static AVMetadata *metadata;
205 static int do_benchmark = 0;
206 static int do_hex_dump = 0;
207 static int do_pkt_dump = 0;
208 static int do_psnr = 0;
209 static int do_pass = 0;
210 static const char *pass_logfilename_prefix;
211 static int audio_stream_copy = 0;
212 static int video_stream_copy = 0;
213 static int subtitle_stream_copy = 0;
214 static int video_sync_method= -1;
215 static int audio_sync_method= 0;
216 static float audio_drift_threshold= 0.1;
217 static int copy_ts= 0;
219 static int opt_shortest = 0;
220 static int video_global_header = 0;
221 static char *vstats_filename;
222 static FILE *vstats_file;
223 static int opt_programid = 0;
224 static int copy_initial_nonkeyframes = 0;
226 static int rate_emu = 0;
228 static int video_channel = 0;
229 static char *video_standard;
231 static int audio_volume = 256;
233 static int exit_on_error = 0;
234 static int using_stdin = 0;
235 static int verbose = 1;
236 static int run_as_daemon = 0;
237 static int thread_count= 1;
238 static int q_pressed = 0;
239 static int64_t video_size = 0;
240 static int64_t audio_size = 0;
241 static int64_t extra_size = 0;
242 static int nb_frames_dup = 0;
243 static int nb_frames_drop = 0;
244 static int input_sync;
245 static uint64_t limit_filesize = 0;
246 static int force_fps = 0;
247 static char *forced_key_frames = NULL;
249 static float dts_delta_threshold = 10;
251 static int64_t timer_start;
253 static uint8_t *audio_buf;
254 static uint8_t *audio_out;
255 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
257 static short *samples;
259 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
260 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
261 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
263 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
265 struct AVInputStream;
267 typedef struct AVOutputStream {
268 int file_index; /* file index */
269 int index; /* stream index in the output file */
270 int source_index; /* AVInputStream index */
271 AVStream *st; /* stream in the output file */
272 int encoding_needed; /* true if encoding needed for this stream */
274 /* input pts and corresponding output pts
276 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
277 struct AVInputStream *sync_ist; /* input stream to sync against */
278 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
279 AVBitStreamFilterContext *bitstream_filters;
282 AVFrame pict_tmp; /* temporary image for resampling */
283 struct SwsContext *img_resample_ctx; /* for image resampling */
286 int resample_pix_fmt;
288 float frame_aspect_ratio;
290 /* forced key frames */
291 int64_t *forced_kf_pts;
297 ReSampleContext *resample; /* for audio resampling */
298 int resample_sample_fmt;
299 int resample_channels;
300 int resample_sample_rate;
302 AVAudioConvert *reformat_ctx;
303 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
307 AVFilterContext *output_video_filter;
308 AVFilterContext *input_video_filter;
309 AVFilterBufferRef *picref;
311 AVFilterGraph *graph;
315 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
316 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
318 typedef struct AVInputStream {
322 int discard; /* true if stream data should be discarded */
323 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
324 int64_t sample_index; /* current sample */
326 int64_t start; /* time when read started */
327 int64_t next_pts; /* synthetic pts for cases where pkt.pts
329 int64_t pts; /* current pts */
330 int is_start; /* is 1 at the start and after a discontinuity */
331 int showed_multi_packet_warning;
332 int is_past_recording_time;
334 AVFrame *filter_frame;
335 int has_filter_frame;
339 typedef struct AVInputFile {
340 int eof_reached; /* true if eof reached */
341 int ist_index; /* index of first stream in ist_table */
342 int buffer_size; /* current total buffer size */
343 int nb_streams; /* nb streams we are aware of */
348 /* init terminal so that we can grab keys */
349 static struct termios oldtty;
354 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
356 AVFilterContext *last_filter, *filter;
357 /** filter graph containing all filters including input & output */
358 AVCodecContext *codec = ost->st->codec;
359 AVCodecContext *icodec = ist->st->codec;
360 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
361 AVRational sample_aspect_ratio;
365 ost->graph = avfilter_graph_alloc();
367 if (ist->st->sample_aspect_ratio.num){
368 sample_aspect_ratio = ist->st->sample_aspect_ratio;
370 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
372 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
373 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
374 sample_aspect_ratio.num, sample_aspect_ratio.den);
376 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
377 "src", args, NULL, ost->graph);
380 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
381 "out", NULL, &ffsink_ctx, ost->graph);
384 last_filter = ost->input_video_filter;
386 if (codec->width != icodec->width || codec->height != icodec->height) {
387 snprintf(args, 255, "%d:%d:flags=0x%X",
390 (int)av_get_int(sws_opts, "sws_flags", NULL));
391 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
392 NULL, args, NULL, ost->graph)) < 0)
394 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
396 last_filter = filter;
399 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
400 ost->graph->scale_sws_opts = av_strdup(args);
403 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
404 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
406 outputs->name = av_strdup("in");
407 outputs->filter_ctx = last_filter;
408 outputs->pad_idx = 0;
409 outputs->next = NULL;
411 inputs->name = av_strdup("out");
412 inputs->filter_ctx = ost->output_video_filter;
416 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
418 av_freep(&ost->avfilter);
420 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
424 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
427 codec->width = ost->output_video_filter->inputs[0]->w;
428 codec->height = ost->output_video_filter->inputs[0]->h;
429 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
430 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
431 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
432 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
436 #endif /* CONFIG_AVFILTER */
438 static void term_exit(void)
440 av_log(NULL, AV_LOG_QUIET, "");
443 tcsetattr (0, TCSANOW, &oldtty);
447 static volatile int received_sigterm = 0;
450 sigterm_handler(int sig)
452 received_sigterm = sig;
457 static void term_init(void)
467 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
468 |INLCR|IGNCR|ICRNL|IXON);
469 tty.c_oflag |= OPOST;
470 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
471 tty.c_cflag &= ~(CSIZE|PARENB);
476 tcsetattr (0, TCSANOW, &tty);
477 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
481 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
482 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
484 signal(SIGXCPU, sigterm_handler);
488 /* read a key without blocking */
489 static int read_key(void)
504 n = select(1, &rfds, NULL, NULL, &tv);
519 static int decode_interrupt_cb(void)
521 q_pressed += read_key() == 'q';
522 return q_pressed > 1;
525 static int ffmpeg_exit(int ret)
530 for(i=0;i<nb_output_files;i++) {
531 AVFormatContext *s = output_files[i];
532 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
534 avformat_free_context(s);
535 av_free(output_streams_for_file[i]);
537 for(i=0;i<nb_input_files;i++) {
538 av_close_input_file(input_files[i]);
539 av_free(input_files_ts_scale[i]);
542 av_free(intra_matrix);
543 av_free(inter_matrix);
547 av_free(vstats_filename);
549 av_free(streamid_map);
550 av_free(input_codecs);
551 av_free(output_codecs);
552 av_free(stream_maps);
553 av_free(meta_data_maps);
555 av_free(video_codec_name);
556 av_free(audio_codec_name);
557 av_free(subtitle_codec_name);
559 av_free(video_standard);
564 allocated_audio_buf_size= allocated_audio_out_size= 0;
571 if (received_sigterm) {
573 "Received signal %d: terminating.\n",
574 (int) received_sigterm);
578 exit(ret); /* not all OS-es handle main() return value */
582 /* similar to ff_dynarray_add() and av_fast_realloc() */
583 static void *grow_array(void *array, int elem_size, int *size, int new_size)
585 if (new_size >= INT_MAX / elem_size) {
586 fprintf(stderr, "Array too big.\n");
589 if (*size < new_size) {
590 uint8_t *tmp = av_realloc(array, new_size*elem_size);
592 fprintf(stderr, "Could not alloc buffer.\n");
595 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
602 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
604 if(codec && codec->sample_fmts){
605 const enum AVSampleFormat *p= codec->sample_fmts;
607 if(*p == st->codec->sample_fmt)
611 av_log(NULL, AV_LOG_WARNING,
612 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
613 av_get_sample_fmt_name(st->codec->sample_fmt),
615 av_get_sample_fmt_name(codec->sample_fmts[0]));
616 st->codec->sample_fmt = codec->sample_fmts[0];
621 static void choose_sample_rate(AVStream *st, AVCodec *codec)
623 if(codec && codec->supported_samplerates){
624 const int *p= codec->supported_samplerates;
626 int best_dist=INT_MAX;
628 int dist= abs(st->codec->sample_rate - *p);
629 if(dist < best_dist){
635 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
637 st->codec->sample_rate= best;
641 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
643 if(codec && codec->pix_fmts){
644 const enum PixelFormat *p= codec->pix_fmts;
645 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
646 if(st->codec->codec_id==CODEC_ID_MJPEG){
647 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
648 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
649 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};
653 if(*p == st->codec->pix_fmt)
657 if(st->codec->pix_fmt != PIX_FMT_NONE)
658 av_log(NULL, AV_LOG_WARNING,
659 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
660 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
662 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
663 st->codec->pix_fmt = codec->pix_fmts[0];
668 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
670 int idx = oc->nb_streams - 1;
673 output_streams_for_file[file_idx] =
674 grow_array(output_streams_for_file[file_idx],
675 sizeof(*output_streams_for_file[file_idx]),
676 &nb_output_streams_for_file[file_idx],
678 ost = output_streams_for_file[file_idx][idx] =
679 av_mallocz(sizeof(AVOutputStream));
681 fprintf(stderr, "Could not alloc output stream\n");
684 ost->file_index = file_idx;
689 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
695 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
698 /* copy stream format */
700 for(i=0;i<ic->nb_streams;i++) {
706 // FIXME: a more elegant solution is needed
707 st = av_mallocz(sizeof(AVStream));
708 memcpy(st, ic->streams[i], sizeof(AVStream));
709 st->codec = avcodec_alloc_context();
711 print_error(filename, AVERROR(ENOMEM));
714 avcodec_copy_context(st->codec, ic->streams[i]->codec);
717 codec = avcodec_find_encoder(st->codec->codec_id);
718 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
719 if (audio_stream_copy) {
722 choose_sample_fmt(st, codec);
723 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
724 if (video_stream_copy) {
727 choose_pixel_fmt(st, codec);
730 if(st->codec->flags & CODEC_FLAG_BITEXACT)
733 new_output_stream(s, nb_output_files);
737 s->timestamp = av_gettime();
739 av_close_input_file(ic);
744 get_sync_ipts(const AVOutputStream *ost)
746 const AVInputStream *ist = ost->sync_ist;
747 return (double)(ist->pts - start_time)/AV_TIME_BASE;
750 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
754 AVPacket new_pkt= *pkt;
755 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
756 &new_pkt.data, &new_pkt.size,
757 pkt->data, pkt->size,
758 pkt->flags & AV_PKT_FLAG_KEY);
761 new_pkt.destruct= av_destruct_packet;
763 fprintf(stderr, "%s failed for stream %d, codec %s",
764 bsfc->filter->name, pkt->stream_index,
765 avctx->codec ? avctx->codec->name : "copy");
775 ret= av_interleaved_write_frame(s, pkt);
777 print_error("av_interleaved_write_frame()", ret);
782 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
784 static void do_audio_out(AVFormatContext *s,
787 unsigned char *buf, int size)
790 int64_t audio_out_size, audio_buf_size;
791 int64_t allocated_for_size= size;
793 int size_out, frame_bytes, ret, resample_changed;
794 AVCodecContext *enc= ost->st->codec;
795 AVCodecContext *dec= ist->st->codec;
796 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
797 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
798 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
801 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
802 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
803 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
804 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
805 audio_buf_size*= osize*enc->channels;
807 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
808 if(coded_bps > 8*osize)
809 audio_out_size= audio_out_size * coded_bps / (8*osize);
810 audio_out_size += FF_MIN_BUFFER_SIZE;
812 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
813 fprintf(stderr, "Buffer sizes too large\n");
817 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
818 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
819 if (!audio_buf || !audio_out){
820 fprintf(stderr, "Out of memory in do_audio_out\n");
824 if (enc->channels != dec->channels)
825 ost->audio_resample = 1;
827 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
828 ost->resample_channels != dec->channels ||
829 ost->resample_sample_rate != dec->sample_rate;
831 if ((ost->audio_resample && !ost->resample) || resample_changed) {
832 if (resample_changed) {
833 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",
834 ist->file_index, ist->index,
835 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
836 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
837 ost->resample_sample_fmt = dec->sample_fmt;
838 ost->resample_channels = dec->channels;
839 ost->resample_sample_rate = dec->sample_rate;
841 audio_resample_close(ost->resample);
843 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
844 if (audio_sync_method <= 1 &&
845 ost->resample_sample_fmt == enc->sample_fmt &&
846 ost->resample_channels == enc->channels &&
847 ost->resample_sample_rate == enc->sample_rate) {
848 ost->resample = NULL;
849 ost->audio_resample = 0;
851 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
852 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
853 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
854 enc->sample_rate, dec->sample_rate,
855 enc->sample_fmt, dec->sample_fmt,
857 if (!ost->resample) {
858 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
859 dec->channels, dec->sample_rate,
860 enc->channels, enc->sample_rate);
866 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
867 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
868 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
869 if (ost->reformat_ctx)
870 av_audio_convert_free(ost->reformat_ctx);
871 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
872 dec->sample_fmt, 1, NULL, 0);
873 if (!ost->reformat_ctx) {
874 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
875 av_get_sample_fmt_name(dec->sample_fmt),
876 av_get_sample_fmt_name(enc->sample_fmt));
879 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
882 if(audio_sync_method){
883 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
884 - av_fifo_size(ost->fifo)/(enc->channels * 2);
885 double idelta= delta*dec->sample_rate / enc->sample_rate;
886 int byte_delta= ((int)idelta)*2*dec->channels;
888 //FIXME resample delay
889 if(fabs(delta) > 50){
890 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
892 byte_delta= FFMAX(byte_delta, -size);
896 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
901 static uint8_t *input_tmp= NULL;
902 input_tmp= av_realloc(input_tmp, byte_delta + size);
904 if(byte_delta > allocated_for_size - size){
905 allocated_for_size= byte_delta + (int64_t)size;
910 memset(input_tmp, 0, byte_delta);
911 memcpy(input_tmp + byte_delta, buf, size);
915 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
917 }else if(audio_sync_method>1){
918 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
919 av_assert0(ost->audio_resample);
921 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
922 // 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));
923 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
927 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
928 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
930 if (ost->audio_resample) {
932 size_out = audio_resample(ost->resample,
933 (short *)buftmp, (short *)buf,
934 size / (dec->channels * isize));
935 size_out = size_out * enc->channels * osize;
941 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
942 const void *ibuf[6]= {buftmp};
943 void *obuf[6]= {audio_buf};
944 int istride[6]= {isize};
945 int ostride[6]= {osize};
946 int len= size_out/istride[0];
947 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
948 printf("av_audio_convert() failed\n");
954 size_out = len*osize;
957 /* now encode as many frames as possible */
958 if (enc->frame_size > 1) {
959 /* output resampled raw samples */
960 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
961 fprintf(stderr, "av_fifo_realloc2() failed\n");
964 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
966 frame_bytes = enc->frame_size * osize * enc->channels;
968 while (av_fifo_size(ost->fifo) >= frame_bytes) {
970 av_init_packet(&pkt);
972 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
974 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
976 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
979 fprintf(stderr, "Audio encoding failed\n");
983 pkt.stream_index= ost->index;
986 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
987 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
988 pkt.flags |= AV_PKT_FLAG_KEY;
989 write_frame(s, &pkt, enc, ost->bitstream_filters);
991 ost->sync_opts += enc->frame_size;
995 av_init_packet(&pkt);
997 ost->sync_opts += size_out / (osize * enc->channels);
999 /* output a pcm frame */
1000 /* determine the size of the coded buffer */
1003 size_out = size_out*coded_bps/8;
1005 if(size_out > audio_out_size){
1006 fprintf(stderr, "Internal error, buffer size too small\n");
1010 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1011 ret = avcodec_encode_audio(enc, audio_out, size_out,
1014 fprintf(stderr, "Audio encoding failed\n");
1018 pkt.stream_index= ost->index;
1019 pkt.data= audio_out;
1021 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1022 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1023 pkt.flags |= AV_PKT_FLAG_KEY;
1024 write_frame(s, &pkt, enc, ost->bitstream_filters);
1028 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1030 AVCodecContext *dec;
1031 AVPicture *picture2;
1032 AVPicture picture_tmp;
1035 dec = ist->st->codec;
1037 /* deinterlace : must be done before any resize */
1038 if (do_deinterlace) {
1041 /* create temporary picture */
1042 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1043 buf = av_malloc(size);
1047 picture2 = &picture_tmp;
1048 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1050 if(avpicture_deinterlace(picture2, picture,
1051 dec->pix_fmt, dec->width, dec->height) < 0) {
1052 /* if error, do not deinterlace */
1053 fprintf(stderr, "Deinterlacing failed\n");
1062 if (picture != picture2)
1063 *picture = *picture2;
1067 /* we begin to correct av delay at this threshold */
1068 #define AV_DELAY_MAX 0.100
1070 static void do_subtitle_out(AVFormatContext *s,
1071 AVOutputStream *ost,
1076 static uint8_t *subtitle_out = NULL;
1077 int subtitle_out_max_size = 1024 * 1024;
1078 int subtitle_out_size, nb, i;
1079 AVCodecContext *enc;
1082 if (pts == AV_NOPTS_VALUE) {
1083 fprintf(stderr, "Subtitle packets must have a pts\n");
1089 enc = ost->st->codec;
1091 if (!subtitle_out) {
1092 subtitle_out = av_malloc(subtitle_out_max_size);
1095 /* Note: DVB subtitle need one packet to draw them and one other
1096 packet to clear them */
1097 /* XXX: signal it in the codec context ? */
1098 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1103 for(i = 0; i < nb; i++) {
1104 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1105 // start_display_time is required to be 0
1106 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1107 sub->end_display_time -= sub->start_display_time;
1108 sub->start_display_time = 0;
1109 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1110 subtitle_out_max_size, sub);
1111 if (subtitle_out_size < 0) {
1112 fprintf(stderr, "Subtitle encoding failed\n");
1116 av_init_packet(&pkt);
1117 pkt.stream_index = ost->index;
1118 pkt.data = subtitle_out;
1119 pkt.size = subtitle_out_size;
1120 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1121 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1122 /* XXX: the pts correction is handled here. Maybe handling
1123 it in the codec would be better */
1125 pkt.pts += 90 * sub->start_display_time;
1127 pkt.pts += 90 * sub->end_display_time;
1129 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1133 static int bit_buffer_size= 1024*256;
1134 static uint8_t *bit_buffer= NULL;
1136 static void do_video_out(AVFormatContext *s,
1137 AVOutputStream *ost,
1139 AVFrame *in_picture,
1142 int nb_frames, i, ret, resample_changed;
1143 AVFrame *final_picture, *formatted_picture, *resampling_dst;
1144 AVCodecContext *enc, *dec;
1147 enc = ost->st->codec;
1148 dec = ist->st->codec;
1150 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1152 /* by default, we output a single frame */
1157 if(video_sync_method){
1158 double vdelta = sync_ipts - ost->sync_opts;
1159 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1162 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1165 }else if(vdelta>0.6)
1166 ost->sync_opts= lrintf(sync_ipts);
1167 }else if (vdelta > 1.1)
1168 nb_frames = lrintf(vdelta);
1169 //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);
1170 if (nb_frames == 0){
1173 fprintf(stderr, "*** drop!\n");
1174 }else if (nb_frames > 1) {
1175 nb_frames_dup += nb_frames - 1;
1177 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1180 ost->sync_opts= lrintf(sync_ipts);
1182 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1186 formatted_picture = in_picture;
1187 final_picture = formatted_picture;
1188 resampling_dst = &ost->pict_tmp;
1190 resample_changed = ost->resample_width != dec->width ||
1191 ost->resample_height != dec->height ||
1192 ost->resample_pix_fmt != dec->pix_fmt;
1194 if (resample_changed) {
1195 av_log(NULL, AV_LOG_INFO,
1196 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1197 ist->file_index, ist->index,
1198 ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1199 dec->width , dec->height , avcodec_get_pix_fmt_name(dec->pix_fmt));
1200 if(!ost->video_resample)
1204 #if !CONFIG_AVFILTER
1205 if (ost->video_resample) {
1206 final_picture = &ost->pict_tmp;
1207 if (resample_changed) {
1208 /* initialize a new scaler context */
1209 sws_freeContext(ost->img_resample_ctx);
1210 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1211 ost->img_resample_ctx = sws_getContext(
1212 ist->st->codec->width,
1213 ist->st->codec->height,
1214 ist->st->codec->pix_fmt,
1215 ost->st->codec->width,
1216 ost->st->codec->height,
1217 ost->st->codec->pix_fmt,
1218 sws_flags, NULL, NULL, NULL);
1219 if (ost->img_resample_ctx == NULL) {
1220 fprintf(stderr, "Cannot get resampling context\n");
1224 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1225 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1229 /* duplicates frame if needed */
1230 for(i=0;i<nb_frames;i++) {
1232 av_init_packet(&pkt);
1233 pkt.stream_index= ost->index;
1235 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1236 /* raw pictures are written as AVPicture structure to
1237 avoid any copies. We support temorarily the older
1239 AVFrame* old_frame = enc->coded_frame;
1240 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1241 pkt.data= (uint8_t *)final_picture;
1242 pkt.size= sizeof(AVPicture);
1243 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1244 pkt.flags |= AV_PKT_FLAG_KEY;
1246 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1247 enc->coded_frame = old_frame;
1249 AVFrame big_picture;
1251 big_picture= *final_picture;
1252 /* better than nothing: use input picture interlaced
1254 big_picture.interlaced_frame = in_picture->interlaced_frame;
1255 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1256 if(top_field_first == -1)
1257 big_picture.top_field_first = in_picture->top_field_first;
1259 big_picture.top_field_first = top_field_first;
1262 /* handles sameq here. This is not correct because it may
1263 not be a global option */
1264 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1266 big_picture.pict_type = 0;
1267 // big_picture.pts = AV_NOPTS_VALUE;
1268 big_picture.pts= ost->sync_opts;
1269 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1270 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1271 if (ost->forced_kf_index < ost->forced_kf_count &&
1272 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1273 big_picture.pict_type = FF_I_TYPE;
1274 ost->forced_kf_index++;
1276 ret = avcodec_encode_video(enc,
1277 bit_buffer, bit_buffer_size,
1280 fprintf(stderr, "Video encoding failed\n");
1285 pkt.data= bit_buffer;
1287 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1288 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1289 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1290 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1291 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1293 if(enc->coded_frame->key_frame)
1294 pkt.flags |= AV_PKT_FLAG_KEY;
1295 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1298 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1299 // enc->frame_number-1, ret, enc->pict_type);
1300 /* if two pass, output log */
1301 if (ost->logfile && enc->stats_out) {
1302 fprintf(ost->logfile, "%s", enc->stats_out);
1307 ost->frame_number++;
1311 static double psnr(double d){
1312 return -10.0*log(d)/log(10.0);
1315 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1318 AVCodecContext *enc;
1320 double ti1, bitrate, avg_bitrate;
1322 /* this is executed just the first time do_video_stats is called */
1324 vstats_file = fopen(vstats_filename, "w");
1331 enc = ost->st->codec;
1332 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1333 frame_number = ost->frame_number;
1334 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1335 if (enc->flags&CODEC_FLAG_PSNR)
1336 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1338 fprintf(vstats_file,"f_size= %6d ", frame_size);
1339 /* compute pts value */
1340 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1344 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1345 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1346 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1347 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1348 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1352 static void print_report(AVFormatContext **output_files,
1353 AVOutputStream **ost_table, int nb_ostreams,
1357 AVOutputStream *ost;
1358 AVFormatContext *oc;
1360 AVCodecContext *enc;
1361 int frame_number, vid, i;
1362 double bitrate, ti1, pts;
1363 static int64_t last_time = -1;
1364 static int qp_histogram[52];
1366 if (!is_last_report) {
1368 /* display the report every 0.5 seconds */
1369 cur_time = av_gettime();
1370 if (last_time == -1) {
1371 last_time = cur_time;
1374 if ((cur_time - last_time) < 500000)
1376 last_time = cur_time;
1380 oc = output_files[0];
1382 total_size = avio_size(oc->pb);
1383 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1384 total_size= avio_tell(oc->pb);
1389 for(i=0;i<nb_ostreams;i++) {
1392 enc = ost->st->codec;
1393 if(!ost->st->stream_copy && enc->coded_frame)
1394 q= enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1395 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1396 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1398 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1399 float t = (av_gettime()-timer_start) / 1000000.0;
1401 frame_number = ost->frame_number;
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1403 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1405 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1409 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1412 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1414 if (enc->flags&CODEC_FLAG_PSNR){
1416 double error, error_sum=0;
1417 double scale, scale_sum=0;
1418 char type[3]= {'Y','U','V'};
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1422 error= enc->error[j];
1423 scale= enc->width*enc->height*255.0*255.0*frame_number;
1425 error= enc->coded_frame->error[j];
1426 scale= enc->width*enc->height*255.0*255.0;
1431 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1433 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1437 /* compute min output value */
1438 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1439 if ((pts < ti1) && (pts > 0))
1445 if (verbose > 0 || is_last_report) {
1446 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1448 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1449 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1450 (double)total_size / 1024, ti1, bitrate);
1452 if (nb_frames_dup || nb_frames_drop)
1453 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1454 nb_frames_dup, nb_frames_drop);
1457 fprintf(stderr, "%s \r", buf);
1462 if (is_last_report && verbose >= 0){
1463 int64_t raw= audio_size + video_size + extra_size;
1464 fprintf(stderr, "\n");
1465 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1469 100.0*(total_size - raw)/raw
1474 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1476 int fill_char = 0x00;
1477 if (sample_fmt == AV_SAMPLE_FMT_U8)
1479 memset(buf, fill_char, size);
1482 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1483 static int output_packet(AVInputStream *ist, int ist_index,
1484 AVOutputStream **ost_table, int nb_ostreams,
1485 const AVPacket *pkt)
1487 AVFormatContext *os;
1488 AVOutputStream *ost;
1492 void *buffer_to_free = NULL;
1493 static unsigned int samples_size= 0;
1494 AVSubtitle subtitle, *subtitle_to_free;
1495 int64_t pkt_pts = AV_NOPTS_VALUE;
1497 int frame_available;
1501 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1503 if(ist->next_pts == AV_NOPTS_VALUE)
1504 ist->next_pts= ist->pts;
1508 av_init_packet(&avpkt);
1516 if(pkt->dts != AV_NOPTS_VALUE)
1517 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1518 if(pkt->pts != AV_NOPTS_VALUE)
1519 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1521 //while we have more to decode or while the decoder did output something on EOF
1522 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1523 uint8_t *data_buf, *decoded_data_buf;
1524 int data_size, decoded_data_size;
1526 ist->pts= ist->next_pts;
1528 if(avpkt.size && avpkt.size != pkt->size &&
1529 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1530 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1531 ist->showed_multi_packet_warning=1;
1534 /* decode the packet if needed */
1535 decoded_data_buf = NULL; /* fail safe */
1536 decoded_data_size= 0;
1537 data_buf = avpkt.data;
1538 data_size = avpkt.size;
1539 subtitle_to_free = NULL;
1540 if (ist->decoding_needed) {
1541 switch(ist->st->codec->codec_type) {
1542 case AVMEDIA_TYPE_AUDIO:{
1543 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1544 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1546 samples= av_malloc(samples_size);
1548 decoded_data_size= samples_size;
1549 /* XXX: could avoid copy if PCM 16 bits with same
1550 endianness as CPU */
1551 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1558 /* Some bug in mpeg audio decoder gives */
1559 /* decoded_data_size < 0, it seems they are overflows */
1560 if (decoded_data_size <= 0) {
1561 /* no audio frame */
1564 decoded_data_buf = (uint8_t *)samples;
1565 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1566 (ist->st->codec->sample_rate * ist->st->codec->channels);
1568 case AVMEDIA_TYPE_VIDEO:
1569 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1570 /* XXX: allocate picture correctly */
1571 avcodec_get_frame_defaults(&picture);
1572 avpkt.pts = pkt_pts;
1573 avpkt.dts = ist->pts;
1574 pkt_pts = AV_NOPTS_VALUE;
1576 ret = avcodec_decode_video2(ist->st->codec,
1577 &picture, &got_picture, &avpkt);
1578 ist->st->quality= picture.quality;
1582 /* no picture yet */
1583 goto discard_packet;
1585 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1586 if (ist->st->codec->time_base.num != 0) {
1587 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1588 ist->next_pts += ((int64_t)AV_TIME_BASE *
1589 ist->st->codec->time_base.num * ticks) /
1590 ist->st->codec->time_base.den;
1593 buffer_to_free = NULL;
1594 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1596 case AVMEDIA_TYPE_SUBTITLE:
1597 ret = avcodec_decode_subtitle2(ist->st->codec,
1598 &subtitle, &got_picture, &avpkt);
1602 goto discard_packet;
1604 subtitle_to_free = &subtitle;
1611 switch(ist->st->codec->codec_type) {
1612 case AVMEDIA_TYPE_AUDIO:
1613 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1614 ist->st->codec->sample_rate;
1616 case AVMEDIA_TYPE_VIDEO:
1617 if (ist->st->codec->time_base.num != 0) {
1618 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1619 ist->next_pts += ((int64_t)AV_TIME_BASE *
1620 ist->st->codec->time_base.num * ticks) /
1621 ist->st->codec->time_base.den;
1630 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1631 for(i=0;i<nb_ostreams;i++) {
1633 if (ost->input_video_filter && ost->source_index == ist_index) {
1635 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1636 else sar = ist->st->codec->sample_aspect_ratio;
1637 // add it to be filtered
1638 av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1640 sar, ist->st->codec->width, ist->st->codec->height,
1641 ist->st->codec->pix_fmt, "0:0"); //TODO user setable params
1647 // preprocess audio (volume)
1648 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1649 if (audio_volume != 256) {
1652 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1653 int v = ((*volp) * audio_volume + 128) >> 8;
1654 if (v < -32768) v = -32768;
1655 if (v > 32767) v = 32767;
1661 /* frame rate emulation */
1663 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1664 int64_t now = av_gettime() - ist->start;
1668 /* if output time reached then transcode raw format,
1669 encode packets and output them */
1670 if (start_time == 0 || ist->pts >= start_time)
1671 for(i=0;i<nb_ostreams;i++) {
1675 if (ost->source_index == ist_index) {
1677 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1678 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1679 while (frame_available) {
1680 AVRational ist_pts_tb;
1681 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1682 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1684 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1686 os = output_files[ost->file_index];
1688 /* set the input output pts pairs */
1689 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1691 if (ost->encoding_needed) {
1692 av_assert0(ist->decoding_needed);
1693 switch(ost->st->codec->codec_type) {
1694 case AVMEDIA_TYPE_AUDIO:
1695 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1697 case AVMEDIA_TYPE_VIDEO:
1699 if (ost->picref->video && !ost->frame_aspect_ratio)
1700 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1702 do_video_out(os, ost, ist, &picture, &frame_size);
1703 if (vstats_filename && frame_size)
1704 do_video_stats(os, ost, frame_size);
1706 case AVMEDIA_TYPE_SUBTITLE:
1707 do_subtitle_out(os, ost, ist, &subtitle,
1714 AVFrame avframe; //FIXME/XXX remove this
1716 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1718 av_init_packet(&opkt);
1720 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1721 #if !CONFIG_AVFILTER
1727 /* no reencoding needed : output the packet directly */
1728 /* force the input stream PTS */
1730 avcodec_get_frame_defaults(&avframe);
1731 ost->st->codec->coded_frame= &avframe;
1732 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1734 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1735 audio_size += data_size;
1736 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1737 video_size += data_size;
1741 opkt.stream_index= ost->index;
1742 if(pkt->pts != AV_NOPTS_VALUE)
1743 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1745 opkt.pts= AV_NOPTS_VALUE;
1747 if (pkt->dts == AV_NOPTS_VALUE)
1748 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1750 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1751 opkt.dts -= ost_tb_start_time;
1753 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1754 opkt.flags= pkt->flags;
1756 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1757 if( ost->st->codec->codec_id != CODEC_ID_H264
1758 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1759 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1761 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1762 opkt.destruct= av_destruct_packet;
1764 opkt.data = data_buf;
1765 opkt.size = data_size;
1768 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1769 ost->st->codec->frame_number++;
1770 ost->frame_number++;
1771 av_free_packet(&opkt);
1775 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1776 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1778 avfilter_unref_buffer(ost->picref);
1784 av_free(buffer_to_free);
1785 /* XXX: allocate the subtitles in the codec ? */
1786 if (subtitle_to_free) {
1787 avsubtitle_free(subtitle_to_free);
1788 subtitle_to_free = NULL;
1795 for(i=0;i<nb_ostreams;i++) {
1797 if (ost->source_index == ist_index) {
1798 AVCodecContext *enc= ost->st->codec;
1799 os = output_files[ost->file_index];
1801 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1803 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1806 if (ost->encoding_needed) {
1810 av_init_packet(&pkt);
1811 pkt.stream_index= ost->index;
1813 switch(ost->st->codec->codec_type) {
1814 case AVMEDIA_TYPE_AUDIO:
1815 fifo_bytes = av_fifo_size(ost->fifo);
1817 /* encode any samples remaining in fifo */
1818 if (fifo_bytes > 0) {
1819 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1820 int fs_tmp = enc->frame_size;
1822 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1823 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1824 enc->frame_size = fifo_bytes / (osize * enc->channels);
1826 int frame_bytes = enc->frame_size*osize*enc->channels;
1827 if (allocated_audio_buf_size < frame_bytes)
1829 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1832 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1833 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1834 ost->st->time_base.num, enc->sample_rate);
1835 enc->frame_size = fs_tmp;
1838 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1841 fprintf(stderr, "Audio encoding failed\n");
1845 pkt.flags |= AV_PKT_FLAG_KEY;
1847 case AVMEDIA_TYPE_VIDEO:
1848 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1850 fprintf(stderr, "Video encoding failed\n");
1854 if(enc->coded_frame && enc->coded_frame->key_frame)
1855 pkt.flags |= AV_PKT_FLAG_KEY;
1856 if (ost->logfile && enc->stats_out) {
1857 fprintf(ost->logfile, "%s", enc->stats_out);
1866 pkt.data= bit_buffer;
1868 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1869 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1870 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1882 static void print_sdp(AVFormatContext **avc, int n)
1886 av_sdp_create(avc, n, sdp, sizeof(sdp));
1887 printf("SDP:\n%s\n", sdp);
1891 static int copy_chapters(int infile, int outfile)
1893 AVFormatContext *is = input_files[infile];
1894 AVFormatContext *os = output_files[outfile];
1897 for (i = 0; i < is->nb_chapters; i++) {
1898 AVChapter *in_ch = is->chapters[i], *out_ch;
1899 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1900 AV_TIME_BASE_Q, in_ch->time_base);
1901 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1902 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1905 if (in_ch->end < ts_off)
1907 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1910 out_ch = av_mallocz(sizeof(AVChapter));
1912 return AVERROR(ENOMEM);
1914 out_ch->id = in_ch->id;
1915 out_ch->time_base = in_ch->time_base;
1916 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1917 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1919 if (metadata_chapters_autocopy)
1920 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1923 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1925 return AVERROR(ENOMEM);
1926 os->chapters[os->nb_chapters - 1] = out_ch;
1931 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1932 AVCodecContext *avctx)
1938 for (p = kf; *p; p++)
1941 ost->forced_kf_count = n;
1942 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1943 if (!ost->forced_kf_pts) {
1944 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1947 for (i = 0; i < n; i++) {
1948 p = i ? strchr(p, ',') + 1 : kf;
1949 t = parse_time_or_die("force_key_frames", p, 1);
1950 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1955 * The following code is the main loop of the file converter
1957 static int transcode(AVFormatContext **output_files,
1958 int nb_output_files,
1959 AVFormatContext **input_files,
1961 AVStreamMap *stream_maps, int nb_stream_maps)
1963 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1964 AVFormatContext *is, *os;
1965 AVCodecContext *codec, *icodec;
1966 AVOutputStream *ost, **ost_table = NULL;
1967 AVInputStream *ist, **ist_table = NULL;
1968 AVInputFile *file_table;
1972 uint8_t no_packet[MAX_FILES]={0};
1973 int no_packet_count=0;
1974 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1975 int nb_streams[AVMEDIA_TYPE_NB]={0};
1977 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1981 /* input stream init */
1983 for(i=0;i<nb_input_files;i++) {
1984 is = input_files[i];
1985 file_table[i].ist_index = j;
1986 file_table[i].nb_streams = is->nb_streams;
1987 j += is->nb_streams;
1991 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1995 for(i=0;i<nb_istreams;i++) {
1996 ist = av_mallocz(sizeof(AVInputStream));
2002 for(i=0;i<nb_input_files;i++) {
2003 is = input_files[i];
2004 for(k=0;k<is->nb_streams;k++) {
2005 ist = ist_table[j++];
2006 ist->st = is->streams[k];
2007 ist->file_index = i;
2009 ist->discard = 1; /* the stream is discarded by default
2013 ist->start = av_gettime();
2018 /* output stream init */
2020 for(i=0;i<nb_output_files;i++) {
2021 os = output_files[i];
2022 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2023 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2024 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2025 ret = AVERROR(EINVAL);
2028 nb_ostreams += os->nb_streams;
2030 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2031 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2032 ret = AVERROR(EINVAL);
2036 /* Sanity check the mapping args -- do the input files & streams exist? */
2037 for(i=0;i<nb_stream_maps;i++) {
2038 int fi = stream_maps[i].file_index;
2039 int si = stream_maps[i].stream_index;
2041 if (fi < 0 || fi > nb_input_files - 1 ||
2042 si < 0 || si > file_table[fi].nb_streams - 1) {
2043 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2044 ret = AVERROR(EINVAL);
2047 fi = stream_maps[i].sync_file_index;
2048 si = stream_maps[i].sync_stream_index;
2049 if (fi < 0 || fi > nb_input_files - 1 ||
2050 si < 0 || si > file_table[fi].nb_streams - 1) {
2051 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2052 ret = AVERROR(EINVAL);
2057 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2061 for(k=0;k<nb_output_files;k++) {
2062 os = output_files[k];
2063 for(i=0;i<os->nb_streams;i++,n++) {
2064 nb_streams[os->streams[i]->codec->codec_type]++;
2067 for(step=1<<30; step; step>>=1){
2068 int found_streams[AVMEDIA_TYPE_NB]={0};
2069 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2070 nb_frame_threshold[j] += step;
2072 for(j=0; j<nb_istreams; j++) {
2077 AVFormatContext *f= input_files[ ist->file_index ];
2079 for(pi=0; pi<f->nb_programs; pi++){
2080 AVProgram *p= f->programs[pi];
2081 if(p->id == opt_programid)
2082 for(si=0; si<p->nb_stream_indexes; si++){
2083 if(f->streams[ p->stream_index[si] ] == ist->st)
2088 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2089 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2090 found_streams[ist->st->codec->codec_type]++;
2093 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2094 if(found_streams[j] < nb_streams[j])
2095 nb_frame_threshold[j] -= step;
2098 for(k=0;k<nb_output_files;k++) {
2099 os = output_files[k];
2100 for(i=0;i<os->nb_streams;i++,n++) {
2102 ost = ost_table[n] = output_streams_for_file[k][i];
2103 ost->st = os->streams[i];
2104 if (nb_stream_maps > 0) {
2105 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2106 stream_maps[n].stream_index;
2108 /* Sanity check that the stream types match */
2109 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2110 int i= ost->file_index;
2111 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2112 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2113 stream_maps[n].file_index, stream_maps[n].stream_index,
2114 ost->file_index, ost->index);
2119 /* get corresponding input stream index : we select the first one with the right type */
2121 for(j=0;j<nb_istreams;j++) {
2126 AVFormatContext *f= input_files[ ist->file_index ];
2128 for(pi=0; pi<f->nb_programs; pi++){
2129 AVProgram *p= f->programs[pi];
2130 if(p->id == opt_programid)
2131 for(si=0; si<p->nb_stream_indexes; si++){
2132 if(f->streams[ p->stream_index[si] ] == ist->st)
2137 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2138 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2139 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2140 ost->source_index = j;
2147 if(! opt_programid) {
2148 /* try again and reuse existing stream */
2149 for(j=0;j<nb_istreams;j++) {
2151 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2152 && ist->st->discard != AVDISCARD_ALL) {
2153 ost->source_index = j;
2159 int i= ost->file_index;
2160 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2161 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2162 ost->file_index, ost->index);
2167 ist = ist_table[ost->source_index];
2169 ost->sync_ist = (nb_stream_maps > 0) ?
2170 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2171 stream_maps[n].sync_stream_index] : ist;
2175 /* for each output stream, we compute the right encoding parameters */
2176 for(i=0;i<nb_ostreams;i++) {
2178 os = output_files[ost->file_index];
2179 ist = ist_table[ost->source_index];
2181 codec = ost->st->codec;
2182 icodec = ist->st->codec;
2184 if (metadata_streams_autocopy)
2185 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2186 AV_METADATA_DONT_OVERWRITE);
2188 ost->st->disposition = ist->st->disposition;
2189 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2190 codec->chroma_sample_location = icodec->chroma_sample_location;
2192 if (ost->st->stream_copy) {
2193 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2195 if (extra_size > INT_MAX)
2198 /* if stream_copy is selected, no need to decode or encode */
2199 codec->codec_id = icodec->codec_id;
2200 codec->codec_type = icodec->codec_type;
2202 if(!codec->codec_tag){
2203 if( !os->oformat->codec_tag
2204 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2205 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2206 codec->codec_tag = icodec->codec_tag;
2209 codec->bit_rate = icodec->bit_rate;
2210 codec->rc_max_rate = icodec->rc_max_rate;
2211 codec->rc_buffer_size = icodec->rc_buffer_size;
2212 codec->extradata= av_mallocz(extra_size);
2213 if (!codec->extradata)
2215 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2216 codec->extradata_size= icodec->extradata_size;
2217 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){
2218 codec->time_base = icodec->time_base;
2219 codec->time_base.num *= icodec->ticks_per_frame;
2220 av_reduce(&codec->time_base.num, &codec->time_base.den,
2221 codec->time_base.num, codec->time_base.den, INT_MAX);
2223 codec->time_base = ist->st->time_base;
2224 switch(codec->codec_type) {
2225 case AVMEDIA_TYPE_AUDIO:
2226 if(audio_volume != 256) {
2227 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2230 codec->channel_layout = icodec->channel_layout;
2231 codec->sample_rate = icodec->sample_rate;
2232 codec->channels = icodec->channels;
2233 codec->frame_size = icodec->frame_size;
2234 codec->audio_service_type = icodec->audio_service_type;
2235 codec->block_align= icodec->block_align;
2236 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2237 codec->block_align= 0;
2238 if(codec->codec_id == CODEC_ID_AC3)
2239 codec->block_align= 0;
2241 case AVMEDIA_TYPE_VIDEO:
2242 codec->pix_fmt = icodec->pix_fmt;
2243 codec->width = icodec->width;
2244 codec->height = icodec->height;
2245 codec->has_b_frames = icodec->has_b_frames;
2246 if (!codec->sample_aspect_ratio.num) {
2247 codec->sample_aspect_ratio =
2248 ost->st->sample_aspect_ratio =
2249 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2250 ist->st->codec->sample_aspect_ratio.num ?
2251 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2254 case AVMEDIA_TYPE_SUBTITLE:
2255 codec->width = icodec->width;
2256 codec->height = icodec->height;
2262 switch(codec->codec_type) {
2263 case AVMEDIA_TYPE_AUDIO:
2264 ost->fifo= av_fifo_alloc(1024);
2267 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2268 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2269 icodec->request_channels = codec->channels;
2270 ist->decoding_needed = 1;
2271 ost->encoding_needed = 1;
2272 ost->resample_sample_fmt = icodec->sample_fmt;
2273 ost->resample_sample_rate = icodec->sample_rate;
2274 ost->resample_channels = icodec->channels;
2276 case AVMEDIA_TYPE_VIDEO:
2277 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2278 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2281 ost->video_resample = codec->width != icodec->width ||
2282 codec->height != icodec->height ||
2283 codec->pix_fmt != icodec->pix_fmt;
2284 if (ost->video_resample) {
2285 #if !CONFIG_AVFILTER
2286 avcodec_get_frame_defaults(&ost->pict_tmp);
2287 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2288 codec->width, codec->height)) {
2289 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2292 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2293 ost->img_resample_ctx = sws_getContext(
2300 sws_flags, NULL, NULL, NULL);
2301 if (ost->img_resample_ctx == NULL) {
2302 fprintf(stderr, "Cannot get resampling context\n");
2306 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2308 ost->resample_height = icodec->height;
2309 ost->resample_width = icodec->width;
2310 ost->resample_pix_fmt= icodec->pix_fmt;
2311 ost->encoding_needed = 1;
2312 ist->decoding_needed = 1;
2315 if (configure_video_filters(ist, ost)) {
2316 fprintf(stderr, "Error opening filters!\n");
2321 case AVMEDIA_TYPE_SUBTITLE:
2322 ost->encoding_needed = 1;
2323 ist->decoding_needed = 1;
2330 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2331 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2332 char logfilename[1024];
2335 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2336 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2338 if (codec->flags & CODEC_FLAG_PASS1) {
2339 f = fopen(logfilename, "wb");
2341 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2347 size_t logbuffer_size;
2348 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2349 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2352 codec->stats_in = logbuffer;
2356 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2357 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2358 int size= codec->width * codec->height;
2359 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2364 bit_buffer = av_malloc(bit_buffer_size);
2366 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2368 ret = AVERROR(ENOMEM);
2372 /* open each encoder */
2373 for(i=0;i<nb_ostreams;i++) {
2375 if (ost->encoding_needed) {
2376 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2377 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2379 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2381 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2382 ost->st->codec->codec_id, ost->file_index, ost->index);
2383 ret = AVERROR(EINVAL);
2386 if (dec->subtitle_header) {
2387 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2388 if (!ost->st->codec->subtitle_header) {
2389 ret = AVERROR(ENOMEM);
2392 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2393 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2395 if (avcodec_open(ost->st->codec, codec) < 0) {
2396 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2397 ost->file_index, ost->index);
2398 ret = AVERROR(EINVAL);
2401 extra_size += ost->st->codec->extradata_size;
2405 /* open each decoder */
2406 for(i=0;i<nb_istreams;i++) {
2408 if (ist->decoding_needed) {
2409 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2411 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2413 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2414 ist->st->codec->codec_id, ist->file_index, ist->index);
2415 ret = AVERROR(EINVAL);
2418 if (avcodec_open(ist->st->codec, codec) < 0) {
2419 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2420 ist->file_index, ist->index);
2421 ret = AVERROR(EINVAL);
2424 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2425 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2430 for(i=0;i<nb_istreams;i++) {
2434 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2435 ist->next_pts = AV_NOPTS_VALUE;
2439 /* set meta data information from input file if required */
2440 for (i=0;i<nb_meta_data_maps;i++) {
2441 AVFormatContext *files[2];
2442 AVMetadata **meta[2];
2445 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2446 if ((index) < 0 || (index) >= (nb_elems)) {\
2447 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2449 ret = AVERROR(EINVAL);\
2453 int out_file_index = meta_data_maps[i][0].file;
2454 int in_file_index = meta_data_maps[i][1].file;
2455 if (in_file_index < 0 || out_file_index < 0)
2457 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2458 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2460 files[0] = output_files[out_file_index];
2461 files[1] = input_files[in_file_index];
2463 for (j = 0; j < 2; j++) {
2464 AVMetaDataMap *map = &meta_data_maps[i][j];
2466 switch (map->type) {
2468 meta[j] = &files[j]->metadata;
2471 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2472 meta[j] = &files[j]->streams[map->index]->metadata;
2475 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2476 meta[j] = &files[j]->chapters[map->index]->metadata;
2479 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2480 meta[j] = &files[j]->programs[map->index]->metadata;
2485 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2488 /* copy global metadata by default */
2489 if (metadata_global_autocopy) {
2491 for (i = 0; i < nb_output_files; i++)
2492 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2493 AV_METADATA_DONT_OVERWRITE);
2496 /* copy chapters according to chapter maps */
2497 for (i = 0; i < nb_chapter_maps; i++) {
2498 int infile = chapter_maps[i].in_file;
2499 int outfile = chapter_maps[i].out_file;
2501 if (infile < 0 || outfile < 0)
2503 if (infile >= nb_input_files) {
2504 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2505 ret = AVERROR(EINVAL);
2508 if (outfile >= nb_output_files) {
2509 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2510 ret = AVERROR(EINVAL);
2513 copy_chapters(infile, outfile);
2516 /* copy chapters from the first input file that has them*/
2517 if (!nb_chapter_maps)
2518 for (i = 0; i < nb_input_files; i++) {
2519 if (!input_files[i]->nb_chapters)
2522 for (j = 0; j < nb_output_files; j++)
2523 if ((ret = copy_chapters(i, j)) < 0)
2528 /* open files and write file headers */
2529 for(i=0;i<nb_output_files;i++) {
2530 os = output_files[i];
2531 if (av_write_header(os) < 0) {
2532 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2533 ret = AVERROR(EINVAL);
2536 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2542 /* dump the file output parameters - cannot be done before in case
2544 for(i=0;i<nb_output_files;i++) {
2545 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2548 /* dump the stream mapping */
2550 fprintf(stderr, "Stream mapping:\n");
2551 for(i=0;i<nb_ostreams;i++) {
2553 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2554 ist_table[ost->source_index]->file_index,
2555 ist_table[ost->source_index]->index,
2558 if (ost->sync_ist != ist_table[ost->source_index])
2559 fprintf(stderr, " [sync #%d.%d]",
2560 ost->sync_ist->file_index,
2561 ost->sync_ist->index);
2562 fprintf(stderr, "\n");
2567 fprintf(stderr, "%s\n", error);
2572 print_sdp(output_files, nb_output_files);
2577 fprintf(stderr, "Press [q] to stop encoding\n");
2578 avio_set_interrupt_cb(decode_interrupt_cb);
2582 timer_start = av_gettime();
2584 for(; received_sigterm == 0;) {
2585 int file_index, ist_index;
2593 /* if 'q' pressed, exits */
2597 /* read_key() returns 0 on EOF */
2603 /* select the stream that we must read now by looking at the
2604 smallest output pts */
2606 for(i=0;i<nb_ostreams;i++) {
2609 os = output_files[ost->file_index];
2610 ist = ist_table[ost->source_index];
2611 if(ist->is_past_recording_time || no_packet[ist->file_index])
2613 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2614 ipts = (double)ist->pts;
2615 if (!file_table[ist->file_index].eof_reached){
2616 if(ipts < ipts_min) {
2618 if(input_sync ) file_index = ist->file_index;
2620 if(opts < opts_min) {
2622 if(!input_sync) file_index = ist->file_index;
2625 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2630 /* if none, if is finished */
2631 if (file_index < 0) {
2632 if(no_packet_count){
2634 memset(no_packet, 0, sizeof(no_packet));
2641 /* finish if limit size exhausted */
2642 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2645 /* read a frame from it and output it in the fifo */
2646 is = input_files[file_index];
2647 ret= av_read_frame(is, &pkt);
2648 if(ret == AVERROR(EAGAIN)){
2649 no_packet[file_index]=1;
2654 file_table[file_index].eof_reached = 1;
2662 memset(no_packet, 0, sizeof(no_packet));
2665 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2666 is->streams[pkt.stream_index]);
2668 /* the following test is needed in case new streams appear
2669 dynamically in stream : we ignore them */
2670 if (pkt.stream_index >= file_table[file_index].nb_streams)
2671 goto discard_packet;
2672 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2673 ist = ist_table[ist_index];
2675 goto discard_packet;
2677 if (pkt.dts != AV_NOPTS_VALUE)
2678 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2679 if (pkt.pts != AV_NOPTS_VALUE)
2680 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2682 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2683 && input_files_ts_scale[file_index][pkt.stream_index]){
2684 if(pkt.pts != AV_NOPTS_VALUE)
2685 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2686 if(pkt.dts != AV_NOPTS_VALUE)
2687 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2690 // 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);
2691 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2692 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2693 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2694 int64_t delta= pkt_dts - ist->next_pts;
2695 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2696 input_files_ts_offset[ist->file_index]-= delta;
2698 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2699 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2700 if(pkt.pts != AV_NOPTS_VALUE)
2701 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2705 /* finish if recording time exhausted */
2706 if (recording_time != INT64_MAX &&
2707 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2708 ist->is_past_recording_time = 1;
2709 goto discard_packet;
2712 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2713 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2716 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2717 ist->file_index, ist->index);
2720 av_free_packet(&pkt);
2725 av_free_packet(&pkt);
2727 /* dump report by using the output first video and audio streams */
2728 print_report(output_files, ost_table, nb_ostreams, 0);
2731 /* at the end of stream, we must flush the decoder buffers */
2732 for(i=0;i<nb_istreams;i++) {
2734 if (ist->decoding_needed) {
2735 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2741 /* write the trailer if needed and close file */
2742 for(i=0;i<nb_output_files;i++) {
2743 os = output_files[i];
2744 av_write_trailer(os);
2747 /* dump report by using the first video and audio streams */
2748 print_report(output_files, ost_table, nb_ostreams, 1);
2750 /* close each encoder */
2751 for(i=0;i<nb_ostreams;i++) {
2753 if (ost->encoding_needed) {
2754 av_freep(&ost->st->codec->stats_in);
2755 avcodec_close(ost->st->codec);
2758 avfilter_graph_free(&ost->graph);
2762 /* close each decoder */
2763 for(i=0;i<nb_istreams;i++) {
2765 if (ist->decoding_needed) {
2766 avcodec_close(ist->st->codec);
2774 av_freep(&bit_buffer);
2775 av_free(file_table);
2778 for(i=0;i<nb_istreams;i++) {
2785 for(i=0;i<nb_ostreams;i++) {
2788 if (ost->st->stream_copy)
2789 av_freep(&ost->st->codec->extradata);
2791 fclose(ost->logfile);
2792 ost->logfile = NULL;
2794 av_fifo_free(ost->fifo); /* works even if fifo is not
2795 initialized but set to zero */
2796 av_freep(&ost->st->codec->subtitle_header);
2797 av_free(ost->pict_tmp.data[0]);
2798 av_free(ost->forced_kf_pts);
2799 if (ost->video_resample)
2800 sws_freeContext(ost->img_resample_ctx);
2802 audio_resample_close(ost->resample);
2803 if (ost->reformat_ctx)
2804 av_audio_convert_free(ost->reformat_ctx);
2813 static void opt_format(const char *arg)
2815 last_asked_format = arg;
2818 static void opt_video_rc_override_string(const char *arg)
2820 video_rc_override_string = arg;
2823 static int opt_me_threshold(const char *opt, const char *arg)
2825 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2829 static int opt_verbose(const char *opt, const char *arg)
2831 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2835 static int opt_frame_rate(const char *opt, const char *arg)
2837 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2838 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2844 static int opt_bitrate(const char *opt, const char *arg)
2846 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2848 opt_default(opt, arg);
2850 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2851 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2856 static int opt_frame_crop(const char *opt, const char *arg)
2858 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2859 return AVERROR(EINVAL);
2862 static void opt_frame_size(const char *arg)
2864 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2865 fprintf(stderr, "Incorrect frame size\n");
2870 static int opt_pad(const char *opt, const char *arg) {
2871 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2875 static void opt_frame_pix_fmt(const char *arg)
2877 if (strcmp(arg, "list")) {
2878 frame_pix_fmt = av_get_pix_fmt(arg);
2879 if (frame_pix_fmt == PIX_FMT_NONE) {
2880 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2889 static void opt_frame_aspect_ratio(const char *arg)
2896 p = strchr(arg, ':');
2898 x = strtol(arg, &end, 10);
2900 y = strtol(end+1, &end, 10);
2902 ar = (double)x / (double)y;
2904 ar = strtod(arg, NULL);
2907 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2910 frame_aspect_ratio = ar;
2913 static int opt_metadata(const char *opt, const char *arg)
2915 char *mid= strchr(arg, '=');
2918 fprintf(stderr, "Missing =\n");
2923 av_metadata_set2(&metadata, arg, mid, 0);
2928 static int opt_qscale(const char *opt, const char *arg)
2930 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2931 if (video_qscale <= 0 || video_qscale > 255) {
2932 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2933 return AVERROR(EINVAL);
2938 static int opt_top_field_first(const char *opt, const char *arg)
2940 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2944 static int opt_thread_count(const char *opt, const char *arg)
2946 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2949 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2954 static void opt_audio_sample_fmt(const char *arg)
2956 if (strcmp(arg, "list")) {
2957 audio_sample_fmt = av_get_sample_fmt(arg);
2958 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2959 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2965 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2966 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2971 static int opt_audio_rate(const char *opt, const char *arg)
2973 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2977 static int opt_audio_channels(const char *opt, const char *arg)
2979 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2983 static int opt_video_channel(const char *opt, const char *arg)
2985 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2989 static void opt_video_standard(const char *arg)
2991 video_standard = av_strdup(arg);
2994 static void opt_codec(int *pstream_copy, char **pcodec_name,
2995 int codec_type, const char *arg)
2997 av_freep(pcodec_name);
2998 if (!strcmp(arg, "copy")) {
3001 *pcodec_name = av_strdup(arg);
3005 static void opt_audio_codec(const char *arg)
3007 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3010 static void opt_video_codec(const char *arg)
3012 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3015 static void opt_subtitle_codec(const char *arg)
3017 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3020 static int opt_codec_tag(const char *opt, const char *arg)
3023 uint32_t *codec_tag;
3025 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3026 !strcmp(opt, "vtag") ? &video_codec_tag :
3027 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3031 *codec_tag = strtol(arg, &tail, 0);
3033 *codec_tag = AV_RL32(arg);
3038 static void opt_map(const char *arg)
3043 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3044 m = &stream_maps[nb_stream_maps-1];
3046 m->file_index = strtol(arg, &p, 0);
3050 m->stream_index = strtol(p, &p, 0);
3053 m->sync_file_index = strtol(p, &p, 0);
3056 m->sync_stream_index = strtol(p, &p, 0);
3058 m->sync_file_index = m->file_index;
3059 m->sync_stream_index = m->stream_index;
3063 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3074 *index = strtol(++arg, endptr, 0);
3077 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3084 static void opt_map_metadata(const char *arg)
3086 AVMetaDataMap *m, *m1;
3089 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3090 &nb_meta_data_maps, nb_meta_data_maps + 1);
3092 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3093 m->file = strtol(arg, &p, 0);
3094 parse_meta_type(p, &m->type, &m->index, &p);
3098 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3099 m1->file = strtol(p, &p, 0);
3100 parse_meta_type(p, &m1->type, &m1->index, &p);
3102 if (m->type == 'g' || m1->type == 'g')
3103 metadata_global_autocopy = 0;
3104 if (m->type == 's' || m1->type == 's')
3105 metadata_streams_autocopy = 0;
3106 if (m->type == 'c' || m1->type == 'c')
3107 metadata_chapters_autocopy = 0;
3110 static void opt_map_meta_data(const char *arg)
3112 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3113 "Use -map_metadata instead.\n");
3114 opt_map_metadata(arg);
3117 static void opt_map_chapters(const char *arg)
3122 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3123 nb_chapter_maps + 1);
3124 c = &chapter_maps[nb_chapter_maps - 1];
3125 c->out_file = strtol(arg, &p, 0);
3129 c->in_file = strtol(p, &p, 0);
3132 static void opt_input_ts_scale(const char *arg)
3134 unsigned int stream;
3138 stream = strtol(arg, &p, 0);
3141 scale= strtod(p, &p);
3143 if(stream >= MAX_STREAMS)
3146 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);
3147 input_files_ts_scale[nb_input_files][stream]= scale;
3150 static int opt_recording_time(const char *opt, const char *arg)
3152 recording_time = parse_time_or_die(opt, arg, 1);
3156 static int opt_start_time(const char *opt, const char *arg)
3158 start_time = parse_time_or_die(opt, arg, 1);
3162 static int opt_recording_timestamp(const char *opt, const char *arg)
3164 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3168 static int opt_input_ts_offset(const char *opt, const char *arg)
3170 input_ts_offset = parse_time_or_die(opt, arg, 1);
3174 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3176 const char *codec_string = encoder ? "encoder" : "decoder";
3180 return CODEC_ID_NONE;
3182 avcodec_find_encoder_by_name(name) :
3183 avcodec_find_decoder_by_name(name);
3185 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3188 if(codec->type != type) {
3189 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3192 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3193 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3194 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3195 "results.\nAdd '-strict experimental' if you want to use it.\n",
3196 codec_string, codec->name);
3198 avcodec_find_encoder(codec->id) :
3199 avcodec_find_decoder(codec->id);
3200 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3201 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3202 codec_string, codec->name);
3208 static void opt_input_file(const char *filename)
3210 AVFormatContext *ic;
3211 AVFormatParameters params, *ap = ¶ms;
3212 AVInputFormat *file_iformat = NULL;
3213 int err, i, ret, rfps, rfps_base;
3216 if (last_asked_format) {
3217 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3218 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3221 last_asked_format = NULL;
3224 if (!strcmp(filename, "-"))
3227 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3228 !strcmp(filename, "/dev/stdin");
3230 /* get default parameters from command line */
3231 ic = avformat_alloc_context();
3233 print_error(filename, AVERROR(ENOMEM));
3237 memset(ap, 0, sizeof(*ap));
3238 ap->prealloced_context = 1;
3239 ap->sample_rate = audio_sample_rate;
3240 ap->channels = audio_channels;
3241 ap->time_base.den = frame_rate.num;
3242 ap->time_base.num = frame_rate.den;
3243 ap->width = frame_width;
3244 ap->height = frame_height;
3245 ap->pix_fmt = frame_pix_fmt;
3246 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3247 ap->channel = video_channel;
3248 ap->standard = video_standard;
3250 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3252 ic->video_codec_id =
3253 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3254 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3255 ic->audio_codec_id =
3256 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3257 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3258 ic->subtitle_codec_id=
3259 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3260 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3261 ic->flags |= AVFMT_FLAG_NONBLOCK;
3263 /* open the input file with generic libav function */
3264 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3266 print_error(filename, err);
3272 for(i=0; i<ic->nb_streams; i++){
3273 ic->streams[i]->discard= AVDISCARD_ALL;
3275 for(i=0; i<ic->nb_programs; i++){
3276 AVProgram *p= ic->programs[i];
3277 if(p->id != opt_programid){
3278 p->discard = AVDISCARD_ALL;
3281 for(j=0; j<p->nb_stream_indexes; j++){
3282 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3287 fprintf(stderr, "Specified program id not found\n");
3293 ic->loop_input = loop_input;
3295 /* If not enough info to get the stream parameters, we decode the
3296 first frames to get it. (used in mpeg case for example) */
3297 ret = av_find_stream_info(ic);
3298 if (ret < 0 && verbose >= 0) {
3299 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3300 av_close_input_file(ic);
3304 timestamp = start_time;
3305 /* add the stream start time */
3306 if (ic->start_time != AV_NOPTS_VALUE)
3307 timestamp += ic->start_time;
3309 /* if seeking requested, we execute it */
3310 if (start_time != 0) {
3311 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3313 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3314 filename, (double)timestamp / AV_TIME_BASE);
3316 /* reset seek info */
3320 /* update the current parameters so that they match the one of the input stream */
3321 for(i=0;i<ic->nb_streams;i++) {
3322 AVStream *st = ic->streams[i];
3323 AVCodecContext *dec = st->codec;
3324 dec->thread_count = thread_count;
3325 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3326 switch (dec->codec_type) {
3327 case AVMEDIA_TYPE_AUDIO:
3328 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3329 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]);
3330 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3331 channel_layout = dec->channel_layout;
3332 audio_channels = dec->channels;
3333 audio_sample_rate = dec->sample_rate;
3334 audio_sample_fmt = dec->sample_fmt;
3336 st->discard= AVDISCARD_ALL;
3337 /* Note that av_find_stream_info can add more streams, and we
3338 * currently have no chance of setting up lowres decoding
3339 * early enough for them. */
3341 audio_sample_rate >>= dec->lowres;
3343 case AVMEDIA_TYPE_VIDEO:
3344 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3345 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]);
3346 frame_height = dec->height;
3347 frame_width = dec->width;
3348 frame_pix_fmt = dec->pix_fmt;
3349 rfps = ic->streams[i]->r_frame_rate.num;
3350 rfps_base = ic->streams[i]->r_frame_rate.den;
3352 dec->flags |= CODEC_FLAG_EMU_EDGE;
3353 frame_height >>= dec->lowres;
3354 frame_width >>= dec->lowres;
3355 dec->height = frame_height;
3356 dec->width = frame_width;
3359 dec->debug |= FF_DEBUG_MV;
3361 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3364 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3365 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3367 (float)rfps / rfps_base, rfps, rfps_base);
3369 /* update the current frame rate to match the stream frame rate */
3370 frame_rate.num = rfps;
3371 frame_rate.den = rfps_base;
3374 st->discard= AVDISCARD_ALL;
3375 else if(video_discard)
3376 st->discard= video_discard;
3378 case AVMEDIA_TYPE_DATA:
3380 case AVMEDIA_TYPE_SUBTITLE:
3381 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3382 if(subtitle_disable)
3383 st->discard = AVDISCARD_ALL;
3385 case AVMEDIA_TYPE_ATTACHMENT:
3386 case AVMEDIA_TYPE_UNKNOWN:
3393 input_files[nb_input_files] = ic;
3394 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3395 /* dump the file content */
3397 av_dump_format(ic, nb_input_files, filename, 0);
3403 av_freep(&video_codec_name);
3404 av_freep(&audio_codec_name);
3405 av_freep(&subtitle_codec_name);
3408 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3409 int *has_subtitle_ptr)
3411 int has_video, has_audio, has_subtitle, i, j;
3412 AVFormatContext *ic;
3417 for(j=0;j<nb_input_files;j++) {
3418 ic = input_files[j];
3419 for(i=0;i<ic->nb_streams;i++) {
3420 AVCodecContext *enc = ic->streams[i]->codec;
3421 switch(enc->codec_type) {
3422 case AVMEDIA_TYPE_AUDIO:
3425 case AVMEDIA_TYPE_VIDEO:
3428 case AVMEDIA_TYPE_SUBTITLE:
3431 case AVMEDIA_TYPE_DATA:
3432 case AVMEDIA_TYPE_ATTACHMENT:
3433 case AVMEDIA_TYPE_UNKNOWN:
3440 *has_video_ptr = has_video;
3441 *has_audio_ptr = has_audio;
3442 *has_subtitle_ptr = has_subtitle;
3445 static void new_video_stream(AVFormatContext *oc, int file_idx)
3448 AVOutputStream *ost;
3449 AVCodecContext *video_enc;
3450 enum CodecID codec_id = CODEC_ID_NONE;
3451 AVCodec *codec= NULL;
3453 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3455 fprintf(stderr, "Could not alloc stream\n");
3458 ost = new_output_stream(oc, file_idx);
3460 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3461 if(!video_stream_copy){
3462 if (video_codec_name) {
3463 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3464 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3465 codec = avcodec_find_encoder_by_name(video_codec_name);
3466 output_codecs[nb_output_codecs-1] = codec;
3468 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3469 codec = avcodec_find_encoder(codec_id);
3471 ost->frame_aspect_ratio = frame_aspect_ratio;
3472 frame_aspect_ratio = 0;
3474 ost->avfilter= vfilters;
3479 avcodec_get_context_defaults3(st->codec, codec);
3480 ost->bitstream_filters = video_bitstream_filters;
3481 video_bitstream_filters= NULL;
3483 st->codec->thread_count= thread_count;
3485 video_enc = st->codec;
3488 video_enc->codec_tag= video_codec_tag;
3490 if( (video_global_header&1)
3491 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3492 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3493 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3495 if(video_global_header&2){
3496 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3497 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3500 if (video_stream_copy) {
3501 st->stream_copy = 1;
3502 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3503 video_enc->sample_aspect_ratio =
3504 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3508 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3510 video_enc->codec_id = codec_id;
3511 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3513 if (codec && codec->supported_framerates && !force_fps)
3514 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3515 video_enc->time_base.den = fps.num;
3516 video_enc->time_base.num = fps.den;
3518 video_enc->width = frame_width;
3519 video_enc->height = frame_height;
3520 video_enc->pix_fmt = frame_pix_fmt;
3521 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3522 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3524 choose_pixel_fmt(st, codec);
3527 video_enc->gop_size = 0;
3528 if (video_qscale || same_quality) {
3529 video_enc->flags |= CODEC_FLAG_QSCALE;
3530 video_enc->global_quality=
3531 st->quality = FF_QP2LAMBDA * video_qscale;
3535 video_enc->intra_matrix = intra_matrix;
3537 video_enc->inter_matrix = inter_matrix;
3539 p= video_rc_override_string;
3542 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3544 fprintf(stderr, "error parsing rc_override\n");
3547 video_enc->rc_override=
3548 av_realloc(video_enc->rc_override,
3549 sizeof(RcOverride)*(i+1));
3550 video_enc->rc_override[i].start_frame= start;
3551 video_enc->rc_override[i].end_frame = end;
3553 video_enc->rc_override[i].qscale= q;
3554 video_enc->rc_override[i].quality_factor= 1.0;
3557 video_enc->rc_override[i].qscale= 0;
3558 video_enc->rc_override[i].quality_factor= -q/100.0;
3563 video_enc->rc_override_count=i;
3564 if (!video_enc->rc_initial_buffer_occupancy)
3565 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3566 video_enc->me_threshold= me_threshold;
3567 video_enc->intra_dc_precision= intra_dc_precision - 8;
3570 video_enc->flags|= CODEC_FLAG_PSNR;
3575 video_enc->flags |= CODEC_FLAG_PASS1;
3577 video_enc->flags |= CODEC_FLAG_PASS2;
3581 if (forced_key_frames)
3582 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3584 if (video_language) {
3585 av_metadata_set2(&st->metadata, "language", video_language, 0);
3586 av_freep(&video_language);
3589 /* reset some key parameters */
3591 av_freep(&video_codec_name);
3592 av_freep(&forced_key_frames);
3593 video_stream_copy = 0;
3594 frame_pix_fmt = PIX_FMT_NONE;
3597 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3600 AVOutputStream *ost;
3601 AVCodec *codec= NULL;
3602 AVCodecContext *audio_enc;
3603 enum CodecID codec_id = CODEC_ID_NONE;
3605 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3607 fprintf(stderr, "Could not alloc stream\n");
3610 ost = new_output_stream(oc, file_idx);
3612 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3613 if(!audio_stream_copy){
3614 if (audio_codec_name) {
3615 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3616 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3617 codec = avcodec_find_encoder_by_name(audio_codec_name);
3618 output_codecs[nb_output_codecs-1] = codec;
3620 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3621 codec = avcodec_find_encoder(codec_id);
3625 avcodec_get_context_defaults3(st->codec, codec);
3627 ost->bitstream_filters = audio_bitstream_filters;
3628 audio_bitstream_filters= NULL;
3630 st->codec->thread_count= thread_count;
3632 audio_enc = st->codec;
3633 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3636 audio_enc->codec_tag= audio_codec_tag;
3638 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3639 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3640 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3642 if (audio_stream_copy) {
3643 st->stream_copy = 1;
3644 audio_enc->channels = audio_channels;
3645 audio_enc->sample_rate = audio_sample_rate;
3647 audio_enc->codec_id = codec_id;
3648 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3650 if (audio_qscale > QSCALE_NONE) {
3651 audio_enc->flags |= CODEC_FLAG_QSCALE;
3652 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3654 audio_enc->channels = audio_channels;
3655 audio_enc->sample_fmt = audio_sample_fmt;
3656 audio_enc->sample_rate = audio_sample_rate;
3657 audio_enc->channel_layout = channel_layout;
3658 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3659 audio_enc->channel_layout = 0;
3660 choose_sample_fmt(st, codec);
3661 choose_sample_rate(st, codec);
3663 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3664 if (audio_language) {
3665 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3666 av_freep(&audio_language);
3669 /* reset some key parameters */
3671 av_freep(&audio_codec_name);
3672 audio_stream_copy = 0;
3675 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3678 AVOutputStream *ost;
3679 AVCodec *codec=NULL;
3680 AVCodecContext *subtitle_enc;
3681 enum CodecID codec_id = CODEC_ID_NONE;
3683 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3685 fprintf(stderr, "Could not alloc stream\n");
3688 ost = new_output_stream(oc, file_idx);
3689 subtitle_enc = st->codec;
3690 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3691 if(!subtitle_stream_copy){
3692 if (subtitle_codec_name) {
3693 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3694 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3695 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3697 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3698 codec = avcodec_find_encoder(codec_id);
3701 avcodec_get_context_defaults3(st->codec, codec);
3703 ost->bitstream_filters = subtitle_bitstream_filters;
3704 subtitle_bitstream_filters= NULL;
3706 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3708 if(subtitle_codec_tag)
3709 subtitle_enc->codec_tag= subtitle_codec_tag;
3711 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3712 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3713 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3715 if (subtitle_stream_copy) {
3716 st->stream_copy = 1;
3718 subtitle_enc->codec_id = codec_id;
3719 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3722 if (subtitle_language) {
3723 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3724 av_freep(&subtitle_language);
3727 subtitle_disable = 0;
3728 av_freep(&subtitle_codec_name);
3729 subtitle_stream_copy = 0;
3732 static int opt_new_stream(const char *opt, const char *arg)
3734 AVFormatContext *oc;
3735 int file_idx = nb_output_files - 1;
3736 if (nb_output_files <= 0) {
3737 fprintf(stderr, "At least one output file must be specified\n");
3740 oc = output_files[file_idx];
3742 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3743 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3744 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3749 /* arg format is "output-stream-index:streamid-value". */
3750 static int opt_streamid(const char *opt, const char *arg)
3756 strncpy(idx_str, arg, sizeof(idx_str));
3757 idx_str[sizeof(idx_str)-1] = '\0';
3758 p = strchr(idx_str, ':');
3761 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3766 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3767 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3768 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3772 static void opt_output_file(const char *filename)
3774 AVFormatContext *oc;
3775 int err, use_video, use_audio, use_subtitle;
3776 int input_has_video, input_has_audio, input_has_subtitle;
3777 AVFormatParameters params, *ap = ¶ms;
3778 AVOutputFormat *file_oformat;
3780 if (!strcmp(filename, "-"))
3783 oc = avformat_alloc_context();
3785 print_error(filename, AVERROR(ENOMEM));
3789 if (last_asked_format) {
3790 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3791 if (!file_oformat) {
3792 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3795 last_asked_format = NULL;
3797 file_oformat = av_guess_format(NULL, filename, NULL);
3798 if (!file_oformat) {
3799 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3805 oc->oformat = file_oformat;
3806 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3808 if (!strcmp(file_oformat->name, "ffm") &&
3809 av_strstart(filename, "http:", NULL)) {
3810 /* special case for files sent to ffserver: we get the stream
3811 parameters from ffserver */
3812 int err = read_ffserver_streams(oc, filename);
3814 print_error(filename, err);
3818 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3819 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3820 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3822 /* disable if no corresponding type found and at least one
3824 if (nb_input_files > 0) {
3825 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3826 &input_has_subtitle);
3827 if (!input_has_video)
3829 if (!input_has_audio)
3831 if (!input_has_subtitle)
3835 /* manual disable */
3836 if (audio_disable) use_audio = 0;
3837 if (video_disable) use_video = 0;
3838 if (subtitle_disable) use_subtitle = 0;
3840 if (use_video) new_video_stream(oc, nb_output_files);
3841 if (use_audio) new_audio_stream(oc, nb_output_files);
3842 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3844 oc->timestamp = recording_timestamp;
3846 av_metadata_copy(&oc->metadata, metadata, 0);
3847 av_metadata_free(&metadata);
3850 output_files[nb_output_files++] = oc;
3852 /* check filename in case of an image number is expected */
3853 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3854 if (!av_filename_number_test(oc->filename)) {
3855 print_error(oc->filename, AVERROR(EINVAL));
3860 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3861 /* test if it already exists to avoid loosing precious files */
3862 if (!file_overwrite &&
3863 (strchr(filename, ':') == NULL ||
3864 filename[1] == ':' ||
3865 av_strstart(filename, "file:", NULL))) {
3866 if (avio_check(filename, 0) == 0) {
3868 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3870 if (!read_yesno()) {
3871 fprintf(stderr, "Not overwriting - exiting\n");
3876 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3883 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3884 print_error(filename, err);
3889 memset(ap, 0, sizeof(*ap));
3890 if (av_set_parameters(oc, ap) < 0) {
3891 fprintf(stderr, "%s: Invalid encoding parameters\n",
3896 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3897 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3898 oc->loop_output = loop_output;
3900 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3902 av_freep(&forced_key_frames);
3905 /* same option as mencoder */
3906 static int opt_pass(const char *opt, const char *arg)
3908 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3912 static int64_t getutime(void)
3915 struct rusage rusage;
3917 getrusage(RUSAGE_SELF, &rusage);
3918 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3919 #elif HAVE_GETPROCESSTIMES
3921 FILETIME c, e, k, u;
3922 proc = GetCurrentProcess();
3923 GetProcessTimes(proc, &c, &e, &k, &u);
3924 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3926 return av_gettime();
3930 static int64_t getmaxrss(void)
3932 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3933 struct rusage rusage;
3934 getrusage(RUSAGE_SELF, &rusage);
3935 return (int64_t)rusage.ru_maxrss * 1024;
3936 #elif HAVE_GETPROCESSMEMORYINFO
3938 PROCESS_MEMORY_COUNTERS memcounters;
3939 proc = GetCurrentProcess();
3940 memcounters.cb = sizeof(memcounters);
3941 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3942 return memcounters.PeakPagefileUsage;
3948 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3951 const char *p = str;
3958 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3965 static void opt_inter_matrix(const char *arg)
3967 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3968 parse_matrix_coeffs(inter_matrix, arg);
3971 static void opt_intra_matrix(const char *arg)
3973 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3974 parse_matrix_coeffs(intra_matrix, arg);
3977 static void show_usage(void)
3979 printf("Hyper fast Audio and Video encoder\n");
3980 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3984 static void show_help(void)
3987 AVOutputFormat *oformat = NULL;
3989 av_log_set_callback(log_callback_help);
3991 show_help_options(options, "Main options:\n",
3992 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3993 show_help_options(options, "\nAdvanced options:\n",
3994 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3996 show_help_options(options, "\nVideo options:\n",
3997 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3999 show_help_options(options, "\nAdvanced Video options:\n",
4000 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4001 OPT_VIDEO | OPT_EXPERT);
4002 show_help_options(options, "\nAudio options:\n",
4003 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4005 show_help_options(options, "\nAdvanced Audio options:\n",
4006 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4007 OPT_AUDIO | OPT_EXPERT);
4008 show_help_options(options, "\nSubtitle options:\n",
4009 OPT_SUBTITLE | OPT_GRAB,
4011 show_help_options(options, "\nAudio/Video grab options:\n",
4015 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4018 /* individual codec options */
4020 while ((c = av_codec_next(c))) {
4021 if (c->priv_class) {
4022 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4027 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4030 /* individual muxer options */
4031 while ((oformat = av_oformat_next(oformat))) {
4032 if (oformat->priv_class) {
4033 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4038 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4041 static void opt_target(const char *arg)
4043 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4044 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4046 if(!strncmp(arg, "pal-", 4)) {
4049 } else if(!strncmp(arg, "ntsc-", 5)) {
4052 } else if(!strncmp(arg, "film-", 5)) {
4057 /* Calculate FR via float to avoid int overflow */
4058 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4061 } else if((fr == 29970) || (fr == 23976)) {
4064 /* Try to determine PAL/NTSC by peeking in the input files */
4065 if(nb_input_files) {
4067 for(j = 0; j < nb_input_files; j++) {
4068 for(i = 0; i < input_files[j]->nb_streams; i++) {
4069 AVCodecContext *c = input_files[j]->streams[i]->codec;
4070 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4072 fr = c->time_base.den * 1000 / c->time_base.num;
4076 } else if((fr == 29970) || (fr == 23976)) {
4086 if(verbose > 0 && norm != UNKNOWN)
4087 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4090 if(norm == UNKNOWN) {
4091 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4092 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4093 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4097 if(!strcmp(arg, "vcd")) {
4099 opt_video_codec("mpeg1video");
4100 opt_audio_codec("mp2");
4103 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4104 opt_frame_rate(NULL, frame_rates[norm]);
4105 opt_default("g", norm == PAL ? "15" : "18");
4107 opt_default("b", "1150000");
4108 opt_default("maxrate", "1150000");
4109 opt_default("minrate", "1150000");
4110 opt_default("bufsize", "327680"); // 40*1024*8;
4112 opt_default("ab", "224000");
4113 audio_sample_rate = 44100;
4116 opt_default("packetsize", "2324");
4117 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4119 /* We have to offset the PTS, so that it is consistent with the SCR.
4120 SCR starts at 36000, but the first two packs contain only padding
4121 and the first pack from the other stream, respectively, may also have
4122 been written before.
4123 So the real data starts at SCR 36000+3*1200. */
4124 mux_preload= (36000+3*1200) / 90000.0; //0.44
4125 } else if(!strcmp(arg, "svcd")) {
4127 opt_video_codec("mpeg2video");
4128 opt_audio_codec("mp2");
4131 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4132 opt_frame_rate(NULL, frame_rates[norm]);
4133 opt_default("g", norm == PAL ? "15" : "18");
4135 opt_default("b", "2040000");
4136 opt_default("maxrate", "2516000");
4137 opt_default("minrate", "0"); //1145000;
4138 opt_default("bufsize", "1835008"); //224*1024*8;
4139 opt_default("flags", "+scan_offset");
4142 opt_default("ab", "224000");
4143 audio_sample_rate = 44100;
4145 opt_default("packetsize", "2324");
4147 } else if(!strcmp(arg, "dvd")) {
4149 opt_video_codec("mpeg2video");
4150 opt_audio_codec("ac3");
4153 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4154 opt_frame_rate(NULL, frame_rates[norm]);
4155 opt_default("g", norm == PAL ? "15" : "18");
4157 opt_default("b", "6000000");
4158 opt_default("maxrate", "9000000");
4159 opt_default("minrate", "0"); //1500000;
4160 opt_default("bufsize", "1835008"); //224*1024*8;
4162 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4163 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4165 opt_default("ab", "448000");
4166 audio_sample_rate = 48000;
4168 } else if(!strncmp(arg, "dv", 2)) {
4172 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4173 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4174 (norm == PAL ? "yuv420p" : "yuv411p"));
4175 opt_frame_rate(NULL, frame_rates[norm]);
4177 audio_sample_rate = 48000;
4181 fprintf(stderr, "Unknown target: %s\n", arg);
4186 static void opt_vstats_file (const char *arg)
4188 av_free (vstats_filename);
4189 vstats_filename=av_strdup (arg);
4192 static void opt_vstats (void)
4195 time_t today2 = time(NULL);
4196 struct tm *today = localtime(&today2);
4198 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4200 opt_vstats_file(filename);
4203 static int opt_bsf(const char *opt, const char *arg)
4205 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4206 AVBitStreamFilterContext **bsfp;
4209 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4213 bsfp= *opt == 'v' ? &video_bitstream_filters :
4214 *opt == 'a' ? &audio_bitstream_filters :
4215 &subtitle_bitstream_filters;
4217 bsfp= &(*bsfp)->next;
4224 static int opt_preset(const char *opt, const char *arg)
4227 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4228 char *codec_name = *opt == 'v' ? video_codec_name :
4229 *opt == 'a' ? audio_codec_name :
4230 subtitle_codec_name;
4232 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4233 fprintf(stderr, "File for preset '%s' not found\n", arg);
4238 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4239 if(line[0] == '#' && !e)
4241 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4243 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4246 if(!strcmp(tmp, "acodec")){
4247 opt_audio_codec(tmp2);
4248 }else if(!strcmp(tmp, "vcodec")){
4249 opt_video_codec(tmp2);
4250 }else if(!strcmp(tmp, "scodec")){
4251 opt_subtitle_codec(tmp2);
4252 }else if(opt_default(tmp, tmp2) < 0){
4253 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4263 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4267 static void opt_passlogfile(const char *arg)
4269 pass_logfilename_prefix = arg;
4270 opt_default("passlogfile", arg);
4273 static const OptionDef options[] = {
4275 #include "cmdutils_common_opts.h"
4276 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4277 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4278 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4279 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4280 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4281 "outfile[,metadata]:infile[,metadata]" },
4282 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4283 "outfile[,metadata]:infile[,metadata]" },
4284 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4285 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4286 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4287 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4288 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4289 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4290 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4291 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4292 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4293 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4294 "add timings for benchmarking" },
4295 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4296 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4297 "dump each input packet" },
4298 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4299 "when dumping packets, also dump the payload" },
4300 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4301 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4302 { "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)", "" },
4303 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4304 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4305 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4306 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4307 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4308 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4309 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4310 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4311 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4312 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4313 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4314 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4315 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4316 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4319 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4320 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4321 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4322 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4323 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4324 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4325 { "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" },
4326 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4327 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4328 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4329 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4330 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4331 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4332 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4333 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4334 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4335 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4336 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4337 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4338 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4339 { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4340 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4341 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4342 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4343 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4344 "use same quantizer as source (implies VBR)" },
4345 { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4346 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4347 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4348 "deinterlace pictures" },
4349 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4350 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4351 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4353 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4355 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4356 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4357 { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4358 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4359 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4360 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4361 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4362 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4363 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4364 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4365 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4368 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4369 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4370 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4371 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4372 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4373 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4374 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4375 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4376 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4377 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4378 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4379 { "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" },
4381 /* subtitle options */
4382 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4383 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4384 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4385 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4386 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4389 { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4390 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4391 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4394 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4395 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4397 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4398 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4399 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4401 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4402 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4403 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4404 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4406 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4410 int main(int argc, char **argv)
4414 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4416 if(argc>1 && !strcmp(argv[1], "-d")){
4419 av_log_set_callback(log_callback_null);
4424 avcodec_register_all();
4426 avdevice_register_all();
4429 avfilter_register_all();
4434 if(isatty(STDIN_FILENO))
4435 avio_set_interrupt_cb(decode_interrupt_cb);
4443 parse_options(argc, argv, options, opt_output_file);
4445 if(nb_output_files <= 0 && nb_input_files == 0) {
4447 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4451 /* file converter / grab */
4452 if (nb_output_files <= 0) {
4453 fprintf(stderr, "At least one output file must be specified\n");
4457 if (nb_input_files == 0) {
4458 fprintf(stderr, "At least one input file must be specified\n");
4463 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4464 stream_maps, nb_stream_maps) < 0)
4466 ti = getutime() - ti;
4468 int maxrss = getmaxrss() / 1024;
4469 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4472 return ffmpeg_exit(0);