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/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/vsink_buffer.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "ffmpeg";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
97 int sync_stream_index;
101 * select an input file for an output file
103 typedef struct MetadataMap {
104 int file; ///< file index
105 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
106 int index; ///< stream/chapter/program number
109 typedef struct ChapterMap {
114 static const OptionDef options[];
116 #define MAX_FILES 100
117 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static double *ts_scale;
120 static int nb_ts_scale;
122 static AVFormatContext *output_files[MAX_FILES];
123 static AVDictionary *output_opts[MAX_FILES];
124 static int nb_output_files = 0;
126 static StreamMap *stream_maps = NULL;
127 static int nb_stream_maps;
129 /* first item specifies output metadata, second is input */
130 static MetadataMap (*meta_data_maps)[2] = NULL;
131 static int nb_meta_data_maps;
132 static int metadata_global_autocopy = 1;
133 static int metadata_streams_autocopy = 1;
134 static int metadata_chapters_autocopy = 1;
136 static ChapterMap *chapter_maps = NULL;
137 static int nb_chapter_maps;
139 /* indexed by output file stream index */
140 static int *streamid_map = NULL;
141 static int nb_streamid_map = 0;
143 static int frame_width = 0;
144 static int frame_height = 0;
145 static float frame_aspect_ratio = 0;
146 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
147 static int frame_bits_per_raw_sample = 0;
148 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
149 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
150 static AVRational frame_rate;
151 static float video_qscale = 0;
152 static uint16_t *intra_matrix = NULL;
153 static uint16_t *inter_matrix = NULL;
154 static const char *video_rc_override_string=NULL;
155 static int video_disable = 0;
156 static int video_discard = 0;
157 static char *video_codec_name = NULL;
158 static unsigned int video_codec_tag = 0;
159 static char *video_language = NULL;
160 static int same_quality = 0;
161 static int do_deinterlace = 0;
162 static int top_field_first = -1;
163 static int me_threshold = 0;
164 static int intra_dc_precision = 8;
165 static int loop_input = 0;
166 static int loop_output = AVFMT_NOOUTPUTLOOP;
167 static int qp_hist = 0;
169 static char *vfilters = NULL;
172 static int intra_only = 0;
173 static int audio_sample_rate = 0;
174 #define QSCALE_NONE -99999
175 static float audio_qscale = QSCALE_NONE;
176 static int audio_disable = 0;
177 static int audio_channels = 0;
178 static char *audio_codec_name = NULL;
179 static unsigned int audio_codec_tag = 0;
180 static char *audio_language = NULL;
182 static int subtitle_disable = 0;
183 static char *subtitle_codec_name = NULL;
184 static char *subtitle_language = NULL;
185 static unsigned int subtitle_codec_tag = 0;
187 static int data_disable = 0;
188 static char *data_codec_name = NULL;
189 static unsigned int data_codec_tag = 0;
191 static float mux_preload= 0.5;
192 static float mux_max_delay= 0.7;
194 static int64_t recording_time = INT64_MAX;
195 static int64_t start_time = 0;
196 static int64_t input_ts_offset = 0;
197 static int file_overwrite = 0;
198 static AVDictionary *metadata;
199 static int do_benchmark = 0;
200 static int do_hex_dump = 0;
201 static int do_pkt_dump = 0;
202 static int do_psnr = 0;
203 static int do_pass = 0;
204 static const char *pass_logfilename_prefix;
205 static int audio_stream_copy = 0;
206 static int video_stream_copy = 0;
207 static int subtitle_stream_copy = 0;
208 static int data_stream_copy = 0;
209 static int video_sync_method= -1;
210 static int audio_sync_method= 0;
211 static float audio_drift_threshold= 0.1;
212 static int copy_ts= 0;
213 static int copy_tb= 0;
214 static int opt_shortest = 0;
215 static char *vstats_filename;
216 static FILE *vstats_file;
217 static int opt_programid = 0;
218 static int copy_initial_nonkeyframes = 0;
220 static int rate_emu = 0;
222 static int audio_volume = 256;
224 static int exit_on_error = 0;
225 static int using_stdin = 0;
226 static int verbose = 1;
227 static int run_as_daemon = 0;
228 static int thread_count= 1;
229 static int q_pressed = 0;
230 static int64_t video_size = 0;
231 static int64_t audio_size = 0;
232 static int64_t extra_size = 0;
233 static int nb_frames_dup = 0;
234 static int nb_frames_drop = 0;
235 static int input_sync;
236 static uint64_t limit_filesize = 0;
237 static int force_fps = 0;
238 static char *forced_key_frames = NULL;
240 static float dts_delta_threshold = 10;
242 static int64_t timer_start;
244 static uint8_t *audio_buf;
245 static uint8_t *audio_out;
246 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
248 static short *samples;
250 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
251 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
252 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
254 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
258 typedef struct OutputStream {
259 int file_index; /* file index */
260 int index; /* stream index in the output file */
261 int source_index; /* InputStream index */
262 AVStream *st; /* stream in the output file */
263 int encoding_needed; /* true if encoding needed for this stream */
265 /* input pts and corresponding output pts
267 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
268 struct InputStream *sync_ist; /* input stream to sync against */
269 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
270 AVBitStreamFilterContext *bitstream_filters;
275 AVFrame resample_frame; /* temporary frame for image resampling */
276 struct SwsContext *img_resample_ctx; /* for image resampling */
279 int resample_pix_fmt;
280 AVRational frame_rate;
282 float frame_aspect_ratio;
284 /* forced key frames */
285 int64_t *forced_kf_pts;
291 ReSampleContext *resample; /* for audio resampling */
292 int resample_sample_fmt;
293 int resample_channels;
294 int resample_sample_rate;
296 AVAudioConvert *reformat_ctx;
297 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
301 AVFilterContext *output_video_filter;
302 AVFilterContext *input_video_filter;
303 AVFilterBufferRef *picref;
305 AVFilterGraph *graph;
312 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
313 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
315 typedef struct InputStream {
318 int discard; /* true if stream data should be discarded */
319 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
322 int64_t start; /* time when read started */
323 int64_t next_pts; /* synthetic pts for cases where pkt.pts
325 int64_t pts; /* current pts */
327 int is_start; /* is 1 at the start and after a discontinuity */
328 int showed_multi_packet_warning;
329 int is_past_recording_time;
333 typedef struct InputFile {
334 AVFormatContext *ctx;
335 int eof_reached; /* true if eof reached */
336 int ist_index; /* index of first stream in ist_table */
337 int buffer_size; /* current total buffer size */
344 /* init terminal so that we can grab keys */
345 static struct termios oldtty;
348 static InputStream *input_streams = NULL;
349 static int nb_input_streams = 0;
350 static InputFile *input_files = NULL;
351 static int nb_input_files = 0;
355 static int configure_video_filters(InputStream *ist, OutputStream *ost)
357 AVFilterContext *last_filter, *filter;
358 /** filter graph containing all filters including input & output */
359 AVCodecContext *codec = ost->st->codec;
360 AVCodecContext *icodec = ist->st->codec;
361 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
362 AVRational sample_aspect_ratio;
366 ost->graph = avfilter_graph_alloc();
368 if (ist->st->sample_aspect_ratio.num){
369 sample_aspect_ratio = ist->st->sample_aspect_ratio;
371 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
373 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
374 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
375 sample_aspect_ratio.num, sample_aspect_ratio.den);
377 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
378 "src", args, NULL, ost->graph);
381 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
382 "out", NULL, pix_fmts, ost->graph);
385 last_filter = ost->input_video_filter;
387 if (codec->width != icodec->width || codec->height != icodec->height) {
388 snprintf(args, 255, "%d:%d:flags=0x%X",
392 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
393 NULL, args, NULL, ost->graph)) < 0)
395 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
397 last_filter = filter;
400 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
401 ost->graph->scale_sws_opts = av_strdup(args);
404 AVFilterInOut *outputs = avfilter_inout_alloc();
405 AVFilterInOut *inputs = avfilter_inout_alloc();
407 outputs->name = av_strdup("in");
408 outputs->filter_ctx = last_filter;
409 outputs->pad_idx = 0;
410 outputs->next = NULL;
412 inputs->name = av_strdup("out");
413 inputs->filter_ctx = ost->output_video_filter;
417 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
419 av_freep(&ost->avfilter);
421 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
425 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
428 codec->width = ost->output_video_filter->inputs[0]->w;
429 codec->height = ost->output_video_filter->inputs[0]->h;
430 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
431 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
432 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
433 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
437 #endif /* CONFIG_AVFILTER */
439 static void term_exit(void)
441 av_log(NULL, AV_LOG_QUIET, "%s", "");
444 tcsetattr (0, TCSANOW, &oldtty);
448 static volatile int received_sigterm = 0;
451 sigterm_handler(int sig)
453 received_sigterm = sig;
458 static void term_init(void)
468 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
469 |INLCR|IGNCR|ICRNL|IXON);
470 tty.c_oflag |= OPOST;
471 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
472 tty.c_cflag &= ~(CSIZE|PARENB);
477 tcsetattr (0, TCSANOW, &tty);
478 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
482 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
483 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
485 signal(SIGXCPU, sigterm_handler);
489 /* read a key without blocking */
490 static int read_key(void)
505 n = select(1, &rfds, NULL, NULL, &tv);
520 static int decode_interrupt_cb(void)
522 q_pressed += read_key() == 'q';
523 return q_pressed > 1;
526 static int ffmpeg_exit(int ret)
531 for(i=0;i<nb_output_files;i++) {
532 AVFormatContext *s = output_files[i];
533 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
535 avformat_free_context(s);
536 av_free(output_streams_for_file[i]);
537 av_dict_free(&output_opts[i]);
539 for(i=0;i<nb_input_files;i++) {
540 av_close_input_file(input_files[i].ctx);
542 for (i = 0; i < nb_input_streams; i++)
543 av_dict_free(&input_streams[i].opts);
545 av_free(intra_matrix);
546 av_free(inter_matrix);
550 av_free(vstats_filename);
552 av_free(streamid_map);
553 av_free(stream_maps);
554 av_free(meta_data_maps);
556 av_freep(&input_streams);
557 av_freep(&input_files);
559 av_free(video_codec_name);
560 av_free(audio_codec_name);
561 av_free(subtitle_codec_name);
562 av_free(data_codec_name);
567 allocated_audio_buf_size= allocated_audio_out_size= 0;
574 if (received_sigterm) {
576 "Received signal %d: terminating.\n",
577 (int) received_sigterm);
581 exit(ret); /* not all OS-es handle main() return value */
585 static void assert_avoptions(AVDictionary *m)
587 AVDictionaryEntry *t;
588 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
589 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
594 static void assert_codec_experimental(AVCodecContext *c, int encoder)
596 const char *codec_string = encoder ? "encoder" : "decoder";
598 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
599 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
600 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
601 "results.\nAdd '-strict experimental' if you want to use it.\n",
602 codec_string, c->codec->name);
603 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
604 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
605 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
606 codec_string, codec->name);
611 /* similar to ff_dynarray_add() and av_fast_realloc() */
612 static void *grow_array(void *array, int elem_size, int *size, int new_size)
614 if (new_size >= INT_MAX / elem_size) {
615 fprintf(stderr, "Array too big.\n");
618 if (*size < new_size) {
619 uint8_t *tmp = av_realloc(array, new_size*elem_size);
621 fprintf(stderr, "Could not alloc buffer.\n");
624 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
631 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
633 if(codec && codec->sample_fmts){
634 const enum AVSampleFormat *p= codec->sample_fmts;
636 if(*p == st->codec->sample_fmt)
640 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
641 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
642 if(av_get_sample_fmt_name(st->codec->sample_fmt))
643 av_log(NULL, AV_LOG_WARNING,
644 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
645 av_get_sample_fmt_name(st->codec->sample_fmt),
647 av_get_sample_fmt_name(codec->sample_fmts[0]));
648 st->codec->sample_fmt = codec->sample_fmts[0];
653 static void choose_sample_rate(AVStream *st, AVCodec *codec)
655 if(codec && codec->supported_samplerates){
656 const int *p= codec->supported_samplerates;
658 int best_dist=INT_MAX;
660 int dist= abs(st->codec->sample_rate - *p);
661 if(dist < best_dist){
667 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
669 st->codec->sample_rate= best;
673 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
675 if(codec && codec->pix_fmts){
676 const enum PixelFormat *p= codec->pix_fmts;
677 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
678 if(st->codec->codec_id==CODEC_ID_MJPEG){
679 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
680 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
681 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};
685 if(*p == st->codec->pix_fmt)
689 if(st->codec->pix_fmt != PIX_FMT_NONE)
690 av_log(NULL, AV_LOG_WARNING,
691 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
692 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
694 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
695 st->codec->pix_fmt = codec->pix_fmts[0];
700 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
703 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
704 int idx = oc->nb_streams - 1;
707 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
711 output_streams_for_file[file_idx] =
712 grow_array(output_streams_for_file[file_idx],
713 sizeof(*output_streams_for_file[file_idx]),
714 &nb_output_streams_for_file[file_idx],
716 ost = output_streams_for_file[file_idx][idx] =
717 av_mallocz(sizeof(OutputStream));
719 fprintf(stderr, "Could not alloc output stream\n");
722 ost->file_index = file_idx;
727 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
729 avcodec_get_context_defaults3(st->codec, codec);
731 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
735 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
738 AVFormatContext *ic = NULL;
740 err = avformat_open_input(&ic, filename, NULL, NULL);
743 /* copy stream format */
744 for(i=0;i<ic->nb_streams;i++) {
749 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
750 ost = new_output_stream(s, nb_output_files, codec);
753 // FIXME: a more elegant solution is needed
754 memcpy(st, ic->streams[i], sizeof(AVStream));
755 st->info = av_malloc(sizeof(*st->info));
756 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
757 avcodec_copy_context(st->codec, ic->streams[i]->codec);
759 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
760 if (audio_stream_copy) {
763 choose_sample_fmt(st, codec);
764 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
765 if (video_stream_copy) {
768 choose_pixel_fmt(st, codec);
772 av_close_input_file(ic);
777 get_sync_ipts(const OutputStream *ost)
779 const InputStream *ist = ost->sync_ist;
780 return (double)(ist->pts - start_time)/AV_TIME_BASE;
783 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
787 AVPacket new_pkt= *pkt;
788 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
789 &new_pkt.data, &new_pkt.size,
790 pkt->data, pkt->size,
791 pkt->flags & AV_PKT_FLAG_KEY);
794 new_pkt.destruct= av_destruct_packet;
796 fprintf(stderr, "%s failed for stream %d, codec %s",
797 bsfc->filter->name, pkt->stream_index,
798 avctx->codec ? avctx->codec->name : "copy");
808 ret= av_interleaved_write_frame(s, pkt);
810 print_error("av_interleaved_write_frame()", ret);
815 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
817 static void do_audio_out(AVFormatContext *s,
820 unsigned char *buf, int size)
823 int64_t audio_out_size, audio_buf_size;
824 int64_t allocated_for_size= size;
826 int size_out, frame_bytes, ret, resample_changed;
827 AVCodecContext *enc= ost->st->codec;
828 AVCodecContext *dec= ist->st->codec;
829 int osize = av_get_bytes_per_sample(enc->sample_fmt);
830 int isize = av_get_bytes_per_sample(dec->sample_fmt);
831 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
834 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
835 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
836 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
837 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
838 audio_buf_size*= osize*enc->channels;
840 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
841 if(coded_bps > 8*osize)
842 audio_out_size= audio_out_size * coded_bps / (8*osize);
843 audio_out_size += FF_MIN_BUFFER_SIZE;
845 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
846 fprintf(stderr, "Buffer sizes too large\n");
850 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
851 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
852 if (!audio_buf || !audio_out){
853 fprintf(stderr, "Out of memory in do_audio_out\n");
857 if (enc->channels != dec->channels)
858 ost->audio_resample = 1;
860 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
861 ost->resample_channels != dec->channels ||
862 ost->resample_sample_rate != dec->sample_rate;
864 if ((ost->audio_resample && !ost->resample) || resample_changed) {
865 if (resample_changed) {
866 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",
867 ist->file_index, ist->st->index,
868 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
869 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
870 ost->resample_sample_fmt = dec->sample_fmt;
871 ost->resample_channels = dec->channels;
872 ost->resample_sample_rate = dec->sample_rate;
874 audio_resample_close(ost->resample);
876 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
877 if (audio_sync_method <= 1 &&
878 ost->resample_sample_fmt == enc->sample_fmt &&
879 ost->resample_channels == enc->channels &&
880 ost->resample_sample_rate == enc->sample_rate) {
881 ost->resample = NULL;
882 ost->audio_resample = 0;
884 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
885 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
886 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
887 enc->sample_rate, dec->sample_rate,
888 enc->sample_fmt, dec->sample_fmt,
890 if (!ost->resample) {
891 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
892 dec->channels, dec->sample_rate,
893 enc->channels, enc->sample_rate);
899 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
900 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
901 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
902 if (ost->reformat_ctx)
903 av_audio_convert_free(ost->reformat_ctx);
904 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
905 dec->sample_fmt, 1, NULL, 0);
906 if (!ost->reformat_ctx) {
907 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
908 av_get_sample_fmt_name(dec->sample_fmt),
909 av_get_sample_fmt_name(enc->sample_fmt));
912 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
915 if(audio_sync_method){
916 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
917 - av_fifo_size(ost->fifo)/(enc->channels * 2);
918 double idelta= delta*dec->sample_rate / enc->sample_rate;
919 int byte_delta= ((int)idelta)*2*dec->channels;
921 //FIXME resample delay
922 if(fabs(delta) > 50){
923 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
925 byte_delta= FFMAX(byte_delta, -size);
929 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
934 static uint8_t *input_tmp= NULL;
935 input_tmp= av_realloc(input_tmp, byte_delta + size);
937 if(byte_delta > allocated_for_size - size){
938 allocated_for_size= byte_delta + (int64_t)size;
943 memset(input_tmp, 0, byte_delta);
944 memcpy(input_tmp + byte_delta, buf, size);
948 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
950 }else if(audio_sync_method>1){
951 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
952 av_assert0(ost->audio_resample);
954 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
955 // 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));
956 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
960 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
961 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
963 if (ost->audio_resample) {
965 size_out = audio_resample(ost->resample,
966 (short *)buftmp, (short *)buf,
967 size / (dec->channels * isize));
968 size_out = size_out * enc->channels * osize;
974 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
975 const void *ibuf[6]= {buftmp};
976 void *obuf[6]= {audio_buf};
977 int istride[6]= {isize};
978 int ostride[6]= {osize};
979 int len= size_out/istride[0];
980 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
981 printf("av_audio_convert() failed\n");
987 size_out = len*osize;
990 /* now encode as many frames as possible */
991 if (enc->frame_size > 1) {
992 /* output resampled raw samples */
993 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
994 fprintf(stderr, "av_fifo_realloc2() failed\n");
997 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
999 frame_bytes = enc->frame_size * osize * enc->channels;
1001 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1003 av_init_packet(&pkt);
1005 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1007 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1009 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1010 (short *)audio_buf);
1012 fprintf(stderr, "Audio encoding failed\n");
1016 pkt.stream_index= ost->index;
1017 pkt.data= audio_out;
1019 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1020 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1021 pkt.flags |= AV_PKT_FLAG_KEY;
1022 write_frame(s, &pkt, enc, ost->bitstream_filters);
1024 ost->sync_opts += enc->frame_size;
1028 av_init_packet(&pkt);
1030 ost->sync_opts += size_out / (osize * enc->channels);
1032 /* output a pcm frame */
1033 /* determine the size of the coded buffer */
1036 size_out = size_out*coded_bps/8;
1038 if(size_out > audio_out_size){
1039 fprintf(stderr, "Internal error, buffer size too small\n");
1043 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1044 ret = avcodec_encode_audio(enc, audio_out, size_out,
1047 fprintf(stderr, "Audio encoding failed\n");
1051 pkt.stream_index= ost->index;
1052 pkt.data= audio_out;
1054 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1055 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1056 pkt.flags |= AV_PKT_FLAG_KEY;
1057 write_frame(s, &pkt, enc, ost->bitstream_filters);
1061 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1063 AVCodecContext *dec;
1064 AVPicture *picture2;
1065 AVPicture picture_tmp;
1068 dec = ist->st->codec;
1070 /* deinterlace : must be done before any resize */
1071 if (do_deinterlace) {
1074 /* create temporary picture */
1075 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1076 buf = av_malloc(size);
1080 picture2 = &picture_tmp;
1081 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1083 if(avpicture_deinterlace(picture2, picture,
1084 dec->pix_fmt, dec->width, dec->height) < 0) {
1085 /* if error, do not deinterlace */
1086 fprintf(stderr, "Deinterlacing failed\n");
1095 if (picture != picture2)
1096 *picture = *picture2;
1100 /* we begin to correct av delay at this threshold */
1101 #define AV_DELAY_MAX 0.100
1103 static void do_subtitle_out(AVFormatContext *s,
1109 static uint8_t *subtitle_out = NULL;
1110 int subtitle_out_max_size = 1024 * 1024;
1111 int subtitle_out_size, nb, i;
1112 AVCodecContext *enc;
1115 if (pts == AV_NOPTS_VALUE) {
1116 fprintf(stderr, "Subtitle packets must have a pts\n");
1122 enc = ost->st->codec;
1124 if (!subtitle_out) {
1125 subtitle_out = av_malloc(subtitle_out_max_size);
1128 /* Note: DVB subtitle need one packet to draw them and one other
1129 packet to clear them */
1130 /* XXX: signal it in the codec context ? */
1131 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1136 for(i = 0; i < nb; i++) {
1137 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1138 // start_display_time is required to be 0
1139 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1140 sub->end_display_time -= sub->start_display_time;
1141 sub->start_display_time = 0;
1142 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1143 subtitle_out_max_size, sub);
1144 if (subtitle_out_size < 0) {
1145 fprintf(stderr, "Subtitle encoding failed\n");
1149 av_init_packet(&pkt);
1150 pkt.stream_index = ost->index;
1151 pkt.data = subtitle_out;
1152 pkt.size = subtitle_out_size;
1153 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1154 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1155 /* XXX: the pts correction is handled here. Maybe handling
1156 it in the codec would be better */
1158 pkt.pts += 90 * sub->start_display_time;
1160 pkt.pts += 90 * sub->end_display_time;
1162 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1166 static int bit_buffer_size= 1024*256;
1167 static uint8_t *bit_buffer= NULL;
1169 static void do_video_out(AVFormatContext *s,
1172 AVFrame *in_picture,
1173 int *frame_size, float quality)
1175 int nb_frames, i, ret, av_unused resample_changed;
1176 AVFrame *final_picture, *formatted_picture;
1177 AVCodecContext *enc, *dec;
1180 enc = ost->st->codec;
1181 dec = ist->st->codec;
1183 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1185 /* by default, we output a single frame */
1190 if(video_sync_method){
1191 double vdelta = sync_ipts - ost->sync_opts;
1192 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1195 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1198 }else if(vdelta>0.6)
1199 ost->sync_opts= lrintf(sync_ipts);
1200 }else if (vdelta > 1.1)
1201 nb_frames = lrintf(vdelta);
1202 //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);
1203 if (nb_frames == 0){
1206 fprintf(stderr, "*** drop!\n");
1207 }else if (nb_frames > 1) {
1208 nb_frames_dup += nb_frames - 1;
1210 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1213 ost->sync_opts= lrintf(sync_ipts);
1215 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1219 formatted_picture = in_picture;
1220 final_picture = formatted_picture;
1222 #if !CONFIG_AVFILTER
1223 resample_changed = ost->resample_width != dec->width ||
1224 ost->resample_height != dec->height ||
1225 ost->resample_pix_fmt != dec->pix_fmt;
1227 if (resample_changed) {
1228 av_log(NULL, AV_LOG_INFO,
1229 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1230 ist->file_index, ist->st->index,
1231 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1232 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1233 ost->resample_width = dec->width;
1234 ost->resample_height = dec->height;
1235 ost->resample_pix_fmt = dec->pix_fmt;
1238 ost->video_resample = dec->width != enc->width ||
1239 dec->height != enc->height ||
1240 dec->pix_fmt != enc->pix_fmt;
1242 if (ost->video_resample) {
1243 final_picture = &ost->resample_frame;
1244 if (!ost->img_resample_ctx || resample_changed) {
1245 /* initialize the destination picture */
1246 if (!ost->resample_frame.data[0]) {
1247 avcodec_get_frame_defaults(&ost->resample_frame);
1248 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1249 enc->width, enc->height)) {
1250 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1254 /* initialize a new scaler context */
1255 sws_freeContext(ost->img_resample_ctx);
1256 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1257 enc->width, enc->height, enc->pix_fmt,
1258 ost->sws_flags, NULL, NULL, NULL);
1259 if (ost->img_resample_ctx == NULL) {
1260 fprintf(stderr, "Cannot get resampling context\n");
1264 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1265 0, ost->resample_height, final_picture->data, final_picture->linesize);
1269 /* duplicates frame if needed */
1270 for(i=0;i<nb_frames;i++) {
1272 av_init_packet(&pkt);
1273 pkt.stream_index= ost->index;
1275 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1276 /* raw pictures are written as AVPicture structure to
1277 avoid any copies. We support temorarily the older
1279 AVFrame* old_frame = enc->coded_frame;
1280 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1281 pkt.data= (uint8_t *)final_picture;
1282 pkt.size= sizeof(AVPicture);
1283 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1284 pkt.flags |= AV_PKT_FLAG_KEY;
1286 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1287 enc->coded_frame = old_frame;
1289 AVFrame big_picture;
1291 big_picture= *final_picture;
1292 /* better than nothing: use input picture interlaced
1294 big_picture.interlaced_frame = in_picture->interlaced_frame;
1295 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1296 if(top_field_first == -1)
1297 big_picture.top_field_first = in_picture->top_field_first;
1299 big_picture.top_field_first = top_field_first;
1302 /* handles sameq here. This is not correct because it may
1303 not be a global option */
1304 big_picture.quality = quality;
1306 big_picture.pict_type = 0;
1307 // big_picture.pts = AV_NOPTS_VALUE;
1308 big_picture.pts= ost->sync_opts;
1309 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1310 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1311 if (ost->forced_kf_index < ost->forced_kf_count &&
1312 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1313 big_picture.pict_type = AV_PICTURE_TYPE_I;
1314 ost->forced_kf_index++;
1316 ret = avcodec_encode_video(enc,
1317 bit_buffer, bit_buffer_size,
1320 fprintf(stderr, "Video encoding failed\n");
1325 pkt.data= bit_buffer;
1327 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1328 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1329 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1330 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1331 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1333 if(enc->coded_frame->key_frame)
1334 pkt.flags |= AV_PKT_FLAG_KEY;
1335 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1338 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1339 // enc->frame_number-1, ret, enc->pict_type);
1340 /* if two pass, output log */
1341 if (ost->logfile && enc->stats_out) {
1342 fprintf(ost->logfile, "%s", enc->stats_out);
1347 ost->frame_number++;
1351 static double psnr(double d){
1352 return -10.0*log(d)/log(10.0);
1355 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1358 AVCodecContext *enc;
1360 double ti1, bitrate, avg_bitrate;
1362 /* this is executed just the first time do_video_stats is called */
1364 vstats_file = fopen(vstats_filename, "w");
1371 enc = ost->st->codec;
1372 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1373 frame_number = ost->frame_number;
1374 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1375 if (enc->flags&CODEC_FLAG_PSNR)
1376 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1378 fprintf(vstats_file,"f_size= %6d ", frame_size);
1379 /* compute pts value */
1380 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1384 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1385 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1386 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1387 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1388 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1392 static void print_report(AVFormatContext **output_files,
1393 OutputStream **ost_table, int nb_ostreams,
1398 AVFormatContext *oc;
1400 AVCodecContext *enc;
1401 int frame_number, vid, i;
1403 int64_t pts = INT64_MAX;
1404 static int64_t last_time = -1;
1405 static int qp_histogram[52];
1407 if (!is_last_report) {
1409 /* display the report every 0.5 seconds */
1410 cur_time = av_gettime();
1411 if (last_time == -1) {
1412 last_time = cur_time;
1415 if ((cur_time - last_time) < 500000)
1417 last_time = cur_time;
1421 oc = output_files[0];
1423 total_size = avio_size(oc->pb);
1424 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1425 total_size= avio_tell(oc->pb);
1429 for(i=0;i<nb_ostreams;i++) {
1432 enc = ost->st->codec;
1433 if (!ost->st->stream_copy && enc->coded_frame)
1434 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1435 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1438 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1439 float t = (av_gettime()-timer_start) / 1000000.0;
1441 frame_number = ost->frame_number;
1442 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1443 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1445 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1449 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1452 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1454 if (enc->flags&CODEC_FLAG_PSNR){
1456 double error, error_sum=0;
1457 double scale, scale_sum=0;
1458 char type[3]= {'Y','U','V'};
1459 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1462 error= enc->error[j];
1463 scale= enc->width*enc->height*255.0*255.0*frame_number;
1465 error= enc->coded_frame->error[j];
1466 scale= enc->width*enc->height*255.0*255.0;
1471 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1477 /* compute min output value */
1478 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1479 ost->st->time_base, AV_TIME_BASE_Q));
1482 if (verbose > 0 || is_last_report) {
1483 int hours, mins, secs, us;
1484 secs = pts / AV_TIME_BASE;
1485 us = pts % AV_TIME_BASE;
1491 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1493 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1494 "size=%8.0fkB time=", total_size / 1024.0);
1495 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1496 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1497 (100 * us) / AV_TIME_BASE);
1498 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1499 "bitrate=%6.1fkbits/s", bitrate);
1501 if (nb_frames_dup || nb_frames_drop)
1502 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1503 nb_frames_dup, nb_frames_drop);
1506 fprintf(stderr, "%s \r", buf);
1511 if (is_last_report && verbose >= 0){
1512 int64_t raw= audio_size + video_size + extra_size;
1513 fprintf(stderr, "\n");
1514 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1518 100.0*(total_size - raw)/raw
1523 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1525 int fill_char = 0x00;
1526 if (sample_fmt == AV_SAMPLE_FMT_U8)
1528 memset(buf, fill_char, size);
1531 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1532 static int output_packet(InputStream *ist, int ist_index,
1533 OutputStream **ost_table, int nb_ostreams,
1534 const AVPacket *pkt)
1536 AVFormatContext *os;
1541 void *buffer_to_free = NULL;
1542 static unsigned int samples_size= 0;
1543 AVSubtitle subtitle, *subtitle_to_free;
1544 int64_t pkt_pts = AV_NOPTS_VALUE;
1546 int frame_available;
1551 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1553 if(ist->next_pts == AV_NOPTS_VALUE)
1554 ist->next_pts= ist->pts;
1558 av_init_packet(&avpkt);
1566 if(pkt->dts != AV_NOPTS_VALUE)
1567 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1568 if(pkt->pts != AV_NOPTS_VALUE)
1569 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1571 //while we have more to decode or while the decoder did output something on EOF
1572 while (avpkt.size > 0 || (!pkt && got_output)) {
1573 uint8_t *data_buf, *decoded_data_buf;
1574 int data_size, decoded_data_size;
1576 ist->pts= ist->next_pts;
1578 if(avpkt.size && avpkt.size != pkt->size &&
1579 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1580 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1581 ist->showed_multi_packet_warning=1;
1584 /* decode the packet if needed */
1585 decoded_data_buf = NULL; /* fail safe */
1586 decoded_data_size= 0;
1587 data_buf = avpkt.data;
1588 data_size = avpkt.size;
1589 subtitle_to_free = NULL;
1590 if (ist->decoding_needed) {
1591 switch(ist->st->codec->codec_type) {
1592 case AVMEDIA_TYPE_AUDIO:{
1593 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1594 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1596 samples= av_malloc(samples_size);
1598 decoded_data_size= samples_size;
1599 /* XXX: could avoid copy if PCM 16 bits with same
1600 endianness as CPU */
1601 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1608 got_output = decoded_data_size > 0;
1609 /* Some bug in mpeg audio decoder gives */
1610 /* decoded_data_size < 0, it seems they are overflows */
1612 /* no audio frame */
1615 decoded_data_buf = (uint8_t *)samples;
1616 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1617 (ist->st->codec->sample_rate * ist->st->codec->channels);
1619 case AVMEDIA_TYPE_VIDEO:
1620 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1621 /* XXX: allocate picture correctly */
1622 avcodec_get_frame_defaults(&picture);
1623 avpkt.pts = pkt_pts;
1624 avpkt.dts = ist->pts;
1625 pkt_pts = AV_NOPTS_VALUE;
1627 ret = avcodec_decode_video2(ist->st->codec,
1628 &picture, &got_output, &avpkt);
1629 quality = same_quality ? picture.quality : 0;
1633 /* no picture yet */
1634 goto discard_packet;
1636 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1637 if (ist->st->codec->time_base.num != 0) {
1638 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1639 ist->next_pts += ((int64_t)AV_TIME_BASE *
1640 ist->st->codec->time_base.num * ticks) /
1641 ist->st->codec->time_base.den;
1644 buffer_to_free = NULL;
1645 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1647 case AVMEDIA_TYPE_SUBTITLE:
1648 ret = avcodec_decode_subtitle2(ist->st->codec,
1649 &subtitle, &got_output, &avpkt);
1653 goto discard_packet;
1655 subtitle_to_free = &subtitle;
1662 switch(ist->st->codec->codec_type) {
1663 case AVMEDIA_TYPE_AUDIO:
1664 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1665 ist->st->codec->sample_rate;
1667 case AVMEDIA_TYPE_VIDEO:
1668 if (ist->st->codec->time_base.num != 0) {
1669 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1670 ist->next_pts += ((int64_t)AV_TIME_BASE *
1671 ist->st->codec->time_base.num * ticks) /
1672 ist->st->codec->time_base.den;
1681 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1682 if (start_time == 0 || ist->pts >= start_time) {
1683 for(i=0;i<nb_ostreams;i++) {
1685 if (ost->input_video_filter && ost->source_index == ist_index) {
1686 if (!picture.sample_aspect_ratio.num)
1687 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1688 picture.pts = ist->pts;
1690 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1696 // preprocess audio (volume)
1697 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1698 if (audio_volume != 256) {
1701 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1702 int v = ((*volp) * audio_volume + 128) >> 8;
1703 if (v < -32768) v = -32768;
1704 if (v > 32767) v = 32767;
1710 /* frame rate emulation */
1712 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1713 int64_t now = av_gettime() - ist->start;
1717 /* if output time reached then transcode raw format,
1718 encode packets and output them */
1719 if (start_time == 0 || ist->pts >= start_time)
1720 for(i=0;i<nb_ostreams;i++) {
1725 /* finish if recording time exhausted */
1726 if (recording_time != INT64_MAX &&
1727 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
1729 ist->is_past_recording_time = 1;
1732 if (ost->source_index == ist_index) {
1734 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1735 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1736 while (frame_available) {
1737 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1738 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1739 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1742 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1743 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1747 os = output_files[ost->file_index];
1749 /* set the input output pts pairs */
1750 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1752 if (ost->encoding_needed) {
1753 av_assert0(ist->decoding_needed);
1754 switch(ost->st->codec->codec_type) {
1755 case AVMEDIA_TYPE_AUDIO:
1756 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1758 case AVMEDIA_TYPE_VIDEO:
1760 if (ost->picref->video && !ost->frame_aspect_ratio)
1761 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1763 do_video_out(os, ost, ist, &picture, &frame_size,
1764 same_quality ? quality : ost->st->codec->global_quality);
1765 if (vstats_filename && frame_size)
1766 do_video_stats(os, ost, frame_size);
1768 case AVMEDIA_TYPE_SUBTITLE:
1769 do_subtitle_out(os, ost, ist, &subtitle,
1776 AVFrame avframe; //FIXME/XXX remove this
1779 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1781 av_init_packet(&opkt);
1783 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1784 #if !CONFIG_AVFILTER
1790 /* no reencoding needed : output the packet directly */
1791 /* force the input stream PTS */
1793 avcodec_get_frame_defaults(&avframe);
1794 ost->st->codec->coded_frame= &avframe;
1795 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1797 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1798 audio_size += data_size;
1799 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1800 video_size += data_size;
1804 opkt.stream_index= ost->index;
1805 if(pkt->pts != AV_NOPTS_VALUE)
1806 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1808 opkt.pts= AV_NOPTS_VALUE;
1810 if (pkt->dts == AV_NOPTS_VALUE)
1811 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1813 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1814 opkt.dts -= ost_tb_start_time;
1816 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1817 opkt.flags= pkt->flags;
1819 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1820 if( ost->st->codec->codec_id != CODEC_ID_H264
1821 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1822 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1824 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1825 opkt.destruct= av_destruct_packet;
1827 opkt.data = data_buf;
1828 opkt.size = data_size;
1831 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1832 /* store AVPicture in AVPacket, as expected by the output format */
1833 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1834 opkt.data = (uint8_t *)&pict;
1835 opkt.size = sizeof(AVPicture);
1836 opkt.flags |= AV_PKT_FLAG_KEY;
1838 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1839 ost->st->codec->frame_number++;
1840 ost->frame_number++;
1841 av_free_packet(&opkt);
1845 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1846 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1847 avfilter_unref_buffer(ost->picref);
1853 av_free(buffer_to_free);
1854 /* XXX: allocate the subtitles in the codec ? */
1855 if (subtitle_to_free) {
1856 avsubtitle_free(subtitle_to_free);
1857 subtitle_to_free = NULL;
1864 for(i=0;i<nb_ostreams;i++) {
1866 if (ost->source_index == ist_index) {
1867 AVCodecContext *enc= ost->st->codec;
1868 os = output_files[ost->file_index];
1870 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1872 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1875 if (ost->encoding_needed) {
1879 av_init_packet(&pkt);
1880 pkt.stream_index= ost->index;
1882 switch(ost->st->codec->codec_type) {
1883 case AVMEDIA_TYPE_AUDIO:
1884 fifo_bytes = av_fifo_size(ost->fifo);
1886 /* encode any samples remaining in fifo */
1887 if (fifo_bytes > 0) {
1888 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1889 int fs_tmp = enc->frame_size;
1891 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1892 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1893 enc->frame_size = fifo_bytes / (osize * enc->channels);
1895 int frame_bytes = enc->frame_size*osize*enc->channels;
1896 if (allocated_audio_buf_size < frame_bytes)
1898 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1901 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1902 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1903 ost->st->time_base.num, enc->sample_rate);
1904 enc->frame_size = fs_tmp;
1907 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1910 fprintf(stderr, "Audio encoding failed\n");
1914 pkt.flags |= AV_PKT_FLAG_KEY;
1916 case AVMEDIA_TYPE_VIDEO:
1917 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1919 fprintf(stderr, "Video encoding failed\n");
1923 if(enc->coded_frame && enc->coded_frame->key_frame)
1924 pkt.flags |= AV_PKT_FLAG_KEY;
1925 if (ost->logfile && enc->stats_out) {
1926 fprintf(ost->logfile, "%s", enc->stats_out);
1935 pkt.data= bit_buffer;
1937 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1938 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1939 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1949 static void print_sdp(AVFormatContext **avc, int n)
1953 av_sdp_create(avc, n, sdp, sizeof(sdp));
1954 printf("SDP:\n%s\n", sdp);
1958 static int copy_chapters(int infile, int outfile)
1960 AVFormatContext *is = input_files[infile].ctx;
1961 AVFormatContext *os = output_files[outfile];
1964 for (i = 0; i < is->nb_chapters; i++) {
1965 AVChapter *in_ch = is->chapters[i], *out_ch;
1966 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1967 AV_TIME_BASE_Q, in_ch->time_base);
1968 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1969 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1972 if (in_ch->end < ts_off)
1974 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1977 out_ch = av_mallocz(sizeof(AVChapter));
1979 return AVERROR(ENOMEM);
1981 out_ch->id = in_ch->id;
1982 out_ch->time_base = in_ch->time_base;
1983 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1984 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1986 if (metadata_chapters_autocopy)
1987 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1990 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1992 return AVERROR(ENOMEM);
1993 os->chapters[os->nb_chapters - 1] = out_ch;
1998 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1999 AVCodecContext *avctx)
2005 for (p = kf; *p; p++)
2008 ost->forced_kf_count = n;
2009 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2010 if (!ost->forced_kf_pts) {
2011 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2014 for (i = 0; i < n; i++) {
2015 p = i ? strchr(p, ',') + 1 : kf;
2016 t = parse_time_or_die("force_key_frames", p, 1);
2017 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2022 * The following code is the main loop of the file converter
2024 static int transcode(AVFormatContext **output_files,
2025 int nb_output_files,
2026 InputFile *input_files,
2028 StreamMap *stream_maps, int nb_stream_maps)
2030 int ret = 0, i, j, k, n, nb_ostreams = 0, step;
2032 AVFormatContext *is, *os;
2033 AVCodecContext *codec, *icodec;
2034 OutputStream *ost, **ost_table = NULL;
2039 uint8_t no_packet[MAX_FILES]={0};
2040 int no_packet_count=0;
2041 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
2042 int nb_streams[AVMEDIA_TYPE_NB]={0};
2045 for (i = 0; i < nb_input_streams; i++)
2046 input_streams[i].start = av_gettime();
2048 /* output stream init */
2050 for(i=0;i<nb_output_files;i++) {
2051 os = output_files[i];
2052 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2053 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2054 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2055 ret = AVERROR(EINVAL);
2058 nb_ostreams += os->nb_streams;
2060 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2061 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2062 ret = AVERROR(EINVAL);
2066 /* Sanity check the mapping args -- do the input files & streams exist? */
2067 for(i=0;i<nb_stream_maps;i++) {
2068 int fi = stream_maps[i].file_index;
2069 int si = stream_maps[i].stream_index;
2071 if (fi < 0 || fi > nb_input_files - 1 ||
2072 si < 0 || si > input_files[fi].nb_streams - 1) {
2073 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2074 ret = AVERROR(EINVAL);
2077 fi = stream_maps[i].sync_file_index;
2078 si = stream_maps[i].sync_stream_index;
2079 if (fi < 0 || fi > nb_input_files - 1 ||
2080 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2081 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2082 ret = AVERROR(EINVAL);
2087 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2091 for(k=0;k<nb_output_files;k++) {
2092 os = output_files[k];
2093 for(i=0;i<os->nb_streams;i++,n++) {
2094 nb_streams[os->streams[i]->codec->codec_type]++;
2097 for(step=1<<30; step; step>>=1){
2098 int found_streams[AVMEDIA_TYPE_NB]={0};
2099 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2100 nb_frame_threshold[j] += step;
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 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2120 found_streams[ist->st->codec->codec_type]++;
2123 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2124 if(found_streams[j] < nb_streams[j])
2125 nb_frame_threshold[j] -= step;
2128 for(k=0;k<nb_output_files;k++) {
2129 os = output_files[k];
2130 for(i=0;i<os->nb_streams;i++,n++) {
2132 ost = ost_table[n] = output_streams_for_file[k][i];
2133 if (nb_stream_maps > 0) {
2134 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2135 stream_maps[n].stream_index;
2137 /* Sanity check that the stream types match */
2138 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2139 int i= ost->file_index;
2140 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2141 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2142 stream_maps[n].file_index, stream_maps[n].stream_index,
2143 ost->file_index, ost->index);
2148 /* get corresponding input stream index : we select the first one with the right type */
2150 for (j = 0; j < nb_input_streams; j++) {
2152 ist = &input_streams[j];
2155 AVFormatContext *f = input_files[ist->file_index].ctx;
2157 for(pi=0; pi<f->nb_programs; pi++){
2158 AVProgram *p= f->programs[pi];
2159 if(p->id == opt_programid)
2160 for(si=0; si<p->nb_stream_indexes; si++){
2161 if(f->streams[ p->stream_index[si] ] == ist->st)
2166 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2167 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2168 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2169 ost->source_index = j;
2176 if(! opt_programid) {
2177 /* try again and reuse existing stream */
2178 for (j = 0; j < nb_input_streams; j++) {
2179 ist = &input_streams[j];
2180 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2181 && ist->st->discard != AVDISCARD_ALL) {
2182 ost->source_index = j;
2188 int i= ost->file_index;
2189 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2190 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2191 ost->file_index, ost->index);
2196 ist = &input_streams[ost->source_index];
2198 ost->sync_ist = (nb_stream_maps > 0) ?
2199 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2200 stream_maps[n].sync_stream_index] : ist;
2204 /* for each output stream, we compute the right encoding parameters */
2205 for(i=0;i<nb_ostreams;i++) {
2207 os = output_files[ost->file_index];
2208 ist = &input_streams[ost->source_index];
2210 codec = ost->st->codec;
2211 icodec = ist->st->codec;
2213 if (metadata_streams_autocopy)
2214 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2215 AV_DICT_DONT_OVERWRITE);
2217 ost->st->disposition = ist->st->disposition;
2218 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2219 codec->chroma_sample_location = icodec->chroma_sample_location;
2221 if (ost->st->stream_copy) {
2222 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2224 if (extra_size > INT_MAX)
2227 /* if stream_copy is selected, no need to decode or encode */
2228 codec->codec_id = icodec->codec_id;
2229 codec->codec_type = icodec->codec_type;
2231 if(!codec->codec_tag){
2232 if( !os->oformat->codec_tag
2233 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2234 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2235 codec->codec_tag = icodec->codec_tag;
2238 codec->bit_rate = icodec->bit_rate;
2239 codec->rc_max_rate = icodec->rc_max_rate;
2240 codec->rc_buffer_size = icodec->rc_buffer_size;
2241 codec->extradata= av_mallocz(extra_size);
2242 if (!codec->extradata)
2244 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2245 codec->extradata_size= icodec->extradata_size;
2247 codec->time_base = ist->st->time_base;
2248 if(!strcmp(os->oformat->name, "avi")) {
2249 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2250 codec->time_base = icodec->time_base;
2251 codec->time_base.num *= icodec->ticks_per_frame;
2252 codec->time_base.den *= 2;
2254 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2255 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){
2256 codec->time_base = icodec->time_base;
2257 codec->time_base.num *= icodec->ticks_per_frame;
2260 av_reduce(&codec->time_base.num, &codec->time_base.den,
2261 codec->time_base.num, codec->time_base.den, INT_MAX);
2263 switch(codec->codec_type) {
2264 case AVMEDIA_TYPE_AUDIO:
2265 if(audio_volume != 256) {
2266 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2269 codec->channel_layout = icodec->channel_layout;
2270 codec->sample_rate = icodec->sample_rate;
2271 codec->channels = icodec->channels;
2272 codec->frame_size = icodec->frame_size;
2273 codec->audio_service_type = icodec->audio_service_type;
2274 codec->block_align= icodec->block_align;
2275 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2276 codec->block_align= 0;
2277 if(codec->codec_id == CODEC_ID_AC3)
2278 codec->block_align= 0;
2280 case AVMEDIA_TYPE_VIDEO:
2281 codec->pix_fmt = icodec->pix_fmt;
2282 codec->width = icodec->width;
2283 codec->height = icodec->height;
2284 codec->has_b_frames = icodec->has_b_frames;
2285 if (!codec->sample_aspect_ratio.num) {
2286 codec->sample_aspect_ratio =
2287 ost->st->sample_aspect_ratio =
2288 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2289 ist->st->codec->sample_aspect_ratio.num ?
2290 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2293 case AVMEDIA_TYPE_SUBTITLE:
2294 codec->width = icodec->width;
2295 codec->height = icodec->height;
2297 case AVMEDIA_TYPE_DATA:
2304 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2305 switch(codec->codec_type) {
2306 case AVMEDIA_TYPE_AUDIO:
2307 ost->fifo= av_fifo_alloc(1024);
2310 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2311 if (!codec->sample_rate) {
2312 codec->sample_rate = icodec->sample_rate;
2314 choose_sample_rate(ost->st, ost->enc);
2315 codec->time_base = (AVRational){1, codec->sample_rate};
2316 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2317 codec->sample_fmt = icodec->sample_fmt;
2318 choose_sample_fmt(ost->st, ost->enc);
2319 if (!codec->channels) {
2320 codec->channels = icodec->channels;
2321 codec->channel_layout = icodec->channel_layout;
2323 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2324 codec->channel_layout = 0;
2325 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2326 icodec->request_channels = codec->channels;
2327 ist->decoding_needed = 1;
2328 ost->encoding_needed = 1;
2329 ost->resample_sample_fmt = icodec->sample_fmt;
2330 ost->resample_sample_rate = icodec->sample_rate;
2331 ost->resample_channels = icodec->channels;
2333 case AVMEDIA_TYPE_VIDEO:
2334 if (codec->pix_fmt == PIX_FMT_NONE)
2335 codec->pix_fmt = icodec->pix_fmt;
2336 choose_pixel_fmt(ost->st, ost->enc);
2338 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2339 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2343 if (!codec->width || !codec->height) {
2344 codec->width = icodec->width;
2345 codec->height = icodec->height;
2348 ost->video_resample = codec->width != icodec->width ||
2349 codec->height != icodec->height ||
2350 codec->pix_fmt != icodec->pix_fmt;
2351 if (ost->video_resample) {
2352 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2355 ost->resample_height = icodec->height;
2356 ost->resample_width = icodec->width;
2357 ost->resample_pix_fmt= icodec->pix_fmt;
2358 ost->encoding_needed = 1;
2359 ist->decoding_needed = 1;
2361 if (!ost->frame_rate.num)
2362 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2363 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2364 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2365 ost->frame_rate = ost->enc->supported_framerates[idx];
2367 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2368 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2369 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2370 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2371 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2375 if (configure_video_filters(ist, ost)) {
2376 fprintf(stderr, "Error opening filters!\n");
2381 case AVMEDIA_TYPE_SUBTITLE:
2382 ost->encoding_needed = 1;
2383 ist->decoding_needed = 1;
2390 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2391 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2392 char logfilename[1024];
2395 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2396 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2398 if (codec->flags & CODEC_FLAG_PASS1) {
2399 f = fopen(logfilename, "wb");
2401 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2407 size_t logbuffer_size;
2408 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2409 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2412 codec->stats_in = logbuffer;
2416 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2417 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2418 int size= codec->width * codec->height;
2419 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2424 bit_buffer = av_malloc(bit_buffer_size);
2426 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2428 ret = AVERROR(ENOMEM);
2432 /* open each encoder */
2433 for(i=0;i<nb_ostreams;i++) {
2435 if (ost->encoding_needed) {
2436 AVCodec *codec = ost->enc;
2437 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2439 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2440 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2441 ret = AVERROR(EINVAL);
2444 if (dec->subtitle_header) {
2445 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2446 if (!ost->st->codec->subtitle_header) {
2447 ret = AVERROR(ENOMEM);
2450 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2451 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2453 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2454 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2455 ost->file_index, ost->index);
2456 ret = AVERROR(EINVAL);
2459 assert_codec_experimental(ost->st->codec, 1);
2460 assert_avoptions(ost->opts);
2461 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2462 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2463 "It takes bits/s as argument, not kbits/s\n");
2464 extra_size += ost->st->codec->extradata_size;
2468 /* open each decoder */
2469 for (i = 0; i < nb_input_streams; i++) {
2470 ist = &input_streams[i];
2471 if (ist->decoding_needed) {
2472 AVCodec *codec = ist->dec;
2474 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2476 snprintf(error, sizeof(error), "Decoder (codec %s) not found for input stream #%d.%d",
2477 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2478 ret = AVERROR(EINVAL);
2481 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2482 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2483 ist->file_index, ist->st->index);
2484 ret = AVERROR(EINVAL);
2487 assert_codec_experimental(ist->st->codec, 0);
2488 assert_avoptions(ost->opts);
2493 for (i = 0; i < nb_input_streams; i++) {
2495 ist = &input_streams[i];
2497 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2498 ist->next_pts = AV_NOPTS_VALUE;
2502 /* set meta data information from input file if required */
2503 for (i=0;i<nb_meta_data_maps;i++) {
2504 AVFormatContext *files[2];
2505 AVDictionary **meta[2];
2508 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2509 if ((index) < 0 || (index) >= (nb_elems)) {\
2510 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2512 ret = AVERROR(EINVAL);\
2516 int out_file_index = meta_data_maps[i][0].file;
2517 int in_file_index = meta_data_maps[i][1].file;
2518 if (in_file_index < 0 || out_file_index < 0)
2520 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2521 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2523 files[0] = output_files[out_file_index];
2524 files[1] = input_files[in_file_index].ctx;
2526 for (j = 0; j < 2; j++) {
2527 MetadataMap *map = &meta_data_maps[i][j];
2529 switch (map->type) {
2531 meta[j] = &files[j]->metadata;
2534 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2535 meta[j] = &files[j]->streams[map->index]->metadata;
2538 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2539 meta[j] = &files[j]->chapters[map->index]->metadata;
2542 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2543 meta[j] = &files[j]->programs[map->index]->metadata;
2548 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2551 /* copy global metadata by default */
2552 if (metadata_global_autocopy) {
2554 for (i = 0; i < nb_output_files; i++)
2555 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2556 AV_DICT_DONT_OVERWRITE);
2559 /* copy chapters according to chapter maps */
2560 for (i = 0; i < nb_chapter_maps; i++) {
2561 int infile = chapter_maps[i].in_file;
2562 int outfile = chapter_maps[i].out_file;
2564 if (infile < 0 || outfile < 0)
2566 if (infile >= nb_input_files) {
2567 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2568 ret = AVERROR(EINVAL);
2571 if (outfile >= nb_output_files) {
2572 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2573 ret = AVERROR(EINVAL);
2576 copy_chapters(infile, outfile);
2579 /* copy chapters from the first input file that has them*/
2580 if (!nb_chapter_maps)
2581 for (i = 0; i < nb_input_files; i++) {
2582 if (!input_files[i].ctx->nb_chapters)
2585 for (j = 0; j < nb_output_files; j++)
2586 if ((ret = copy_chapters(i, j)) < 0)
2591 /* open files and write file headers */
2592 for(i=0;i<nb_output_files;i++) {
2593 os = output_files[i];
2594 if (avformat_write_header(os, &output_opts[i]) < 0) {
2595 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2596 ret = AVERROR(EINVAL);
2599 // assert_avoptions(output_opts[i]);
2600 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2606 /* dump the file output parameters - cannot be done before in case
2608 for(i=0;i<nb_output_files;i++) {
2609 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2612 /* dump the stream mapping */
2614 fprintf(stderr, "Stream mapping:\n");
2615 for(i=0;i<nb_ostreams;i++) {
2617 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2618 input_streams[ost->source_index].file_index,
2619 input_streams[ost->source_index].st->index,
2622 if (ost->sync_ist != &input_streams[ost->source_index])
2623 fprintf(stderr, " [sync #%d.%d]",
2624 ost->sync_ist->file_index,
2625 ost->sync_ist->st->index);
2626 if(ost->encoding_needed)
2627 fprintf(stderr, ": %s -> %s",
2628 input_streams[ost->source_index].dec ?
2629 input_streams[ost->source_index].dec->name : "?",
2630 ost->enc ? ost->enc->name : "?");
2632 fprintf(stderr, ": copy");
2633 fprintf(stderr, "\n");
2638 fprintf(stderr, "%s\n", error);
2643 print_sdp(output_files, nb_output_files);
2648 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2649 avio_set_interrupt_cb(decode_interrupt_cb);
2653 timer_start = av_gettime();
2655 for(; received_sigterm == 0;) {
2656 int file_index, ist_index;
2664 /* if 'q' pressed, exits */
2668 /* read_key() returns 0 on EOF */
2672 if (key == '+') verbose++;
2673 if (key == '-') verbose--;
2674 if (key == 's') qp_hist ^= 1;
2677 do_hex_dump = do_pkt_dump = 0;
2678 } else if(do_pkt_dump){
2682 av_log_set_level(AV_LOG_DEBUG);
2684 if (key == 'd' || key == 'D'){
2687 debug = input_streams[0].st->codec->debug<<1;
2688 if(!debug) debug = 1;
2689 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2692 scanf("%d", &debug);
2693 for(i=0;i<nb_input_streams;i++) {
2694 input_streams[i].st->codec->debug = debug;
2696 for(i=0;i<nb_ostreams;i++) {
2698 ost->st->codec->debug = debug;
2700 if(debug) av_log_set_level(AV_LOG_DEBUG);
2701 fprintf(stderr,"debug=%d\n", debug);
2704 fprintf(stderr, "key function\n"
2705 "? show this help\n"
2706 "+ increase verbosity\n"
2707 "- decrease verbosity\n"
2708 "D cycle through available debug modes\n"
2709 "h dump packets/hex press to cycle through the 3 states\n"
2711 "s Show QP histogram\n"
2716 /* select the stream that we must read now by looking at the
2717 smallest output pts */
2719 for(i=0;i<nb_ostreams;i++) {
2722 os = output_files[ost->file_index];
2723 ist = &input_streams[ost->source_index];
2724 if(ist->is_past_recording_time || no_packet[ist->file_index])
2726 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2727 ipts = (double)ist->pts;
2728 if (!input_files[ist->file_index].eof_reached){
2729 if(ipts < ipts_min) {
2731 if(input_sync ) file_index = ist->file_index;
2733 if(opts < opts_min) {
2735 if(!input_sync) file_index = ist->file_index;
2738 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2743 /* if none, if is finished */
2744 if (file_index < 0) {
2745 if(no_packet_count){
2747 memset(no_packet, 0, sizeof(no_packet));
2754 /* finish if limit size exhausted */
2755 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2758 /* read a frame from it and output it in the fifo */
2759 is = input_files[file_index].ctx;
2760 ret= av_read_frame(is, &pkt);
2761 if(ret == AVERROR(EAGAIN)){
2762 no_packet[file_index]=1;
2767 input_files[file_index].eof_reached = 1;
2775 memset(no_packet, 0, sizeof(no_packet));
2778 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2779 is->streams[pkt.stream_index]);
2781 /* the following test is needed in case new streams appear
2782 dynamically in stream : we ignore them */
2783 if (pkt.stream_index >= input_files[file_index].nb_streams)
2784 goto discard_packet;
2785 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2786 ist = &input_streams[ist_index];
2788 goto discard_packet;
2790 if (pkt.dts != AV_NOPTS_VALUE)
2791 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2792 if (pkt.pts != AV_NOPTS_VALUE)
2793 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2795 if (ist->ts_scale) {
2796 if(pkt.pts != AV_NOPTS_VALUE)
2797 pkt.pts *= ist->ts_scale;
2798 if(pkt.dts != AV_NOPTS_VALUE)
2799 pkt.dts *= ist->ts_scale;
2802 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2803 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2804 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2805 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2806 int64_t delta= pkt_dts - ist->next_pts;
2807 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2808 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2809 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2810 pkt_dts+1<ist->pts)&& !copy_ts){
2811 input_files[ist->file_index].ts_offset -= delta;
2813 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2814 delta, input_files[ist->file_index].ts_offset);
2815 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2816 if(pkt.pts != AV_NOPTS_VALUE)
2817 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2821 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2822 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2825 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2826 ist->file_index, ist->st->index);
2829 av_free_packet(&pkt);
2834 av_free_packet(&pkt);
2836 /* dump report by using the output first video and audio streams */
2837 print_report(output_files, ost_table, nb_ostreams, 0);
2840 /* at the end of stream, we must flush the decoder buffers */
2841 for (i = 0; i < nb_input_streams; i++) {
2842 ist = &input_streams[i];
2843 if (ist->decoding_needed) {
2844 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2850 /* write the trailer if needed and close file */
2851 for(i=0;i<nb_output_files;i++) {
2852 os = output_files[i];
2853 av_write_trailer(os);
2856 /* dump report by using the first video and audio streams */
2857 print_report(output_files, ost_table, nb_ostreams, 1);
2859 /* close each encoder */
2860 for(i=0;i<nb_ostreams;i++) {
2862 if (ost->encoding_needed) {
2863 av_freep(&ost->st->codec->stats_in);
2864 avcodec_close(ost->st->codec);
2867 avfilter_graph_free(&ost->graph);
2871 /* close each decoder */
2872 for (i = 0; i < nb_input_streams; i++) {
2873 ist = &input_streams[i];
2874 if (ist->decoding_needed) {
2875 avcodec_close(ist->st->codec);
2883 av_freep(&bit_buffer);
2886 for(i=0;i<nb_ostreams;i++) {
2889 if (ost->st->stream_copy)
2890 av_freep(&ost->st->codec->extradata);
2892 fclose(ost->logfile);
2893 ost->logfile = NULL;
2895 av_fifo_free(ost->fifo); /* works even if fifo is not
2896 initialized but set to zero */
2897 av_freep(&ost->st->codec->subtitle_header);
2898 av_free(ost->resample_frame.data[0]);
2899 av_free(ost->forced_kf_pts);
2900 if (ost->video_resample)
2901 sws_freeContext(ost->img_resample_ctx);
2903 audio_resample_close(ost->resample);
2904 if (ost->reformat_ctx)
2905 av_audio_convert_free(ost->reformat_ctx);
2906 av_dict_free(&ost->opts);
2915 static int opt_format(const char *opt, const char *arg)
2917 last_asked_format = arg;
2921 static int opt_video_rc_override_string(const char *opt, const char *arg)
2923 video_rc_override_string = arg;
2927 static int opt_me_threshold(const char *opt, const char *arg)
2929 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2933 static int opt_verbose(const char *opt, const char *arg)
2935 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2939 static int opt_frame_rate(const char *opt, const char *arg)
2941 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2942 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2948 static int opt_frame_crop(const char *opt, const char *arg)
2950 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2951 return AVERROR(EINVAL);
2954 static int opt_frame_size(const char *opt, const char *arg)
2956 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2957 fprintf(stderr, "Incorrect frame size\n");
2958 return AVERROR(EINVAL);
2963 static int opt_pad(const char *opt, const char *arg) {
2964 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2968 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2970 if (strcmp(arg, "list")) {
2971 frame_pix_fmt = av_get_pix_fmt(arg);
2972 if (frame_pix_fmt == PIX_FMT_NONE) {
2973 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2974 return AVERROR(EINVAL);
2977 opt_pix_fmts(NULL, NULL);
2983 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2990 p = strchr(arg, ':');
2992 x = strtol(arg, &end, 10);
2994 y = strtol(end+1, &end, 10);
2996 ar = (double)x / (double)y;
2998 ar = strtod(arg, NULL);
3001 fprintf(stderr, "Incorrect aspect ratio specification.\n");
3002 return AVERROR(EINVAL);
3004 frame_aspect_ratio = ar;
3008 static int opt_metadata(const char *opt, const char *arg)
3010 char *mid= strchr(arg, '=');
3013 fprintf(stderr, "Missing =\n");
3018 av_dict_set(&metadata, arg, mid, 0);
3023 static int opt_qscale(const char *opt, const char *arg)
3025 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
3026 if (video_qscale <= 0 || video_qscale > 255) {
3027 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
3028 return AVERROR(EINVAL);
3033 static int opt_top_field_first(const char *opt, const char *arg)
3035 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
3036 return opt_default(opt, arg);
3039 static int opt_thread_count(const char *opt, const char *arg)
3041 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3044 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
3049 static int opt_audio_sample_fmt(const char *opt, const char *arg)
3051 if (strcmp(arg, "list")) {
3052 audio_sample_fmt = av_get_sample_fmt(arg);
3053 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3054 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3055 return AVERROR(EINVAL);
3060 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3061 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3067 static int opt_audio_rate(const char *opt, const char *arg)
3069 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3073 static int opt_audio_channels(const char *opt, const char *arg)
3075 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3079 static int opt_video_channel(const char *opt, const char *arg)
3081 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3082 return opt_default("channel", arg);
3085 static int opt_video_standard(const char *opt, const char *arg)
3087 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3088 return opt_default("standard", arg);
3091 static int opt_codec(const char *opt, const char *arg)
3093 int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3095 if (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy; pcodec_name = &audio_codec_name; codec_type = AVMEDIA_TYPE_AUDIO; }
3096 else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy; pcodec_name = &video_codec_name; codec_type = AVMEDIA_TYPE_VIDEO; }
3097 else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3098 else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy; pcodec_name = &data_codec_name; codec_type = AVMEDIA_TYPE_DATA; }
3100 av_freep(pcodec_name);
3101 if (!strcmp(arg, "copy")) {
3104 *pcodec_name = av_strdup(arg);
3109 static int opt_codec_tag(const char *opt, const char *arg)
3112 uint32_t *codec_tag;
3114 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3115 !strcmp(opt, "vtag") ? &video_codec_tag :
3116 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3120 *codec_tag = strtol(arg, &tail, 0);
3122 *codec_tag = AV_RL32(arg);
3127 static int opt_map(const char *opt, const char *arg)
3132 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3133 m = &stream_maps[nb_stream_maps-1];
3135 m->file_index = strtol(arg, &p, 0);
3139 m->stream_index = strtol(p, &p, 0);
3142 m->sync_file_index = strtol(p, &p, 0);
3145 m->sync_stream_index = strtol(p, &p, 0);
3147 m->sync_file_index = m->file_index;
3148 m->sync_stream_index = m->stream_index;
3153 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3164 *index = strtol(++arg, endptr, 0);
3167 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3174 static int opt_map_metadata(const char *opt, const char *arg)
3176 MetadataMap *m, *m1;
3179 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3180 &nb_meta_data_maps, nb_meta_data_maps + 1);
3182 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3183 m->file = strtol(arg, &p, 0);
3184 parse_meta_type(p, &m->type, &m->index, &p);
3188 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3189 m1->file = strtol(p, &p, 0);
3190 parse_meta_type(p, &m1->type, &m1->index, &p);
3192 if (m->type == 'g' || m1->type == 'g')
3193 metadata_global_autocopy = 0;
3194 if (m->type == 's' || m1->type == 's')
3195 metadata_streams_autocopy = 0;
3196 if (m->type == 'c' || m1->type == 'c')
3197 metadata_chapters_autocopy = 0;
3202 static int opt_map_meta_data(const char *opt, const char *arg)
3204 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3205 "Use -map_metadata instead.\n");
3206 return opt_map_metadata(opt, arg);
3209 static int opt_map_chapters(const char *opt, const char *arg)
3214 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3215 nb_chapter_maps + 1);
3216 c = &chapter_maps[nb_chapter_maps - 1];
3217 c->out_file = strtol(arg, &p, 0);
3221 c->in_file = strtol(p, &p, 0);
3225 static int opt_input_ts_scale(const char *opt, const char *arg)
3227 unsigned int stream;
3231 stream = strtol(arg, &p, 0);
3234 scale= strtod(p, &p);
3236 if(stream >= MAX_STREAMS)
3239 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3240 ts_scale[stream] = scale;
3244 static int opt_recording_time(const char *opt, const char *arg)
3246 recording_time = parse_time_or_die(opt, arg, 1);
3250 static int opt_start_time(const char *opt, const char *arg)
3252 start_time = parse_time_or_die(opt, arg, 1);
3256 static int opt_recording_timestamp(const char *opt, const char *arg)
3259 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3260 struct tm time = *gmtime((time_t*)&recording_timestamp);
3261 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3262 opt_metadata("metadata", buf);
3264 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3265 "tag instead.\n", opt);
3269 static int opt_input_ts_offset(const char *opt, const char *arg)
3271 input_ts_offset = parse_time_or_die(opt, arg, 1);
3275 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3277 const char *codec_string = encoder ? "encoder" : "decoder";
3281 return CODEC_ID_NONE;
3283 avcodec_find_encoder_by_name(name) :
3284 avcodec_find_decoder_by_name(name);
3286 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3289 if(codec->type != type) {
3290 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3296 static int opt_input_file(const char *opt, const char *filename)
3298 AVFormatContext *ic;
3299 AVInputFormat *file_iformat = NULL;
3300 int err, i, ret, rfps, rfps_base;
3303 AVDictionary **opts;
3304 int orig_nb_streams; // number of streams before avformat_find_stream_info
3306 if (last_asked_format) {
3307 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3308 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3311 last_asked_format = NULL;
3314 if (!strcmp(filename, "-"))
3317 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3318 !strcmp(filename, "/dev/stdin");
3320 /* get default parameters from command line */
3321 ic = avformat_alloc_context();
3323 print_error(filename, AVERROR(ENOMEM));
3326 if (audio_sample_rate) {
3327 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3328 av_dict_set(&format_opts, "sample_rate", buf, 0);
3330 if (audio_channels) {
3331 snprintf(buf, sizeof(buf), "%d", audio_channels);
3332 av_dict_set(&format_opts, "channels", buf, 0);
3334 if (frame_rate.num) {
3335 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3336 av_dict_set(&format_opts, "framerate", buf, 0);
3338 if (frame_width && frame_height) {
3339 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3340 av_dict_set(&format_opts, "video_size", buf, 0);
3342 if (frame_pix_fmt != PIX_FMT_NONE)
3343 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3345 ic->video_codec_id =
3346 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3347 ic->audio_codec_id =
3348 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3349 ic->subtitle_codec_id=
3350 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3351 ic->flags |= AVFMT_FLAG_NONBLOCK;
3354 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3355 ic->loop_input = loop_input;
3358 /* open the input file with generic libav function */
3359 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3361 print_error(filename, err);
3364 assert_avoptions(format_opts);
3369 for(i=0; i<ic->nb_streams; i++){
3370 ic->streams[i]->discard= AVDISCARD_ALL;
3372 for(i=0; i<ic->nb_programs; i++){
3373 AVProgram *p= ic->programs[i];
3374 if(p->id != opt_programid){
3375 p->discard = AVDISCARD_ALL;
3378 for(j=0; j<p->nb_stream_indexes; j++){
3379 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3384 fprintf(stderr, "Specified program id not found\n");
3390 /* Set AVCodecContext options for avformat_find_stream_info */
3391 opts = setup_find_stream_info_opts(ic, codec_opts);
3392 orig_nb_streams = ic->nb_streams;
3394 /* If not enough info to get the stream parameters, we decode the
3395 first frames to get it. (used in mpeg case for example) */
3396 ret = avformat_find_stream_info(ic, opts);
3397 if (ret < 0 && verbose >= 0) {
3398 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3399 av_close_input_file(ic);
3403 timestamp = start_time;
3404 /* add the stream start time */
3405 if (ic->start_time != AV_NOPTS_VALUE)
3406 timestamp += ic->start_time;
3408 /* if seeking requested, we execute it */
3409 if (start_time != 0) {
3410 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3412 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3413 filename, (double)timestamp / AV_TIME_BASE);
3415 /* reset seek info */
3419 /* update the current parameters so that they match the one of the input stream */
3420 for(i=0;i<ic->nb_streams;i++) {
3421 AVStream *st = ic->streams[i];
3422 AVCodecContext *dec = st->codec;
3425 dec->thread_count = thread_count;
3427 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3428 ist = &input_streams[nb_input_streams - 1];
3430 ist->file_index = nb_input_files;
3432 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3434 if (i < nb_ts_scale)
3435 ist->ts_scale = ts_scale[i];
3437 switch (dec->codec_type) {
3438 case AVMEDIA_TYPE_AUDIO:
3439 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3441 ist->dec = avcodec_find_decoder(dec->codec_id);
3443 st->discard= AVDISCARD_ALL;
3445 case AVMEDIA_TYPE_VIDEO:
3446 ist->dec= avcodec_find_decoder_by_name(video_codec_name);
3448 ist->dec = avcodec_find_decoder(dec->codec_id);
3449 rfps = ic->streams[i]->r_frame_rate.num;
3450 rfps_base = ic->streams[i]->r_frame_rate.den;
3452 dec->flags |= CODEC_FLAG_EMU_EDGE;
3455 dec->debug |= FF_DEBUG_MV;
3457 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3460 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3461 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3463 (float)rfps / rfps_base, rfps, rfps_base);
3467 st->discard= AVDISCARD_ALL;
3468 else if(video_discard)
3469 st->discard= video_discard;
3471 case AVMEDIA_TYPE_DATA:
3473 case AVMEDIA_TYPE_SUBTITLE:
3474 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3476 ist->dec = avcodec_find_decoder(dec->codec_id);
3477 if(subtitle_disable)
3478 st->discard = AVDISCARD_ALL;
3480 case AVMEDIA_TYPE_ATTACHMENT:
3481 case AVMEDIA_TYPE_UNKNOWN:
3488 /* dump the file content */
3490 av_dump_format(ic, nb_input_files, filename, 0);
3492 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3493 input_files[nb_input_files - 1].ctx = ic;
3494 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3495 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3496 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3498 top_field_first = -1;
3499 frame_rate = (AVRational){0, 0};
3500 frame_pix_fmt = PIX_FMT_NONE;
3503 audio_sample_rate = 0;
3505 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3506 av_freep(&ts_scale);
3509 for (i = 0; i < orig_nb_streams; i++)
3510 av_dict_free(&opts[i]);
3512 av_freep(&video_codec_name);
3513 av_freep(&audio_codec_name);
3514 av_freep(&subtitle_codec_name);
3520 static void check_inputs(int *has_video_ptr,
3522 int *has_subtitle_ptr,
3525 int has_video, has_audio, has_subtitle, has_data, i, j;
3526 AVFormatContext *ic;
3533 for(j=0;j<nb_input_files;j++) {
3534 ic = input_files[j].ctx;
3535 for(i=0;i<ic->nb_streams;i++) {
3536 AVCodecContext *enc = ic->streams[i]->codec;
3537 switch(enc->codec_type) {
3538 case AVMEDIA_TYPE_AUDIO:
3541 case AVMEDIA_TYPE_VIDEO:
3544 case AVMEDIA_TYPE_SUBTITLE:
3547 case AVMEDIA_TYPE_DATA:
3548 case AVMEDIA_TYPE_ATTACHMENT:
3549 case AVMEDIA_TYPE_UNKNOWN:
3557 *has_video_ptr = has_video;
3558 *has_audio_ptr = has_audio;
3559 *has_subtitle_ptr = has_subtitle;
3560 *has_data_ptr = has_data;
3563 static void new_video_stream(AVFormatContext *oc, int file_idx)
3567 AVCodecContext *video_enc;
3568 enum CodecID codec_id = CODEC_ID_NONE;
3569 AVCodec *codec= NULL;
3571 if(!video_stream_copy){
3572 if (video_codec_name) {
3573 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3574 codec = avcodec_find_encoder_by_name(video_codec_name);
3576 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3577 codec = avcodec_find_encoder(codec_id);
3581 ost = new_output_stream(oc, file_idx, codec);
3583 if (!video_stream_copy) {
3584 ost->frame_aspect_ratio = frame_aspect_ratio;
3585 frame_aspect_ratio = 0;
3587 ost->avfilter = vfilters;
3592 ost->bitstream_filters = video_bitstream_filters;
3593 video_bitstream_filters= NULL;
3595 st->codec->thread_count= thread_count;
3597 video_enc = st->codec;
3600 video_enc->codec_tag= video_codec_tag;
3602 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3603 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3606 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3607 if (video_stream_copy) {
3608 st->stream_copy = 1;
3609 video_enc->sample_aspect_ratio =
3610 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3616 ost->frame_rate = frame_rate;
3617 video_enc->codec_id = codec_id;
3619 video_enc->width = frame_width;
3620 video_enc->height = frame_height;
3621 video_enc->pix_fmt = frame_pix_fmt;
3622 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3623 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3626 video_enc->gop_size = 0;
3627 if (video_qscale || same_quality) {
3628 video_enc->flags |= CODEC_FLAG_QSCALE;
3629 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3633 video_enc->intra_matrix = intra_matrix;
3635 video_enc->inter_matrix = inter_matrix;
3637 p= video_rc_override_string;
3640 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3642 fprintf(stderr, "error parsing rc_override\n");
3645 video_enc->rc_override=
3646 av_realloc(video_enc->rc_override,
3647 sizeof(RcOverride)*(i+1));
3648 video_enc->rc_override[i].start_frame= start;
3649 video_enc->rc_override[i].end_frame = end;
3651 video_enc->rc_override[i].qscale= q;
3652 video_enc->rc_override[i].quality_factor= 1.0;
3655 video_enc->rc_override[i].qscale= 0;
3656 video_enc->rc_override[i].quality_factor= -q/100.0;
3661 video_enc->rc_override_count=i;
3662 if (!video_enc->rc_initial_buffer_occupancy)
3663 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3664 video_enc->me_threshold= me_threshold;
3665 video_enc->intra_dc_precision= intra_dc_precision - 8;
3668 video_enc->flags|= CODEC_FLAG_PSNR;
3673 video_enc->flags |= CODEC_FLAG_PASS1;
3675 video_enc->flags |= CODEC_FLAG_PASS2;
3679 if (forced_key_frames)
3680 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3682 if (video_language) {
3683 av_dict_set(&st->metadata, "language", video_language, 0);
3684 av_freep(&video_language);
3687 /* reset some key parameters */
3689 av_freep(&video_codec_name);
3690 av_freep(&forced_key_frames);
3691 video_stream_copy = 0;
3692 frame_pix_fmt = PIX_FMT_NONE;
3695 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3699 AVCodec *codec= NULL;
3700 AVCodecContext *audio_enc;
3701 enum CodecID codec_id = CODEC_ID_NONE;
3703 if(!audio_stream_copy){
3704 if (audio_codec_name) {
3705 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3706 codec = avcodec_find_encoder_by_name(audio_codec_name);
3708 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3709 codec = avcodec_find_encoder(codec_id);
3712 ost = new_output_stream(oc, file_idx, codec);
3715 ost->bitstream_filters = audio_bitstream_filters;
3716 audio_bitstream_filters= NULL;
3718 st->codec->thread_count= thread_count;
3720 audio_enc = st->codec;
3721 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3724 audio_enc->codec_tag= audio_codec_tag;
3726 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3727 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3729 if (audio_stream_copy) {
3730 st->stream_copy = 1;
3732 audio_enc->codec_id = codec_id;
3734 if (audio_qscale > QSCALE_NONE) {
3735 audio_enc->flags |= CODEC_FLAG_QSCALE;
3736 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3739 audio_enc->channels = audio_channels;
3740 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3741 audio_enc->sample_fmt = audio_sample_fmt;
3742 if (audio_sample_rate)
3743 audio_enc->sample_rate = audio_sample_rate;
3745 if (audio_language) {
3746 av_dict_set(&st->metadata, "language", audio_language, 0);
3747 av_freep(&audio_language);
3750 /* reset some key parameters */
3752 av_freep(&audio_codec_name);
3753 audio_stream_copy = 0;
3756 static void new_data_stream(AVFormatContext *oc, int file_idx)
3760 AVCodecContext *data_enc;
3762 ost = new_output_stream(oc, file_idx, NULL);
3764 data_enc = st->codec;
3765 if (!data_stream_copy) {
3766 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3770 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3773 data_enc->codec_tag= data_codec_tag;
3775 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3776 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3778 if (data_stream_copy) {
3779 st->stream_copy = 1;
3783 av_freep(&data_codec_name);
3784 data_stream_copy = 0;
3787 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3791 AVCodec *codec=NULL;
3792 AVCodecContext *subtitle_enc;
3793 enum CodecID codec_id = CODEC_ID_NONE;
3795 if(!subtitle_stream_copy){
3796 if (subtitle_codec_name) {
3797 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3798 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3800 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3801 codec = avcodec_find_encoder(codec_id);
3804 ost = new_output_stream(oc, file_idx, codec);
3806 subtitle_enc = st->codec;
3808 ost->bitstream_filters = subtitle_bitstream_filters;
3809 subtitle_bitstream_filters= NULL;
3811 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3813 if(subtitle_codec_tag)
3814 subtitle_enc->codec_tag= subtitle_codec_tag;
3816 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3817 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3819 if (subtitle_stream_copy) {
3820 st->stream_copy = 1;
3822 subtitle_enc->codec_id = codec_id;
3825 if (subtitle_language) {
3826 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3827 av_freep(&subtitle_language);
3830 subtitle_disable = 0;
3831 av_freep(&subtitle_codec_name);
3832 subtitle_stream_copy = 0;
3835 static int opt_new_stream(const char *opt, const char *arg)
3837 AVFormatContext *oc;
3838 int file_idx = nb_output_files - 1;
3839 if (nb_output_files <= 0) {
3840 fprintf(stderr, "At least one output file must be specified\n");
3843 oc = output_files[file_idx];
3845 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3846 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3847 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3848 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3853 /* arg format is "output-stream-index:streamid-value". */
3854 static int opt_streamid(const char *opt, const char *arg)
3860 av_strlcpy(idx_str, arg, sizeof(idx_str));
3861 p = strchr(idx_str, ':');
3864 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3869 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3870 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3871 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3875 static int opt_output_file(const char *opt, const char *filename)
3877 AVFormatContext *oc;
3878 int err, use_video, use_audio, use_subtitle, use_data;
3879 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3880 AVOutputFormat *file_oformat;
3882 if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3883 fprintf(stderr, "Too many output files\n");
3887 if (!strcmp(filename, "-"))
3890 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3891 last_asked_format = NULL;
3893 print_error(filename, err);
3896 file_oformat= oc->oformat;
3898 if (!strcmp(file_oformat->name, "ffm") &&
3899 av_strstart(filename, "http:", NULL)) {
3900 /* special case for files sent to ffserver: we get the stream
3901 parameters from ffserver */
3902 int err = read_ffserver_streams(oc, filename);
3904 print_error(filename, err);
3908 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3909 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3910 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3911 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 */
3913 /* disable if no corresponding type found */
3914 check_inputs(&input_has_video,
3916 &input_has_subtitle,
3919 if (!input_has_video)
3921 if (!input_has_audio)
3923 if (!input_has_subtitle)
3925 if (!input_has_data)
3928 /* manual disable */
3929 if (audio_disable) use_audio = 0;
3930 if (video_disable) use_video = 0;
3931 if (subtitle_disable) use_subtitle = 0;
3932 if (data_disable) use_data = 0;
3934 if (use_video) new_video_stream(oc, nb_output_files);
3935 if (use_audio) new_audio_stream(oc, nb_output_files);
3936 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3937 if (use_data) new_data_stream(oc, nb_output_files);
3939 av_dict_copy(&oc->metadata, metadata, 0);
3940 av_dict_free(&metadata);
3943 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3944 output_files[nb_output_files++] = oc;
3946 /* check filename in case of an image number is expected */
3947 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3948 if (!av_filename_number_test(oc->filename)) {
3949 print_error(oc->filename, AVERROR(EINVAL));
3954 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3955 /* test if it already exists to avoid loosing precious files */
3956 if (!file_overwrite &&
3957 (strchr(filename, ':') == NULL ||
3958 filename[1] == ':' ||
3959 av_strstart(filename, "file:", NULL))) {
3960 if (avio_check(filename, 0) == 0) {
3962 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3964 if (!read_yesno()) {
3965 fprintf(stderr, "Not overwriting - exiting\n");
3970 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3977 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3978 print_error(filename, err);
3983 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3984 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3986 if (loop_output >= 0) {
3987 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3988 oc->loop_output = loop_output;
3991 frame_rate = (AVRational){0, 0};
3994 audio_sample_rate = 0;
3996 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3998 av_freep(&forced_key_frames);
4004 /* same option as mencoder */
4005 static int opt_pass(const char *opt, const char *arg)
4007 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4011 static int64_t getutime(void)
4014 struct rusage rusage;
4016 getrusage(RUSAGE_SELF, &rusage);
4017 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4018 #elif HAVE_GETPROCESSTIMES
4020 FILETIME c, e, k, u;
4021 proc = GetCurrentProcess();
4022 GetProcessTimes(proc, &c, &e, &k, &u);
4023 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4025 return av_gettime();
4029 static int64_t getmaxrss(void)
4031 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4032 struct rusage rusage;
4033 getrusage(RUSAGE_SELF, &rusage);
4034 return (int64_t)rusage.ru_maxrss * 1024;
4035 #elif HAVE_GETPROCESSMEMORYINFO
4037 PROCESS_MEMORY_COUNTERS memcounters;
4038 proc = GetCurrentProcess();
4039 memcounters.cb = sizeof(memcounters);
4040 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4041 return memcounters.PeakPagefileUsage;
4047 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4050 const char *p = str;
4057 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4064 static int opt_inter_matrix(const char *opt, const char *arg)
4066 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4067 parse_matrix_coeffs(inter_matrix, arg);
4071 static int opt_intra_matrix(const char *opt, const char *arg)
4073 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4074 parse_matrix_coeffs(intra_matrix, arg);
4078 static void show_usage(void)
4080 printf("Hyper fast Audio and Video encoder\n");
4081 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4085 static int opt_help(const char *opt, const char *arg)
4088 AVOutputFormat *oformat = NULL;
4089 AVInputFormat *iformat = NULL;
4091 av_log_set_callback(log_callback_help);
4093 show_help_options(options, "Main options:\n",
4094 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4095 show_help_options(options, "\nAdvanced options:\n",
4096 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4098 show_help_options(options, "\nVideo options:\n",
4099 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4101 show_help_options(options, "\nAdvanced Video options:\n",
4102 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4103 OPT_VIDEO | OPT_EXPERT);
4104 show_help_options(options, "\nAudio options:\n",
4105 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4107 show_help_options(options, "\nAdvanced Audio options:\n",
4108 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4109 OPT_AUDIO | OPT_EXPERT);
4110 show_help_options(options, "\nSubtitle options:\n",
4111 OPT_SUBTITLE | OPT_GRAB,
4113 show_help_options(options, "\nAudio/Video grab options:\n",
4117 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4120 /* individual codec options */
4122 while ((c = av_codec_next(c))) {
4123 if (c->priv_class) {
4124 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4129 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4132 /* individual muxer options */
4133 while ((oformat = av_oformat_next(oformat))) {
4134 if (oformat->priv_class) {
4135 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4140 /* individual demuxer options */
4141 while ((iformat = av_iformat_next(iformat))) {
4142 if (iformat->priv_class) {
4143 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4148 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4152 static int opt_target(const char *opt, const char *arg)
4154 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4155 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4157 if(!strncmp(arg, "pal-", 4)) {
4160 } else if(!strncmp(arg, "ntsc-", 5)) {
4163 } else if(!strncmp(arg, "film-", 5)) {
4168 /* Calculate FR via float to avoid int overflow */
4169 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4172 } else if((fr == 29970) || (fr == 23976)) {
4175 /* Try to determine PAL/NTSC by peeking in the input files */
4176 if(nb_input_files) {
4178 for (j = 0; j < nb_input_files; j++) {
4179 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4180 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4181 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4183 fr = c->time_base.den * 1000 / c->time_base.num;
4187 } else if((fr == 29970) || (fr == 23976)) {
4197 if(verbose > 0 && norm != UNKNOWN)
4198 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4201 if(norm == UNKNOWN) {
4202 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4203 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4204 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4208 if(!strcmp(arg, "vcd")) {
4209 opt_codec("vcodec", "mpeg1video");
4210 opt_codec("acodec", "mp2");
4211 opt_format("f", "vcd");
4213 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4214 opt_frame_rate("r", frame_rates[norm]);
4215 opt_default("g", norm == PAL ? "15" : "18");
4217 opt_default("b", "1150000");
4218 opt_default("maxrate", "1150000");
4219 opt_default("minrate", "1150000");
4220 opt_default("bufsize", "327680"); // 40*1024*8;
4222 opt_default("ab", "224000");
4223 audio_sample_rate = 44100;
4226 opt_default("packetsize", "2324");
4227 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4229 /* We have to offset the PTS, so that it is consistent with the SCR.
4230 SCR starts at 36000, but the first two packs contain only padding
4231 and the first pack from the other stream, respectively, may also have
4232 been written before.
4233 So the real data starts at SCR 36000+3*1200. */
4234 mux_preload= (36000+3*1200) / 90000.0; //0.44
4235 } else if(!strcmp(arg, "svcd")) {
4237 opt_codec("vcodec", "mpeg2video");
4238 opt_codec("acodec", "mp2");
4239 opt_format("f", "svcd");
4241 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4242 opt_frame_rate("r", frame_rates[norm]);
4243 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4244 opt_default("g", norm == PAL ? "15" : "18");
4246 opt_default("b", "2040000");
4247 opt_default("maxrate", "2516000");
4248 opt_default("minrate", "0"); //1145000;
4249 opt_default("bufsize", "1835008"); //224*1024*8;
4250 opt_default("flags", "+scan_offset");
4253 opt_default("ab", "224000");
4254 audio_sample_rate = 44100;
4256 opt_default("packetsize", "2324");
4258 } else if(!strcmp(arg, "dvd")) {
4260 opt_codec("vcodec", "mpeg2video");
4261 opt_codec("acodec", "ac3");
4262 opt_format("f", "dvd");
4264 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4265 opt_frame_rate("r", frame_rates[norm]);
4266 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4267 opt_default("g", norm == PAL ? "15" : "18");
4269 opt_default("b", "6000000");
4270 opt_default("maxrate", "9000000");
4271 opt_default("minrate", "0"); //1500000;
4272 opt_default("bufsize", "1835008"); //224*1024*8;
4274 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4275 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4277 opt_default("ab", "448000");
4278 audio_sample_rate = 48000;
4280 } else if(!strncmp(arg, "dv", 2)) {
4282 opt_format("f", "dv");
4284 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4285 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4286 norm == PAL ? "yuv420p" : "yuv411p");
4287 opt_frame_rate("r", frame_rates[norm]);
4289 audio_sample_rate = 48000;
4293 fprintf(stderr, "Unknown target: %s\n", arg);
4294 return AVERROR(EINVAL);
4299 static int opt_vstats_file(const char *opt, const char *arg)
4301 av_free (vstats_filename);
4302 vstats_filename=av_strdup (arg);
4306 static int opt_vstats(const char *opt, const char *arg)
4309 time_t today2 = time(NULL);
4310 struct tm *today = localtime(&today2);
4312 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4314 return opt_vstats_file(opt, filename);
4317 static int opt_bsf(const char *opt, const char *arg)
4319 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4320 AVBitStreamFilterContext **bsfp;
4323 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4327 bsfp= *opt == 'v' ? &video_bitstream_filters :
4328 *opt == 'a' ? &audio_bitstream_filters :
4329 &subtitle_bitstream_filters;
4331 bsfp= &(*bsfp)->next;
4338 static int opt_preset(const char *opt, const char *arg)
4341 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4342 char *codec_name = *opt == 'v' ? video_codec_name :
4343 *opt == 'a' ? audio_codec_name :
4344 subtitle_codec_name;
4346 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4347 fprintf(stderr, "File for preset '%s' not found\n", arg);
4352 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4353 if(line[0] == '#' && !e)
4355 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4357 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4360 if (!strcmp(tmp, "acodec") ||
4361 !strcmp(tmp, "vcodec") ||
4362 !strcmp(tmp, "scodec") ||
4363 !strcmp(tmp, "dcodec")) {
4364 opt_codec(tmp, tmp2);
4365 }else if(opt_default(tmp, tmp2) < 0){
4366 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4376 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4380 static int opt_passlogfile(const char *opt, const char *arg)
4382 pass_logfilename_prefix = arg;
4383 #if CONFIG_LIBX264_ENCODER
4384 return opt_default("passlogfile", arg);
4390 static const OptionDef options[] = {
4392 #include "cmdutils_common_opts.h"
4393 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4394 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4395 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4396 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4397 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4398 "outfile[,metadata]:infile[,metadata]" },
4399 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4400 "outfile[,metadata]:infile[,metadata]" },
4401 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4402 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4403 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4404 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4405 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4406 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4407 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4408 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4409 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4410 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4411 "add timings for benchmarking" },
4412 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4413 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4414 "dump each input packet" },
4415 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4416 "when dumping packets, also dump the payload" },
4417 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4418 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4419 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4420 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4421 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4422 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4423 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4424 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4425 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4426 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4427 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4428 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4429 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4430 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4431 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4432 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4435 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4436 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4437 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4438 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4439 { "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" },
4440 { "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" },
4441 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4442 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4443 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4444 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4445 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4446 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4447 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4448 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4449 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4450 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4451 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4452 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4453 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4454 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4455 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4456 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4457 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, "use same quantizer as source (implies VBR)" },
4458 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, "use same quantizer as source (implies VBR)" },
4459 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4460 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4461 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4462 "deinterlace pictures" },
4463 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4464 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4465 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4467 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4469 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4470 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4471 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4472 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4473 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4474 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4475 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4476 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4477 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4478 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4479 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4482 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4483 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4484 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4485 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4486 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4487 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4488 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4489 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4490 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4491 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4492 { "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" },
4494 /* subtitle options */
4495 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4496 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4497 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4498 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4499 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4502 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4503 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4504 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4507 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4508 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4510 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4511 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4512 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4514 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4515 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4516 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4517 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4518 /* data codec support */
4519 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4521 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4525 int main(int argc, char **argv)
4529 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4531 if(argc>1 && !strcmp(argv[1], "-d")){
4534 av_log_set_callback(log_callback_null);
4539 avcodec_register_all();
4541 avdevice_register_all();
4544 avfilter_register_all();
4549 if(isatty(STDIN_FILENO))
4550 avio_set_interrupt_cb(decode_interrupt_cb);
4559 parse_options(argc, argv, options, opt_output_file);
4561 if(nb_output_files <= 0 && nb_input_files == 0) {
4563 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4567 /* file converter / grab */
4568 if (nb_output_files <= 0) {
4569 fprintf(stderr, "At least one output file must be specified\n");
4573 if (nb_input_files == 0) {
4574 fprintf(stderr, "At least one input file must be specified\n");
4579 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4580 stream_maps, nb_stream_maps) < 0)
4582 ti = getutime() - ti;
4584 int maxrss = getmaxrss() / 1024;
4585 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4588 return ffmpeg_exit(0);