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 = AV_PICTURE_TYPE_I;
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_picture_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) {
1634 if (!picture.sample_aspect_ratio.num)
1635 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1636 // add it to be filtered
1637 av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1639 ist->st->codec->width, ist->st->codec->height,
1640 ist->st->codec->pix_fmt, ""); //TODO user setable params
1646 // preprocess audio (volume)
1647 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1648 if (audio_volume != 256) {
1651 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1652 int v = ((*volp) * audio_volume + 128) >> 8;
1653 if (v < -32768) v = -32768;
1654 if (v > 32767) v = 32767;
1660 /* frame rate emulation */
1662 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1663 int64_t now = av_gettime() - ist->start;
1667 /* if output time reached then transcode raw format,
1668 encode packets and output them */
1669 if (start_time == 0 || ist->pts >= start_time)
1670 for(i=0;i<nb_ostreams;i++) {
1674 if (ost->source_index == ist_index) {
1676 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1677 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1678 while (frame_available) {
1679 AVRational ist_pts_tb;
1680 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1681 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1683 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1685 os = output_files[ost->file_index];
1687 /* set the input output pts pairs */
1688 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1690 if (ost->encoding_needed) {
1691 av_assert0(ist->decoding_needed);
1692 switch(ost->st->codec->codec_type) {
1693 case AVMEDIA_TYPE_AUDIO:
1694 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1696 case AVMEDIA_TYPE_VIDEO:
1698 if (ost->picref->video && !ost->frame_aspect_ratio)
1699 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1701 do_video_out(os, ost, ist, &picture, &frame_size);
1702 if (vstats_filename && frame_size)
1703 do_video_stats(os, ost, frame_size);
1705 case AVMEDIA_TYPE_SUBTITLE:
1706 do_subtitle_out(os, ost, ist, &subtitle,
1713 AVFrame avframe; //FIXME/XXX remove this
1715 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1717 av_init_packet(&opkt);
1719 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1720 #if !CONFIG_AVFILTER
1726 /* no reencoding needed : output the packet directly */
1727 /* force the input stream PTS */
1729 avcodec_get_frame_defaults(&avframe);
1730 ost->st->codec->coded_frame= &avframe;
1731 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1733 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1734 audio_size += data_size;
1735 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1736 video_size += data_size;
1740 opkt.stream_index= ost->index;
1741 if(pkt->pts != AV_NOPTS_VALUE)
1742 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1744 opkt.pts= AV_NOPTS_VALUE;
1746 if (pkt->dts == AV_NOPTS_VALUE)
1747 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1749 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1750 opkt.dts -= ost_tb_start_time;
1752 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1753 opkt.flags= pkt->flags;
1755 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1756 if( ost->st->codec->codec_id != CODEC_ID_H264
1757 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1758 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1760 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1761 opkt.destruct= av_destruct_packet;
1763 opkt.data = data_buf;
1764 opkt.size = data_size;
1767 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1768 ost->st->codec->frame_number++;
1769 ost->frame_number++;
1770 av_free_packet(&opkt);
1774 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1775 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1777 avfilter_unref_buffer(ost->picref);
1783 av_free(buffer_to_free);
1784 /* XXX: allocate the subtitles in the codec ? */
1785 if (subtitle_to_free) {
1786 avsubtitle_free(subtitle_to_free);
1787 subtitle_to_free = NULL;
1794 for(i=0;i<nb_ostreams;i++) {
1796 if (ost->source_index == ist_index) {
1797 AVCodecContext *enc= ost->st->codec;
1798 os = output_files[ost->file_index];
1800 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1802 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1805 if (ost->encoding_needed) {
1809 av_init_packet(&pkt);
1810 pkt.stream_index= ost->index;
1812 switch(ost->st->codec->codec_type) {
1813 case AVMEDIA_TYPE_AUDIO:
1814 fifo_bytes = av_fifo_size(ost->fifo);
1816 /* encode any samples remaining in fifo */
1817 if (fifo_bytes > 0) {
1818 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1819 int fs_tmp = enc->frame_size;
1821 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1822 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1823 enc->frame_size = fifo_bytes / (osize * enc->channels);
1825 int frame_bytes = enc->frame_size*osize*enc->channels;
1826 if (allocated_audio_buf_size < frame_bytes)
1828 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1831 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1832 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1833 ost->st->time_base.num, enc->sample_rate);
1834 enc->frame_size = fs_tmp;
1837 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1840 fprintf(stderr, "Audio encoding failed\n");
1844 pkt.flags |= AV_PKT_FLAG_KEY;
1846 case AVMEDIA_TYPE_VIDEO:
1847 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1849 fprintf(stderr, "Video encoding failed\n");
1853 if(enc->coded_frame && enc->coded_frame->key_frame)
1854 pkt.flags |= AV_PKT_FLAG_KEY;
1855 if (ost->logfile && enc->stats_out) {
1856 fprintf(ost->logfile, "%s", enc->stats_out);
1865 pkt.data= bit_buffer;
1867 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1868 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1869 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1881 static void print_sdp(AVFormatContext **avc, int n)
1885 av_sdp_create(avc, n, sdp, sizeof(sdp));
1886 printf("SDP:\n%s\n", sdp);
1890 static int copy_chapters(int infile, int outfile)
1892 AVFormatContext *is = input_files[infile];
1893 AVFormatContext *os = output_files[outfile];
1896 for (i = 0; i < is->nb_chapters; i++) {
1897 AVChapter *in_ch = is->chapters[i], *out_ch;
1898 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1899 AV_TIME_BASE_Q, in_ch->time_base);
1900 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1901 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1904 if (in_ch->end < ts_off)
1906 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1909 out_ch = av_mallocz(sizeof(AVChapter));
1911 return AVERROR(ENOMEM);
1913 out_ch->id = in_ch->id;
1914 out_ch->time_base = in_ch->time_base;
1915 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1916 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1918 if (metadata_chapters_autocopy)
1919 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1922 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1924 return AVERROR(ENOMEM);
1925 os->chapters[os->nb_chapters - 1] = out_ch;
1930 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1931 AVCodecContext *avctx)
1937 for (p = kf; *p; p++)
1940 ost->forced_kf_count = n;
1941 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1942 if (!ost->forced_kf_pts) {
1943 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1946 for (i = 0; i < n; i++) {
1947 p = i ? strchr(p, ',') + 1 : kf;
1948 t = parse_time_or_die("force_key_frames", p, 1);
1949 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1954 * The following code is the main loop of the file converter
1956 static int transcode(AVFormatContext **output_files,
1957 int nb_output_files,
1958 AVFormatContext **input_files,
1960 AVStreamMap *stream_maps, int nb_stream_maps)
1962 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1963 AVFormatContext *is, *os;
1964 AVCodecContext *codec, *icodec;
1965 AVOutputStream *ost, **ost_table = NULL;
1966 AVInputStream *ist, **ist_table = NULL;
1967 AVInputFile *file_table;
1971 uint8_t no_packet[MAX_FILES]={0};
1972 int no_packet_count=0;
1973 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1974 int nb_streams[AVMEDIA_TYPE_NB]={0};
1976 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1980 /* input stream init */
1982 for(i=0;i<nb_input_files;i++) {
1983 is = input_files[i];
1984 file_table[i].ist_index = j;
1985 file_table[i].nb_streams = is->nb_streams;
1986 j += is->nb_streams;
1990 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1994 for(i=0;i<nb_istreams;i++) {
1995 ist = av_mallocz(sizeof(AVInputStream));
2001 for(i=0;i<nb_input_files;i++) {
2002 is = input_files[i];
2003 for(k=0;k<is->nb_streams;k++) {
2004 ist = ist_table[j++];
2005 ist->st = is->streams[k];
2006 ist->file_index = i;
2008 ist->discard = 1; /* the stream is discarded by default
2012 ist->start = av_gettime();
2017 /* output stream init */
2019 for(i=0;i<nb_output_files;i++) {
2020 os = output_files[i];
2021 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2022 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2023 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2024 ret = AVERROR(EINVAL);
2027 nb_ostreams += os->nb_streams;
2029 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2030 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2031 ret = AVERROR(EINVAL);
2035 /* Sanity check the mapping args -- do the input files & streams exist? */
2036 for(i=0;i<nb_stream_maps;i++) {
2037 int fi = stream_maps[i].file_index;
2038 int si = stream_maps[i].stream_index;
2040 if (fi < 0 || fi > nb_input_files - 1 ||
2041 si < 0 || si > file_table[fi].nb_streams - 1) {
2042 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2043 ret = AVERROR(EINVAL);
2046 fi = stream_maps[i].sync_file_index;
2047 si = stream_maps[i].sync_stream_index;
2048 if (fi < 0 || fi > nb_input_files - 1 ||
2049 si < 0 || si > file_table[fi].nb_streams - 1) {
2050 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2051 ret = AVERROR(EINVAL);
2056 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2060 for(k=0;k<nb_output_files;k++) {
2061 os = output_files[k];
2062 for(i=0;i<os->nb_streams;i++,n++) {
2063 nb_streams[os->streams[i]->codec->codec_type]++;
2066 for(step=1<<30; step; step>>=1){
2067 int found_streams[AVMEDIA_TYPE_NB]={0};
2068 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2069 nb_frame_threshold[j] += step;
2071 for(j=0; j<nb_istreams; j++) {
2076 AVFormatContext *f= input_files[ ist->file_index ];
2078 for(pi=0; pi<f->nb_programs; pi++){
2079 AVProgram *p= f->programs[pi];
2080 if(p->id == opt_programid)
2081 for(si=0; si<p->nb_stream_indexes; si++){
2082 if(f->streams[ p->stream_index[si] ] == ist->st)
2087 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2088 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2089 found_streams[ist->st->codec->codec_type]++;
2092 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2093 if(found_streams[j] < nb_streams[j])
2094 nb_frame_threshold[j] -= step;
2097 for(k=0;k<nb_output_files;k++) {
2098 os = output_files[k];
2099 for(i=0;i<os->nb_streams;i++,n++) {
2101 ost = ost_table[n] = output_streams_for_file[k][i];
2102 ost->st = os->streams[i];
2103 if (nb_stream_maps > 0) {
2104 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2105 stream_maps[n].stream_index;
2107 /* Sanity check that the stream types match */
2108 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2109 int i= ost->file_index;
2110 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2111 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2112 stream_maps[n].file_index, stream_maps[n].stream_index,
2113 ost->file_index, ost->index);
2118 /* get corresponding input stream index : we select the first one with the right type */
2120 for(j=0;j<nb_istreams;j++) {
2125 AVFormatContext *f= input_files[ ist->file_index ];
2127 for(pi=0; pi<f->nb_programs; pi++){
2128 AVProgram *p= f->programs[pi];
2129 if(p->id == opt_programid)
2130 for(si=0; si<p->nb_stream_indexes; si++){
2131 if(f->streams[ p->stream_index[si] ] == ist->st)
2136 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2137 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2138 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2139 ost->source_index = j;
2146 if(! opt_programid) {
2147 /* try again and reuse existing stream */
2148 for(j=0;j<nb_istreams;j++) {
2150 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2151 && ist->st->discard != AVDISCARD_ALL) {
2152 ost->source_index = j;
2158 int i= ost->file_index;
2159 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2160 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2161 ost->file_index, ost->index);
2166 ist = ist_table[ost->source_index];
2168 ost->sync_ist = (nb_stream_maps > 0) ?
2169 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2170 stream_maps[n].sync_stream_index] : ist;
2174 /* for each output stream, we compute the right encoding parameters */
2175 for(i=0;i<nb_ostreams;i++) {
2177 os = output_files[ost->file_index];
2178 ist = ist_table[ost->source_index];
2180 codec = ost->st->codec;
2181 icodec = ist->st->codec;
2183 if (metadata_streams_autocopy)
2184 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2185 AV_METADATA_DONT_OVERWRITE);
2187 ost->st->disposition = ist->st->disposition;
2188 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2189 codec->chroma_sample_location = icodec->chroma_sample_location;
2191 if (ost->st->stream_copy) {
2192 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2194 if (extra_size > INT_MAX)
2197 /* if stream_copy is selected, no need to decode or encode */
2198 codec->codec_id = icodec->codec_id;
2199 codec->codec_type = icodec->codec_type;
2201 if(!codec->codec_tag){
2202 if( !os->oformat->codec_tag
2203 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2204 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2205 codec->codec_tag = icodec->codec_tag;
2208 codec->bit_rate = icodec->bit_rate;
2209 codec->rc_max_rate = icodec->rc_max_rate;
2210 codec->rc_buffer_size = icodec->rc_buffer_size;
2211 codec->extradata= av_mallocz(extra_size);
2212 if (!codec->extradata)
2214 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2215 codec->extradata_size= icodec->extradata_size;
2216 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){
2217 codec->time_base = icodec->time_base;
2218 codec->time_base.num *= icodec->ticks_per_frame;
2219 av_reduce(&codec->time_base.num, &codec->time_base.den,
2220 codec->time_base.num, codec->time_base.den, INT_MAX);
2222 codec->time_base = ist->st->time_base;
2223 switch(codec->codec_type) {
2224 case AVMEDIA_TYPE_AUDIO:
2225 if(audio_volume != 256) {
2226 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2229 codec->channel_layout = icodec->channel_layout;
2230 codec->sample_rate = icodec->sample_rate;
2231 codec->channels = icodec->channels;
2232 codec->frame_size = icodec->frame_size;
2233 codec->audio_service_type = icodec->audio_service_type;
2234 codec->block_align= icodec->block_align;
2235 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2236 codec->block_align= 0;
2237 if(codec->codec_id == CODEC_ID_AC3)
2238 codec->block_align= 0;
2240 case AVMEDIA_TYPE_VIDEO:
2241 codec->pix_fmt = icodec->pix_fmt;
2242 codec->width = icodec->width;
2243 codec->height = icodec->height;
2244 codec->has_b_frames = icodec->has_b_frames;
2245 if (!codec->sample_aspect_ratio.num) {
2246 codec->sample_aspect_ratio =
2247 ost->st->sample_aspect_ratio =
2248 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2249 ist->st->codec->sample_aspect_ratio.num ?
2250 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2253 case AVMEDIA_TYPE_SUBTITLE:
2254 codec->width = icodec->width;
2255 codec->height = icodec->height;
2261 switch(codec->codec_type) {
2262 case AVMEDIA_TYPE_AUDIO:
2263 ost->fifo= av_fifo_alloc(1024);
2266 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2267 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2268 icodec->request_channels = codec->channels;
2269 ist->decoding_needed = 1;
2270 ost->encoding_needed = 1;
2271 ost->resample_sample_fmt = icodec->sample_fmt;
2272 ost->resample_sample_rate = icodec->sample_rate;
2273 ost->resample_channels = icodec->channels;
2275 case AVMEDIA_TYPE_VIDEO:
2276 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2277 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2280 ost->video_resample = codec->width != icodec->width ||
2281 codec->height != icodec->height ||
2282 codec->pix_fmt != icodec->pix_fmt;
2283 if (ost->video_resample) {
2284 #if !CONFIG_AVFILTER
2285 avcodec_get_frame_defaults(&ost->pict_tmp);
2286 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2287 codec->width, codec->height)) {
2288 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2291 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2292 ost->img_resample_ctx = sws_getContext(
2299 sws_flags, NULL, NULL, NULL);
2300 if (ost->img_resample_ctx == NULL) {
2301 fprintf(stderr, "Cannot get resampling context\n");
2305 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2307 ost->resample_height = icodec->height;
2308 ost->resample_width = icodec->width;
2309 ost->resample_pix_fmt= icodec->pix_fmt;
2310 ost->encoding_needed = 1;
2311 ist->decoding_needed = 1;
2314 if (configure_video_filters(ist, ost)) {
2315 fprintf(stderr, "Error opening filters!\n");
2320 case AVMEDIA_TYPE_SUBTITLE:
2321 ost->encoding_needed = 1;
2322 ist->decoding_needed = 1;
2329 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2330 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2331 char logfilename[1024];
2334 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2335 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2337 if (codec->flags & CODEC_FLAG_PASS1) {
2338 f = fopen(logfilename, "wb");
2340 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2346 size_t logbuffer_size;
2347 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2348 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2351 codec->stats_in = logbuffer;
2355 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2356 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2357 int size= codec->width * codec->height;
2358 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2363 bit_buffer = av_malloc(bit_buffer_size);
2365 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2367 ret = AVERROR(ENOMEM);
2371 /* open each encoder */
2372 for(i=0;i<nb_ostreams;i++) {
2374 if (ost->encoding_needed) {
2375 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2376 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2378 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2380 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2381 ost->st->codec->codec_id, ost->file_index, ost->index);
2382 ret = AVERROR(EINVAL);
2385 if (dec->subtitle_header) {
2386 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2387 if (!ost->st->codec->subtitle_header) {
2388 ret = AVERROR(ENOMEM);
2391 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2392 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2394 if (avcodec_open(ost->st->codec, codec) < 0) {
2395 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2396 ost->file_index, ost->index);
2397 ret = AVERROR(EINVAL);
2400 extra_size += ost->st->codec->extradata_size;
2404 /* open each decoder */
2405 for(i=0;i<nb_istreams;i++) {
2407 if (ist->decoding_needed) {
2408 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2410 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2412 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2413 ist->st->codec->codec_id, ist->file_index, ist->index);
2414 ret = AVERROR(EINVAL);
2417 if (avcodec_open(ist->st->codec, codec) < 0) {
2418 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2419 ist->file_index, ist->index);
2420 ret = AVERROR(EINVAL);
2423 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2424 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2429 for(i=0;i<nb_istreams;i++) {
2433 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2434 ist->next_pts = AV_NOPTS_VALUE;
2438 /* set meta data information from input file if required */
2439 for (i=0;i<nb_meta_data_maps;i++) {
2440 AVFormatContext *files[2];
2441 AVMetadata **meta[2];
2444 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2445 if ((index) < 0 || (index) >= (nb_elems)) {\
2446 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2448 ret = AVERROR(EINVAL);\
2452 int out_file_index = meta_data_maps[i][0].file;
2453 int in_file_index = meta_data_maps[i][1].file;
2454 if (in_file_index < 0 || out_file_index < 0)
2456 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2457 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2459 files[0] = output_files[out_file_index];
2460 files[1] = input_files[in_file_index];
2462 for (j = 0; j < 2; j++) {
2463 AVMetaDataMap *map = &meta_data_maps[i][j];
2465 switch (map->type) {
2467 meta[j] = &files[j]->metadata;
2470 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2471 meta[j] = &files[j]->streams[map->index]->metadata;
2474 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2475 meta[j] = &files[j]->chapters[map->index]->metadata;
2478 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2479 meta[j] = &files[j]->programs[map->index]->metadata;
2484 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2487 /* copy global metadata by default */
2488 if (metadata_global_autocopy) {
2490 for (i = 0; i < nb_output_files; i++)
2491 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2492 AV_METADATA_DONT_OVERWRITE);
2495 /* copy chapters according to chapter maps */
2496 for (i = 0; i < nb_chapter_maps; i++) {
2497 int infile = chapter_maps[i].in_file;
2498 int outfile = chapter_maps[i].out_file;
2500 if (infile < 0 || outfile < 0)
2502 if (infile >= nb_input_files) {
2503 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2504 ret = AVERROR(EINVAL);
2507 if (outfile >= nb_output_files) {
2508 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2509 ret = AVERROR(EINVAL);
2512 copy_chapters(infile, outfile);
2515 /* copy chapters from the first input file that has them*/
2516 if (!nb_chapter_maps)
2517 for (i = 0; i < nb_input_files; i++) {
2518 if (!input_files[i]->nb_chapters)
2521 for (j = 0; j < nb_output_files; j++)
2522 if ((ret = copy_chapters(i, j)) < 0)
2527 /* open files and write file headers */
2528 for(i=0;i<nb_output_files;i++) {
2529 os = output_files[i];
2530 if (av_write_header(os) < 0) {
2531 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2532 ret = AVERROR(EINVAL);
2535 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2541 /* dump the file output parameters - cannot be done before in case
2543 for(i=0;i<nb_output_files;i++) {
2544 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2547 /* dump the stream mapping */
2549 fprintf(stderr, "Stream mapping:\n");
2550 for(i=0;i<nb_ostreams;i++) {
2552 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2553 ist_table[ost->source_index]->file_index,
2554 ist_table[ost->source_index]->index,
2557 if (ost->sync_ist != ist_table[ost->source_index])
2558 fprintf(stderr, " [sync #%d.%d]",
2559 ost->sync_ist->file_index,
2560 ost->sync_ist->index);
2561 fprintf(stderr, "\n");
2566 fprintf(stderr, "%s\n", error);
2571 print_sdp(output_files, nb_output_files);
2576 fprintf(stderr, "Press [q] to stop encoding\n");
2577 avio_set_interrupt_cb(decode_interrupt_cb);
2581 timer_start = av_gettime();
2583 for(; received_sigterm == 0;) {
2584 int file_index, ist_index;
2592 /* if 'q' pressed, exits */
2596 /* read_key() returns 0 on EOF */
2602 /* select the stream that we must read now by looking at the
2603 smallest output pts */
2605 for(i=0;i<nb_ostreams;i++) {
2608 os = output_files[ost->file_index];
2609 ist = ist_table[ost->source_index];
2610 if(ist->is_past_recording_time || no_packet[ist->file_index])
2612 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2613 ipts = (double)ist->pts;
2614 if (!file_table[ist->file_index].eof_reached){
2615 if(ipts < ipts_min) {
2617 if(input_sync ) file_index = ist->file_index;
2619 if(opts < opts_min) {
2621 if(!input_sync) file_index = ist->file_index;
2624 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2629 /* if none, if is finished */
2630 if (file_index < 0) {
2631 if(no_packet_count){
2633 memset(no_packet, 0, sizeof(no_packet));
2640 /* finish if limit size exhausted */
2641 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2644 /* read a frame from it and output it in the fifo */
2645 is = input_files[file_index];
2646 ret= av_read_frame(is, &pkt);
2647 if(ret == AVERROR(EAGAIN)){
2648 no_packet[file_index]=1;
2653 file_table[file_index].eof_reached = 1;
2661 memset(no_packet, 0, sizeof(no_packet));
2664 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2665 is->streams[pkt.stream_index]);
2667 /* the following test is needed in case new streams appear
2668 dynamically in stream : we ignore them */
2669 if (pkt.stream_index >= file_table[file_index].nb_streams)
2670 goto discard_packet;
2671 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2672 ist = ist_table[ist_index];
2674 goto discard_packet;
2676 if (pkt.dts != AV_NOPTS_VALUE)
2677 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2678 if (pkt.pts != AV_NOPTS_VALUE)
2679 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2681 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2682 && input_files_ts_scale[file_index][pkt.stream_index]){
2683 if(pkt.pts != AV_NOPTS_VALUE)
2684 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2685 if(pkt.dts != AV_NOPTS_VALUE)
2686 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2689 // 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);
2690 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2691 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2692 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2693 int64_t delta= pkt_dts - ist->next_pts;
2694 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2695 input_files_ts_offset[ist->file_index]-= delta;
2697 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2698 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2699 if(pkt.pts != AV_NOPTS_VALUE)
2700 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2704 /* finish if recording time exhausted */
2705 if (recording_time != INT64_MAX &&
2706 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2707 ist->is_past_recording_time = 1;
2708 goto discard_packet;
2711 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2712 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2715 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2716 ist->file_index, ist->index);
2719 av_free_packet(&pkt);
2724 av_free_packet(&pkt);
2726 /* dump report by using the output first video and audio streams */
2727 print_report(output_files, ost_table, nb_ostreams, 0);
2730 /* at the end of stream, we must flush the decoder buffers */
2731 for(i=0;i<nb_istreams;i++) {
2733 if (ist->decoding_needed) {
2734 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2740 /* write the trailer if needed and close file */
2741 for(i=0;i<nb_output_files;i++) {
2742 os = output_files[i];
2743 av_write_trailer(os);
2746 /* dump report by using the first video and audio streams */
2747 print_report(output_files, ost_table, nb_ostreams, 1);
2749 /* close each encoder */
2750 for(i=0;i<nb_ostreams;i++) {
2752 if (ost->encoding_needed) {
2753 av_freep(&ost->st->codec->stats_in);
2754 avcodec_close(ost->st->codec);
2757 avfilter_graph_free(&ost->graph);
2761 /* close each decoder */
2762 for(i=0;i<nb_istreams;i++) {
2764 if (ist->decoding_needed) {
2765 avcodec_close(ist->st->codec);
2773 av_freep(&bit_buffer);
2774 av_free(file_table);
2777 for(i=0;i<nb_istreams;i++) {
2784 for(i=0;i<nb_ostreams;i++) {
2787 if (ost->st->stream_copy)
2788 av_freep(&ost->st->codec->extradata);
2790 fclose(ost->logfile);
2791 ost->logfile = NULL;
2793 av_fifo_free(ost->fifo); /* works even if fifo is not
2794 initialized but set to zero */
2795 av_freep(&ost->st->codec->subtitle_header);
2796 av_free(ost->pict_tmp.data[0]);
2797 av_free(ost->forced_kf_pts);
2798 if (ost->video_resample)
2799 sws_freeContext(ost->img_resample_ctx);
2801 audio_resample_close(ost->resample);
2802 if (ost->reformat_ctx)
2803 av_audio_convert_free(ost->reformat_ctx);
2812 static void opt_format(const char *arg)
2814 last_asked_format = arg;
2817 static void opt_video_rc_override_string(const char *arg)
2819 video_rc_override_string = arg;
2822 static int opt_me_threshold(const char *opt, const char *arg)
2824 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2828 static int opt_verbose(const char *opt, const char *arg)
2830 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2834 static int opt_frame_rate(const char *opt, const char *arg)
2836 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2837 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2843 static int opt_bitrate(const char *opt, const char *arg)
2845 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2847 opt_default(opt, arg);
2849 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2850 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2855 static int opt_frame_crop(const char *opt, const char *arg)
2857 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2858 return AVERROR(EINVAL);
2861 static void opt_frame_size(const char *arg)
2863 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2864 fprintf(stderr, "Incorrect frame size\n");
2869 static int opt_pad(const char *opt, const char *arg) {
2870 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2874 static void opt_frame_pix_fmt(const char *arg)
2876 if (strcmp(arg, "list")) {
2877 frame_pix_fmt = av_get_pix_fmt(arg);
2878 if (frame_pix_fmt == PIX_FMT_NONE) {
2879 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2888 static void opt_frame_aspect_ratio(const char *arg)
2895 p = strchr(arg, ':');
2897 x = strtol(arg, &end, 10);
2899 y = strtol(end+1, &end, 10);
2901 ar = (double)x / (double)y;
2903 ar = strtod(arg, NULL);
2906 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2909 frame_aspect_ratio = ar;
2912 static int opt_metadata(const char *opt, const char *arg)
2914 char *mid= strchr(arg, '=');
2917 fprintf(stderr, "Missing =\n");
2922 av_metadata_set2(&metadata, arg, mid, 0);
2927 static int opt_qscale(const char *opt, const char *arg)
2929 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2930 if (video_qscale <= 0 || video_qscale > 255) {
2931 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2932 return AVERROR(EINVAL);
2937 static int opt_top_field_first(const char *opt, const char *arg)
2939 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2943 static int opt_thread_count(const char *opt, const char *arg)
2945 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2948 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2953 static void opt_audio_sample_fmt(const char *arg)
2955 if (strcmp(arg, "list")) {
2956 audio_sample_fmt = av_get_sample_fmt(arg);
2957 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2958 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2964 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2965 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2970 static int opt_audio_rate(const char *opt, const char *arg)
2972 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2976 static int opt_audio_channels(const char *opt, const char *arg)
2978 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2982 static int opt_video_channel(const char *opt, const char *arg)
2984 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2988 static void opt_video_standard(const char *arg)
2990 video_standard = av_strdup(arg);
2993 static void opt_codec(int *pstream_copy, char **pcodec_name,
2994 int codec_type, const char *arg)
2996 av_freep(pcodec_name);
2997 if (!strcmp(arg, "copy")) {
3000 *pcodec_name = av_strdup(arg);
3004 static void opt_audio_codec(const char *arg)
3006 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3009 static void opt_video_codec(const char *arg)
3011 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3014 static void opt_subtitle_codec(const char *arg)
3016 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3019 static int opt_codec_tag(const char *opt, const char *arg)
3022 uint32_t *codec_tag;
3024 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3025 !strcmp(opt, "vtag") ? &video_codec_tag :
3026 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3030 *codec_tag = strtol(arg, &tail, 0);
3032 *codec_tag = AV_RL32(arg);
3037 static void opt_map(const char *arg)
3042 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3043 m = &stream_maps[nb_stream_maps-1];
3045 m->file_index = strtol(arg, &p, 0);
3049 m->stream_index = strtol(p, &p, 0);
3052 m->sync_file_index = strtol(p, &p, 0);
3055 m->sync_stream_index = strtol(p, &p, 0);
3057 m->sync_file_index = m->file_index;
3058 m->sync_stream_index = m->stream_index;
3062 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3073 *index = strtol(++arg, endptr, 0);
3076 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3083 static void opt_map_metadata(const char *arg)
3085 AVMetaDataMap *m, *m1;
3088 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3089 &nb_meta_data_maps, nb_meta_data_maps + 1);
3091 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3092 m->file = strtol(arg, &p, 0);
3093 parse_meta_type(p, &m->type, &m->index, &p);
3097 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3098 m1->file = strtol(p, &p, 0);
3099 parse_meta_type(p, &m1->type, &m1->index, &p);
3101 if (m->type == 'g' || m1->type == 'g')
3102 metadata_global_autocopy = 0;
3103 if (m->type == 's' || m1->type == 's')
3104 metadata_streams_autocopy = 0;
3105 if (m->type == 'c' || m1->type == 'c')
3106 metadata_chapters_autocopy = 0;
3109 static void opt_map_meta_data(const char *arg)
3111 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3112 "Use -map_metadata instead.\n");
3113 opt_map_metadata(arg);
3116 static void opt_map_chapters(const char *arg)
3121 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3122 nb_chapter_maps + 1);
3123 c = &chapter_maps[nb_chapter_maps - 1];
3124 c->out_file = strtol(arg, &p, 0);
3128 c->in_file = strtol(p, &p, 0);
3131 static void opt_input_ts_scale(const char *arg)
3133 unsigned int stream;
3137 stream = strtol(arg, &p, 0);
3140 scale= strtod(p, &p);
3142 if(stream >= MAX_STREAMS)
3145 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);
3146 input_files_ts_scale[nb_input_files][stream]= scale;
3149 static int opt_recording_time(const char *opt, const char *arg)
3151 recording_time = parse_time_or_die(opt, arg, 1);
3155 static int opt_start_time(const char *opt, const char *arg)
3157 start_time = parse_time_or_die(opt, arg, 1);
3161 static int opt_recording_timestamp(const char *opt, const char *arg)
3163 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3167 static int opt_input_ts_offset(const char *opt, const char *arg)
3169 input_ts_offset = parse_time_or_die(opt, arg, 1);
3173 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3175 const char *codec_string = encoder ? "encoder" : "decoder";
3179 return CODEC_ID_NONE;
3181 avcodec_find_encoder_by_name(name) :
3182 avcodec_find_decoder_by_name(name);
3184 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3187 if(codec->type != type) {
3188 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3191 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3192 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3193 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3194 "results.\nAdd '-strict experimental' if you want to use it.\n",
3195 codec_string, codec->name);
3197 avcodec_find_encoder(codec->id) :
3198 avcodec_find_decoder(codec->id);
3199 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3200 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3201 codec_string, codec->name);
3207 static void opt_input_file(const char *filename)
3209 AVFormatContext *ic;
3210 AVFormatParameters params, *ap = ¶ms;
3211 AVInputFormat *file_iformat = NULL;
3212 int err, i, ret, rfps, rfps_base;
3215 if (last_asked_format) {
3216 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3217 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3220 last_asked_format = NULL;
3223 if (!strcmp(filename, "-"))
3226 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3227 !strcmp(filename, "/dev/stdin");
3229 /* get default parameters from command line */
3230 ic = avformat_alloc_context();
3232 print_error(filename, AVERROR(ENOMEM));
3236 memset(ap, 0, sizeof(*ap));
3237 ap->prealloced_context = 1;
3238 ap->sample_rate = audio_sample_rate;
3239 ap->channels = audio_channels;
3240 ap->time_base.den = frame_rate.num;
3241 ap->time_base.num = frame_rate.den;
3242 ap->width = frame_width;
3243 ap->height = frame_height;
3244 ap->pix_fmt = frame_pix_fmt;
3245 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3246 ap->channel = video_channel;
3247 ap->standard = video_standard;
3249 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3251 ic->video_codec_id =
3252 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3253 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3254 ic->audio_codec_id =
3255 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3256 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3257 ic->subtitle_codec_id=
3258 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3259 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3260 ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3262 /* open the input file with generic libav function */
3263 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3265 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3266 err = av_demuxer_open(ic, ap);
3268 avformat_free_context(ic);
3271 print_error(filename, err);
3277 for(i=0; i<ic->nb_streams; i++){
3278 ic->streams[i]->discard= AVDISCARD_ALL;
3280 for(i=0; i<ic->nb_programs; i++){
3281 AVProgram *p= ic->programs[i];
3282 if(p->id != opt_programid){
3283 p->discard = AVDISCARD_ALL;
3286 for(j=0; j<p->nb_stream_indexes; j++){
3287 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3292 fprintf(stderr, "Specified program id not found\n");
3298 ic->loop_input = loop_input;
3300 /* If not enough info to get the stream parameters, we decode the
3301 first frames to get it. (used in mpeg case for example) */
3302 ret = av_find_stream_info(ic);
3303 if (ret < 0 && verbose >= 0) {
3304 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3305 av_close_input_file(ic);
3309 timestamp = start_time;
3310 /* add the stream start time */
3311 if (ic->start_time != AV_NOPTS_VALUE)
3312 timestamp += ic->start_time;
3314 /* if seeking requested, we execute it */
3315 if (start_time != 0) {
3316 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3318 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3319 filename, (double)timestamp / AV_TIME_BASE);
3321 /* reset seek info */
3325 /* update the current parameters so that they match the one of the input stream */
3326 for(i=0;i<ic->nb_streams;i++) {
3327 AVStream *st = ic->streams[i];
3328 AVCodecContext *dec = st->codec;
3329 dec->thread_count = thread_count;
3330 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3331 switch (dec->codec_type) {
3332 case AVMEDIA_TYPE_AUDIO:
3333 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3334 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]);
3335 channel_layout = dec->channel_layout;
3336 audio_channels = dec->channels;
3337 audio_sample_rate = dec->sample_rate;
3338 audio_sample_fmt = dec->sample_fmt;
3340 st->discard= AVDISCARD_ALL;
3341 /* Note that av_find_stream_info can add more streams, and we
3342 * currently have no chance of setting up lowres decoding
3343 * early enough for them. */
3345 audio_sample_rate >>= dec->lowres;
3347 case AVMEDIA_TYPE_VIDEO:
3348 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3349 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]);
3350 frame_height = dec->height;
3351 frame_width = dec->width;
3352 frame_pix_fmt = dec->pix_fmt;
3353 rfps = ic->streams[i]->r_frame_rate.num;
3354 rfps_base = ic->streams[i]->r_frame_rate.den;
3356 dec->flags |= CODEC_FLAG_EMU_EDGE;
3357 frame_height >>= dec->lowres;
3358 frame_width >>= dec->lowres;
3359 dec->height = frame_height;
3360 dec->width = frame_width;
3363 dec->debug |= FF_DEBUG_MV;
3365 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3368 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3369 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3371 (float)rfps / rfps_base, rfps, rfps_base);
3373 /* update the current frame rate to match the stream frame rate */
3374 frame_rate.num = rfps;
3375 frame_rate.den = rfps_base;
3378 st->discard= AVDISCARD_ALL;
3379 else if(video_discard)
3380 st->discard= video_discard;
3382 case AVMEDIA_TYPE_DATA:
3384 case AVMEDIA_TYPE_SUBTITLE:
3385 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3386 if(subtitle_disable)
3387 st->discard = AVDISCARD_ALL;
3389 case AVMEDIA_TYPE_ATTACHMENT:
3390 case AVMEDIA_TYPE_UNKNOWN:
3397 input_files[nb_input_files] = ic;
3398 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3399 /* dump the file content */
3401 av_dump_format(ic, nb_input_files, filename, 0);
3407 av_freep(&video_codec_name);
3408 av_freep(&audio_codec_name);
3409 av_freep(&subtitle_codec_name);
3412 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3413 int *has_subtitle_ptr)
3415 int has_video, has_audio, has_subtitle, i, j;
3416 AVFormatContext *ic;
3421 for(j=0;j<nb_input_files;j++) {
3422 ic = input_files[j];
3423 for(i=0;i<ic->nb_streams;i++) {
3424 AVCodecContext *enc = ic->streams[i]->codec;
3425 switch(enc->codec_type) {
3426 case AVMEDIA_TYPE_AUDIO:
3429 case AVMEDIA_TYPE_VIDEO:
3432 case AVMEDIA_TYPE_SUBTITLE:
3435 case AVMEDIA_TYPE_DATA:
3436 case AVMEDIA_TYPE_ATTACHMENT:
3437 case AVMEDIA_TYPE_UNKNOWN:
3444 *has_video_ptr = has_video;
3445 *has_audio_ptr = has_audio;
3446 *has_subtitle_ptr = has_subtitle;
3449 static void new_video_stream(AVFormatContext *oc, int file_idx)
3452 AVOutputStream *ost;
3453 AVCodecContext *video_enc;
3454 enum CodecID codec_id = CODEC_ID_NONE;
3455 AVCodec *codec= NULL;
3457 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3459 fprintf(stderr, "Could not alloc stream\n");
3462 ost = new_output_stream(oc, file_idx);
3464 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3465 if(!video_stream_copy){
3466 if (video_codec_name) {
3467 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3468 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3469 codec = avcodec_find_encoder_by_name(video_codec_name);
3470 output_codecs[nb_output_codecs-1] = codec;
3472 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3473 codec = avcodec_find_encoder(codec_id);
3475 ost->frame_aspect_ratio = frame_aspect_ratio;
3476 frame_aspect_ratio = 0;
3478 ost->avfilter= vfilters;
3483 avcodec_get_context_defaults3(st->codec, codec);
3484 ost->bitstream_filters = video_bitstream_filters;
3485 video_bitstream_filters= NULL;
3487 st->codec->thread_count= thread_count;
3489 video_enc = st->codec;
3492 video_enc->codec_tag= video_codec_tag;
3494 if( (video_global_header&1)
3495 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3496 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3497 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3499 if(video_global_header&2){
3500 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3501 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3504 if (video_stream_copy) {
3505 st->stream_copy = 1;
3506 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3507 video_enc->sample_aspect_ratio =
3508 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3512 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3514 video_enc->codec_id = codec_id;
3515 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3517 if (codec && codec->supported_framerates && !force_fps)
3518 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3519 video_enc->time_base.den = fps.num;
3520 video_enc->time_base.num = fps.den;
3522 video_enc->width = frame_width;
3523 video_enc->height = frame_height;
3524 video_enc->pix_fmt = frame_pix_fmt;
3525 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3526 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3528 choose_pixel_fmt(st, codec);
3531 video_enc->gop_size = 0;
3532 if (video_qscale || same_quality) {
3533 video_enc->flags |= CODEC_FLAG_QSCALE;
3534 video_enc->global_quality=
3535 st->quality = FF_QP2LAMBDA * video_qscale;
3539 video_enc->intra_matrix = intra_matrix;
3541 video_enc->inter_matrix = inter_matrix;
3543 p= video_rc_override_string;
3546 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3548 fprintf(stderr, "error parsing rc_override\n");
3551 video_enc->rc_override=
3552 av_realloc(video_enc->rc_override,
3553 sizeof(RcOverride)*(i+1));
3554 video_enc->rc_override[i].start_frame= start;
3555 video_enc->rc_override[i].end_frame = end;
3557 video_enc->rc_override[i].qscale= q;
3558 video_enc->rc_override[i].quality_factor= 1.0;
3561 video_enc->rc_override[i].qscale= 0;
3562 video_enc->rc_override[i].quality_factor= -q/100.0;
3567 video_enc->rc_override_count=i;
3568 if (!video_enc->rc_initial_buffer_occupancy)
3569 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3570 video_enc->me_threshold= me_threshold;
3571 video_enc->intra_dc_precision= intra_dc_precision - 8;
3574 video_enc->flags|= CODEC_FLAG_PSNR;
3579 video_enc->flags |= CODEC_FLAG_PASS1;
3581 video_enc->flags |= CODEC_FLAG_PASS2;
3585 if (forced_key_frames)
3586 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3588 if (video_language) {
3589 av_metadata_set2(&st->metadata, "language", video_language, 0);
3590 av_freep(&video_language);
3593 /* reset some key parameters */
3595 av_freep(&video_codec_name);
3596 av_freep(&forced_key_frames);
3597 video_stream_copy = 0;
3598 frame_pix_fmt = PIX_FMT_NONE;
3601 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3604 AVOutputStream *ost;
3605 AVCodec *codec= NULL;
3606 AVCodecContext *audio_enc;
3607 enum CodecID codec_id = CODEC_ID_NONE;
3609 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3611 fprintf(stderr, "Could not alloc stream\n");
3614 ost = new_output_stream(oc, file_idx);
3616 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3617 if(!audio_stream_copy){
3618 if (audio_codec_name) {
3619 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3620 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3621 codec = avcodec_find_encoder_by_name(audio_codec_name);
3622 output_codecs[nb_output_codecs-1] = codec;
3624 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3625 codec = avcodec_find_encoder(codec_id);
3629 avcodec_get_context_defaults3(st->codec, codec);
3631 ost->bitstream_filters = audio_bitstream_filters;
3632 audio_bitstream_filters= NULL;
3634 st->codec->thread_count= thread_count;
3636 audio_enc = st->codec;
3637 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3640 audio_enc->codec_tag= audio_codec_tag;
3642 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3643 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3644 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3646 if (audio_stream_copy) {
3647 st->stream_copy = 1;
3648 audio_enc->channels = audio_channels;
3649 audio_enc->sample_rate = audio_sample_rate;
3651 audio_enc->codec_id = codec_id;
3652 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3654 if (audio_qscale > QSCALE_NONE) {
3655 audio_enc->flags |= CODEC_FLAG_QSCALE;
3656 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3658 audio_enc->channels = audio_channels;
3659 audio_enc->sample_fmt = audio_sample_fmt;
3660 audio_enc->sample_rate = audio_sample_rate;
3661 audio_enc->channel_layout = channel_layout;
3662 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3663 audio_enc->channel_layout = 0;
3664 choose_sample_fmt(st, codec);
3665 choose_sample_rate(st, codec);
3667 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3668 if (audio_language) {
3669 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3670 av_freep(&audio_language);
3673 /* reset some key parameters */
3675 av_freep(&audio_codec_name);
3676 audio_stream_copy = 0;
3679 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3682 AVOutputStream *ost;
3683 AVCodec *codec=NULL;
3684 AVCodecContext *subtitle_enc;
3685 enum CodecID codec_id = CODEC_ID_NONE;
3687 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3689 fprintf(stderr, "Could not alloc stream\n");
3692 ost = new_output_stream(oc, file_idx);
3693 subtitle_enc = st->codec;
3694 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3695 if(!subtitle_stream_copy){
3696 if (subtitle_codec_name) {
3697 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3698 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3699 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3701 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3702 codec = avcodec_find_encoder(codec_id);
3705 avcodec_get_context_defaults3(st->codec, codec);
3707 ost->bitstream_filters = subtitle_bitstream_filters;
3708 subtitle_bitstream_filters= NULL;
3710 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3712 if(subtitle_codec_tag)
3713 subtitle_enc->codec_tag= subtitle_codec_tag;
3715 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3716 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3717 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3719 if (subtitle_stream_copy) {
3720 st->stream_copy = 1;
3722 subtitle_enc->codec_id = codec_id;
3723 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3726 if (subtitle_language) {
3727 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3728 av_freep(&subtitle_language);
3731 subtitle_disable = 0;
3732 av_freep(&subtitle_codec_name);
3733 subtitle_stream_copy = 0;
3736 static int opt_new_stream(const char *opt, const char *arg)
3738 AVFormatContext *oc;
3739 int file_idx = nb_output_files - 1;
3740 if (nb_output_files <= 0) {
3741 fprintf(stderr, "At least one output file must be specified\n");
3744 oc = output_files[file_idx];
3746 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3747 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3748 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3753 /* arg format is "output-stream-index:streamid-value". */
3754 static int opt_streamid(const char *opt, const char *arg)
3760 strncpy(idx_str, arg, sizeof(idx_str));
3761 idx_str[sizeof(idx_str)-1] = '\0';
3762 p = strchr(idx_str, ':');
3765 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3770 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3771 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3772 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3776 static void opt_output_file(const char *filename)
3778 AVFormatContext *oc;
3779 int err, use_video, use_audio, use_subtitle;
3780 int input_has_video, input_has_audio, input_has_subtitle;
3781 AVFormatParameters params, *ap = ¶ms;
3782 AVOutputFormat *file_oformat;
3784 if (!strcmp(filename, "-"))
3787 oc = avformat_alloc_output_context(last_asked_format, NULL, filename);
3788 last_asked_format = NULL;
3790 print_error(filename, AVERROR(ENOMEM));
3793 file_oformat= oc->oformat;
3795 if (!strcmp(file_oformat->name, "ffm") &&
3796 av_strstart(filename, "http:", NULL)) {
3797 /* special case for files sent to ffserver: we get the stream
3798 parameters from ffserver */
3799 int err = read_ffserver_streams(oc, filename);
3801 print_error(filename, err);
3805 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3806 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3807 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3809 /* disable if no corresponding type found and at least one
3811 if (nb_input_files > 0) {
3812 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3813 &input_has_subtitle);
3814 if (!input_has_video)
3816 if (!input_has_audio)
3818 if (!input_has_subtitle)
3822 /* manual disable */
3823 if (audio_disable) use_audio = 0;
3824 if (video_disable) use_video = 0;
3825 if (subtitle_disable) use_subtitle = 0;
3827 if (use_video) new_video_stream(oc, nb_output_files);
3828 if (use_audio) new_audio_stream(oc, nb_output_files);
3829 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3831 oc->timestamp = recording_timestamp;
3833 av_metadata_copy(&oc->metadata, metadata, 0);
3834 av_metadata_free(&metadata);
3837 output_files[nb_output_files++] = oc;
3839 /* check filename in case of an image number is expected */
3840 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3841 if (!av_filename_number_test(oc->filename)) {
3842 print_error(oc->filename, AVERROR(EINVAL));
3847 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3848 /* test if it already exists to avoid loosing precious files */
3849 if (!file_overwrite &&
3850 (strchr(filename, ':') == NULL ||
3851 filename[1] == ':' ||
3852 av_strstart(filename, "file:", NULL))) {
3853 if (avio_check(filename, 0) == 0) {
3855 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3857 if (!read_yesno()) {
3858 fprintf(stderr, "Not overwriting - exiting\n");
3863 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3870 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3871 print_error(filename, err);
3876 memset(ap, 0, sizeof(*ap));
3877 if (av_set_parameters(oc, ap) < 0) {
3878 fprintf(stderr, "%s: Invalid encoding parameters\n",
3883 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3884 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3885 oc->loop_output = loop_output;
3887 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3889 av_freep(&forced_key_frames);
3892 /* same option as mencoder */
3893 static int opt_pass(const char *opt, const char *arg)
3895 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3899 static int64_t getutime(void)
3902 struct rusage rusage;
3904 getrusage(RUSAGE_SELF, &rusage);
3905 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3906 #elif HAVE_GETPROCESSTIMES
3908 FILETIME c, e, k, u;
3909 proc = GetCurrentProcess();
3910 GetProcessTimes(proc, &c, &e, &k, &u);
3911 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3913 return av_gettime();
3917 static int64_t getmaxrss(void)
3919 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3920 struct rusage rusage;
3921 getrusage(RUSAGE_SELF, &rusage);
3922 return (int64_t)rusage.ru_maxrss * 1024;
3923 #elif HAVE_GETPROCESSMEMORYINFO
3925 PROCESS_MEMORY_COUNTERS memcounters;
3926 proc = GetCurrentProcess();
3927 memcounters.cb = sizeof(memcounters);
3928 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3929 return memcounters.PeakPagefileUsage;
3935 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3938 const char *p = str;
3945 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3952 static void opt_inter_matrix(const char *arg)
3954 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3955 parse_matrix_coeffs(inter_matrix, arg);
3958 static void opt_intra_matrix(const char *arg)
3960 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3961 parse_matrix_coeffs(intra_matrix, arg);
3964 static void show_usage(void)
3966 printf("Hyper fast Audio and Video encoder\n");
3967 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3971 static void show_help(void)
3974 AVOutputFormat *oformat = NULL;
3976 av_log_set_callback(log_callback_help);
3978 show_help_options(options, "Main options:\n",
3979 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3980 show_help_options(options, "\nAdvanced options:\n",
3981 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3983 show_help_options(options, "\nVideo options:\n",
3984 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3986 show_help_options(options, "\nAdvanced Video options:\n",
3987 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3988 OPT_VIDEO | OPT_EXPERT);
3989 show_help_options(options, "\nAudio options:\n",
3990 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3992 show_help_options(options, "\nAdvanced Audio options:\n",
3993 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3994 OPT_AUDIO | OPT_EXPERT);
3995 show_help_options(options, "\nSubtitle options:\n",
3996 OPT_SUBTITLE | OPT_GRAB,
3998 show_help_options(options, "\nAudio/Video grab options:\n",
4002 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4005 /* individual codec options */
4007 while ((c = av_codec_next(c))) {
4008 if (c->priv_class) {
4009 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4014 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4017 /* individual muxer options */
4018 while ((oformat = av_oformat_next(oformat))) {
4019 if (oformat->priv_class) {
4020 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4025 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4028 static void opt_target(const char *arg)
4030 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4031 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4033 if(!strncmp(arg, "pal-", 4)) {
4036 } else if(!strncmp(arg, "ntsc-", 5)) {
4039 } else if(!strncmp(arg, "film-", 5)) {
4044 /* Calculate FR via float to avoid int overflow */
4045 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4048 } else if((fr == 29970) || (fr == 23976)) {
4051 /* Try to determine PAL/NTSC by peeking in the input files */
4052 if(nb_input_files) {
4054 for(j = 0; j < nb_input_files; j++) {
4055 for(i = 0; i < input_files[j]->nb_streams; i++) {
4056 AVCodecContext *c = input_files[j]->streams[i]->codec;
4057 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4059 fr = c->time_base.den * 1000 / c->time_base.num;
4063 } else if((fr == 29970) || (fr == 23976)) {
4073 if(verbose > 0 && norm != UNKNOWN)
4074 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4077 if(norm == UNKNOWN) {
4078 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4079 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4080 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4084 if(!strcmp(arg, "vcd")) {
4086 opt_video_codec("mpeg1video");
4087 opt_audio_codec("mp2");
4090 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4091 opt_frame_rate(NULL, frame_rates[norm]);
4092 opt_default("g", norm == PAL ? "15" : "18");
4094 opt_default("b", "1150000");
4095 opt_default("maxrate", "1150000");
4096 opt_default("minrate", "1150000");
4097 opt_default("bufsize", "327680"); // 40*1024*8;
4099 opt_default("ab", "224000");
4100 audio_sample_rate = 44100;
4103 opt_default("packetsize", "2324");
4104 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4106 /* We have to offset the PTS, so that it is consistent with the SCR.
4107 SCR starts at 36000, but the first two packs contain only padding
4108 and the first pack from the other stream, respectively, may also have
4109 been written before.
4110 So the real data starts at SCR 36000+3*1200. */
4111 mux_preload= (36000+3*1200) / 90000.0; //0.44
4112 } else if(!strcmp(arg, "svcd")) {
4114 opt_video_codec("mpeg2video");
4115 opt_audio_codec("mp2");
4118 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4119 opt_frame_rate(NULL, frame_rates[norm]);
4120 opt_default("g", norm == PAL ? "15" : "18");
4122 opt_default("b", "2040000");
4123 opt_default("maxrate", "2516000");
4124 opt_default("minrate", "0"); //1145000;
4125 opt_default("bufsize", "1835008"); //224*1024*8;
4126 opt_default("flags", "+scan_offset");
4129 opt_default("ab", "224000");
4130 audio_sample_rate = 44100;
4132 opt_default("packetsize", "2324");
4134 } else if(!strcmp(arg, "dvd")) {
4136 opt_video_codec("mpeg2video");
4137 opt_audio_codec("ac3");
4140 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4141 opt_frame_rate(NULL, frame_rates[norm]);
4142 opt_default("g", norm == PAL ? "15" : "18");
4144 opt_default("b", "6000000");
4145 opt_default("maxrate", "9000000");
4146 opt_default("minrate", "0"); //1500000;
4147 opt_default("bufsize", "1835008"); //224*1024*8;
4149 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4150 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4152 opt_default("ab", "448000");
4153 audio_sample_rate = 48000;
4155 } else if(!strncmp(arg, "dv", 2)) {
4159 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4160 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4161 (norm == PAL ? "yuv420p" : "yuv411p"));
4162 opt_frame_rate(NULL, frame_rates[norm]);
4164 audio_sample_rate = 48000;
4168 fprintf(stderr, "Unknown target: %s\n", arg);
4173 static void opt_vstats_file (const char *arg)
4175 av_free (vstats_filename);
4176 vstats_filename=av_strdup (arg);
4179 static void opt_vstats (void)
4182 time_t today2 = time(NULL);
4183 struct tm *today = localtime(&today2);
4185 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4187 opt_vstats_file(filename);
4190 static int opt_bsf(const char *opt, const char *arg)
4192 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4193 AVBitStreamFilterContext **bsfp;
4196 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4200 bsfp= *opt == 'v' ? &video_bitstream_filters :
4201 *opt == 'a' ? &audio_bitstream_filters :
4202 &subtitle_bitstream_filters;
4204 bsfp= &(*bsfp)->next;
4211 static int opt_preset(const char *opt, const char *arg)
4214 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4215 char *codec_name = *opt == 'v' ? video_codec_name :
4216 *opt == 'a' ? audio_codec_name :
4217 subtitle_codec_name;
4219 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4220 fprintf(stderr, "File for preset '%s' not found\n", arg);
4225 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4226 if(line[0] == '#' && !e)
4228 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4230 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4233 if(!strcmp(tmp, "acodec")){
4234 opt_audio_codec(tmp2);
4235 }else if(!strcmp(tmp, "vcodec")){
4236 opt_video_codec(tmp2);
4237 }else if(!strcmp(tmp, "scodec")){
4238 opt_subtitle_codec(tmp2);
4239 }else if(opt_default(tmp, tmp2) < 0){
4240 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4250 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4254 static void opt_passlogfile(const char *arg)
4256 pass_logfilename_prefix = arg;
4257 opt_default("passlogfile", arg);
4260 static const OptionDef options[] = {
4262 #include "cmdutils_common_opts.h"
4263 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4264 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4265 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4266 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4267 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4268 "outfile[,metadata]:infile[,metadata]" },
4269 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4270 "outfile[,metadata]:infile[,metadata]" },
4271 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4272 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4273 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4274 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4275 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4276 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4277 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4278 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4279 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4280 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4281 "add timings for benchmarking" },
4282 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4283 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4284 "dump each input packet" },
4285 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4286 "when dumping packets, also dump the payload" },
4287 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4288 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4289 { "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)", "" },
4290 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4291 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4292 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4293 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4294 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4295 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4296 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4297 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4298 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4299 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4300 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4301 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4302 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4303 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4306 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4307 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4308 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4309 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4310 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4311 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4312 { "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" },
4313 { "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" },
4314 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4315 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4316 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4317 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4318 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4319 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4320 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4321 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4322 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4323 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4324 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4325 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4326 { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4327 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4328 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4329 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4330 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4331 "use same quantizer as source (implies VBR)" },
4332 { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4333 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4334 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4335 "deinterlace pictures" },
4336 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4337 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4338 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4340 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4342 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4343 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4344 { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4345 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4346 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4347 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4348 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4349 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4350 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4351 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4352 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4355 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4356 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4357 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4358 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4359 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4360 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4361 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4362 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4363 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4364 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4365 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4366 { "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" },
4368 /* subtitle options */
4369 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4370 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4371 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4372 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4373 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4376 { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4377 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4378 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4381 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4382 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4384 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4385 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4386 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4388 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4389 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4390 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4391 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4393 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4397 int main(int argc, char **argv)
4401 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4403 if(argc>1 && !strcmp(argv[1], "-d")){
4406 av_log_set_callback(log_callback_null);
4411 avcodec_register_all();
4413 avdevice_register_all();
4416 avfilter_register_all();
4421 if(isatty(STDIN_FILENO))
4422 avio_set_interrupt_cb(decode_interrupt_cb);
4430 parse_options(argc, argv, options, opt_output_file);
4432 if(nb_output_files <= 0 && nb_input_files == 0) {
4434 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4438 /* file converter / grab */
4439 if (nb_output_files <= 0) {
4440 fprintf(stderr, "At least one output file must be specified\n");
4444 if (nb_input_files == 0) {
4445 fprintf(stderr, "At least one input file must be specified\n");
4450 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4451 stream_maps, nb_stream_maps) < 0)
4453 ti = getutime() - ti;
4455 int maxrss = getmaxrss() / 1024;
4456 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4459 return ffmpeg_exit(0);