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
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/libm.h"
45 #include "libavformat/os_support.h"
47 #include "libavformat/ffm.h" // not public API
50 # include "libavfilter/avcodec.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
74 #include <sys/ioctl.h>
84 #include "libavutil/avassert.h"
86 const char program_name[] = "ffmpeg";
87 const int program_birth_year = 2000;
89 /* select an input stream for an output stream */
90 typedef struct AVStreamMap {
94 int sync_stream_index;
98 * select an input file for an output file
100 typedef struct AVMetaDataMap {
101 int file; //< file index
102 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103 int index; //< stream/chapter/program number
106 typedef struct AVChapterMap {
111 static const OptionDef options[];
113 #define MAX_FILES 100
114 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
116 static const char *last_asked_format = NULL;
117 static int64_t input_files_ts_offset[MAX_FILES];
118 static double *input_files_ts_scale[MAX_FILES] = {NULL};
119 static AVCodec **input_codecs = NULL;
120 static int nb_input_codecs = 0;
121 static int nb_input_files_ts_scale[MAX_FILES] = {0};
123 static AVFormatContext *output_files[MAX_FILES];
124 static AVCodec **output_codecs = NULL;
125 static int nb_output_files = 0;
126 static int nb_output_codecs = 0;
128 static AVStreamMap *stream_maps = NULL;
129 static int nb_stream_maps;
131 /* first item specifies output metadata, second is input */
132 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
133 static int nb_meta_data_maps;
134 static int metadata_global_autocopy = 1;
135 static int metadata_streams_autocopy = 1;
136 static int metadata_chapters_autocopy = 1;
138 static AVChapterMap *chapter_maps = NULL;
139 static int nb_chapter_maps;
141 /* indexed by output file stream index */
142 static int *streamid_map = NULL;
143 static int nb_streamid_map = 0;
145 static int frame_width = 0;
146 static int frame_height = 0;
147 static float frame_aspect_ratio = 0;
148 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
149 static int frame_bits_per_raw_sample = 0;
150 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
151 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
152 static AVRational frame_rate;
153 static float video_qscale = 0;
154 static uint16_t *intra_matrix = NULL;
155 static uint16_t *inter_matrix = NULL;
156 static const char *video_rc_override_string=NULL;
157 static int video_disable = 0;
158 static int video_discard = 0;
159 static char *video_codec_name = NULL;
160 static unsigned int video_codec_tag = 0;
161 static char *video_language = NULL;
162 static int same_quality = 0;
163 static int do_deinterlace = 0;
164 static int top_field_first = -1;
165 static int me_threshold = 0;
166 static int intra_dc_precision = 8;
167 static int loop_input = 0;
168 static int loop_output = AVFMT_NOOUTPUTLOOP;
169 static int qp_hist = 0;
171 static char *vfilters = NULL;
174 static int intra_only = 0;
175 static int audio_sample_rate = 44100;
176 static int64_t channel_layout = 0;
177 #define QSCALE_NONE -99999
178 static float audio_qscale = QSCALE_NONE;
179 static int audio_disable = 0;
180 static int audio_channels = 1;
181 static char *audio_codec_name = NULL;
182 static unsigned int audio_codec_tag = 0;
183 static char *audio_language = NULL;
185 static int subtitle_disable = 0;
186 static char *subtitle_codec_name = NULL;
187 static char *subtitle_language = NULL;
188 static unsigned int subtitle_codec_tag = 0;
190 static int data_disable = 0;
191 static char *data_codec_name = NULL;
192 static unsigned int data_codec_tag = 0;
194 static float mux_preload= 0.5;
195 static float mux_max_delay= 0.7;
197 static int64_t recording_time = INT64_MAX;
198 static int64_t start_time = 0;
199 static int64_t recording_timestamp = 0;
200 static int64_t input_ts_offset = 0;
201 static int file_overwrite = 0;
202 static AVMetadata *metadata;
203 static int do_benchmark = 0;
204 static int do_hex_dump = 0;
205 static int do_pkt_dump = 0;
206 static int do_psnr = 0;
207 static int do_pass = 0;
208 static const char *pass_logfilename_prefix;
209 static int audio_stream_copy = 0;
210 static int video_stream_copy = 0;
211 static int subtitle_stream_copy = 0;
212 static int data_stream_copy = 0;
213 static int video_sync_method= -1;
214 static int audio_sync_method= 0;
215 static float audio_drift_threshold= 0.1;
216 static int copy_ts= 0;
217 static int copy_tb= 0;
218 static int opt_shortest = 0;
219 static char *vstats_filename;
220 static FILE *vstats_file;
221 static int opt_programid = 0;
222 static int copy_initial_nonkeyframes = 0;
224 static int rate_emu = 0;
226 static int video_channel = 0;
227 static char *video_standard;
229 static int audio_volume = 256;
231 static int exit_on_error = 0;
232 static int using_stdin = 0;
233 static int verbose = 1;
234 static int run_as_daemon = 0;
235 static int thread_count= 1;
236 static int q_pressed = 0;
237 static int64_t video_size = 0;
238 static int64_t audio_size = 0;
239 static int64_t extra_size = 0;
240 static int nb_frames_dup = 0;
241 static int nb_frames_drop = 0;
242 static int input_sync;
243 static uint64_t limit_filesize = 0;
244 static int force_fps = 0;
245 static char *forced_key_frames = NULL;
247 static float dts_delta_threshold = 10;
249 static int64_t timer_start;
251 static uint8_t *audio_buf;
252 static uint8_t *audio_out;
253 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
255 static short *samples;
257 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
258 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
261 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263 struct AVInputStream;
265 typedef struct AVOutputStream {
266 int file_index; /* file index */
267 int index; /* stream index in the output file */
268 int source_index; /* AVInputStream index */
269 AVStream *st; /* stream in the output file */
270 int encoding_needed; /* true if encoding needed for this stream */
272 /* input pts and corresponding output pts
274 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
275 struct AVInputStream *sync_ist; /* input stream to sync against */
276 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
277 AVBitStreamFilterContext *bitstream_filters;
280 AVFrame resample_frame; /* temporary frame for image resampling */
281 struct SwsContext *img_resample_ctx; /* for image resampling */
284 int resample_pix_fmt;
286 float frame_aspect_ratio;
288 /* forced key frames */
289 int64_t *forced_kf_pts;
295 ReSampleContext *resample; /* for audio resampling */
296 int resample_sample_fmt;
297 int resample_channels;
298 int resample_sample_rate;
300 AVAudioConvert *reformat_ctx;
301 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
305 AVFilterContext *output_video_filter;
306 AVFilterContext *input_video_filter;
307 AVFilterBufferRef *picref;
309 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 {
321 int discard; /* true if stream data should be discarded */
322 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
323 int64_t sample_index; /* current sample */
325 int64_t start; /* time when read started */
326 int64_t next_pts; /* synthetic pts for cases where pkt.pts
328 int64_t pts; /* current pts */
329 int is_start; /* is 1 at the start and after a discontinuity */
330 int showed_multi_packet_warning;
331 int is_past_recording_time;
333 AVFrame *filter_frame;
334 int has_filter_frame;
338 typedef struct AVInputFile {
339 AVFormatContext *ctx;
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 */
347 /* init terminal so that we can grab keys */
348 static struct termios oldtty;
351 static AVInputStream *input_streams = NULL;
352 static int nb_input_streams = 0;
353 static AVInputFile *input_files = NULL;
354 static int nb_input_files = 0;
358 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
360 AVFilterContext *last_filter, *filter;
361 /** filter graph containing all filters including input & output */
362 AVCodecContext *codec = ost->st->codec;
363 AVCodecContext *icodec = ist->st->codec;
364 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
365 AVRational sample_aspect_ratio;
369 ost->graph = avfilter_graph_alloc();
371 if (ist->st->sample_aspect_ratio.num){
372 sample_aspect_ratio = ist->st->sample_aspect_ratio;
374 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
376 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
377 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
378 sample_aspect_ratio.num, sample_aspect_ratio.den);
380 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
381 "src", args, NULL, ost->graph);
384 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
385 "out", NULL, &ffsink_ctx, ost->graph);
388 last_filter = ost->input_video_filter;
390 if (codec->width != icodec->width || codec->height != icodec->height) {
391 snprintf(args, 255, "%d:%d:flags=0x%X",
395 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
396 NULL, args, NULL, ost->graph)) < 0)
398 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
400 last_filter = filter;
403 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
404 ost->graph->scale_sws_opts = av_strdup(args);
407 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
408 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
410 outputs->name = av_strdup("in");
411 outputs->filter_ctx = last_filter;
412 outputs->pad_idx = 0;
413 outputs->next = NULL;
415 inputs->name = av_strdup("out");
416 inputs->filter_ctx = ost->output_video_filter;
420 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
422 av_freep(&ost->avfilter);
424 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
428 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
431 codec->width = ost->output_video_filter->inputs[0]->w;
432 codec->height = ost->output_video_filter->inputs[0]->h;
433 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
434 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
435 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
436 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
440 #endif /* CONFIG_AVFILTER */
442 static void term_exit(void)
444 av_log(NULL, AV_LOG_QUIET, "");
447 tcsetattr (0, TCSANOW, &oldtty);
451 static volatile int received_sigterm = 0;
454 sigterm_handler(int sig)
456 received_sigterm = sig;
461 static void term_init(void)
471 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
472 |INLCR|IGNCR|ICRNL|IXON);
473 tty.c_oflag |= OPOST;
474 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
475 tty.c_cflag &= ~(CSIZE|PARENB);
480 tcsetattr (0, TCSANOW, &tty);
481 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
485 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
486 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
488 signal(SIGXCPU, sigterm_handler);
492 /* read a key without blocking */
493 static int read_key(void)
508 n = select(1, &rfds, NULL, NULL, &tv);
523 static int decode_interrupt_cb(void)
525 q_pressed += read_key() == 'q';
526 return q_pressed > 1;
529 static int ffmpeg_exit(int ret)
534 for(i=0;i<nb_output_files;i++) {
535 AVFormatContext *s = output_files[i];
536 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
538 avformat_free_context(s);
539 av_free(output_streams_for_file[i]);
541 for(i=0;i<nb_input_files;i++) {
542 av_close_input_file(input_files[i].ctx);
543 av_free(input_files_ts_scale[i]);
546 av_free(intra_matrix);
547 av_free(inter_matrix);
551 av_free(vstats_filename);
553 av_free(streamid_map);
554 av_free(input_codecs);
555 av_free(output_codecs);
556 av_free(stream_maps);
557 av_free(meta_data_maps);
559 av_freep(&input_streams);
560 av_freep(&input_files);
562 av_free(video_codec_name);
563 av_free(audio_codec_name);
564 av_free(subtitle_codec_name);
565 av_free(data_codec_name);
567 av_free(video_standard);
572 allocated_audio_buf_size= allocated_audio_out_size= 0;
579 if (received_sigterm) {
581 "Received signal %d: terminating.\n",
582 (int) received_sigterm);
586 exit(ret); /* not all OS-es handle main() return value */
590 /* similar to ff_dynarray_add() and av_fast_realloc() */
591 static void *grow_array(void *array, int elem_size, int *size, int new_size)
593 if (new_size >= INT_MAX / elem_size) {
594 fprintf(stderr, "Array too big.\n");
597 if (*size < new_size) {
598 uint8_t *tmp = av_realloc(array, new_size*elem_size);
600 fprintf(stderr, "Could not alloc buffer.\n");
603 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
610 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
612 if(codec && codec->sample_fmts){
613 const enum AVSampleFormat *p= codec->sample_fmts;
615 if(*p == st->codec->sample_fmt)
619 av_log(NULL, AV_LOG_WARNING,
620 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
621 av_get_sample_fmt_name(st->codec->sample_fmt),
623 av_get_sample_fmt_name(codec->sample_fmts[0]));
624 st->codec->sample_fmt = codec->sample_fmts[0];
629 static void choose_sample_rate(AVStream *st, AVCodec *codec)
631 if(codec && codec->supported_samplerates){
632 const int *p= codec->supported_samplerates;
634 int best_dist=INT_MAX;
636 int dist= abs(st->codec->sample_rate - *p);
637 if(dist < best_dist){
643 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
645 st->codec->sample_rate= best;
649 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
651 if(codec && codec->pix_fmts){
652 const enum PixelFormat *p= codec->pix_fmts;
653 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
654 if(st->codec->codec_id==CODEC_ID_MJPEG){
655 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
656 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
657 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};
661 if(*p == st->codec->pix_fmt)
665 if(st->codec->pix_fmt != PIX_FMT_NONE)
666 av_log(NULL, AV_LOG_WARNING,
667 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
668 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
670 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
671 st->codec->pix_fmt = codec->pix_fmts[0];
676 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
678 int idx = oc->nb_streams - 1;
681 output_streams_for_file[file_idx] =
682 grow_array(output_streams_for_file[file_idx],
683 sizeof(*output_streams_for_file[file_idx]),
684 &nb_output_streams_for_file[file_idx],
686 ost = output_streams_for_file[file_idx][idx] =
687 av_mallocz(sizeof(AVOutputStream));
689 fprintf(stderr, "Could not alloc output stream\n");
692 ost->file_index = file_idx;
695 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
699 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
705 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
708 /* copy stream format */
710 s->streams = av_mallocz(sizeof(AVStream *) * ic->nb_streams);
711 for(i=0;i<ic->nb_streams;i++) {
717 // FIXME: a more elegant solution is needed
718 st = av_mallocz(sizeof(AVStream));
719 memcpy(st, ic->streams[i], sizeof(AVStream));
720 st->info = av_malloc(sizeof(*st->info));
721 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
722 st->codec = avcodec_alloc_context();
724 print_error(filename, AVERROR(ENOMEM));
727 avcodec_copy_context(st->codec, ic->streams[i]->codec);
730 codec = avcodec_find_encoder(st->codec->codec_id);
731 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
732 if (audio_stream_copy) {
735 choose_sample_fmt(st, codec);
736 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
737 if (video_stream_copy) {
740 choose_pixel_fmt(st, codec);
743 if(st->codec->flags & CODEC_FLAG_BITEXACT)
746 new_output_stream(s, nb_output_files);
750 s->timestamp = av_gettime();
752 av_close_input_file(ic);
757 get_sync_ipts(const AVOutputStream *ost)
759 const AVInputStream *ist = ost->sync_ist;
760 return (double)(ist->pts - start_time)/AV_TIME_BASE;
763 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
767 AVPacket new_pkt= *pkt;
768 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
769 &new_pkt.data, &new_pkt.size,
770 pkt->data, pkt->size,
771 pkt->flags & AV_PKT_FLAG_KEY);
774 new_pkt.destruct= av_destruct_packet;
776 fprintf(stderr, "%s failed for stream %d, codec %s",
777 bsfc->filter->name, pkt->stream_index,
778 avctx->codec ? avctx->codec->name : "copy");
788 ret= av_interleaved_write_frame(s, pkt);
790 print_error("av_interleaved_write_frame()", ret);
795 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
797 static void do_audio_out(AVFormatContext *s,
800 unsigned char *buf, int size)
803 int64_t audio_out_size, audio_buf_size;
804 int64_t allocated_for_size= size;
806 int size_out, frame_bytes, ret, resample_changed;
807 AVCodecContext *enc= ost->st->codec;
808 AVCodecContext *dec= ist->st->codec;
809 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
810 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
811 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
814 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
815 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
816 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
817 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
818 audio_buf_size*= osize*enc->channels;
820 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
821 if(coded_bps > 8*osize)
822 audio_out_size= audio_out_size * coded_bps / (8*osize);
823 audio_out_size += FF_MIN_BUFFER_SIZE;
825 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
826 fprintf(stderr, "Buffer sizes too large\n");
830 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
831 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
832 if (!audio_buf || !audio_out){
833 fprintf(stderr, "Out of memory in do_audio_out\n");
837 if (enc->channels != dec->channels)
838 ost->audio_resample = 1;
840 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
841 ost->resample_channels != dec->channels ||
842 ost->resample_sample_rate != dec->sample_rate;
844 if ((ost->audio_resample && !ost->resample) || resample_changed) {
845 if (resample_changed) {
846 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",
847 ist->file_index, ist->st->index,
848 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
849 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
850 ost->resample_sample_fmt = dec->sample_fmt;
851 ost->resample_channels = dec->channels;
852 ost->resample_sample_rate = dec->sample_rate;
854 audio_resample_close(ost->resample);
856 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
857 if (audio_sync_method <= 1 &&
858 ost->resample_sample_fmt == enc->sample_fmt &&
859 ost->resample_channels == enc->channels &&
860 ost->resample_sample_rate == enc->sample_rate) {
861 ost->resample = NULL;
862 ost->audio_resample = 0;
864 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
865 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
866 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
867 enc->sample_rate, dec->sample_rate,
868 enc->sample_fmt, dec->sample_fmt,
870 if (!ost->resample) {
871 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
872 dec->channels, dec->sample_rate,
873 enc->channels, enc->sample_rate);
879 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
880 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
881 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
882 if (ost->reformat_ctx)
883 av_audio_convert_free(ost->reformat_ctx);
884 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
885 dec->sample_fmt, 1, NULL, 0);
886 if (!ost->reformat_ctx) {
887 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
888 av_get_sample_fmt_name(dec->sample_fmt),
889 av_get_sample_fmt_name(enc->sample_fmt));
892 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
895 if(audio_sync_method){
896 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
897 - av_fifo_size(ost->fifo)/(enc->channels * 2);
898 double idelta= delta*dec->sample_rate / enc->sample_rate;
899 int byte_delta= ((int)idelta)*2*dec->channels;
901 //FIXME resample delay
902 if(fabs(delta) > 50){
903 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
905 byte_delta= FFMAX(byte_delta, -size);
909 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
914 static uint8_t *input_tmp= NULL;
915 input_tmp= av_realloc(input_tmp, byte_delta + size);
917 if(byte_delta > allocated_for_size - size){
918 allocated_for_size= byte_delta + (int64_t)size;
923 memset(input_tmp, 0, byte_delta);
924 memcpy(input_tmp + byte_delta, buf, size);
928 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
930 }else if(audio_sync_method>1){
931 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
932 av_assert0(ost->audio_resample);
934 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
935 // 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));
936 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
940 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
941 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
943 if (ost->audio_resample) {
945 size_out = audio_resample(ost->resample,
946 (short *)buftmp, (short *)buf,
947 size / (dec->channels * isize));
948 size_out = size_out * enc->channels * osize;
954 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
955 const void *ibuf[6]= {buftmp};
956 void *obuf[6]= {audio_buf};
957 int istride[6]= {isize};
958 int ostride[6]= {osize};
959 int len= size_out/istride[0];
960 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
961 printf("av_audio_convert() failed\n");
967 size_out = len*osize;
970 /* now encode as many frames as possible */
971 if (enc->frame_size > 1) {
972 /* output resampled raw samples */
973 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
974 fprintf(stderr, "av_fifo_realloc2() failed\n");
977 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
979 frame_bytes = enc->frame_size * osize * enc->channels;
981 while (av_fifo_size(ost->fifo) >= frame_bytes) {
983 av_init_packet(&pkt);
985 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
987 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
989 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
992 fprintf(stderr, "Audio encoding failed\n");
996 pkt.stream_index= ost->index;
999 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1000 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1001 pkt.flags |= AV_PKT_FLAG_KEY;
1002 write_frame(s, &pkt, enc, ost->bitstream_filters);
1004 ost->sync_opts += enc->frame_size;
1008 av_init_packet(&pkt);
1010 ost->sync_opts += size_out / (osize * enc->channels);
1012 /* output a pcm frame */
1013 /* determine the size of the coded buffer */
1016 size_out = size_out*coded_bps/8;
1018 if(size_out > audio_out_size){
1019 fprintf(stderr, "Internal error, buffer size too small\n");
1023 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1024 ret = avcodec_encode_audio(enc, audio_out, size_out,
1027 fprintf(stderr, "Audio encoding failed\n");
1031 pkt.stream_index= ost->index;
1032 pkt.data= audio_out;
1034 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1035 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1036 pkt.flags |= AV_PKT_FLAG_KEY;
1037 write_frame(s, &pkt, enc, ost->bitstream_filters);
1041 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1043 AVCodecContext *dec;
1044 AVPicture *picture2;
1045 AVPicture picture_tmp;
1048 dec = ist->st->codec;
1050 /* deinterlace : must be done before any resize */
1051 if (do_deinterlace) {
1054 /* create temporary picture */
1055 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1056 buf = av_malloc(size);
1060 picture2 = &picture_tmp;
1061 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1063 if(avpicture_deinterlace(picture2, picture,
1064 dec->pix_fmt, dec->width, dec->height) < 0) {
1065 /* if error, do not deinterlace */
1066 fprintf(stderr, "Deinterlacing failed\n");
1075 if (picture != picture2)
1076 *picture = *picture2;
1080 /* we begin to correct av delay at this threshold */
1081 #define AV_DELAY_MAX 0.100
1083 static void do_subtitle_out(AVFormatContext *s,
1084 AVOutputStream *ost,
1089 static uint8_t *subtitle_out = NULL;
1090 int subtitle_out_max_size = 1024 * 1024;
1091 int subtitle_out_size, nb, i;
1092 AVCodecContext *enc;
1095 if (pts == AV_NOPTS_VALUE) {
1096 fprintf(stderr, "Subtitle packets must have a pts\n");
1102 enc = ost->st->codec;
1104 if (!subtitle_out) {
1105 subtitle_out = av_malloc(subtitle_out_max_size);
1108 /* Note: DVB subtitle need one packet to draw them and one other
1109 packet to clear them */
1110 /* XXX: signal it in the codec context ? */
1111 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1116 for(i = 0; i < nb; i++) {
1117 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1118 // start_display_time is required to be 0
1119 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1120 sub->end_display_time -= sub->start_display_time;
1121 sub->start_display_time = 0;
1122 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1123 subtitle_out_max_size, sub);
1124 if (subtitle_out_size < 0) {
1125 fprintf(stderr, "Subtitle encoding failed\n");
1129 av_init_packet(&pkt);
1130 pkt.stream_index = ost->index;
1131 pkt.data = subtitle_out;
1132 pkt.size = subtitle_out_size;
1133 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1134 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1135 /* XXX: the pts correction is handled here. Maybe handling
1136 it in the codec would be better */
1138 pkt.pts += 90 * sub->start_display_time;
1140 pkt.pts += 90 * sub->end_display_time;
1142 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1146 static int bit_buffer_size= 1024*256;
1147 static uint8_t *bit_buffer= NULL;
1149 static void do_video_out(AVFormatContext *s,
1150 AVOutputStream *ost,
1152 AVFrame *in_picture,
1155 int nb_frames, i, ret, av_unused resample_changed;
1156 AVFrame *final_picture, *formatted_picture;
1157 AVCodecContext *enc, *dec;
1160 enc = ost->st->codec;
1161 dec = ist->st->codec;
1163 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1165 /* by default, we output a single frame */
1170 if(video_sync_method){
1171 double vdelta = sync_ipts - ost->sync_opts;
1172 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1175 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1178 }else if(vdelta>0.6)
1179 ost->sync_opts= lrintf(sync_ipts);
1180 }else if (vdelta > 1.1)
1181 nb_frames = lrintf(vdelta);
1182 //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);
1183 if (nb_frames == 0){
1186 fprintf(stderr, "*** drop!\n");
1187 }else if (nb_frames > 1) {
1188 nb_frames_dup += nb_frames - 1;
1190 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1193 ost->sync_opts= lrintf(sync_ipts);
1195 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1199 formatted_picture = in_picture;
1200 final_picture = formatted_picture;
1202 #if !CONFIG_AVFILTER
1203 resample_changed = ost->resample_width != dec->width ||
1204 ost->resample_height != dec->height ||
1205 ost->resample_pix_fmt != dec->pix_fmt;
1207 if (resample_changed) {
1208 av_log(NULL, AV_LOG_INFO,
1209 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1210 ist->file_index, ist->st->index,
1211 ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1212 dec->width , dec->height , avcodec_get_pix_fmt_name(dec->pix_fmt));
1213 ost->resample_width = dec->width;
1214 ost->resample_height = dec->height;
1215 ost->resample_pix_fmt = dec->pix_fmt;
1218 ost->video_resample = dec->width != enc->width ||
1219 dec->height != enc->height ||
1220 dec->pix_fmt != enc->pix_fmt;
1222 if (ost->video_resample) {
1223 final_picture = &ost->resample_frame;
1224 if (!ost->img_resample_ctx || resample_changed) {
1225 /* initialize the destination picture */
1226 if (!ost->resample_frame.data[0]) {
1227 avcodec_get_frame_defaults(&ost->resample_frame);
1228 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1229 enc->width, enc->height)) {
1230 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1234 /* initialize a new scaler context */
1235 sws_freeContext(ost->img_resample_ctx);
1236 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1237 enc->width, enc->height, enc->pix_fmt,
1238 ost->sws_flags, NULL, NULL, NULL);
1239 if (ost->img_resample_ctx == NULL) {
1240 fprintf(stderr, "Cannot get resampling context\n");
1244 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1245 0, ost->resample_height, ost->resample_frame.data, ost->resample_frame.linesize);
1249 /* duplicates frame if needed */
1250 for(i=0;i<nb_frames;i++) {
1252 av_init_packet(&pkt);
1253 pkt.stream_index= ost->index;
1255 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1256 /* raw pictures are written as AVPicture structure to
1257 avoid any copies. We support temorarily the older
1259 AVFrame* old_frame = enc->coded_frame;
1260 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1261 pkt.data= (uint8_t *)final_picture;
1262 pkt.size= sizeof(AVPicture);
1263 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1264 pkt.flags |= AV_PKT_FLAG_KEY;
1266 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1267 enc->coded_frame = old_frame;
1269 AVFrame big_picture;
1271 big_picture= *final_picture;
1272 /* better than nothing: use input picture interlaced
1274 big_picture.interlaced_frame = in_picture->interlaced_frame;
1275 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1276 if(top_field_first == -1)
1277 big_picture.top_field_first = in_picture->top_field_first;
1279 big_picture.top_field_first = top_field_first;
1282 /* handles sameq here. This is not correct because it may
1283 not be a global option */
1284 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1286 big_picture.pict_type = 0;
1287 // big_picture.pts = AV_NOPTS_VALUE;
1288 big_picture.pts= ost->sync_opts;
1289 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1290 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1291 if (ost->forced_kf_index < ost->forced_kf_count &&
1292 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1293 big_picture.pict_type = AV_PICTURE_TYPE_I;
1294 ost->forced_kf_index++;
1296 ret = avcodec_encode_video(enc,
1297 bit_buffer, bit_buffer_size,
1300 fprintf(stderr, "Video encoding failed\n");
1305 pkt.data= bit_buffer;
1307 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1308 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1309 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1310 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1311 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1313 if(enc->coded_frame->key_frame)
1314 pkt.flags |= AV_PKT_FLAG_KEY;
1315 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1318 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1319 // enc->frame_number-1, ret, enc->pict_type);
1320 /* if two pass, output log */
1321 if (ost->logfile && enc->stats_out) {
1322 fprintf(ost->logfile, "%s", enc->stats_out);
1327 ost->frame_number++;
1331 static double psnr(double d){
1332 return -10.0*log(d)/log(10.0);
1335 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1338 AVCodecContext *enc;
1340 double ti1, bitrate, avg_bitrate;
1342 /* this is executed just the first time do_video_stats is called */
1344 vstats_file = fopen(vstats_filename, "w");
1351 enc = ost->st->codec;
1352 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353 frame_number = ost->frame_number;
1354 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1355 if (enc->flags&CODEC_FLAG_PSNR)
1356 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1358 fprintf(vstats_file,"f_size= %6d ", frame_size);
1359 /* compute pts value */
1360 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1364 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1365 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1366 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1367 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1368 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1372 static void print_report(AVFormatContext **output_files,
1373 AVOutputStream **ost_table, int nb_ostreams,
1377 AVOutputStream *ost;
1378 AVFormatContext *oc;
1380 AVCodecContext *enc;
1381 int frame_number, vid, i;
1382 double bitrate, ti1, pts;
1383 static int64_t last_time = -1;
1384 static int qp_histogram[52];
1386 if (!is_last_report) {
1388 /* display the report every 0.5 seconds */
1389 cur_time = av_gettime();
1390 if (last_time == -1) {
1391 last_time = cur_time;
1394 if ((cur_time - last_time) < 500000)
1396 last_time = cur_time;
1400 oc = output_files[0];
1402 total_size = avio_size(oc->pb);
1403 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1404 total_size= avio_tell(oc->pb);
1409 for(i=0;i<nb_ostreams;i++) {
1412 enc = ost->st->codec;
1413 if (!ost->st->stream_copy && enc->coded_frame)
1414 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1415 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1418 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1419 float t = (av_gettime()-timer_start) / 1000000.0;
1421 frame_number = ost->frame_number;
1422 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1423 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1425 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1429 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1432 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1434 if (enc->flags&CODEC_FLAG_PSNR){
1436 double error, error_sum=0;
1437 double scale, scale_sum=0;
1438 char type[3]= {'Y','U','V'};
1439 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1442 error= enc->error[j];
1443 scale= enc->width*enc->height*255.0*255.0*frame_number;
1445 error= enc->coded_frame->error[j];
1446 scale= enc->width*enc->height*255.0*255.0;
1451 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1453 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1457 /* compute min output value */
1458 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1459 if ((pts < ti1) && (pts > 0))
1465 if (verbose > 0 || is_last_report) {
1466 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1468 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1469 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1470 (double)total_size / 1024, ti1, bitrate);
1472 if (nb_frames_dup || nb_frames_drop)
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1474 nb_frames_dup, nb_frames_drop);
1477 fprintf(stderr, "%s \r", buf);
1482 if (is_last_report && verbose >= 0){
1483 int64_t raw= audio_size + video_size + extra_size;
1484 fprintf(stderr, "\n");
1485 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1489 100.0*(total_size - raw)/raw
1494 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1496 int fill_char = 0x00;
1497 if (sample_fmt == AV_SAMPLE_FMT_U8)
1499 memset(buf, fill_char, size);
1502 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1503 static int output_packet(AVInputStream *ist, int ist_index,
1504 AVOutputStream **ost_table, int nb_ostreams,
1505 const AVPacket *pkt)
1507 AVFormatContext *os;
1508 AVOutputStream *ost;
1512 void *buffer_to_free = NULL;
1513 static unsigned int samples_size= 0;
1514 AVSubtitle subtitle, *subtitle_to_free;
1515 int64_t pkt_pts = AV_NOPTS_VALUE;
1517 int frame_available;
1521 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1523 if(ist->next_pts == AV_NOPTS_VALUE)
1524 ist->next_pts= ist->pts;
1528 av_init_packet(&avpkt);
1536 if(pkt->dts != AV_NOPTS_VALUE)
1537 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1538 if(pkt->pts != AV_NOPTS_VALUE)
1539 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1541 //while we have more to decode or while the decoder did output something on EOF
1542 while (avpkt.size > 0 || (!pkt && got_output)) {
1543 uint8_t *data_buf, *decoded_data_buf;
1544 int data_size, decoded_data_size;
1546 ist->pts= ist->next_pts;
1548 if(avpkt.size && avpkt.size != pkt->size &&
1549 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1550 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1551 ist->showed_multi_packet_warning=1;
1554 /* decode the packet if needed */
1555 decoded_data_buf = NULL; /* fail safe */
1556 decoded_data_size= 0;
1557 data_buf = avpkt.data;
1558 data_size = avpkt.size;
1559 subtitle_to_free = NULL;
1560 if (ist->decoding_needed) {
1561 switch(ist->st->codec->codec_type) {
1562 case AVMEDIA_TYPE_AUDIO:{
1563 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1564 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1566 samples= av_malloc(samples_size);
1568 decoded_data_size= samples_size;
1569 /* XXX: could avoid copy if PCM 16 bits with same
1570 endianness as CPU */
1571 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1578 got_output = decoded_data_size > 0;
1579 /* Some bug in mpeg audio decoder gives */
1580 /* decoded_data_size < 0, it seems they are overflows */
1582 /* no audio frame */
1585 decoded_data_buf = (uint8_t *)samples;
1586 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1587 (ist->st->codec->sample_rate * ist->st->codec->channels);
1589 case AVMEDIA_TYPE_VIDEO:
1590 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1591 /* XXX: allocate picture correctly */
1592 avcodec_get_frame_defaults(&picture);
1593 avpkt.pts = pkt_pts;
1594 avpkt.dts = ist->pts;
1595 pkt_pts = AV_NOPTS_VALUE;
1597 ret = avcodec_decode_video2(ist->st->codec,
1598 &picture, &got_output, &avpkt);
1599 ist->st->quality= picture.quality;
1603 /* no picture yet */
1604 goto discard_packet;
1606 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1607 if (ist->st->codec->time_base.num != 0) {
1608 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1609 ist->next_pts += ((int64_t)AV_TIME_BASE *
1610 ist->st->codec->time_base.num * ticks) /
1611 ist->st->codec->time_base.den;
1614 buffer_to_free = NULL;
1615 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1617 case AVMEDIA_TYPE_SUBTITLE:
1618 ret = avcodec_decode_subtitle2(ist->st->codec,
1619 &subtitle, &got_output, &avpkt);
1623 goto discard_packet;
1625 subtitle_to_free = &subtitle;
1632 switch(ist->st->codec->codec_type) {
1633 case AVMEDIA_TYPE_AUDIO:
1634 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1635 ist->st->codec->sample_rate;
1637 case AVMEDIA_TYPE_VIDEO:
1638 if (ist->st->codec->time_base.num != 0) {
1639 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1640 ist->next_pts += ((int64_t)AV_TIME_BASE *
1641 ist->st->codec->time_base.num * ticks) /
1642 ist->st->codec->time_base.den;
1651 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1652 for(i=0;i<nb_ostreams;i++) {
1654 if (ost->input_video_filter && ost->source_index == ist_index) {
1655 if (!picture.sample_aspect_ratio.num)
1656 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1657 picture.pts = ist->pts;
1659 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture);
1665 // preprocess audio (volume)
1666 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1667 if (audio_volume != 256) {
1670 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1671 int v = ((*volp) * audio_volume + 128) >> 8;
1672 if (v < -32768) v = -32768;
1673 if (v > 32767) v = 32767;
1679 /* frame rate emulation */
1681 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1682 int64_t now = av_gettime() - ist->start;
1686 /* if output time reached then transcode raw format,
1687 encode packets and output them */
1688 if (start_time == 0 || ist->pts >= start_time)
1689 for(i=0;i<nb_ostreams;i++) {
1693 if (ost->source_index == ist_index) {
1695 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1696 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1697 while (frame_available) {
1698 AVRational ist_pts_tb;
1699 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1700 if (get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb) < 0)
1703 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1705 os = output_files[ost->file_index];
1707 /* set the input output pts pairs */
1708 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1710 if (ost->encoding_needed) {
1711 av_assert0(ist->decoding_needed);
1712 switch(ost->st->codec->codec_type) {
1713 case AVMEDIA_TYPE_AUDIO:
1714 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1716 case AVMEDIA_TYPE_VIDEO:
1718 if (ost->picref->video && !ost->frame_aspect_ratio)
1719 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1721 do_video_out(os, ost, ist, &picture, &frame_size);
1722 if (vstats_filename && frame_size)
1723 do_video_stats(os, ost, frame_size);
1725 case AVMEDIA_TYPE_SUBTITLE:
1726 do_subtitle_out(os, ost, ist, &subtitle,
1733 AVFrame avframe; //FIXME/XXX remove this
1735 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1737 av_init_packet(&opkt);
1739 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1740 #if !CONFIG_AVFILTER
1746 /* no reencoding needed : output the packet directly */
1747 /* force the input stream PTS */
1749 avcodec_get_frame_defaults(&avframe);
1750 ost->st->codec->coded_frame= &avframe;
1751 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1753 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1754 audio_size += data_size;
1755 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1756 video_size += data_size;
1760 opkt.stream_index= ost->index;
1761 if(pkt->pts != AV_NOPTS_VALUE)
1762 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1764 opkt.pts= AV_NOPTS_VALUE;
1766 if (pkt->dts == AV_NOPTS_VALUE)
1767 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1769 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1770 opkt.dts -= ost_tb_start_time;
1772 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1773 opkt.flags= pkt->flags;
1775 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1776 if( ost->st->codec->codec_id != CODEC_ID_H264
1777 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1778 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1780 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1781 opkt.destruct= av_destruct_packet;
1783 opkt.data = data_buf;
1784 opkt.size = data_size;
1787 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1788 ost->st->codec->frame_number++;
1789 ost->frame_number++;
1790 av_free_packet(&opkt);
1794 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1795 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1796 avfilter_unref_buffer(ost->picref);
1802 av_free(buffer_to_free);
1803 /* XXX: allocate the subtitles in the codec ? */
1804 if (subtitle_to_free) {
1805 avsubtitle_free(subtitle_to_free);
1806 subtitle_to_free = NULL;
1813 for(i=0;i<nb_ostreams;i++) {
1815 if (ost->source_index == ist_index) {
1816 AVCodecContext *enc= ost->st->codec;
1817 os = output_files[ost->file_index];
1819 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1821 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1824 if (ost->encoding_needed) {
1828 av_init_packet(&pkt);
1829 pkt.stream_index= ost->index;
1831 switch(ost->st->codec->codec_type) {
1832 case AVMEDIA_TYPE_AUDIO:
1833 fifo_bytes = av_fifo_size(ost->fifo);
1835 /* encode any samples remaining in fifo */
1836 if (fifo_bytes > 0) {
1837 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1838 int fs_tmp = enc->frame_size;
1840 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1841 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1842 enc->frame_size = fifo_bytes / (osize * enc->channels);
1844 int frame_bytes = enc->frame_size*osize*enc->channels;
1845 if (allocated_audio_buf_size < frame_bytes)
1847 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1850 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1851 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1852 ost->st->time_base.num, enc->sample_rate);
1853 enc->frame_size = fs_tmp;
1856 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1859 fprintf(stderr, "Audio encoding failed\n");
1863 pkt.flags |= AV_PKT_FLAG_KEY;
1865 case AVMEDIA_TYPE_VIDEO:
1866 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1868 fprintf(stderr, "Video encoding failed\n");
1872 if(enc->coded_frame && enc->coded_frame->key_frame)
1873 pkt.flags |= AV_PKT_FLAG_KEY;
1874 if (ost->logfile && enc->stats_out) {
1875 fprintf(ost->logfile, "%s", enc->stats_out);
1884 pkt.data= bit_buffer;
1886 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1887 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1888 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1900 static void print_sdp(AVFormatContext **avc, int n)
1904 av_sdp_create(avc, n, sdp, sizeof(sdp));
1905 printf("SDP:\n%s\n", sdp);
1909 static int copy_chapters(int infile, int outfile)
1911 AVFormatContext *is = input_files[infile].ctx;
1912 AVFormatContext *os = output_files[outfile];
1915 for (i = 0; i < is->nb_chapters; i++) {
1916 AVChapter *in_ch = is->chapters[i], *out_ch;
1917 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1918 AV_TIME_BASE_Q, in_ch->time_base);
1919 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1920 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1923 if (in_ch->end < ts_off)
1925 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1928 out_ch = av_mallocz(sizeof(AVChapter));
1930 return AVERROR(ENOMEM);
1932 out_ch->id = in_ch->id;
1933 out_ch->time_base = in_ch->time_base;
1934 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1935 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1937 if (metadata_chapters_autocopy)
1938 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1941 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1943 return AVERROR(ENOMEM);
1944 os->chapters[os->nb_chapters - 1] = out_ch;
1949 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1950 AVCodecContext *avctx)
1956 for (p = kf; *p; p++)
1959 ost->forced_kf_count = n;
1960 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1961 if (!ost->forced_kf_pts) {
1962 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1965 for (i = 0; i < n; i++) {
1966 p = i ? strchr(p, ',') + 1 : kf;
1967 t = parse_time_or_die("force_key_frames", p, 1);
1968 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1973 * The following code is the main loop of the file converter
1975 static int transcode(AVFormatContext **output_files,
1976 int nb_output_files,
1977 AVInputFile *input_files,
1979 AVStreamMap *stream_maps, int nb_stream_maps)
1981 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0,step;
1983 AVFormatContext *is, *os;
1984 AVCodecContext *codec, *icodec;
1985 AVOutputStream *ost, **ost_table = NULL;
1990 uint8_t no_packet[MAX_FILES]={0};
1991 int no_packet_count=0;
1992 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1993 int nb_streams[AVMEDIA_TYPE_NB]={0};
1996 for (i = 0; i < nb_input_streams; i++)
1997 input_streams[i].start = av_gettime();
1999 /* output stream init */
2001 for(i=0;i<nb_output_files;i++) {
2002 os = output_files[i];
2003 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2004 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2005 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2006 ret = AVERROR(EINVAL);
2009 nb_ostreams += os->nb_streams;
2011 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2012 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2013 ret = AVERROR(EINVAL);
2017 /* Sanity check the mapping args -- do the input files & streams exist? */
2018 for(i=0;i<nb_stream_maps;i++) {
2019 int fi = stream_maps[i].file_index;
2020 int si = stream_maps[i].stream_index;
2022 if (fi < 0 || fi > nb_input_files - 1 ||
2023 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2024 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2025 ret = AVERROR(EINVAL);
2028 fi = stream_maps[i].sync_file_index;
2029 si = stream_maps[i].sync_stream_index;
2030 if (fi < 0 || fi > nb_input_files - 1 ||
2031 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2032 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2033 ret = AVERROR(EINVAL);
2038 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2042 for(k=0;k<nb_output_files;k++) {
2043 os = output_files[k];
2044 for(i=0;i<os->nb_streams;i++,n++) {
2045 nb_streams[os->streams[i]->codec->codec_type]++;
2048 for(step=1<<30; step; step>>=1){
2049 int found_streams[AVMEDIA_TYPE_NB]={0};
2050 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2051 nb_frame_threshold[j] += step;
2053 for(j=0; j<nb_input_streams; j++) {
2055 ist = &input_streams[j];
2058 AVFormatContext *f= input_files[ ist->file_index ].ctx;
2060 for(pi=0; pi<f->nb_programs; pi++){
2061 AVProgram *p= f->programs[pi];
2062 if(p->id == opt_programid)
2063 for(si=0; si<p->nb_stream_indexes; si++){
2064 if(f->streams[ p->stream_index[si] ] == ist->st)
2069 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2070 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2071 found_streams[ist->st->codec->codec_type]++;
2074 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2075 if(found_streams[j] < nb_streams[j])
2076 nb_frame_threshold[j] -= step;
2079 for(k=0;k<nb_output_files;k++) {
2080 os = output_files[k];
2081 for(i=0;i<os->nb_streams;i++,n++) {
2083 ost = ost_table[n] = output_streams_for_file[k][i];
2084 ost->st = os->streams[i];
2085 if (nb_stream_maps > 0) {
2086 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2087 stream_maps[n].stream_index;
2089 /* Sanity check that the stream types match */
2090 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2091 int i= ost->file_index;
2092 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2093 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2094 stream_maps[n].file_index, stream_maps[n].stream_index,
2095 ost->file_index, ost->index);
2100 /* get corresponding input stream index : we select the first one with the right type */
2102 for (j = 0; j < nb_input_streams; j++) {
2104 ist = &input_streams[j];
2107 AVFormatContext *f = input_files[ist->file_index].ctx;
2109 for(pi=0; pi<f->nb_programs; pi++){
2110 AVProgram *p= f->programs[pi];
2111 if(p->id == opt_programid)
2112 for(si=0; si<p->nb_stream_indexes; si++){
2113 if(f->streams[ p->stream_index[si] ] == ist->st)
2118 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2119 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2120 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2121 ost->source_index = j;
2128 if(! opt_programid) {
2129 /* try again and reuse existing stream */
2130 for (j = 0; j < nb_input_streams; j++) {
2131 ist = &input_streams[j];
2132 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2133 && ist->st->discard != AVDISCARD_ALL) {
2134 ost->source_index = j;
2140 int i= ost->file_index;
2141 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2142 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2143 ost->file_index, ost->index);
2148 ist = &input_streams[ost->source_index];
2150 ost->sync_ist = (nb_stream_maps > 0) ?
2151 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2152 stream_maps[n].sync_stream_index] : ist;
2156 /* for each output stream, we compute the right encoding parameters */
2157 for(i=0;i<nb_ostreams;i++) {
2159 os = output_files[ost->file_index];
2160 ist = &input_streams[ost->source_index];
2162 codec = ost->st->codec;
2163 icodec = ist->st->codec;
2165 if (metadata_streams_autocopy)
2166 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2167 AV_METADATA_DONT_OVERWRITE);
2169 ost->st->disposition = ist->st->disposition;
2170 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2171 codec->chroma_sample_location = icodec->chroma_sample_location;
2173 if (ost->st->stream_copy) {
2174 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2176 if (extra_size > INT_MAX)
2179 /* if stream_copy is selected, no need to decode or encode */
2180 codec->codec_id = icodec->codec_id;
2181 codec->codec_type = icodec->codec_type;
2183 if(!codec->codec_tag){
2184 if( !os->oformat->codec_tag
2185 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2186 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2187 codec->codec_tag = icodec->codec_tag;
2190 codec->bit_rate = icodec->bit_rate;
2191 codec->rc_max_rate = icodec->rc_max_rate;
2192 codec->rc_buffer_size = icodec->rc_buffer_size;
2193 codec->extradata= av_mallocz(extra_size);
2194 if (!codec->extradata)
2196 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2197 codec->extradata_size= icodec->extradata_size;
2198 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){
2199 codec->time_base = icodec->time_base;
2200 codec->time_base.num *= icodec->ticks_per_frame;
2201 av_reduce(&codec->time_base.num, &codec->time_base.den,
2202 codec->time_base.num, codec->time_base.den, INT_MAX);
2204 codec->time_base = ist->st->time_base;
2205 switch(codec->codec_type) {
2206 case AVMEDIA_TYPE_AUDIO:
2207 if(audio_volume != 256) {
2208 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2211 codec->channel_layout = icodec->channel_layout;
2212 codec->sample_rate = icodec->sample_rate;
2213 codec->channels = icodec->channels;
2214 codec->frame_size = icodec->frame_size;
2215 codec->audio_service_type = icodec->audio_service_type;
2216 codec->block_align= icodec->block_align;
2217 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2218 codec->block_align= 0;
2219 if(codec->codec_id == CODEC_ID_AC3)
2220 codec->block_align= 0;
2222 case AVMEDIA_TYPE_VIDEO:
2223 codec->pix_fmt = icodec->pix_fmt;
2224 codec->width = icodec->width;
2225 codec->height = icodec->height;
2226 codec->has_b_frames = icodec->has_b_frames;
2227 if (!codec->sample_aspect_ratio.num) {
2228 codec->sample_aspect_ratio =
2229 ost->st->sample_aspect_ratio =
2230 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2231 ist->st->codec->sample_aspect_ratio.num ?
2232 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2235 case AVMEDIA_TYPE_SUBTITLE:
2236 codec->width = icodec->width;
2237 codec->height = icodec->height;
2239 case AVMEDIA_TYPE_DATA:
2245 switch(codec->codec_type) {
2246 case AVMEDIA_TYPE_AUDIO:
2247 ost->fifo= av_fifo_alloc(1024);
2250 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2251 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2252 icodec->request_channels = codec->channels;
2253 ist->decoding_needed = 1;
2254 ost->encoding_needed = 1;
2255 ost->resample_sample_fmt = icodec->sample_fmt;
2256 ost->resample_sample_rate = icodec->sample_rate;
2257 ost->resample_channels = icodec->channels;
2259 case AVMEDIA_TYPE_VIDEO:
2260 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2261 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2264 ost->video_resample = codec->width != icodec->width ||
2265 codec->height != icodec->height ||
2266 codec->pix_fmt != icodec->pix_fmt;
2267 if (ost->video_resample) {
2268 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2270 ost->resample_height = icodec->height;
2271 ost->resample_width = icodec->width;
2272 ost->resample_pix_fmt= icodec->pix_fmt;
2273 ost->encoding_needed = 1;
2274 ist->decoding_needed = 1;
2277 if (configure_video_filters(ist, ost)) {
2278 fprintf(stderr, "Error opening filters!\n");
2283 case AVMEDIA_TYPE_SUBTITLE:
2284 ost->encoding_needed = 1;
2285 ist->decoding_needed = 1;
2292 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2293 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2294 char logfilename[1024];
2297 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2298 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2300 if (codec->flags & CODEC_FLAG_PASS1) {
2301 f = fopen(logfilename, "wb");
2303 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2309 size_t logbuffer_size;
2310 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2311 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2314 codec->stats_in = logbuffer;
2318 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2319 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2320 int size= codec->width * codec->height;
2321 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2326 bit_buffer = av_malloc(bit_buffer_size);
2328 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2330 ret = AVERROR(ENOMEM);
2334 /* open each encoder */
2335 for(i=0;i<nb_ostreams;i++) {
2337 if (ost->encoding_needed) {
2338 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2339 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2341 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2343 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2344 ost->st->codec->codec_id, ost->file_index, ost->index);
2345 ret = AVERROR(EINVAL);
2348 if (dec->subtitle_header) {
2349 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2350 if (!ost->st->codec->subtitle_header) {
2351 ret = AVERROR(ENOMEM);
2354 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2355 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2357 if (avcodec_open(ost->st->codec, codec) < 0) {
2358 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2359 ost->file_index, ost->index);
2360 ret = AVERROR(EINVAL);
2363 extra_size += ost->st->codec->extradata_size;
2367 /* open each decoder */
2368 for (i = 0; i < nb_input_streams; i++) {
2369 ist = &input_streams[i];
2370 if (ist->decoding_needed) {
2371 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2373 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2375 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2376 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2377 ret = AVERROR(EINVAL);
2380 if (avcodec_open(ist->st->codec, codec) < 0) {
2381 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2382 ist->file_index, ist->st->index);
2383 ret = AVERROR(EINVAL);
2386 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2387 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2392 for (i = 0; i < nb_input_streams; i++) {
2394 ist = &input_streams[i];
2396 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2397 ist->next_pts = AV_NOPTS_VALUE;
2401 /* set meta data information from input file if required */
2402 for (i=0;i<nb_meta_data_maps;i++) {
2403 AVFormatContext *files[2];
2404 AVMetadata **meta[2];
2407 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2408 if ((index) < 0 || (index) >= (nb_elems)) {\
2409 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2411 ret = AVERROR(EINVAL);\
2415 int out_file_index = meta_data_maps[i][0].file;
2416 int in_file_index = meta_data_maps[i][1].file;
2417 if (in_file_index < 0 || out_file_index < 0)
2419 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2420 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2422 files[0] = output_files[out_file_index];
2423 files[1] = input_files[in_file_index].ctx;
2425 for (j = 0; j < 2; j++) {
2426 AVMetaDataMap *map = &meta_data_maps[i][j];
2428 switch (map->type) {
2430 meta[j] = &files[j]->metadata;
2433 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2434 meta[j] = &files[j]->streams[map->index]->metadata;
2437 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2438 meta[j] = &files[j]->chapters[map->index]->metadata;
2441 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2442 meta[j] = &files[j]->programs[map->index]->metadata;
2447 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2450 /* copy global metadata by default */
2451 if (metadata_global_autocopy) {
2453 for (i = 0; i < nb_output_files; i++)
2454 av_metadata_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2455 AV_METADATA_DONT_OVERWRITE);
2458 /* copy chapters according to chapter maps */
2459 for (i = 0; i < nb_chapter_maps; i++) {
2460 int infile = chapter_maps[i].in_file;
2461 int outfile = chapter_maps[i].out_file;
2463 if (infile < 0 || outfile < 0)
2465 if (infile >= nb_input_files) {
2466 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2467 ret = AVERROR(EINVAL);
2470 if (outfile >= nb_output_files) {
2471 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2472 ret = AVERROR(EINVAL);
2475 copy_chapters(infile, outfile);
2478 /* copy chapters from the first input file that has them*/
2479 if (!nb_chapter_maps)
2480 for (i = 0; i < nb_input_files; i++) {
2481 if (!input_files[i].ctx->nb_chapters)
2484 for (j = 0; j < nb_output_files; j++)
2485 if ((ret = copy_chapters(i, j)) < 0)
2490 /* open files and write file headers */
2491 for(i=0;i<nb_output_files;i++) {
2492 os = output_files[i];
2493 if (av_write_header(os) < 0) {
2494 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2495 ret = AVERROR(EINVAL);
2498 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2504 /* dump the file output parameters - cannot be done before in case
2506 for(i=0;i<nb_output_files;i++) {
2507 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2510 /* dump the stream mapping */
2512 fprintf(stderr, "Stream mapping:\n");
2513 for(i=0;i<nb_ostreams;i++) {
2515 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2516 input_streams[ost->source_index].file_index,
2517 input_streams[ost->source_index].st->index,
2520 if (ost->sync_ist != &input_streams[ost->source_index])
2521 fprintf(stderr, " [sync #%d.%d]",
2522 ost->sync_ist->file_index,
2523 ost->sync_ist->st->index);
2524 fprintf(stderr, "\n");
2529 fprintf(stderr, "%s\n", error);
2534 print_sdp(output_files, nb_output_files);
2539 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2540 avio_set_interrupt_cb(decode_interrupt_cb);
2544 timer_start = av_gettime();
2546 for(; received_sigterm == 0;) {
2547 int file_index, ist_index;
2555 /* if 'q' pressed, exits */
2559 /* read_key() returns 0 on EOF */
2563 if (key == '+') verbose++;
2564 if (key == '-') verbose--;
2565 if (key == 's') qp_hist ^= 1;
2568 do_hex_dump = do_pkt_dump = 0;
2569 } else if(do_pkt_dump){
2573 av_log_set_level(AV_LOG_DEBUG);
2575 if (key == 'd' || key == 'D'){
2578 debug = input_streams[0].st->codec->debug<<1;
2579 if(!debug) debug = 1;
2580 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2583 scanf("%d", &debug);
2584 for(i=0;i<nb_input_streams;i++) {
2585 input_streams[i].st->codec->debug = debug;
2587 for(i=0;i<nb_ostreams;i++) {
2589 ost->st->codec->debug = debug;
2591 if(debug) av_log_set_level(AV_LOG_DEBUG);
2592 fprintf(stderr,"debug=%d\n", debug);
2595 fprintf(stderr, "key function\n"
2596 "? show this help\n"
2597 "+ increase verbosity\n"
2598 "- decrease verbosity\n"
2599 "D cycle through available debug modes\n"
2600 "h dump packets/hex press to cycle through the 3 states\n"
2602 "s Show QP histogram\n"
2607 /* select the stream that we must read now by looking at the
2608 smallest output pts */
2610 for(i=0;i<nb_ostreams;i++) {
2613 os = output_files[ost->file_index];
2614 ist = &input_streams[ost->source_index];
2615 if(ist->is_past_recording_time || no_packet[ist->file_index])
2617 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2618 ipts = (double)ist->pts;
2619 if (!input_files[ist->file_index].eof_reached){
2620 if(ipts < ipts_min) {
2622 if(input_sync ) file_index = ist->file_index;
2624 if(opts < opts_min) {
2626 if(!input_sync) file_index = ist->file_index;
2629 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2634 /* if none, if is finished */
2635 if (file_index < 0) {
2636 if(no_packet_count){
2638 memset(no_packet, 0, sizeof(no_packet));
2645 /* finish if limit size exhausted */
2646 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2649 /* read a frame from it and output it in the fifo */
2650 is = input_files[file_index].ctx;
2651 ret= av_read_frame(is, &pkt);
2652 if(ret == AVERROR(EAGAIN)){
2653 no_packet[file_index]=1;
2658 input_files[file_index].eof_reached = 1;
2666 memset(no_packet, 0, sizeof(no_packet));
2669 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2670 is->streams[pkt.stream_index]);
2672 /* the following test is needed in case new streams appear
2673 dynamically in stream : we ignore them */
2674 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2675 goto discard_packet;
2676 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2677 ist = &input_streams[ist_index];
2679 goto discard_packet;
2681 if (pkt.dts != AV_NOPTS_VALUE)
2682 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2683 if (pkt.pts != AV_NOPTS_VALUE)
2684 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2686 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2687 && input_files_ts_scale[file_index][pkt.stream_index]){
2688 if(pkt.pts != AV_NOPTS_VALUE)
2689 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2690 if(pkt.dts != AV_NOPTS_VALUE)
2691 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2694 // 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);
2695 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2696 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2697 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2698 int64_t delta= pkt_dts - ist->next_pts;
2699 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2700 input_files_ts_offset[ist->file_index]-= delta;
2702 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2703 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2704 if(pkt.pts != AV_NOPTS_VALUE)
2705 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2709 /* finish if recording time exhausted */
2710 if (recording_time != INT64_MAX &&
2711 (pkt.pts != AV_NOPTS_VALUE || pkt.dts != AV_NOPTS_VALUE ?
2712 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2714 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2716 ist->is_past_recording_time = 1;
2717 goto discard_packet;
2720 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2721 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2724 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2725 ist->file_index, ist->st->index);
2728 av_free_packet(&pkt);
2733 av_free_packet(&pkt);
2735 /* dump report by using the output first video and audio streams */
2736 print_report(output_files, ost_table, nb_ostreams, 0);
2739 /* at the end of stream, we must flush the decoder buffers */
2740 for (i = 0; i < nb_input_streams; i++) {
2741 ist = &input_streams[i];
2742 if (ist->decoding_needed) {
2743 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2749 /* write the trailer if needed and close file */
2750 for(i=0;i<nb_output_files;i++) {
2751 os = output_files[i];
2752 av_write_trailer(os);
2755 /* dump report by using the first video and audio streams */
2756 print_report(output_files, ost_table, nb_ostreams, 1);
2758 /* close each encoder */
2759 for(i=0;i<nb_ostreams;i++) {
2761 if (ost->encoding_needed) {
2762 av_freep(&ost->st->codec->stats_in);
2763 avcodec_close(ost->st->codec);
2766 avfilter_graph_free(&ost->graph);
2770 /* close each decoder */
2771 for (i = 0; i < nb_input_streams; i++) {
2772 ist = &input_streams[i];
2773 if (ist->decoding_needed) {
2774 avcodec_close(ist->st->codec);
2782 av_freep(&bit_buffer);
2785 for(i=0;i<nb_ostreams;i++) {
2788 if (ost->st->stream_copy)
2789 av_freep(&ost->st->codec->extradata);
2791 fclose(ost->logfile);
2792 ost->logfile = NULL;
2794 av_fifo_free(ost->fifo); /* works even if fifo is not
2795 initialized but set to zero */
2796 av_freep(&ost->st->codec->subtitle_header);
2797 av_free(ost->resample_frame.data[0]);
2798 av_free(ost->forced_kf_pts);
2799 if (ost->video_resample)
2800 sws_freeContext(ost->img_resample_ctx);
2802 audio_resample_close(ost->resample);
2803 if (ost->reformat_ctx)
2804 av_audio_convert_free(ost->reformat_ctx);
2813 static void opt_format(const char *arg)
2815 last_asked_format = arg;
2818 static void opt_video_rc_override_string(const char *arg)
2820 video_rc_override_string = arg;
2823 static int opt_me_threshold(const char *opt, const char *arg)
2825 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2829 static int opt_verbose(const char *opt, const char *arg)
2831 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2835 static int opt_frame_rate(const char *opt, const char *arg)
2837 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2838 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2844 static int opt_bitrate(const char *opt, const char *arg)
2846 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2848 opt_default(opt, arg);
2850 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2851 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2856 static int opt_frame_crop(const char *opt, const char *arg)
2858 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2859 return AVERROR(EINVAL);
2862 static void opt_frame_size(const char *arg)
2864 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2865 fprintf(stderr, "Incorrect frame size\n");
2870 static int opt_pad(const char *opt, const char *arg) {
2871 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2875 static void opt_frame_pix_fmt(const char *arg)
2877 if (strcmp(arg, "list")) {
2878 frame_pix_fmt = av_get_pix_fmt(arg);
2879 if (frame_pix_fmt == PIX_FMT_NONE) {
2880 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2889 static void opt_frame_aspect_ratio(const char *arg)
2896 p = strchr(arg, ':');
2898 x = strtol(arg, &end, 10);
2900 y = strtol(end+1, &end, 10);
2902 ar = (double)x / (double)y;
2904 ar = strtod(arg, NULL);
2907 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2910 frame_aspect_ratio = ar;
2913 static int opt_metadata(const char *opt, const char *arg)
2915 char *mid= strchr(arg, '=');
2918 fprintf(stderr, "Missing =\n");
2923 av_metadata_set2(&metadata, arg, mid, 0);
2928 static int opt_qscale(const char *opt, const char *arg)
2930 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2931 if (video_qscale <= 0 || video_qscale > 255) {
2932 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2933 return AVERROR(EINVAL);
2938 static int opt_top_field_first(const char *opt, const char *arg)
2940 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2941 opt_default(opt, arg);
2945 static int opt_thread_count(const char *opt, const char *arg)
2947 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2950 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2955 static void opt_audio_sample_fmt(const char *arg)
2957 if (strcmp(arg, "list")) {
2958 audio_sample_fmt = av_get_sample_fmt(arg);
2959 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2960 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2966 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2967 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2972 static int opt_audio_rate(const char *opt, const char *arg)
2974 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2978 static int opt_audio_channels(const char *opt, const char *arg)
2980 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2984 static int opt_video_channel(const char *opt, const char *arg)
2986 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2990 static void opt_video_standard(const char *arg)
2992 video_standard = av_strdup(arg);
2995 static void opt_codec(int *pstream_copy, char **pcodec_name,
2996 int codec_type, const char *arg)
2998 av_freep(pcodec_name);
2999 if (!strcmp(arg, "copy")) {
3002 *pcodec_name = av_strdup(arg);
3006 static void opt_audio_codec(const char *arg)
3008 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3011 static void opt_video_codec(const char *arg)
3013 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3016 static void opt_subtitle_codec(const char *arg)
3018 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3021 static void opt_data_codec(const char *arg)
3023 opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
3026 static int opt_codec_tag(const char *opt, const char *arg)
3029 uint32_t *codec_tag;
3031 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3032 !strcmp(opt, "vtag") ? &video_codec_tag :
3033 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3037 *codec_tag = strtol(arg, &tail, 0);
3039 *codec_tag = AV_RL32(arg);
3044 static void opt_map(const char *arg)
3049 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3050 m = &stream_maps[nb_stream_maps-1];
3052 m->file_index = strtol(arg, &p, 0);
3056 m->stream_index = strtol(p, &p, 0);
3059 m->sync_file_index = strtol(p, &p, 0);
3062 m->sync_stream_index = strtol(p, &p, 0);
3064 m->sync_file_index = m->file_index;
3065 m->sync_stream_index = m->stream_index;
3069 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3080 *index = strtol(++arg, endptr, 0);
3083 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3090 static void opt_map_metadata(const char *arg)
3092 AVMetaDataMap *m, *m1;
3095 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3096 &nb_meta_data_maps, nb_meta_data_maps + 1);
3098 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3099 m->file = strtol(arg, &p, 0);
3100 parse_meta_type(p, &m->type, &m->index, &p);
3104 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3105 m1->file = strtol(p, &p, 0);
3106 parse_meta_type(p, &m1->type, &m1->index, &p);
3108 if (m->type == 'g' || m1->type == 'g')
3109 metadata_global_autocopy = 0;
3110 if (m->type == 's' || m1->type == 's')
3111 metadata_streams_autocopy = 0;
3112 if (m->type == 'c' || m1->type == 'c')
3113 metadata_chapters_autocopy = 0;
3116 static void opt_map_meta_data(const char *arg)
3118 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3119 "Use -map_metadata instead.\n");
3120 opt_map_metadata(arg);
3123 static void opt_map_chapters(const char *arg)
3128 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3129 nb_chapter_maps + 1);
3130 c = &chapter_maps[nb_chapter_maps - 1];
3131 c->out_file = strtol(arg, &p, 0);
3135 c->in_file = strtol(p, &p, 0);
3138 static void opt_input_ts_scale(const char *arg)
3140 unsigned int stream;
3144 stream = strtol(arg, &p, 0);
3147 scale= strtod(p, &p);
3149 if(stream >= MAX_STREAMS)
3152 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);
3153 input_files_ts_scale[nb_input_files][stream]= scale;
3156 static int opt_recording_time(const char *opt, const char *arg)
3158 recording_time = parse_time_or_die(opt, arg, 1);
3162 static int opt_start_time(const char *opt, const char *arg)
3164 start_time = parse_time_or_die(opt, arg, 1);
3168 static int opt_recording_timestamp(const char *opt, const char *arg)
3170 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3174 static int opt_input_ts_offset(const char *opt, const char *arg)
3176 input_ts_offset = parse_time_or_die(opt, arg, 1);
3180 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3182 const char *codec_string = encoder ? "encoder" : "decoder";
3186 return CODEC_ID_NONE;
3188 avcodec_find_encoder_by_name(name) :
3189 avcodec_find_decoder_by_name(name);
3191 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3194 if(codec->type != type) {
3195 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3198 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3199 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3200 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3201 "results.\nAdd '-strict experimental' if you want to use it.\n",
3202 codec_string, codec->name);
3204 avcodec_find_encoder(codec->id) :
3205 avcodec_find_decoder(codec->id);
3206 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3207 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3208 codec_string, codec->name);
3214 static void opt_input_file(const char *filename)
3216 AVFormatContext *ic;
3217 AVFormatParameters params, *ap = ¶ms;
3218 AVInputFormat *file_iformat = NULL;
3219 int err, i, ret, rfps, rfps_base;
3222 if (last_asked_format) {
3223 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3224 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3227 last_asked_format = NULL;
3230 if (!strcmp(filename, "-"))
3233 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3234 !strcmp(filename, "/dev/stdin");
3236 /* get default parameters from command line */
3237 ic = avformat_alloc_context();
3239 print_error(filename, AVERROR(ENOMEM));
3243 memset(ap, 0, sizeof(*ap));
3244 ap->prealloced_context = 1;
3245 ap->sample_rate = audio_sample_rate;
3246 ap->channels = audio_channels;
3247 ap->time_base.den = frame_rate.num;
3248 ap->time_base.num = frame_rate.den;
3249 ap->width = frame_width;
3250 ap->height = frame_height;
3251 ap->pix_fmt = frame_pix_fmt;
3252 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3253 ap->channel = video_channel;
3254 ap->standard = video_standard;
3256 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3258 ic->video_codec_id =
3259 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3260 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3261 ic->audio_codec_id =
3262 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3263 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3264 ic->subtitle_codec_id=
3265 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3266 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3267 ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3269 /* open the input file with generic libav function */
3270 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3272 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3273 err = av_demuxer_open(ic, ap);
3275 avformat_free_context(ic);
3278 print_error(filename, err);
3284 for(i=0; i<ic->nb_streams; i++){
3285 ic->streams[i]->discard= AVDISCARD_ALL;
3287 for(i=0; i<ic->nb_programs; i++){
3288 AVProgram *p= ic->programs[i];
3289 if(p->id != opt_programid){
3290 p->discard = AVDISCARD_ALL;
3293 for(j=0; j<p->nb_stream_indexes; j++){
3294 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3299 fprintf(stderr, "Specified program id not found\n");
3305 ic->loop_input = loop_input;
3307 /* If not enough info to get the stream parameters, we decode the
3308 first frames to get it. (used in mpeg case for example) */
3309 ret = av_find_stream_info(ic);
3310 if (ret < 0 && verbose >= 0) {
3311 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3312 av_close_input_file(ic);
3316 timestamp = start_time;
3317 /* add the stream start time */
3318 if (ic->start_time != AV_NOPTS_VALUE)
3319 timestamp += ic->start_time;
3321 /* if seeking requested, we execute it */
3322 if (start_time != 0) {
3323 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3325 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3326 filename, (double)timestamp / AV_TIME_BASE);
3328 /* reset seek info */
3332 /* update the current parameters so that they match the one of the input stream */
3333 for(i=0;i<ic->nb_streams;i++) {
3334 AVStream *st = ic->streams[i];
3335 AVCodecContext *dec = st->codec;
3338 dec->thread_count = thread_count;
3339 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3341 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3342 ist = &input_streams[nb_input_streams - 1];
3344 ist->file_index = nb_input_files;
3347 switch (dec->codec_type) {
3348 case AVMEDIA_TYPE_AUDIO:
3349 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3350 if(!input_codecs[nb_input_codecs-1])
3351 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3352 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]);
3353 channel_layout = dec->channel_layout;
3354 audio_channels = dec->channels;
3355 audio_sample_rate = dec->sample_rate;
3356 audio_sample_fmt = dec->sample_fmt;
3358 st->discard= AVDISCARD_ALL;
3359 /* Note that av_find_stream_info can add more streams, and we
3360 * currently have no chance of setting up lowres decoding
3361 * early enough for them. */
3363 audio_sample_rate >>= dec->lowres;
3365 case AVMEDIA_TYPE_VIDEO:
3366 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3367 if(!input_codecs[nb_input_codecs-1])
3368 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3369 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]);
3370 frame_height = dec->height;
3371 frame_width = dec->width;
3372 frame_pix_fmt = dec->pix_fmt;
3373 rfps = ic->streams[i]->r_frame_rate.num;
3374 rfps_base = ic->streams[i]->r_frame_rate.den;
3376 dec->flags |= CODEC_FLAG_EMU_EDGE;
3377 frame_height >>= dec->lowres;
3378 frame_width >>= dec->lowres;
3379 dec->height = frame_height;
3380 dec->width = frame_width;
3383 dec->debug |= FF_DEBUG_MV;
3385 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3388 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3389 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3391 (float)rfps / rfps_base, rfps, rfps_base);
3393 /* update the current frame rate to match the stream frame rate */
3394 frame_rate.num = rfps;
3395 frame_rate.den = rfps_base;
3398 st->discard= AVDISCARD_ALL;
3399 else if(video_discard)
3400 st->discard= video_discard;
3402 case AVMEDIA_TYPE_DATA:
3404 case AVMEDIA_TYPE_SUBTITLE:
3405 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3406 if(!input_codecs[nb_input_codecs-1])
3407 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3408 if(subtitle_disable)
3409 st->discard = AVDISCARD_ALL;
3411 case AVMEDIA_TYPE_ATTACHMENT:
3412 case AVMEDIA_TYPE_UNKNOWN:
3419 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3420 /* dump the file content */
3422 av_dump_format(ic, nb_input_files, filename, 0);
3424 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3425 input_files[nb_input_files - 1].ctx = ic;
3426 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3429 top_field_first = -1;
3431 av_freep(&video_codec_name);
3432 av_freep(&audio_codec_name);
3433 av_freep(&subtitle_codec_name);
3438 static void check_inputs(int *has_video_ptr,
3440 int *has_subtitle_ptr,
3443 int has_video, has_audio, has_subtitle, has_data, i, j;
3444 AVFormatContext *ic;
3451 for(j=0;j<nb_input_files;j++) {
3452 ic = input_files[j].ctx;
3453 for(i=0;i<ic->nb_streams;i++) {
3454 AVCodecContext *enc = ic->streams[i]->codec;
3455 switch(enc->codec_type) {
3456 case AVMEDIA_TYPE_AUDIO:
3459 case AVMEDIA_TYPE_VIDEO:
3462 case AVMEDIA_TYPE_SUBTITLE:
3465 case AVMEDIA_TYPE_DATA:
3466 case AVMEDIA_TYPE_ATTACHMENT:
3467 case AVMEDIA_TYPE_UNKNOWN:
3475 *has_video_ptr = has_video;
3476 *has_audio_ptr = has_audio;
3477 *has_subtitle_ptr = has_subtitle;
3478 *has_data_ptr = has_data;
3481 static void new_video_stream(AVFormatContext *oc, int file_idx)
3484 AVOutputStream *ost;
3485 AVCodecContext *video_enc;
3486 enum CodecID codec_id = CODEC_ID_NONE;
3487 AVCodec *codec= NULL;
3489 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3491 fprintf(stderr, "Could not alloc stream\n");
3494 ost = new_output_stream(oc, file_idx);
3496 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3497 if(!video_stream_copy){
3498 if (video_codec_name) {
3499 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3500 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3501 codec = avcodec_find_encoder_by_name(video_codec_name);
3502 output_codecs[nb_output_codecs-1] = codec;
3504 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3505 codec = avcodec_find_encoder(codec_id);
3507 ost->frame_aspect_ratio = frame_aspect_ratio;
3508 frame_aspect_ratio = 0;
3510 ost->avfilter = vfilters;
3515 avcodec_get_context_defaults3(st->codec, codec);
3516 ost->bitstream_filters = video_bitstream_filters;
3517 video_bitstream_filters= NULL;
3519 st->codec->thread_count= thread_count;
3521 video_enc = st->codec;
3524 video_enc->codec_tag= video_codec_tag;
3526 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3527 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3528 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3531 if (video_stream_copy) {
3532 st->stream_copy = 1;
3533 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3534 video_enc->sample_aspect_ratio =
3535 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3539 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3541 video_enc->codec_id = codec_id;
3542 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3544 if (codec && codec->supported_framerates && !force_fps)
3545 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3546 video_enc->time_base.den = fps.num;
3547 video_enc->time_base.num = fps.den;
3549 video_enc->width = frame_width;
3550 video_enc->height = frame_height;
3551 video_enc->pix_fmt = frame_pix_fmt;
3552 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3553 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3555 choose_pixel_fmt(st, codec);
3558 video_enc->gop_size = 0;
3559 if (video_qscale || same_quality) {
3560 video_enc->flags |= CODEC_FLAG_QSCALE;
3561 video_enc->global_quality=
3562 st->quality = FF_QP2LAMBDA * video_qscale;
3566 video_enc->intra_matrix = intra_matrix;
3568 video_enc->inter_matrix = inter_matrix;
3570 p= video_rc_override_string;
3573 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3575 fprintf(stderr, "error parsing rc_override\n");
3578 video_enc->rc_override=
3579 av_realloc(video_enc->rc_override,
3580 sizeof(RcOverride)*(i+1));
3581 video_enc->rc_override[i].start_frame= start;
3582 video_enc->rc_override[i].end_frame = end;
3584 video_enc->rc_override[i].qscale= q;
3585 video_enc->rc_override[i].quality_factor= 1.0;
3588 video_enc->rc_override[i].qscale= 0;
3589 video_enc->rc_override[i].quality_factor= -q/100.0;
3594 video_enc->rc_override_count=i;
3595 if (!video_enc->rc_initial_buffer_occupancy)
3596 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3597 video_enc->me_threshold= me_threshold;
3598 video_enc->intra_dc_precision= intra_dc_precision - 8;
3601 video_enc->flags|= CODEC_FLAG_PSNR;
3606 video_enc->flags |= CODEC_FLAG_PASS1;
3608 video_enc->flags |= CODEC_FLAG_PASS2;
3612 if (forced_key_frames)
3613 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3615 if (video_language) {
3616 av_metadata_set2(&st->metadata, "language", video_language, 0);
3617 av_freep(&video_language);
3620 /* reset some key parameters */
3622 av_freep(&video_codec_name);
3623 av_freep(&forced_key_frames);
3624 video_stream_copy = 0;
3625 frame_pix_fmt = PIX_FMT_NONE;
3628 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3631 AVOutputStream *ost;
3632 AVCodec *codec= NULL;
3633 AVCodecContext *audio_enc;
3634 enum CodecID codec_id = CODEC_ID_NONE;
3636 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3638 fprintf(stderr, "Could not alloc stream\n");
3641 ost = new_output_stream(oc, file_idx);
3643 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3644 if(!audio_stream_copy){
3645 if (audio_codec_name) {
3646 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3647 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3648 codec = avcodec_find_encoder_by_name(audio_codec_name);
3649 output_codecs[nb_output_codecs-1] = codec;
3651 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3652 codec = avcodec_find_encoder(codec_id);
3656 avcodec_get_context_defaults3(st->codec, codec);
3658 ost->bitstream_filters = audio_bitstream_filters;
3659 audio_bitstream_filters= NULL;
3661 st->codec->thread_count= thread_count;
3663 audio_enc = st->codec;
3664 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3667 audio_enc->codec_tag= audio_codec_tag;
3669 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3670 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3671 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3673 if (audio_stream_copy) {
3674 st->stream_copy = 1;
3675 audio_enc->channels = audio_channels;
3676 audio_enc->sample_rate = audio_sample_rate;
3678 audio_enc->codec_id = codec_id;
3679 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3681 if (audio_qscale > QSCALE_NONE) {
3682 audio_enc->flags |= CODEC_FLAG_QSCALE;
3683 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3685 audio_enc->channels = audio_channels;
3686 audio_enc->sample_fmt = audio_sample_fmt;
3687 audio_enc->sample_rate = audio_sample_rate;
3688 audio_enc->channel_layout = channel_layout;
3689 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3690 audio_enc->channel_layout = 0;
3691 choose_sample_fmt(st, codec);
3692 choose_sample_rate(st, codec);
3694 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3695 if (audio_language) {
3696 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3697 av_freep(&audio_language);
3700 /* reset some key parameters */
3702 av_freep(&audio_codec_name);
3703 audio_stream_copy = 0;
3706 static void new_data_stream(AVFormatContext *oc, int file_idx)
3709 AVOutputStream *ost;
3710 AVCodec *codec=NULL;
3711 AVCodecContext *data_enc;
3713 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3715 fprintf(stderr, "Could not alloc stream\n");
3718 ost = new_output_stream(oc, file_idx);
3719 data_enc = st->codec;
3720 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3721 if (!data_stream_copy) {
3722 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3725 avcodec_get_context_defaults3(st->codec, codec);
3727 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3730 data_enc->codec_tag= data_codec_tag;
3732 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3733 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3734 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3736 if (data_stream_copy) {
3737 st->stream_copy = 1;
3741 av_freep(&data_codec_name);
3742 data_stream_copy = 0;
3745 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3748 AVOutputStream *ost;
3749 AVCodec *codec=NULL;
3750 AVCodecContext *subtitle_enc;
3751 enum CodecID codec_id = CODEC_ID_NONE;
3753 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3755 fprintf(stderr, "Could not alloc stream\n");
3758 ost = new_output_stream(oc, file_idx);
3759 subtitle_enc = st->codec;
3760 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3761 if(!subtitle_stream_copy){
3762 if (subtitle_codec_name) {
3763 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3764 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3765 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3767 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3768 codec = avcodec_find_encoder(codec_id);
3771 avcodec_get_context_defaults3(st->codec, codec);
3773 ost->bitstream_filters = subtitle_bitstream_filters;
3774 subtitle_bitstream_filters= NULL;
3776 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3778 if(subtitle_codec_tag)
3779 subtitle_enc->codec_tag= subtitle_codec_tag;
3781 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3782 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3783 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3785 if (subtitle_stream_copy) {
3786 st->stream_copy = 1;
3788 subtitle_enc->codec_id = codec_id;
3789 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3792 if (subtitle_language) {
3793 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3794 av_freep(&subtitle_language);
3797 subtitle_disable = 0;
3798 av_freep(&subtitle_codec_name);
3799 subtitle_stream_copy = 0;
3802 static int opt_new_stream(const char *opt, const char *arg)
3804 AVFormatContext *oc;
3805 int file_idx = nb_output_files - 1;
3806 if (nb_output_files <= 0) {
3807 fprintf(stderr, "At least one output file must be specified\n");
3810 oc = output_files[file_idx];
3812 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3813 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3814 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3815 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3820 /* arg format is "output-stream-index:streamid-value". */
3821 static int opt_streamid(const char *opt, const char *arg)
3827 av_strlcpy(idx_str, arg, sizeof(idx_str));
3828 p = strchr(idx_str, ':');
3831 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3836 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3837 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3838 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3842 static void opt_output_file(const char *filename)
3844 AVFormatContext *oc;
3845 int err, use_video, use_audio, use_subtitle, use_data;
3846 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3847 AVFormatParameters params, *ap = ¶ms;
3848 AVOutputFormat *file_oformat;
3850 if (!strcmp(filename, "-"))
3853 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3854 last_asked_format = NULL;
3856 print_error(filename, err);
3859 file_oformat= oc->oformat;
3861 if (!strcmp(file_oformat->name, "ffm") &&
3862 av_strstart(filename, "http:", NULL)) {
3863 /* special case for files sent to ffserver: we get the stream
3864 parameters from ffserver */
3865 int err = read_ffserver_streams(oc, filename);
3867 print_error(filename, err);
3871 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3872 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3873 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3874 use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3876 /* disable if no corresponding type found and at least one
3878 if (nb_input_files > 0) {
3879 check_inputs(&input_has_video,
3881 &input_has_subtitle,
3884 if (!input_has_video)
3886 if (!input_has_audio)
3888 if (!input_has_subtitle)
3890 if (!input_has_data)
3894 /* manual disable */
3895 if (audio_disable) use_audio = 0;
3896 if (video_disable) use_video = 0;
3897 if (subtitle_disable) use_subtitle = 0;
3898 if (data_disable) use_data = 0;
3900 if (use_video) new_video_stream(oc, nb_output_files);
3901 if (use_audio) new_audio_stream(oc, nb_output_files);
3902 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3903 if (use_data) new_data_stream(oc, nb_output_files);
3905 oc->timestamp = recording_timestamp;
3907 av_metadata_copy(&oc->metadata, metadata, 0);
3908 av_metadata_free(&metadata);
3911 output_files[nb_output_files++] = oc;
3913 /* check filename in case of an image number is expected */
3914 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3915 if (!av_filename_number_test(oc->filename)) {
3916 print_error(oc->filename, AVERROR(EINVAL));
3921 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3922 /* test if it already exists to avoid loosing precious files */
3923 if (!file_overwrite &&
3924 (strchr(filename, ':') == NULL ||
3925 filename[1] == ':' ||
3926 av_strstart(filename, "file:", NULL))) {
3927 if (avio_check(filename, 0) == 0) {
3929 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3931 if (!read_yesno()) {
3932 fprintf(stderr, "Not overwriting - exiting\n");
3937 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3944 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3945 print_error(filename, err);
3950 memset(ap, 0, sizeof(*ap));
3951 if (av_set_parameters(oc, ap) < 0) {
3952 fprintf(stderr, "%s: Invalid encoding parameters\n",
3957 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3958 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3959 oc->loop_output = loop_output;
3961 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3963 av_freep(&forced_key_frames);
3968 /* same option as mencoder */
3969 static int opt_pass(const char *opt, const char *arg)
3971 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3975 static int64_t getutime(void)
3978 struct rusage rusage;
3980 getrusage(RUSAGE_SELF, &rusage);
3981 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3982 #elif HAVE_GETPROCESSTIMES
3984 FILETIME c, e, k, u;
3985 proc = GetCurrentProcess();
3986 GetProcessTimes(proc, &c, &e, &k, &u);
3987 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3989 return av_gettime();
3993 static int64_t getmaxrss(void)
3995 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3996 struct rusage rusage;
3997 getrusage(RUSAGE_SELF, &rusage);
3998 return (int64_t)rusage.ru_maxrss * 1024;
3999 #elif HAVE_GETPROCESSMEMORYINFO
4001 PROCESS_MEMORY_COUNTERS memcounters;
4002 proc = GetCurrentProcess();
4003 memcounters.cb = sizeof(memcounters);
4004 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4005 return memcounters.PeakPagefileUsage;
4011 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4014 const char *p = str;
4021 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4028 static void opt_inter_matrix(const char *arg)
4030 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4031 parse_matrix_coeffs(inter_matrix, arg);
4034 static void opt_intra_matrix(const char *arg)
4036 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4037 parse_matrix_coeffs(intra_matrix, arg);
4040 static void show_usage(void)
4042 printf("Hyper fast Audio and Video encoder\n");
4043 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4047 static void show_help(void)
4050 AVOutputFormat *oformat = NULL;
4052 av_log_set_callback(log_callback_help);
4054 show_help_options(options, "Main options:\n",
4055 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4056 show_help_options(options, "\nAdvanced options:\n",
4057 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4059 show_help_options(options, "\nVideo options:\n",
4060 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4062 show_help_options(options, "\nAdvanced Video options:\n",
4063 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4064 OPT_VIDEO | OPT_EXPERT);
4065 show_help_options(options, "\nAudio options:\n",
4066 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4068 show_help_options(options, "\nAdvanced Audio options:\n",
4069 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4070 OPT_AUDIO | OPT_EXPERT);
4071 show_help_options(options, "\nSubtitle options:\n",
4072 OPT_SUBTITLE | OPT_GRAB,
4074 show_help_options(options, "\nAudio/Video grab options:\n",
4078 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4081 /* individual codec options */
4083 while ((c = av_codec_next(c))) {
4084 if (c->priv_class) {
4085 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4090 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4093 /* individual muxer options */
4094 while ((oformat = av_oformat_next(oformat))) {
4095 if (oformat->priv_class) {
4096 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4101 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4104 static void opt_target(const char *arg)
4106 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4107 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4109 if(!strncmp(arg, "pal-", 4)) {
4112 } else if(!strncmp(arg, "ntsc-", 5)) {
4115 } else if(!strncmp(arg, "film-", 5)) {
4120 /* Calculate FR via float to avoid int overflow */
4121 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4124 } else if((fr == 29970) || (fr == 23976)) {
4127 /* Try to determine PAL/NTSC by peeking in the input files */
4128 if(nb_input_files) {
4130 for (j = 0; j < nb_input_files; j++) {
4131 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4132 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4133 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4135 fr = c->time_base.den * 1000 / c->time_base.num;
4139 } else if((fr == 29970) || (fr == 23976)) {
4149 if(verbose > 0 && norm != UNKNOWN)
4150 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4153 if(norm == UNKNOWN) {
4154 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4155 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4156 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4160 if(!strcmp(arg, "vcd")) {
4162 opt_video_codec("mpeg1video");
4163 opt_audio_codec("mp2");
4166 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4167 opt_frame_rate(NULL, frame_rates[norm]);
4168 opt_default("g", norm == PAL ? "15" : "18");
4170 opt_default("b", "1150000");
4171 opt_default("maxrate", "1150000");
4172 opt_default("minrate", "1150000");
4173 opt_default("bufsize", "327680"); // 40*1024*8;
4175 opt_default("ab", "224000");
4176 audio_sample_rate = 44100;
4179 opt_default("packetsize", "2324");
4180 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4182 /* We have to offset the PTS, so that it is consistent with the SCR.
4183 SCR starts at 36000, but the first two packs contain only padding
4184 and the first pack from the other stream, respectively, may also have
4185 been written before.
4186 So the real data starts at SCR 36000+3*1200. */
4187 mux_preload= (36000+3*1200) / 90000.0; //0.44
4188 } else if(!strcmp(arg, "svcd")) {
4190 opt_video_codec("mpeg2video");
4191 opt_audio_codec("mp2");
4194 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4195 opt_frame_rate(NULL, frame_rates[norm]);
4196 opt_default("g", norm == PAL ? "15" : "18");
4198 opt_default("b", "2040000");
4199 opt_default("maxrate", "2516000");
4200 opt_default("minrate", "0"); //1145000;
4201 opt_default("bufsize", "1835008"); //224*1024*8;
4202 opt_default("flags", "+scan_offset");
4205 opt_default("ab", "224000");
4206 audio_sample_rate = 44100;
4208 opt_default("packetsize", "2324");
4210 } else if(!strcmp(arg, "dvd")) {
4212 opt_video_codec("mpeg2video");
4213 opt_audio_codec("ac3");
4216 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4217 opt_frame_rate(NULL, frame_rates[norm]);
4218 opt_default("g", norm == PAL ? "15" : "18");
4220 opt_default("b", "6000000");
4221 opt_default("maxrate", "9000000");
4222 opt_default("minrate", "0"); //1500000;
4223 opt_default("bufsize", "1835008"); //224*1024*8;
4225 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4226 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4228 opt_default("ab", "448000");
4229 audio_sample_rate = 48000;
4231 } else if(!strncmp(arg, "dv", 2)) {
4235 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4236 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4237 (norm == PAL ? "yuv420p" : "yuv411p"));
4238 opt_frame_rate(NULL, frame_rates[norm]);
4240 audio_sample_rate = 48000;
4244 fprintf(stderr, "Unknown target: %s\n", arg);
4249 static void opt_vstats_file (const char *arg)
4251 av_free (vstats_filename);
4252 vstats_filename=av_strdup (arg);
4255 static void opt_vstats (void)
4258 time_t today2 = time(NULL);
4259 struct tm *today = localtime(&today2);
4261 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4263 opt_vstats_file(filename);
4266 static int opt_bsf(const char *opt, const char *arg)
4268 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4269 AVBitStreamFilterContext **bsfp;
4272 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4276 bsfp= *opt == 'v' ? &video_bitstream_filters :
4277 *opt == 'a' ? &audio_bitstream_filters :
4278 &subtitle_bitstream_filters;
4280 bsfp= &(*bsfp)->next;
4287 static int opt_preset(const char *opt, const char *arg)
4290 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4291 char *codec_name = *opt == 'v' ? video_codec_name :
4292 *opt == 'a' ? audio_codec_name :
4293 subtitle_codec_name;
4295 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4296 fprintf(stderr, "File for preset '%s' not found\n", arg);
4301 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4302 if(line[0] == '#' && !e)
4304 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4306 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4309 if(!strcmp(tmp, "acodec")){
4310 opt_audio_codec(tmp2);
4311 }else if(!strcmp(tmp, "vcodec")){
4312 opt_video_codec(tmp2);
4313 }else if(!strcmp(tmp, "scodec")){
4314 opt_subtitle_codec(tmp2);
4315 }else if(!strcmp(tmp, "dcodec")){
4316 opt_data_codec(tmp2);
4317 }else if(opt_default(tmp, tmp2) < 0){
4318 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4328 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4332 static void opt_passlogfile(const char *arg)
4334 pass_logfilename_prefix = arg;
4335 opt_default("passlogfile", arg);
4338 static const OptionDef options[] = {
4340 #include "cmdutils_common_opts.h"
4341 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4342 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4343 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4344 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4345 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4346 "outfile[,metadata]:infile[,metadata]" },
4347 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4348 "outfile[,metadata]:infile[,metadata]" },
4349 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4350 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4351 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4352 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4353 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4354 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4355 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4356 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4357 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4358 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4359 "add timings for benchmarking" },
4360 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4361 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4362 "dump each input packet" },
4363 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4364 "when dumping packets, also dump the payload" },
4365 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4366 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4367 { "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)", "" },
4368 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4369 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4370 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4371 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4372 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4373 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4374 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4375 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4376 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4377 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4378 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4379 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4380 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4383 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4384 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4385 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4386 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4387 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4388 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4389 { "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" },
4390 { "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" },
4391 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4392 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4393 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4394 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4395 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4396 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4397 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4398 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4399 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4400 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4401 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4402 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4403 { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4404 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4405 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4406 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4407 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4408 "use same quantizer as source (implies VBR)" },
4409 { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4410 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4411 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4412 "deinterlace pictures" },
4413 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4414 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4415 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4417 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4419 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4420 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4421 { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4422 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4423 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4424 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4425 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4426 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4427 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4428 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4429 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4432 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4433 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4434 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4435 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4436 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4437 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4438 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4439 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4440 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4441 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4442 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4443 { "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" },
4445 /* subtitle options */
4446 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4447 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4448 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4449 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4450 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4453 { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4454 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4455 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4458 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4459 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4461 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4462 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4463 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4465 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4466 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4467 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4468 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4469 /* data codec support */
4470 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4472 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4476 int main(int argc, char **argv)
4480 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4482 if(argc>1 && !strcmp(argv[1], "-d")){
4485 av_log_set_callback(log_callback_null);
4490 avcodec_register_all();
4492 avdevice_register_all();
4495 avfilter_register_all();
4500 if(isatty(STDIN_FILENO))
4501 avio_set_interrupt_cb(decode_interrupt_cb);
4510 parse_options(argc, argv, options, opt_output_file);
4512 if(nb_output_files <= 0 && nb_input_files == 0) {
4514 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4518 /* file converter / grab */
4519 if (nb_output_files <= 0) {
4520 fprintf(stderr, "At least one output file must be specified\n");
4524 if (nb_input_files == 0) {
4525 fprintf(stderr, "At least one input file must be specified\n");
4530 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4531 stream_maps, nb_stream_maps) < 0)
4533 ti = getutime() - ti;
4535 int maxrss = getmaxrss() / 1024;
4536 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4539 return ffmpeg_exit(0);