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 */
343 /* init terminal so that we can grab keys */
344 static struct termios oldtty;
347 static InputStream *input_streams = NULL;
348 static int nb_input_streams = 0;
349 static InputFile *input_files = NULL;
350 static int nb_input_files = 0;
354 static int configure_video_filters(InputStream *ist, OutputStream *ost)
356 AVFilterContext *last_filter, *filter;
357 /** filter graph containing all filters including input & output */
358 AVCodecContext *codec = ost->st->codec;
359 AVCodecContext *icodec = ist->st->codec;
360 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
361 AVRational sample_aspect_ratio;
365 ost->graph = avfilter_graph_alloc();
367 if (ist->st->sample_aspect_ratio.num){
368 sample_aspect_ratio = ist->st->sample_aspect_ratio;
370 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
372 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
373 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
374 sample_aspect_ratio.num, sample_aspect_ratio.den);
376 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
377 "src", args, NULL, ost->graph);
380 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
381 "out", NULL, pix_fmts, ost->graph);
384 last_filter = ost->input_video_filter;
386 if (codec->width != icodec->width || codec->height != icodec->height) {
387 snprintf(args, 255, "%d:%d:flags=0x%X",
391 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
392 NULL, args, NULL, ost->graph)) < 0)
394 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
396 last_filter = filter;
399 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
400 ost->graph->scale_sws_opts = av_strdup(args);
403 AVFilterInOut *outputs = avfilter_inout_alloc();
404 AVFilterInOut *inputs = avfilter_inout_alloc();
406 outputs->name = av_strdup("in");
407 outputs->filter_ctx = last_filter;
408 outputs->pad_idx = 0;
409 outputs->next = NULL;
411 inputs->name = av_strdup("out");
412 inputs->filter_ctx = ost->output_video_filter;
416 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
418 av_freep(&ost->avfilter);
420 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
424 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
427 codec->width = ost->output_video_filter->inputs[0]->w;
428 codec->height = ost->output_video_filter->inputs[0]->h;
429 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
430 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
431 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
432 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
436 #endif /* CONFIG_AVFILTER */
438 static void term_exit(void)
440 av_log(NULL, AV_LOG_QUIET, "%s", "");
443 tcsetattr (0, TCSANOW, &oldtty);
447 static volatile int received_sigterm = 0;
450 sigterm_handler(int sig)
452 received_sigterm = sig;
457 static void term_init(void)
467 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
468 |INLCR|IGNCR|ICRNL|IXON);
469 tty.c_oflag |= OPOST;
470 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
471 tty.c_cflag &= ~(CSIZE|PARENB);
476 tcsetattr (0, TCSANOW, &tty);
477 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
481 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
482 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
484 signal(SIGXCPU, sigterm_handler);
488 /* read a key without blocking */
489 static int read_key(void)
504 n = select(1, &rfds, NULL, NULL, &tv);
519 static int decode_interrupt_cb(void)
521 q_pressed += read_key() == 'q';
522 return q_pressed > 1;
525 static int ffmpeg_exit(int ret)
530 for(i=0;i<nb_output_files;i++) {
531 AVFormatContext *s = output_files[i];
532 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
534 avformat_free_context(s);
535 av_free(output_streams_for_file[i]);
536 av_dict_free(&output_opts[i]);
538 for(i=0;i<nb_input_files;i++) {
539 av_close_input_file(input_files[i].ctx);
541 for (i = 0; i < nb_input_streams; i++)
542 av_dict_free(&input_streams[i].opts);
544 av_free(intra_matrix);
545 av_free(inter_matrix);
549 av_free(vstats_filename);
551 av_free(streamid_map);
552 av_free(stream_maps);
553 av_free(meta_data_maps);
555 av_freep(&input_streams);
556 av_freep(&input_files);
558 av_free(video_codec_name);
559 av_free(audio_codec_name);
560 av_free(subtitle_codec_name);
561 av_free(data_codec_name);
566 allocated_audio_buf_size= allocated_audio_out_size= 0;
573 if (received_sigterm) {
575 "Received signal %d: terminating.\n",
576 (int) received_sigterm);
580 exit(ret); /* not all OS-es handle main() return value */
584 static void assert_avoptions(AVDictionary *m)
586 AVDictionaryEntry *t;
587 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
588 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
593 static void assert_codec_experimental(AVCodecContext *c, int encoder)
595 const char *codec_string = encoder ? "encoder" : "decoder";
597 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
598 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
599 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
600 "results.\nAdd '-strict experimental' if you want to use it.\n",
601 codec_string, c->codec->name);
602 codec = encoder ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
603 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
604 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
605 codec_string, codec->name);
610 /* similar to ff_dynarray_add() and av_fast_realloc() */
611 static void *grow_array(void *array, int elem_size, int *size, int new_size)
613 if (new_size >= INT_MAX / elem_size) {
614 fprintf(stderr, "Array too big.\n");
617 if (*size < new_size) {
618 uint8_t *tmp = av_realloc(array, new_size*elem_size);
620 fprintf(stderr, "Could not alloc buffer.\n");
623 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
630 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
632 if(codec && codec->sample_fmts){
633 const enum AVSampleFormat *p= codec->sample_fmts;
635 if(*p == st->codec->sample_fmt)
639 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
640 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
641 av_log(NULL, AV_LOG_WARNING,
642 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
643 av_get_sample_fmt_name(st->codec->sample_fmt),
645 av_get_sample_fmt_name(codec->sample_fmts[0]));
646 st->codec->sample_fmt = codec->sample_fmts[0];
651 static void choose_sample_rate(AVStream *st, AVCodec *codec)
653 if(codec && codec->supported_samplerates){
654 const int *p= codec->supported_samplerates;
656 int best_dist=INT_MAX;
658 int dist= abs(st->codec->sample_rate - *p);
659 if(dist < best_dist){
665 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
667 st->codec->sample_rate= best;
671 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
673 if(codec && codec->pix_fmts){
674 const enum PixelFormat *p= codec->pix_fmts;
675 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
676 if(st->codec->codec_id==CODEC_ID_MJPEG){
677 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
678 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
679 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};
683 if(*p == st->codec->pix_fmt)
687 if(st->codec->pix_fmt != PIX_FMT_NONE)
688 av_log(NULL, AV_LOG_WARNING,
689 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
690 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
692 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
693 st->codec->pix_fmt = codec->pix_fmts[0];
698 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
701 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
702 int idx = oc->nb_streams - 1;
705 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
709 output_streams_for_file[file_idx] =
710 grow_array(output_streams_for_file[file_idx],
711 sizeof(*output_streams_for_file[file_idx]),
712 &nb_output_streams_for_file[file_idx],
714 ost = output_streams_for_file[file_idx][idx] =
715 av_mallocz(sizeof(OutputStream));
717 fprintf(stderr, "Could not alloc output stream\n");
720 ost->file_index = file_idx;
725 ost->opts = filter_codec_opts(codec_opts, codec->id, 1);
727 avcodec_get_context_defaults3(st->codec, codec);
729 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
733 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
736 AVFormatContext *ic = NULL;
739 err = avformat_open_input(&ic, filename, NULL, NULL);
742 /* copy stream format */
743 for(i=0;i<ic->nb_streams;i++) {
748 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
749 ost = new_output_stream(s, nb_output_files, codec);
752 // FIXME: a more elegant solution is needed
753 memcpy(st, ic->streams[i], sizeof(AVStream));
754 st->info = av_malloc(sizeof(*st->info));
755 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
756 avcodec_copy_context(st->codec, ic->streams[i]->codec);
758 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
759 if (audio_stream_copy) {
762 choose_sample_fmt(st, codec);
763 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
764 if (video_stream_copy) {
767 choose_pixel_fmt(st, codec);
770 if(st->codec->flags & CODEC_FLAG_BITEXACT)
774 av_close_input_file(ic);
779 get_sync_ipts(const OutputStream *ost)
781 const InputStream *ist = ost->sync_ist;
782 return (double)(ist->pts - start_time)/AV_TIME_BASE;
785 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
789 AVPacket new_pkt= *pkt;
790 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
791 &new_pkt.data, &new_pkt.size,
792 pkt->data, pkt->size,
793 pkt->flags & AV_PKT_FLAG_KEY);
796 new_pkt.destruct= av_destruct_packet;
798 fprintf(stderr, "%s failed for stream %d, codec %s",
799 bsfc->filter->name, pkt->stream_index,
800 avctx->codec ? avctx->codec->name : "copy");
810 ret= av_interleaved_write_frame(s, pkt);
812 print_error("av_interleaved_write_frame()", ret);
817 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
819 static void do_audio_out(AVFormatContext *s,
822 unsigned char *buf, int size)
825 int64_t audio_out_size, audio_buf_size;
826 int64_t allocated_for_size= size;
828 int size_out, frame_bytes, ret, resample_changed;
829 AVCodecContext *enc= ost->st->codec;
830 AVCodecContext *dec= ist->st->codec;
831 int osize = av_get_bytes_per_sample(enc->sample_fmt);
832 int isize = av_get_bytes_per_sample(dec->sample_fmt);
833 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
836 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
837 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
838 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
839 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
840 audio_buf_size*= osize*enc->channels;
842 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
843 if(coded_bps > 8*osize)
844 audio_out_size= audio_out_size * coded_bps / (8*osize);
845 audio_out_size += FF_MIN_BUFFER_SIZE;
847 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
848 fprintf(stderr, "Buffer sizes too large\n");
852 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
853 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
854 if (!audio_buf || !audio_out){
855 fprintf(stderr, "Out of memory in do_audio_out\n");
859 if (enc->channels != dec->channels)
860 ost->audio_resample = 1;
862 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
863 ost->resample_channels != dec->channels ||
864 ost->resample_sample_rate != dec->sample_rate;
866 if ((ost->audio_resample && !ost->resample) || resample_changed) {
867 if (resample_changed) {
868 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",
869 ist->file_index, ist->st->index,
870 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
871 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
872 ost->resample_sample_fmt = dec->sample_fmt;
873 ost->resample_channels = dec->channels;
874 ost->resample_sample_rate = dec->sample_rate;
876 audio_resample_close(ost->resample);
878 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
879 if (audio_sync_method <= 1 &&
880 ost->resample_sample_fmt == enc->sample_fmt &&
881 ost->resample_channels == enc->channels &&
882 ost->resample_sample_rate == enc->sample_rate) {
883 ost->resample = NULL;
884 ost->audio_resample = 0;
886 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
887 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
888 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
889 enc->sample_rate, dec->sample_rate,
890 enc->sample_fmt, dec->sample_fmt,
892 if (!ost->resample) {
893 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
894 dec->channels, dec->sample_rate,
895 enc->channels, enc->sample_rate);
901 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
902 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
903 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
904 if (ost->reformat_ctx)
905 av_audio_convert_free(ost->reformat_ctx);
906 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
907 dec->sample_fmt, 1, NULL, 0);
908 if (!ost->reformat_ctx) {
909 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
910 av_get_sample_fmt_name(dec->sample_fmt),
911 av_get_sample_fmt_name(enc->sample_fmt));
914 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
917 if(audio_sync_method){
918 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
919 - av_fifo_size(ost->fifo)/(enc->channels * 2);
920 double idelta= delta*dec->sample_rate / enc->sample_rate;
921 int byte_delta= ((int)idelta)*2*dec->channels;
923 //FIXME resample delay
924 if(fabs(delta) > 50){
925 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
927 byte_delta= FFMAX(byte_delta, -size);
931 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
936 static uint8_t *input_tmp= NULL;
937 input_tmp= av_realloc(input_tmp, byte_delta + size);
939 if(byte_delta > allocated_for_size - size){
940 allocated_for_size= byte_delta + (int64_t)size;
945 memset(input_tmp, 0, byte_delta);
946 memcpy(input_tmp + byte_delta, buf, size);
950 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
952 }else if(audio_sync_method>1){
953 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
954 av_assert0(ost->audio_resample);
956 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
957 // 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));
958 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
962 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
963 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
965 if (ost->audio_resample) {
967 size_out = audio_resample(ost->resample,
968 (short *)buftmp, (short *)buf,
969 size / (dec->channels * isize));
970 size_out = size_out * enc->channels * osize;
976 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
977 const void *ibuf[6]= {buftmp};
978 void *obuf[6]= {audio_buf};
979 int istride[6]= {isize};
980 int ostride[6]= {osize};
981 int len= size_out/istride[0];
982 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
983 printf("av_audio_convert() failed\n");
989 size_out = len*osize;
992 /* now encode as many frames as possible */
993 if (enc->frame_size > 1) {
994 /* output resampled raw samples */
995 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
996 fprintf(stderr, "av_fifo_realloc2() failed\n");
999 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1001 frame_bytes = enc->frame_size * osize * enc->channels;
1003 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1005 av_init_packet(&pkt);
1007 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1009 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1011 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1012 (short *)audio_buf);
1014 fprintf(stderr, "Audio encoding failed\n");
1018 pkt.stream_index= ost->index;
1019 pkt.data= audio_out;
1021 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1022 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1023 pkt.flags |= AV_PKT_FLAG_KEY;
1024 write_frame(s, &pkt, enc, ost->bitstream_filters);
1026 ost->sync_opts += enc->frame_size;
1030 av_init_packet(&pkt);
1032 ost->sync_opts += size_out / (osize * enc->channels);
1034 /* output a pcm frame */
1035 /* determine the size of the coded buffer */
1038 size_out = size_out*coded_bps/8;
1040 if(size_out > audio_out_size){
1041 fprintf(stderr, "Internal error, buffer size too small\n");
1045 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1046 ret = avcodec_encode_audio(enc, audio_out, size_out,
1049 fprintf(stderr, "Audio encoding failed\n");
1053 pkt.stream_index= ost->index;
1054 pkt.data= audio_out;
1056 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1057 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1058 pkt.flags |= AV_PKT_FLAG_KEY;
1059 write_frame(s, &pkt, enc, ost->bitstream_filters);
1063 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1065 AVCodecContext *dec;
1066 AVPicture *picture2;
1067 AVPicture picture_tmp;
1070 dec = ist->st->codec;
1072 /* deinterlace : must be done before any resize */
1073 if (do_deinterlace) {
1076 /* create temporary picture */
1077 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1078 buf = av_malloc(size);
1082 picture2 = &picture_tmp;
1083 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1085 if(avpicture_deinterlace(picture2, picture,
1086 dec->pix_fmt, dec->width, dec->height) < 0) {
1087 /* if error, do not deinterlace */
1088 fprintf(stderr, "Deinterlacing failed\n");
1097 if (picture != picture2)
1098 *picture = *picture2;
1102 /* we begin to correct av delay at this threshold */
1103 #define AV_DELAY_MAX 0.100
1105 static void do_subtitle_out(AVFormatContext *s,
1111 static uint8_t *subtitle_out = NULL;
1112 int subtitle_out_max_size = 1024 * 1024;
1113 int subtitle_out_size, nb, i;
1114 AVCodecContext *enc;
1117 if (pts == AV_NOPTS_VALUE) {
1118 fprintf(stderr, "Subtitle packets must have a pts\n");
1124 enc = ost->st->codec;
1126 if (!subtitle_out) {
1127 subtitle_out = av_malloc(subtitle_out_max_size);
1130 /* Note: DVB subtitle need one packet to draw them and one other
1131 packet to clear them */
1132 /* XXX: signal it in the codec context ? */
1133 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1138 for(i = 0; i < nb; i++) {
1139 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1140 // start_display_time is required to be 0
1141 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1142 sub->end_display_time -= sub->start_display_time;
1143 sub->start_display_time = 0;
1144 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1145 subtitle_out_max_size, sub);
1146 if (subtitle_out_size < 0) {
1147 fprintf(stderr, "Subtitle encoding failed\n");
1151 av_init_packet(&pkt);
1152 pkt.stream_index = ost->index;
1153 pkt.data = subtitle_out;
1154 pkt.size = subtitle_out_size;
1155 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1156 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1157 /* XXX: the pts correction is handled here. Maybe handling
1158 it in the codec would be better */
1160 pkt.pts += 90 * sub->start_display_time;
1162 pkt.pts += 90 * sub->end_display_time;
1164 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1168 static int bit_buffer_size= 1024*256;
1169 static uint8_t *bit_buffer= NULL;
1171 static void do_video_out(AVFormatContext *s,
1174 AVFrame *in_picture,
1175 int *frame_size, float quality)
1177 int nb_frames, i, ret, av_unused resample_changed;
1178 AVFrame *final_picture, *formatted_picture;
1179 AVCodecContext *enc, *dec;
1182 enc = ost->st->codec;
1183 dec = ist->st->codec;
1185 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1187 /* by default, we output a single frame */
1192 if(video_sync_method){
1193 double vdelta = sync_ipts - ost->sync_opts;
1194 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1197 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1200 }else if(vdelta>0.6)
1201 ost->sync_opts= lrintf(sync_ipts);
1202 }else if (vdelta > 1.1)
1203 nb_frames = lrintf(vdelta);
1204 //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);
1205 if (nb_frames == 0){
1208 fprintf(stderr, "*** drop!\n");
1209 }else if (nb_frames > 1) {
1210 nb_frames_dup += nb_frames - 1;
1212 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1215 ost->sync_opts= lrintf(sync_ipts);
1217 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1221 formatted_picture = in_picture;
1222 final_picture = formatted_picture;
1224 #if !CONFIG_AVFILTER
1225 resample_changed = ost->resample_width != dec->width ||
1226 ost->resample_height != dec->height ||
1227 ost->resample_pix_fmt != dec->pix_fmt;
1229 if (resample_changed) {
1230 av_log(NULL, AV_LOG_INFO,
1231 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1232 ist->file_index, ist->st->index,
1233 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1234 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1235 ost->resample_width = dec->width;
1236 ost->resample_height = dec->height;
1237 ost->resample_pix_fmt = dec->pix_fmt;
1240 ost->video_resample = dec->width != enc->width ||
1241 dec->height != enc->height ||
1242 dec->pix_fmt != enc->pix_fmt;
1244 if (ost->video_resample) {
1245 final_picture = &ost->resample_frame;
1246 if (!ost->img_resample_ctx || resample_changed) {
1247 /* initialize the destination picture */
1248 if (!ost->resample_frame.data[0]) {
1249 avcodec_get_frame_defaults(&ost->resample_frame);
1250 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1251 enc->width, enc->height)) {
1252 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1256 /* initialize a new scaler context */
1257 sws_freeContext(ost->img_resample_ctx);
1258 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1259 enc->width, enc->height, enc->pix_fmt,
1260 ost->sws_flags, NULL, NULL, NULL);
1261 if (ost->img_resample_ctx == NULL) {
1262 fprintf(stderr, "Cannot get resampling context\n");
1266 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1267 0, ost->resample_height, final_picture->data, final_picture->linesize);
1271 /* duplicates frame if needed */
1272 for(i=0;i<nb_frames;i++) {
1274 av_init_packet(&pkt);
1275 pkt.stream_index= ost->index;
1277 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1278 /* raw pictures are written as AVPicture structure to
1279 avoid any copies. We support temorarily the older
1281 AVFrame* old_frame = enc->coded_frame;
1282 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1283 pkt.data= (uint8_t *)final_picture;
1284 pkt.size= sizeof(AVPicture);
1285 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1286 pkt.flags |= AV_PKT_FLAG_KEY;
1288 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1289 enc->coded_frame = old_frame;
1291 AVFrame big_picture;
1293 big_picture= *final_picture;
1294 /* better than nothing: use input picture interlaced
1296 big_picture.interlaced_frame = in_picture->interlaced_frame;
1297 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1298 if(top_field_first == -1)
1299 big_picture.top_field_first = in_picture->top_field_first;
1301 big_picture.top_field_first = top_field_first;
1304 /* handles sameq here. This is not correct because it may
1305 not be a global option */
1306 big_picture.quality = quality;
1308 big_picture.pict_type = 0;
1309 // big_picture.pts = AV_NOPTS_VALUE;
1310 big_picture.pts= ost->sync_opts;
1311 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1312 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1313 if (ost->forced_kf_index < ost->forced_kf_count &&
1314 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1315 big_picture.pict_type = AV_PICTURE_TYPE_I;
1316 ost->forced_kf_index++;
1318 ret = avcodec_encode_video(enc,
1319 bit_buffer, bit_buffer_size,
1322 fprintf(stderr, "Video encoding failed\n");
1327 pkt.data= bit_buffer;
1329 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1330 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1331 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1332 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1333 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1335 if(enc->coded_frame->key_frame)
1336 pkt.flags |= AV_PKT_FLAG_KEY;
1337 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1340 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1341 // enc->frame_number-1, ret, enc->pict_type);
1342 /* if two pass, output log */
1343 if (ost->logfile && enc->stats_out) {
1344 fprintf(ost->logfile, "%s", enc->stats_out);
1349 ost->frame_number++;
1353 static double psnr(double d){
1354 return -10.0*log(d)/log(10.0);
1357 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1360 AVCodecContext *enc;
1362 double ti1, bitrate, avg_bitrate;
1364 /* this is executed just the first time do_video_stats is called */
1366 vstats_file = fopen(vstats_filename, "w");
1373 enc = ost->st->codec;
1374 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1375 frame_number = ost->frame_number;
1376 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1377 if (enc->flags&CODEC_FLAG_PSNR)
1378 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1380 fprintf(vstats_file,"f_size= %6d ", frame_size);
1381 /* compute pts value */
1382 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1386 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1387 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1388 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1389 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1390 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1394 static void print_report(AVFormatContext **output_files,
1395 OutputStream **ost_table, int nb_ostreams,
1400 AVFormatContext *oc;
1402 AVCodecContext *enc;
1403 int frame_number, vid, i;
1405 int64_t pts = INT64_MAX;
1406 static int64_t last_time = -1;
1407 static int qp_histogram[52];
1409 if (!is_last_report) {
1411 /* display the report every 0.5 seconds */
1412 cur_time = av_gettime();
1413 if (last_time == -1) {
1414 last_time = cur_time;
1417 if ((cur_time - last_time) < 500000)
1419 last_time = cur_time;
1423 oc = output_files[0];
1425 total_size = avio_size(oc->pb);
1426 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1427 total_size= avio_tell(oc->pb);
1431 for(i=0;i<nb_ostreams;i++) {
1434 enc = ost->st->codec;
1435 if (!ost->st->stream_copy && enc->coded_frame)
1436 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1437 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1438 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1440 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1441 float t = (av_gettime()-timer_start) / 1000000.0;
1443 frame_number = ost->frame_number;
1444 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1445 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1447 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1451 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1454 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1456 if (enc->flags&CODEC_FLAG_PSNR){
1458 double error, error_sum=0;
1459 double scale, scale_sum=0;
1460 char type[3]= {'Y','U','V'};
1461 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1464 error= enc->error[j];
1465 scale= enc->width*enc->height*255.0*255.0*frame_number;
1467 error= enc->coded_frame->error[j];
1468 scale= enc->width*enc->height*255.0*255.0;
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1475 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1479 /* compute min output value */
1480 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1481 ost->st->time_base, AV_TIME_BASE_Q));
1484 if (verbose > 0 || is_last_report) {
1485 int hours, mins, secs, us;
1486 secs = pts / AV_TIME_BASE;
1487 us = pts % AV_TIME_BASE;
1493 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1495 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1496 "size=%8.0fkB time=", total_size / 1024.0);
1497 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1498 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1499 (100 * us) / AV_TIME_BASE);
1500 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1501 "bitrate=%6.1fkbits/s", bitrate);
1503 if (nb_frames_dup || nb_frames_drop)
1504 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1505 nb_frames_dup, nb_frames_drop);
1508 fprintf(stderr, "%s \r", buf);
1513 if (is_last_report && verbose >= 0){
1514 int64_t raw= audio_size + video_size + extra_size;
1515 fprintf(stderr, "\n");
1516 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1520 100.0*(total_size - raw)/raw
1525 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1527 int fill_char = 0x00;
1528 if (sample_fmt == AV_SAMPLE_FMT_U8)
1530 memset(buf, fill_char, size);
1533 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1534 static int output_packet(InputStream *ist, int ist_index,
1535 OutputStream **ost_table, int nb_ostreams,
1536 const AVPacket *pkt)
1538 AVFormatContext *os;
1543 void *buffer_to_free = NULL;
1544 static unsigned int samples_size= 0;
1545 AVSubtitle subtitle, *subtitle_to_free;
1546 int64_t pkt_pts = AV_NOPTS_VALUE;
1548 int frame_available;
1553 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1555 if(ist->next_pts == AV_NOPTS_VALUE)
1556 ist->next_pts= ist->pts;
1560 av_init_packet(&avpkt);
1568 if(pkt->dts != AV_NOPTS_VALUE)
1569 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1570 if(pkt->pts != AV_NOPTS_VALUE)
1571 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1573 //while we have more to decode or while the decoder did output something on EOF
1574 while (avpkt.size > 0 || (!pkt && got_output)) {
1575 uint8_t *data_buf, *decoded_data_buf;
1576 int data_size, decoded_data_size;
1578 ist->pts= ist->next_pts;
1580 if(avpkt.size && avpkt.size != pkt->size &&
1581 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1582 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1583 ist->showed_multi_packet_warning=1;
1586 /* decode the packet if needed */
1587 decoded_data_buf = NULL; /* fail safe */
1588 decoded_data_size= 0;
1589 data_buf = avpkt.data;
1590 data_size = avpkt.size;
1591 subtitle_to_free = NULL;
1592 if (ist->decoding_needed) {
1593 switch(ist->st->codec->codec_type) {
1594 case AVMEDIA_TYPE_AUDIO:{
1595 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1596 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1598 samples= av_malloc(samples_size);
1600 decoded_data_size= samples_size;
1601 /* XXX: could avoid copy if PCM 16 bits with same
1602 endianness as CPU */
1603 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1610 got_output = decoded_data_size > 0;
1611 /* Some bug in mpeg audio decoder gives */
1612 /* decoded_data_size < 0, it seems they are overflows */
1614 /* no audio frame */
1617 decoded_data_buf = (uint8_t *)samples;
1618 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1619 (ist->st->codec->sample_rate * ist->st->codec->channels);
1621 case AVMEDIA_TYPE_VIDEO:
1622 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1623 /* XXX: allocate picture correctly */
1624 avcodec_get_frame_defaults(&picture);
1625 avpkt.pts = pkt_pts;
1626 avpkt.dts = ist->pts;
1627 pkt_pts = AV_NOPTS_VALUE;
1629 ret = avcodec_decode_video2(ist->st->codec,
1630 &picture, &got_output, &avpkt);
1631 quality = same_quality ? picture.quality : 0;
1635 /* no picture yet */
1636 goto discard_packet;
1638 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1639 if (ist->st->codec->time_base.num != 0) {
1640 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1641 ist->next_pts += ((int64_t)AV_TIME_BASE *
1642 ist->st->codec->time_base.num * ticks) /
1643 ist->st->codec->time_base.den;
1646 buffer_to_free = NULL;
1647 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1649 case AVMEDIA_TYPE_SUBTITLE:
1650 ret = avcodec_decode_subtitle2(ist->st->codec,
1651 &subtitle, &got_output, &avpkt);
1655 goto discard_packet;
1657 subtitle_to_free = &subtitle;
1664 switch(ist->st->codec->codec_type) {
1665 case AVMEDIA_TYPE_AUDIO:
1666 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1667 ist->st->codec->sample_rate;
1669 case AVMEDIA_TYPE_VIDEO:
1670 if (ist->st->codec->time_base.num != 0) {
1671 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1672 ist->next_pts += ((int64_t)AV_TIME_BASE *
1673 ist->st->codec->time_base.num * ticks) /
1674 ist->st->codec->time_base.den;
1683 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1684 if (start_time == 0 || ist->pts >= start_time) {
1685 for(i=0;i<nb_ostreams;i++) {
1687 if (ost->input_video_filter && ost->source_index == ist_index) {
1688 if (!picture.sample_aspect_ratio.num)
1689 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1690 picture.pts = ist->pts;
1692 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1698 // preprocess audio (volume)
1699 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1700 if (audio_volume != 256) {
1703 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1704 int v = ((*volp) * audio_volume + 128) >> 8;
1705 if (v < -32768) v = -32768;
1706 if (v > 32767) v = 32767;
1712 /* frame rate emulation */
1714 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1715 int64_t now = av_gettime() - ist->start;
1719 /* if output time reached then transcode raw format,
1720 encode packets and output them */
1721 if (start_time == 0 || ist->pts >= start_time)
1722 for(i=0;i<nb_ostreams;i++) {
1726 if (ost->source_index == ist_index) {
1728 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1729 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1730 while (frame_available) {
1731 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1732 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1733 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1736 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1737 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1741 os = output_files[ost->file_index];
1743 /* set the input output pts pairs */
1744 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1746 if (ost->encoding_needed) {
1747 av_assert0(ist->decoding_needed);
1748 switch(ost->st->codec->codec_type) {
1749 case AVMEDIA_TYPE_AUDIO:
1750 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1752 case AVMEDIA_TYPE_VIDEO:
1754 if (ost->picref->video && !ost->frame_aspect_ratio)
1755 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1757 do_video_out(os, ost, ist, &picture, &frame_size,
1758 same_quality ? quality : ost->st->codec->global_quality);
1759 if (vstats_filename && frame_size)
1760 do_video_stats(os, ost, frame_size);
1762 case AVMEDIA_TYPE_SUBTITLE:
1763 do_subtitle_out(os, ost, ist, &subtitle,
1770 AVFrame avframe; //FIXME/XXX remove this
1773 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1775 av_init_packet(&opkt);
1777 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1778 #if !CONFIG_AVFILTER
1784 /* no reencoding needed : output the packet directly */
1785 /* force the input stream PTS */
1787 avcodec_get_frame_defaults(&avframe);
1788 ost->st->codec->coded_frame= &avframe;
1789 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1791 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1792 audio_size += data_size;
1793 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1794 video_size += data_size;
1798 opkt.stream_index= ost->index;
1799 if(pkt->pts != AV_NOPTS_VALUE)
1800 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1802 opkt.pts= AV_NOPTS_VALUE;
1804 if (pkt->dts == AV_NOPTS_VALUE)
1805 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1807 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1808 opkt.dts -= ost_tb_start_time;
1810 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1811 opkt.flags= pkt->flags;
1813 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1814 if( ost->st->codec->codec_id != CODEC_ID_H264
1815 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1816 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1818 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1819 opkt.destruct= av_destruct_packet;
1821 opkt.data = data_buf;
1822 opkt.size = data_size;
1825 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1826 /* store AVPicture in AVPacket, as expected by the output format */
1827 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1828 opkt.data = (uint8_t *)&pict;
1829 opkt.size = sizeof(AVPicture);
1830 opkt.flags |= AV_PKT_FLAG_KEY;
1832 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1833 ost->st->codec->frame_number++;
1834 ost->frame_number++;
1835 av_free_packet(&opkt);
1839 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1840 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1841 avfilter_unref_buffer(ost->picref);
1847 av_free(buffer_to_free);
1848 /* XXX: allocate the subtitles in the codec ? */
1849 if (subtitle_to_free) {
1850 avsubtitle_free(subtitle_to_free);
1851 subtitle_to_free = NULL;
1858 for(i=0;i<nb_ostreams;i++) {
1860 if (ost->source_index == ist_index) {
1861 AVCodecContext *enc= ost->st->codec;
1862 os = output_files[ost->file_index];
1864 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1866 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1869 if (ost->encoding_needed) {
1873 av_init_packet(&pkt);
1874 pkt.stream_index= ost->index;
1876 switch(ost->st->codec->codec_type) {
1877 case AVMEDIA_TYPE_AUDIO:
1878 fifo_bytes = av_fifo_size(ost->fifo);
1880 /* encode any samples remaining in fifo */
1881 if (fifo_bytes > 0) {
1882 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1883 int fs_tmp = enc->frame_size;
1885 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1886 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1887 enc->frame_size = fifo_bytes / (osize * enc->channels);
1889 int frame_bytes = enc->frame_size*osize*enc->channels;
1890 if (allocated_audio_buf_size < frame_bytes)
1892 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1895 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1896 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1897 ost->st->time_base.num, enc->sample_rate);
1898 enc->frame_size = fs_tmp;
1901 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1904 fprintf(stderr, "Audio encoding failed\n");
1908 pkt.flags |= AV_PKT_FLAG_KEY;
1910 case AVMEDIA_TYPE_VIDEO:
1911 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1913 fprintf(stderr, "Video encoding failed\n");
1917 if(enc->coded_frame && enc->coded_frame->key_frame)
1918 pkt.flags |= AV_PKT_FLAG_KEY;
1919 if (ost->logfile && enc->stats_out) {
1920 fprintf(ost->logfile, "%s", enc->stats_out);
1929 pkt.data= bit_buffer;
1931 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1932 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1933 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1943 static void print_sdp(AVFormatContext **avc, int n)
1947 av_sdp_create(avc, n, sdp, sizeof(sdp));
1948 printf("SDP:\n%s\n", sdp);
1952 static int copy_chapters(int infile, int outfile)
1954 AVFormatContext *is = input_files[infile].ctx;
1955 AVFormatContext *os = output_files[outfile];
1958 for (i = 0; i < is->nb_chapters; i++) {
1959 AVChapter *in_ch = is->chapters[i], *out_ch;
1960 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1961 AV_TIME_BASE_Q, in_ch->time_base);
1962 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1963 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1966 if (in_ch->end < ts_off)
1968 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1971 out_ch = av_mallocz(sizeof(AVChapter));
1973 return AVERROR(ENOMEM);
1975 out_ch->id = in_ch->id;
1976 out_ch->time_base = in_ch->time_base;
1977 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1978 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1980 if (metadata_chapters_autocopy)
1981 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1984 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1986 return AVERROR(ENOMEM);
1987 os->chapters[os->nb_chapters - 1] = out_ch;
1992 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1993 AVCodecContext *avctx)
1999 for (p = kf; *p; p++)
2002 ost->forced_kf_count = n;
2003 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2004 if (!ost->forced_kf_pts) {
2005 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2008 for (i = 0; i < n; i++) {
2009 p = i ? strchr(p, ',') + 1 : kf;
2010 t = parse_time_or_die("force_key_frames", p, 1);
2011 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2016 * The following code is the main loop of the file converter
2018 static int transcode(AVFormatContext **output_files,
2019 int nb_output_files,
2020 InputFile *input_files,
2022 StreamMap *stream_maps, int nb_stream_maps)
2024 int ret = 0, i, j, k, n, nb_ostreams = 0, step;
2026 AVFormatContext *is, *os;
2027 AVCodecContext *codec, *icodec;
2028 OutputStream *ost, **ost_table = NULL;
2033 uint8_t no_packet[MAX_FILES]={0};
2034 int no_packet_count=0;
2035 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
2036 int nb_streams[AVMEDIA_TYPE_NB]={0};
2039 for (i = 0; i < nb_input_streams; i++)
2040 input_streams[i].start = av_gettime();
2042 /* output stream init */
2044 for(i=0;i<nb_output_files;i++) {
2045 os = output_files[i];
2046 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2047 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2048 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2049 ret = AVERROR(EINVAL);
2052 nb_ostreams += os->nb_streams;
2054 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2055 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2056 ret = AVERROR(EINVAL);
2060 /* Sanity check the mapping args -- do the input files & streams exist? */
2061 for(i=0;i<nb_stream_maps;i++) {
2062 int fi = stream_maps[i].file_index;
2063 int si = stream_maps[i].stream_index;
2065 if (fi < 0 || fi > nb_input_files - 1 ||
2066 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2067 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2068 ret = AVERROR(EINVAL);
2071 fi = stream_maps[i].sync_file_index;
2072 si = stream_maps[i].sync_stream_index;
2073 if (fi < 0 || fi > nb_input_files - 1 ||
2074 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2075 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2076 ret = AVERROR(EINVAL);
2081 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2085 for(k=0;k<nb_output_files;k++) {
2086 os = output_files[k];
2087 for(i=0;i<os->nb_streams;i++,n++) {
2088 nb_streams[os->streams[i]->codec->codec_type]++;
2091 for(step=1<<30; step; step>>=1){
2092 int found_streams[AVMEDIA_TYPE_NB]={0};
2093 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2094 nb_frame_threshold[j] += step;
2096 for(j=0; j<nb_input_streams; j++) {
2098 ist = &input_streams[j];
2101 AVFormatContext *f= input_files[ ist->file_index ].ctx;
2103 for(pi=0; pi<f->nb_programs; pi++){
2104 AVProgram *p= f->programs[pi];
2105 if(p->id == opt_programid)
2106 for(si=0; si<p->nb_stream_indexes; si++){
2107 if(f->streams[ p->stream_index[si] ] == ist->st)
2112 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2113 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2114 found_streams[ist->st->codec->codec_type]++;
2117 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2118 if(found_streams[j] < nb_streams[j])
2119 nb_frame_threshold[j] -= step;
2122 for(k=0;k<nb_output_files;k++) {
2123 os = output_files[k];
2124 for(i=0;i<os->nb_streams;i++,n++) {
2126 ost = ost_table[n] = output_streams_for_file[k][i];
2127 if (nb_stream_maps > 0) {
2128 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2129 stream_maps[n].stream_index;
2131 /* Sanity check that the stream types match */
2132 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2133 int i= ost->file_index;
2134 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2135 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2136 stream_maps[n].file_index, stream_maps[n].stream_index,
2137 ost->file_index, ost->index);
2142 /* get corresponding input stream index : we select the first one with the right type */
2144 for (j = 0; j < nb_input_streams; j++) {
2146 ist = &input_streams[j];
2149 AVFormatContext *f = input_files[ist->file_index].ctx;
2151 for(pi=0; pi<f->nb_programs; pi++){
2152 AVProgram *p= f->programs[pi];
2153 if(p->id == opt_programid)
2154 for(si=0; si<p->nb_stream_indexes; si++){
2155 if(f->streams[ p->stream_index[si] ] == ist->st)
2160 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2161 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2162 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2163 ost->source_index = j;
2170 if(! opt_programid) {
2171 /* try again and reuse existing stream */
2172 for (j = 0; j < nb_input_streams; j++) {
2173 ist = &input_streams[j];
2174 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2175 && ist->st->discard != AVDISCARD_ALL) {
2176 ost->source_index = j;
2182 int i= ost->file_index;
2183 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2184 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2185 ost->file_index, ost->index);
2190 ist = &input_streams[ost->source_index];
2192 ost->sync_ist = (nb_stream_maps > 0) ?
2193 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2194 stream_maps[n].sync_stream_index] : ist;
2198 /* for each output stream, we compute the right encoding parameters */
2199 for(i=0;i<nb_ostreams;i++) {
2201 os = output_files[ost->file_index];
2202 ist = &input_streams[ost->source_index];
2204 codec = ost->st->codec;
2205 icodec = ist->st->codec;
2207 if (metadata_streams_autocopy)
2208 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2209 AV_DICT_DONT_OVERWRITE);
2211 ost->st->disposition = ist->st->disposition;
2212 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2213 codec->chroma_sample_location = icodec->chroma_sample_location;
2215 if (ost->st->stream_copy) {
2216 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2218 if (extra_size > INT_MAX)
2221 /* if stream_copy is selected, no need to decode or encode */
2222 codec->codec_id = icodec->codec_id;
2223 codec->codec_type = icodec->codec_type;
2225 if(!codec->codec_tag){
2226 if( !os->oformat->codec_tag
2227 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2228 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2229 codec->codec_tag = icodec->codec_tag;
2232 codec->bit_rate = icodec->bit_rate;
2233 codec->rc_max_rate = icodec->rc_max_rate;
2234 codec->rc_buffer_size = icodec->rc_buffer_size;
2235 codec->extradata= av_mallocz(extra_size);
2236 if (!codec->extradata)
2238 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2239 codec->extradata_size= icodec->extradata_size;
2240 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){
2241 codec->time_base = icodec->time_base;
2242 codec->time_base.num *= icodec->ticks_per_frame;
2243 av_reduce(&codec->time_base.num, &codec->time_base.den,
2244 codec->time_base.num, codec->time_base.den, INT_MAX);
2246 codec->time_base = ist->st->time_base;
2247 switch(codec->codec_type) {
2248 case AVMEDIA_TYPE_AUDIO:
2249 if(audio_volume != 256) {
2250 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2253 codec->channel_layout = icodec->channel_layout;
2254 codec->sample_rate = icodec->sample_rate;
2255 codec->channels = icodec->channels;
2256 codec->frame_size = icodec->frame_size;
2257 codec->audio_service_type = icodec->audio_service_type;
2258 codec->block_align= icodec->block_align;
2259 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2260 codec->block_align= 0;
2261 if(codec->codec_id == CODEC_ID_AC3)
2262 codec->block_align= 0;
2264 case AVMEDIA_TYPE_VIDEO:
2265 codec->pix_fmt = icodec->pix_fmt;
2266 codec->width = icodec->width;
2267 codec->height = icodec->height;
2268 codec->has_b_frames = icodec->has_b_frames;
2269 if (!codec->sample_aspect_ratio.num) {
2270 codec->sample_aspect_ratio =
2271 ost->st->sample_aspect_ratio =
2272 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2273 ist->st->codec->sample_aspect_ratio.num ?
2274 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2277 case AVMEDIA_TYPE_SUBTITLE:
2278 codec->width = icodec->width;
2279 codec->height = icodec->height;
2281 case AVMEDIA_TYPE_DATA:
2288 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2289 switch(codec->codec_type) {
2290 case AVMEDIA_TYPE_AUDIO:
2291 ost->fifo= av_fifo_alloc(1024);
2294 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2295 if (!codec->sample_rate) {
2296 codec->sample_rate = icodec->sample_rate;
2298 choose_sample_rate(ost->st, ost->enc);
2299 codec->time_base = (AVRational){1, codec->sample_rate};
2300 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2301 codec->sample_fmt = icodec->sample_fmt;
2302 choose_sample_fmt(ost->st, ost->enc);
2303 if (!codec->channels) {
2304 codec->channels = icodec->channels;
2305 codec->channel_layout = icodec->channel_layout;
2307 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2308 codec->channel_layout = 0;
2309 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2310 icodec->request_channels = codec->channels;
2311 ist->decoding_needed = 1;
2312 ost->encoding_needed = 1;
2313 ost->resample_sample_fmt = icodec->sample_fmt;
2314 ost->resample_sample_rate = icodec->sample_rate;
2315 ost->resample_channels = icodec->channels;
2317 case AVMEDIA_TYPE_VIDEO:
2318 if (codec->pix_fmt == PIX_FMT_NONE)
2319 codec->pix_fmt = icodec->pix_fmt;
2320 choose_pixel_fmt(ost->st, ost->enc);
2322 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2323 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2326 ost->video_resample = codec->width != icodec->width ||
2327 codec->height != icodec->height ||
2328 codec->pix_fmt != icodec->pix_fmt;
2329 if (ost->video_resample) {
2330 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2332 if (!codec->width || !codec->height) {
2333 codec->width = icodec->width;
2334 codec->height = icodec->height;
2336 ost->resample_height = icodec->height;
2337 ost->resample_width = icodec->width;
2338 ost->resample_pix_fmt= icodec->pix_fmt;
2339 ost->encoding_needed = 1;
2340 ist->decoding_needed = 1;
2342 if (!ost->frame_rate.num)
2343 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2344 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2345 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2346 ost->frame_rate = ost->enc->supported_framerates[idx];
2348 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2349 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2350 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2351 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2352 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2356 if (configure_video_filters(ist, ost)) {
2357 fprintf(stderr, "Error opening filters!\n");
2362 case AVMEDIA_TYPE_SUBTITLE:
2363 ost->encoding_needed = 1;
2364 ist->decoding_needed = 1;
2371 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2372 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2373 char logfilename[1024];
2376 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2377 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2379 if (codec->flags & CODEC_FLAG_PASS1) {
2380 f = fopen(logfilename, "wb");
2382 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2388 size_t logbuffer_size;
2389 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2390 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2393 codec->stats_in = logbuffer;
2397 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2398 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2399 int size= codec->width * codec->height;
2400 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2405 bit_buffer = av_malloc(bit_buffer_size);
2407 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2409 ret = AVERROR(ENOMEM);
2413 /* open each encoder */
2414 for(i=0;i<nb_ostreams;i++) {
2416 if (ost->encoding_needed) {
2417 AVCodec *codec = ost->enc;
2418 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2420 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2421 ost->st->codec->codec_id, ost->file_index, ost->index);
2422 ret = AVERROR(EINVAL);
2425 if (dec->subtitle_header) {
2426 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2427 if (!ost->st->codec->subtitle_header) {
2428 ret = AVERROR(ENOMEM);
2431 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2432 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2434 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2435 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2436 ost->file_index, ost->index);
2437 ret = AVERROR(EINVAL);
2440 assert_codec_experimental(ost->st->codec, 1);
2441 assert_avoptions(ost->opts);
2442 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2443 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2444 "It takes bits/s as argument, not kbits/s\n");
2445 extra_size += ost->st->codec->extradata_size;
2449 /* open each decoder */
2450 for (i = 0; i < nb_input_streams; i++) {
2451 ist = &input_streams[i];
2452 if (ist->decoding_needed) {
2453 AVCodec *codec = ist->dec;
2455 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2457 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2458 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2459 ret = AVERROR(EINVAL);
2462 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2463 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2464 ist->file_index, ist->st->index);
2465 ret = AVERROR(EINVAL);
2468 assert_codec_experimental(ist->st->codec, 0);
2469 assert_avoptions(ost->opts);
2470 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2471 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2476 for (i = 0; i < nb_input_streams; i++) {
2478 ist = &input_streams[i];
2480 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2481 ist->next_pts = AV_NOPTS_VALUE;
2485 /* set meta data information from input file if required */
2486 for (i=0;i<nb_meta_data_maps;i++) {
2487 AVFormatContext *files[2];
2488 AVDictionary **meta[2];
2491 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2492 if ((index) < 0 || (index) >= (nb_elems)) {\
2493 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2495 ret = AVERROR(EINVAL);\
2499 int out_file_index = meta_data_maps[i][0].file;
2500 int in_file_index = meta_data_maps[i][1].file;
2501 if (in_file_index < 0 || out_file_index < 0)
2503 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2504 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2506 files[0] = output_files[out_file_index];
2507 files[1] = input_files[in_file_index].ctx;
2509 for (j = 0; j < 2; j++) {
2510 MetadataMap *map = &meta_data_maps[i][j];
2512 switch (map->type) {
2514 meta[j] = &files[j]->metadata;
2517 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2518 meta[j] = &files[j]->streams[map->index]->metadata;
2521 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2522 meta[j] = &files[j]->chapters[map->index]->metadata;
2525 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2526 meta[j] = &files[j]->programs[map->index]->metadata;
2531 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2534 /* copy global metadata by default */
2535 if (metadata_global_autocopy) {
2537 for (i = 0; i < nb_output_files; i++)
2538 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2539 AV_DICT_DONT_OVERWRITE);
2542 /* copy chapters according to chapter maps */
2543 for (i = 0; i < nb_chapter_maps; i++) {
2544 int infile = chapter_maps[i].in_file;
2545 int outfile = chapter_maps[i].out_file;
2547 if (infile < 0 || outfile < 0)
2549 if (infile >= nb_input_files) {
2550 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2551 ret = AVERROR(EINVAL);
2554 if (outfile >= nb_output_files) {
2555 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2556 ret = AVERROR(EINVAL);
2559 copy_chapters(infile, outfile);
2562 /* copy chapters from the first input file that has them*/
2563 if (!nb_chapter_maps)
2564 for (i = 0; i < nb_input_files; i++) {
2565 if (!input_files[i].ctx->nb_chapters)
2568 for (j = 0; j < nb_output_files; j++)
2569 if ((ret = copy_chapters(i, j)) < 0)
2574 /* open files and write file headers */
2575 for(i=0;i<nb_output_files;i++) {
2576 os = output_files[i];
2577 if (avformat_write_header(os, &output_opts[i]) < 0) {
2578 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2579 ret = AVERROR(EINVAL);
2582 assert_avoptions(output_opts[i]);
2583 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2589 /* dump the file output parameters - cannot be done before in case
2591 for(i=0;i<nb_output_files;i++) {
2592 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2595 /* dump the stream mapping */
2597 fprintf(stderr, "Stream mapping:\n");
2598 for(i=0;i<nb_ostreams;i++) {
2600 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2601 input_streams[ost->source_index].file_index,
2602 input_streams[ost->source_index].st->index,
2605 if (ost->sync_ist != &input_streams[ost->source_index])
2606 fprintf(stderr, " [sync #%d.%d]",
2607 ost->sync_ist->file_index,
2608 ost->sync_ist->st->index);
2609 fprintf(stderr, "\n");
2614 fprintf(stderr, "%s\n", error);
2619 print_sdp(output_files, nb_output_files);
2624 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2625 avio_set_interrupt_cb(decode_interrupt_cb);
2629 timer_start = av_gettime();
2631 for(; received_sigterm == 0;) {
2632 int file_index, ist_index;
2640 /* if 'q' pressed, exits */
2644 /* read_key() returns 0 on EOF */
2648 if (key == '+') verbose++;
2649 if (key == '-') verbose--;
2650 if (key == 's') qp_hist ^= 1;
2653 do_hex_dump = do_pkt_dump = 0;
2654 } else if(do_pkt_dump){
2658 av_log_set_level(AV_LOG_DEBUG);
2660 if (key == 'd' || key == 'D'){
2663 debug = input_streams[0].st->codec->debug<<1;
2664 if(!debug) debug = 1;
2665 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2668 scanf("%d", &debug);
2669 for(i=0;i<nb_input_streams;i++) {
2670 input_streams[i].st->codec->debug = debug;
2672 for(i=0;i<nb_ostreams;i++) {
2674 ost->st->codec->debug = debug;
2676 if(debug) av_log_set_level(AV_LOG_DEBUG);
2677 fprintf(stderr,"debug=%d\n", debug);
2680 fprintf(stderr, "key function\n"
2681 "? show this help\n"
2682 "+ increase verbosity\n"
2683 "- decrease verbosity\n"
2684 "D cycle through available debug modes\n"
2685 "h dump packets/hex press to cycle through the 3 states\n"
2687 "s Show QP histogram\n"
2692 /* select the stream that we must read now by looking at the
2693 smallest output pts */
2695 for(i=0;i<nb_ostreams;i++) {
2698 os = output_files[ost->file_index];
2699 ist = &input_streams[ost->source_index];
2700 if(ist->is_past_recording_time || no_packet[ist->file_index])
2702 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2703 ipts = (double)ist->pts;
2704 if (!input_files[ist->file_index].eof_reached){
2705 if(ipts < ipts_min) {
2707 if(input_sync ) file_index = ist->file_index;
2709 if(opts < opts_min) {
2711 if(!input_sync) file_index = ist->file_index;
2714 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2719 /* if none, if is finished */
2720 if (file_index < 0) {
2721 if(no_packet_count){
2723 memset(no_packet, 0, sizeof(no_packet));
2730 /* finish if limit size exhausted */
2731 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2734 /* read a frame from it and output it in the fifo */
2735 is = input_files[file_index].ctx;
2736 ret= av_read_frame(is, &pkt);
2737 if(ret == AVERROR(EAGAIN)){
2738 no_packet[file_index]=1;
2743 input_files[file_index].eof_reached = 1;
2751 memset(no_packet, 0, sizeof(no_packet));
2754 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2755 is->streams[pkt.stream_index]);
2757 /* the following test is needed in case new streams appear
2758 dynamically in stream : we ignore them */
2759 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2760 goto discard_packet;
2761 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2762 ist = &input_streams[ist_index];
2764 goto discard_packet;
2766 if (pkt.dts != AV_NOPTS_VALUE)
2767 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2768 if (pkt.pts != AV_NOPTS_VALUE)
2769 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2771 if (ist->ts_scale) {
2772 if(pkt.pts != AV_NOPTS_VALUE)
2773 pkt.pts *= ist->ts_scale;
2774 if(pkt.dts != AV_NOPTS_VALUE)
2775 pkt.dts *= ist->ts_scale;
2778 // 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);
2779 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2780 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2781 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2782 int64_t delta= pkt_dts - ist->next_pts;
2783 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2784 input_files[ist->file_index].ts_offset -= delta;
2786 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2787 delta, input_files[ist->file_index].ts_offset);
2788 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2789 if(pkt.pts != AV_NOPTS_VALUE)
2790 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2794 /* finish if recording time exhausted */
2795 if (recording_time != INT64_MAX &&
2796 (pkt.pts != AV_NOPTS_VALUE ?
2797 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2799 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2801 ist->is_past_recording_time = 1;
2802 goto discard_packet;
2805 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2806 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2809 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2810 ist->file_index, ist->st->index);
2813 av_free_packet(&pkt);
2818 av_free_packet(&pkt);
2820 /* dump report by using the output first video and audio streams */
2821 print_report(output_files, ost_table, nb_ostreams, 0);
2824 /* at the end of stream, we must flush the decoder buffers */
2825 for (i = 0; i < nb_input_streams; i++) {
2826 ist = &input_streams[i];
2827 if (ist->decoding_needed) {
2828 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2834 /* write the trailer if needed and close file */
2835 for(i=0;i<nb_output_files;i++) {
2836 os = output_files[i];
2837 av_write_trailer(os);
2840 /* dump report by using the first video and audio streams */
2841 print_report(output_files, ost_table, nb_ostreams, 1);
2843 /* close each encoder */
2844 for(i=0;i<nb_ostreams;i++) {
2846 if (ost->encoding_needed) {
2847 av_freep(&ost->st->codec->stats_in);
2848 avcodec_close(ost->st->codec);
2851 avfilter_graph_free(&ost->graph);
2855 /* close each decoder */
2856 for (i = 0; i < nb_input_streams; i++) {
2857 ist = &input_streams[i];
2858 if (ist->decoding_needed) {
2859 avcodec_close(ist->st->codec);
2867 av_freep(&bit_buffer);
2870 for(i=0;i<nb_ostreams;i++) {
2873 if (ost->st->stream_copy)
2874 av_freep(&ost->st->codec->extradata);
2876 fclose(ost->logfile);
2877 ost->logfile = NULL;
2879 av_fifo_free(ost->fifo); /* works even if fifo is not
2880 initialized but set to zero */
2881 av_freep(&ost->st->codec->subtitle_header);
2882 av_free(ost->resample_frame.data[0]);
2883 av_free(ost->forced_kf_pts);
2884 if (ost->video_resample)
2885 sws_freeContext(ost->img_resample_ctx);
2887 audio_resample_close(ost->resample);
2888 if (ost->reformat_ctx)
2889 av_audio_convert_free(ost->reformat_ctx);
2890 av_dict_free(&ost->opts);
2899 static int opt_format(const char *opt, const char *arg)
2901 last_asked_format = arg;
2905 static int opt_video_rc_override_string(const char *opt, const char *arg)
2907 video_rc_override_string = arg;
2911 static int opt_me_threshold(const char *opt, const char *arg)
2913 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2917 static int opt_verbose(const char *opt, const char *arg)
2919 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2923 static int opt_frame_rate(const char *opt, const char *arg)
2925 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2926 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2932 static int opt_frame_crop(const char *opt, const char *arg)
2934 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2935 return AVERROR(EINVAL);
2938 static int opt_frame_size(const char *opt, const char *arg)
2940 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2941 fprintf(stderr, "Incorrect frame size\n");
2942 return AVERROR(EINVAL);
2947 static int opt_pad(const char *opt, const char *arg) {
2948 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2952 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2954 if (strcmp(arg, "list")) {
2955 frame_pix_fmt = av_get_pix_fmt(arg);
2956 if (frame_pix_fmt == PIX_FMT_NONE) {
2957 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2958 return AVERROR(EINVAL);
2961 opt_pix_fmts(NULL, NULL);
2967 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2974 p = strchr(arg, ':');
2976 x = strtol(arg, &end, 10);
2978 y = strtol(end+1, &end, 10);
2980 ar = (double)x / (double)y;
2982 ar = strtod(arg, NULL);
2985 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2986 return AVERROR(EINVAL);
2988 frame_aspect_ratio = ar;
2992 static int opt_metadata(const char *opt, const char *arg)
2994 char *mid= strchr(arg, '=');
2997 fprintf(stderr, "Missing =\n");
3002 av_dict_set(&metadata, arg, mid, 0);
3007 static int opt_qscale(const char *opt, const char *arg)
3009 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
3010 if (video_qscale <= 0 || video_qscale > 255) {
3011 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
3012 return AVERROR(EINVAL);
3017 static int opt_top_field_first(const char *opt, const char *arg)
3019 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
3020 opt_default(opt, arg);
3024 static int opt_thread_count(const char *opt, const char *arg)
3026 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3029 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
3034 static int opt_audio_sample_fmt(const char *opt, const char *arg)
3036 if (strcmp(arg, "list")) {
3037 audio_sample_fmt = av_get_sample_fmt(arg);
3038 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3039 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3040 return AVERROR(EINVAL);
3045 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3046 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3052 static int opt_audio_rate(const char *opt, const char *arg)
3054 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3058 static int opt_audio_channels(const char *opt, const char *arg)
3060 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3064 static int opt_video_channel(const char *opt, const char *arg)
3066 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3067 opt_default("channel", arg);
3071 static int opt_video_standard(const char *opt, const char *arg)
3073 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3074 opt_default("standard", arg);
3078 static int opt_codec(const char *opt, const char *arg)
3080 int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3082 if (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy; pcodec_name = &audio_codec_name; codec_type = AVMEDIA_TYPE_AUDIO; }
3083 else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy; pcodec_name = &video_codec_name; codec_type = AVMEDIA_TYPE_VIDEO; }
3084 else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3085 else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy; pcodec_name = &data_codec_name; codec_type = AVMEDIA_TYPE_DATA; }
3087 av_freep(pcodec_name);
3088 if (!strcmp(arg, "copy")) {
3091 *pcodec_name = av_strdup(arg);
3096 static int opt_codec_tag(const char *opt, const char *arg)
3099 uint32_t *codec_tag;
3101 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3102 !strcmp(opt, "vtag") ? &video_codec_tag :
3103 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3107 *codec_tag = strtol(arg, &tail, 0);
3109 *codec_tag = AV_RL32(arg);
3114 static int opt_map(const char *opt, const char *arg)
3119 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3120 m = &stream_maps[nb_stream_maps-1];
3122 m->file_index = strtol(arg, &p, 0);
3126 m->stream_index = strtol(p, &p, 0);
3129 m->sync_file_index = strtol(p, &p, 0);
3132 m->sync_stream_index = strtol(p, &p, 0);
3134 m->sync_file_index = m->file_index;
3135 m->sync_stream_index = m->stream_index;
3140 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3151 *index = strtol(++arg, endptr, 0);
3154 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3161 static int opt_map_metadata(const char *opt, const char *arg)
3163 MetadataMap *m, *m1;
3166 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3167 &nb_meta_data_maps, nb_meta_data_maps + 1);
3169 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3170 m->file = strtol(arg, &p, 0);
3171 parse_meta_type(p, &m->type, &m->index, &p);
3175 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3176 m1->file = strtol(p, &p, 0);
3177 parse_meta_type(p, &m1->type, &m1->index, &p);
3179 if (m->type == 'g' || m1->type == 'g')
3180 metadata_global_autocopy = 0;
3181 if (m->type == 's' || m1->type == 's')
3182 metadata_streams_autocopy = 0;
3183 if (m->type == 'c' || m1->type == 'c')
3184 metadata_chapters_autocopy = 0;
3189 static int opt_map_meta_data(const char *opt, const char *arg)
3191 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3192 "Use -map_metadata instead.\n");
3193 return opt_map_metadata(opt, arg);
3196 static int opt_map_chapters(const char *opt, const char *arg)
3201 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3202 nb_chapter_maps + 1);
3203 c = &chapter_maps[nb_chapter_maps - 1];
3204 c->out_file = strtol(arg, &p, 0);
3208 c->in_file = strtol(p, &p, 0);
3212 static int opt_input_ts_scale(const char *opt, const char *arg)
3214 unsigned int stream;
3218 stream = strtol(arg, &p, 0);
3221 scale= strtod(p, &p);
3223 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3224 ts_scale[stream] = scale;
3228 static int opt_recording_time(const char *opt, const char *arg)
3230 recording_time = parse_time_or_die(opt, arg, 1);
3234 static int opt_start_time(const char *opt, const char *arg)
3236 start_time = parse_time_or_die(opt, arg, 1);
3240 static int opt_recording_timestamp(const char *opt, const char *arg)
3243 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3244 struct tm time = *gmtime((time_t*)&recording_timestamp);
3245 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3246 opt_metadata("metadata", buf);
3248 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3249 "tag instead.\n", opt);
3253 static int opt_input_ts_offset(const char *opt, const char *arg)
3255 input_ts_offset = parse_time_or_die(opt, arg, 1);
3259 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3261 const char *codec_string = encoder ? "encoder" : "decoder";
3265 return CODEC_ID_NONE;
3267 avcodec_find_encoder_by_name(name) :
3268 avcodec_find_decoder_by_name(name);
3270 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3273 if(codec->type != type) {
3274 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3280 static int opt_input_file(const char *opt, const char *filename)
3282 AVFormatContext *ic;
3283 AVInputFormat *file_iformat = NULL;
3284 int err, i, ret, rfps, rfps_base;
3287 AVDictionary **opts;
3288 int orig_nb_streams; // number of streams before avformat_find_stream_info
3290 if (last_asked_format) {
3291 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3292 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3295 last_asked_format = NULL;
3298 if (!strcmp(filename, "-"))
3301 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3302 !strcmp(filename, "/dev/stdin");
3304 /* get default parameters from command line */
3305 ic = avformat_alloc_context();
3307 print_error(filename, AVERROR(ENOMEM));
3310 if (audio_sample_rate) {
3311 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3312 av_dict_set(&format_opts, "sample_rate", buf, 0);
3314 if (audio_channels) {
3315 snprintf(buf, sizeof(buf), "%d", audio_channels);
3316 av_dict_set(&format_opts, "channels", buf, 0);
3318 if (frame_rate.num) {
3319 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3320 av_dict_set(&format_opts, "framerate", buf, 0);
3322 if (frame_width && frame_height) {
3323 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3324 av_dict_set(&format_opts, "video_size", buf, 0);
3326 if (frame_pix_fmt != PIX_FMT_NONE)
3327 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3329 ic->video_codec_id =
3330 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3331 ic->audio_codec_id =
3332 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3333 ic->subtitle_codec_id=
3334 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3335 ic->flags |= AVFMT_FLAG_NONBLOCK;
3337 /* open the input file with generic libav function */
3338 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3340 print_error(filename, err);
3343 assert_avoptions(format_opts);
3348 for(i=0; i<ic->nb_streams; i++){
3349 ic->streams[i]->discard= AVDISCARD_ALL;
3351 for(i=0; i<ic->nb_programs; i++){
3352 AVProgram *p= ic->programs[i];
3353 if(p->id != opt_programid){
3354 p->discard = AVDISCARD_ALL;
3357 for(j=0; j<p->nb_stream_indexes; j++){
3358 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3363 fprintf(stderr, "Specified program id not found\n");
3370 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3371 ic->loop_input = loop_input;
3374 /* Set AVCodecContext options for avformat_find_stream_info */
3375 opts = setup_find_stream_info_opts(ic);
3376 orig_nb_streams = ic->nb_streams;
3378 /* If not enough info to get the stream parameters, we decode the
3379 first frames to get it. (used in mpeg case for example) */
3380 ret = avformat_find_stream_info(ic, opts);
3381 if (ret < 0 && verbose >= 0) {
3382 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3383 av_close_input_file(ic);
3387 timestamp = start_time;
3388 /* add the stream start time */
3389 if (ic->start_time != AV_NOPTS_VALUE)
3390 timestamp += ic->start_time;
3392 /* if seeking requested, we execute it */
3393 if (start_time != 0) {
3394 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3396 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3397 filename, (double)timestamp / AV_TIME_BASE);
3399 /* reset seek info */
3403 /* update the current parameters so that they match the one of the input stream */
3404 for(i=0;i<ic->nb_streams;i++) {
3405 AVStream *st = ic->streams[i];
3406 AVCodecContext *dec = st->codec;
3409 dec->thread_count = thread_count;
3411 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3412 ist = &input_streams[nb_input_streams - 1];
3414 ist->file_index = nb_input_files;
3416 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3418 if (i < nb_ts_scale)
3419 ist->ts_scale = ts_scale[i];
3421 switch (dec->codec_type) {
3422 case AVMEDIA_TYPE_AUDIO:
3423 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3425 ist->dec = avcodec_find_decoder(dec->codec_id);
3427 st->discard= AVDISCARD_ALL;
3429 case AVMEDIA_TYPE_VIDEO:
3430 ist->dec= avcodec_find_decoder_by_name(video_codec_name);
3432 ist->dec = avcodec_find_decoder(dec->codec_id);
3433 rfps = ic->streams[i]->r_frame_rate.num;
3434 rfps_base = ic->streams[i]->r_frame_rate.den;
3436 dec->flags |= CODEC_FLAG_EMU_EDGE;
3439 dec->debug |= FF_DEBUG_MV;
3441 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3444 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3445 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3447 (float)rfps / rfps_base, rfps, rfps_base);
3451 st->discard= AVDISCARD_ALL;
3452 else if(video_discard)
3453 st->discard= video_discard;
3455 case AVMEDIA_TYPE_DATA:
3457 case AVMEDIA_TYPE_SUBTITLE:
3458 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3460 ist->dec = avcodec_find_decoder(dec->codec_id);
3461 if(subtitle_disable)
3462 st->discard = AVDISCARD_ALL;
3464 case AVMEDIA_TYPE_ATTACHMENT:
3465 case AVMEDIA_TYPE_UNKNOWN:
3472 /* dump the file content */
3474 av_dump_format(ic, nb_input_files, filename, 0);
3476 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3477 input_files[nb_input_files - 1].ctx = ic;
3478 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3479 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3481 top_field_first = -1;
3482 frame_rate = (AVRational){0, 0};
3483 frame_pix_fmt = PIX_FMT_NONE;
3486 audio_sample_rate = 0;
3488 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3489 av_freep(&ts_scale);
3492 for (i = 0; i < orig_nb_streams; i++)
3493 av_dict_free(&opts[i]);
3495 av_freep(&video_codec_name);
3496 av_freep(&audio_codec_name);
3497 av_freep(&subtitle_codec_name);
3503 static void check_inputs(int *has_video_ptr,
3505 int *has_subtitle_ptr,
3508 int has_video, has_audio, has_subtitle, has_data, i, j;
3509 AVFormatContext *ic;
3516 for(j=0;j<nb_input_files;j++) {
3517 ic = input_files[j].ctx;
3518 for(i=0;i<ic->nb_streams;i++) {
3519 AVCodecContext *enc = ic->streams[i]->codec;
3520 switch(enc->codec_type) {
3521 case AVMEDIA_TYPE_AUDIO:
3524 case AVMEDIA_TYPE_VIDEO:
3527 case AVMEDIA_TYPE_SUBTITLE:
3530 case AVMEDIA_TYPE_DATA:
3531 case AVMEDIA_TYPE_ATTACHMENT:
3532 case AVMEDIA_TYPE_UNKNOWN:
3540 *has_video_ptr = has_video;
3541 *has_audio_ptr = has_audio;
3542 *has_subtitle_ptr = has_subtitle;
3543 *has_data_ptr = has_data;
3546 static void new_video_stream(AVFormatContext *oc, int file_idx)
3550 AVCodecContext *video_enc;
3551 enum CodecID codec_id = CODEC_ID_NONE;
3552 AVCodec *codec= NULL;
3554 if(!video_stream_copy){
3555 if (video_codec_name) {
3556 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3557 codec = avcodec_find_encoder_by_name(video_codec_name);
3559 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3560 codec = avcodec_find_encoder(codec_id);
3564 ost = new_output_stream(oc, file_idx, codec);
3566 if (!video_stream_copy) {
3567 ost->frame_aspect_ratio = frame_aspect_ratio;
3568 frame_aspect_ratio = 0;
3570 ost->avfilter = vfilters;
3575 ost->bitstream_filters = video_bitstream_filters;
3576 video_bitstream_filters= NULL;
3578 st->codec->thread_count= thread_count;
3580 video_enc = st->codec;
3583 video_enc->codec_tag= video_codec_tag;
3585 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3586 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3589 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3590 if (video_stream_copy) {
3591 st->stream_copy = 1;
3592 video_enc->sample_aspect_ratio =
3593 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3599 ost->frame_rate = frame_rate;
3600 video_enc->codec_id = codec_id;
3602 video_enc->width = frame_width;
3603 video_enc->height = frame_height;
3604 video_enc->pix_fmt = frame_pix_fmt;
3605 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3606 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3609 video_enc->gop_size = 0;
3610 if (video_qscale || same_quality) {
3611 video_enc->flags |= CODEC_FLAG_QSCALE;
3612 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3616 video_enc->intra_matrix = intra_matrix;
3618 video_enc->inter_matrix = inter_matrix;
3620 p= video_rc_override_string;
3623 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3625 fprintf(stderr, "error parsing rc_override\n");
3628 video_enc->rc_override=
3629 av_realloc(video_enc->rc_override,
3630 sizeof(RcOverride)*(i+1));
3631 video_enc->rc_override[i].start_frame= start;
3632 video_enc->rc_override[i].end_frame = end;
3634 video_enc->rc_override[i].qscale= q;
3635 video_enc->rc_override[i].quality_factor= 1.0;
3638 video_enc->rc_override[i].qscale= 0;
3639 video_enc->rc_override[i].quality_factor= -q/100.0;
3644 video_enc->rc_override_count=i;
3645 if (!video_enc->rc_initial_buffer_occupancy)
3646 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3647 video_enc->me_threshold= me_threshold;
3648 video_enc->intra_dc_precision= intra_dc_precision - 8;
3651 video_enc->flags|= CODEC_FLAG_PSNR;
3656 video_enc->flags |= CODEC_FLAG_PASS1;
3658 video_enc->flags |= CODEC_FLAG_PASS2;
3662 if (forced_key_frames)
3663 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3665 if (video_language) {
3666 av_dict_set(&st->metadata, "language", video_language, 0);
3667 av_freep(&video_language);
3670 /* reset some key parameters */
3672 av_freep(&video_codec_name);
3673 av_freep(&forced_key_frames);
3674 video_stream_copy = 0;
3675 frame_pix_fmt = PIX_FMT_NONE;
3678 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3682 AVCodec *codec= NULL;
3683 AVCodecContext *audio_enc;
3684 enum CodecID codec_id = CODEC_ID_NONE;
3686 if(!audio_stream_copy){
3687 if (audio_codec_name) {
3688 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3689 codec = avcodec_find_encoder_by_name(audio_codec_name);
3691 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3692 codec = avcodec_find_encoder(codec_id);
3695 ost = new_output_stream(oc, file_idx, codec);
3698 ost->bitstream_filters = audio_bitstream_filters;
3699 audio_bitstream_filters= NULL;
3701 st->codec->thread_count= thread_count;
3703 audio_enc = st->codec;
3704 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3707 audio_enc->codec_tag= audio_codec_tag;
3709 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3710 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3712 if (audio_stream_copy) {
3713 st->stream_copy = 1;
3715 audio_enc->codec_id = codec_id;
3717 if (audio_qscale > QSCALE_NONE) {
3718 audio_enc->flags |= CODEC_FLAG_QSCALE;
3719 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3722 audio_enc->channels = audio_channels;
3723 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3724 audio_enc->sample_fmt = audio_sample_fmt;
3725 if (audio_sample_rate)
3726 audio_enc->sample_rate = audio_sample_rate;
3728 if (audio_language) {
3729 av_dict_set(&st->metadata, "language", audio_language, 0);
3730 av_freep(&audio_language);
3733 /* reset some key parameters */
3735 av_freep(&audio_codec_name);
3736 audio_stream_copy = 0;
3739 static void new_data_stream(AVFormatContext *oc, int file_idx)
3743 AVCodecContext *data_enc;
3745 ost = new_output_stream(oc, file_idx, NULL);
3747 data_enc = st->codec;
3748 if (!data_stream_copy) {
3749 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3753 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3756 data_enc->codec_tag= data_codec_tag;
3758 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3759 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3761 if (data_stream_copy) {
3762 st->stream_copy = 1;
3766 av_freep(&data_codec_name);
3767 data_stream_copy = 0;
3770 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3774 AVCodec *codec=NULL;
3775 AVCodecContext *subtitle_enc;
3776 enum CodecID codec_id = CODEC_ID_NONE;
3778 if(!subtitle_stream_copy){
3779 if (subtitle_codec_name) {
3780 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3781 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3783 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3784 codec = avcodec_find_encoder(codec_id);
3787 ost = new_output_stream(oc, file_idx, codec);
3789 subtitle_enc = st->codec;
3791 ost->bitstream_filters = subtitle_bitstream_filters;
3792 subtitle_bitstream_filters= NULL;
3794 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3796 if(subtitle_codec_tag)
3797 subtitle_enc->codec_tag= subtitle_codec_tag;
3799 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3800 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3802 if (subtitle_stream_copy) {
3803 st->stream_copy = 1;
3805 subtitle_enc->codec_id = codec_id;
3808 if (subtitle_language) {
3809 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3810 av_freep(&subtitle_language);
3813 subtitle_disable = 0;
3814 av_freep(&subtitle_codec_name);
3815 subtitle_stream_copy = 0;
3818 static int opt_new_stream(const char *opt, const char *arg)
3820 AVFormatContext *oc;
3821 int file_idx = nb_output_files - 1;
3822 if (nb_output_files <= 0) {
3823 fprintf(stderr, "At least one output file must be specified\n");
3826 oc = output_files[file_idx];
3828 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3829 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3830 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3831 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3836 /* arg format is "output-stream-index:streamid-value". */
3837 static int opt_streamid(const char *opt, const char *arg)
3843 av_strlcpy(idx_str, arg, sizeof(idx_str));
3844 p = strchr(idx_str, ':');
3847 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3852 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3853 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3854 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3858 static int opt_output_file(const char *opt, const char *filename)
3860 AVFormatContext *oc;
3861 int err, use_video, use_audio, use_subtitle, use_data;
3862 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3863 AVOutputFormat *file_oformat;
3865 if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3866 fprintf(stderr, "Too many output files\n");
3870 if (!strcmp(filename, "-"))
3873 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3874 last_asked_format = NULL;
3876 print_error(filename, err);
3879 file_oformat= oc->oformat;
3881 if (!strcmp(file_oformat->name, "ffm") &&
3882 av_strstart(filename, "http:", NULL)) {
3883 /* special case for files sent to ffserver: we get the stream
3884 parameters from ffserver */
3885 int err = read_ffserver_streams(oc, filename);
3887 print_error(filename, err);
3891 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3892 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3893 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3894 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 */
3896 /* disable if no corresponding type found */
3897 check_inputs(&input_has_video,
3899 &input_has_subtitle,
3902 if (!input_has_video)
3904 if (!input_has_audio)
3906 if (!input_has_subtitle)
3908 if (!input_has_data)
3911 /* manual disable */
3912 if (audio_disable) use_audio = 0;
3913 if (video_disable) use_video = 0;
3914 if (subtitle_disable) use_subtitle = 0;
3915 if (data_disable) use_data = 0;
3917 if (use_video) new_video_stream(oc, nb_output_files);
3918 if (use_audio) new_audio_stream(oc, nb_output_files);
3919 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3920 if (use_data) new_data_stream(oc, nb_output_files);
3922 av_dict_copy(&oc->metadata, metadata, 0);
3923 av_dict_free(&metadata);
3926 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3927 output_files[nb_output_files++] = oc;
3929 /* check filename in case of an image number is expected */
3930 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3931 if (!av_filename_number_test(oc->filename)) {
3932 print_error(oc->filename, AVERROR(EINVAL));
3937 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3938 /* test if it already exists to avoid loosing precious files */
3939 if (!file_overwrite &&
3940 (strchr(filename, ':') == NULL ||
3941 filename[1] == ':' ||
3942 av_strstart(filename, "file:", NULL))) {
3943 if (avio_check(filename, 0) == 0) {
3945 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3947 if (!read_yesno()) {
3948 fprintf(stderr, "Not overwriting - exiting\n");
3953 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3960 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3961 print_error(filename, err);
3966 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3967 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3969 if (loop_output >= 0) {
3970 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3971 oc->loop_output = loop_output;
3973 oc->flags |= AVFMT_FLAG_NONBLOCK;
3975 frame_rate = (AVRational){0, 0};
3978 audio_sample_rate = 0;
3980 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3982 av_freep(&forced_key_frames);
3988 /* same option as mencoder */
3989 static int opt_pass(const char *opt, const char *arg)
3991 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3995 static int64_t getutime(void)
3998 struct rusage rusage;
4000 getrusage(RUSAGE_SELF, &rusage);
4001 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4002 #elif HAVE_GETPROCESSTIMES
4004 FILETIME c, e, k, u;
4005 proc = GetCurrentProcess();
4006 GetProcessTimes(proc, &c, &e, &k, &u);
4007 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4009 return av_gettime();
4013 static int64_t getmaxrss(void)
4015 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4016 struct rusage rusage;
4017 getrusage(RUSAGE_SELF, &rusage);
4018 return (int64_t)rusage.ru_maxrss * 1024;
4019 #elif HAVE_GETPROCESSMEMORYINFO
4021 PROCESS_MEMORY_COUNTERS memcounters;
4022 proc = GetCurrentProcess();
4023 memcounters.cb = sizeof(memcounters);
4024 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4025 return memcounters.PeakPagefileUsage;
4031 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4034 const char *p = str;
4041 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4048 static int opt_inter_matrix(const char *opt, const char *arg)
4050 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4051 parse_matrix_coeffs(inter_matrix, arg);
4055 static int opt_intra_matrix(const char *opt, const char *arg)
4057 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4058 parse_matrix_coeffs(intra_matrix, arg);
4062 static void show_usage(void)
4064 printf("Hyper fast Audio and Video encoder\n");
4065 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4069 static int opt_help(const char *opt, const char *arg)
4072 AVOutputFormat *oformat = NULL;
4073 AVInputFormat *iformat = NULL;
4075 av_log_set_callback(log_callback_help);
4077 show_help_options(options, "Main options:\n",
4078 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4079 show_help_options(options, "\nAdvanced options:\n",
4080 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4082 show_help_options(options, "\nVideo options:\n",
4083 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4085 show_help_options(options, "\nAdvanced Video options:\n",
4086 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4087 OPT_VIDEO | OPT_EXPERT);
4088 show_help_options(options, "\nAudio options:\n",
4089 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4091 show_help_options(options, "\nAdvanced Audio options:\n",
4092 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4093 OPT_AUDIO | OPT_EXPERT);
4094 show_help_options(options, "\nSubtitle options:\n",
4095 OPT_SUBTITLE | OPT_GRAB,
4097 show_help_options(options, "\nAudio/Video grab options:\n",
4101 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4104 /* individual codec options */
4106 while ((c = av_codec_next(c))) {
4107 if (c->priv_class) {
4108 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4113 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4116 /* individual muxer options */
4117 while ((oformat = av_oformat_next(oformat))) {
4118 if (oformat->priv_class) {
4119 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4124 /* individual demuxer options */
4125 while ((iformat = av_iformat_next(iformat))) {
4126 if (iformat->priv_class) {
4127 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4132 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4136 static int opt_target(const char *opt, const char *arg)
4138 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4139 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4141 if(!strncmp(arg, "pal-", 4)) {
4144 } else if(!strncmp(arg, "ntsc-", 5)) {
4147 } else if(!strncmp(arg, "film-", 5)) {
4152 /* Calculate FR via float to avoid int overflow */
4153 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4156 } else if((fr == 29970) || (fr == 23976)) {
4159 /* Try to determine PAL/NTSC by peeking in the input files */
4160 if(nb_input_files) {
4162 for (j = 0; j < nb_input_files; j++) {
4163 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4164 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4165 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4167 fr = c->time_base.den * 1000 / c->time_base.num;
4171 } else if((fr == 29970) || (fr == 23976)) {
4181 if(verbose > 0 && norm != UNKNOWN)
4182 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4185 if(norm == UNKNOWN) {
4186 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4187 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4188 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4192 if(!strcmp(arg, "vcd")) {
4193 opt_codec("vcodec", "mpeg1video");
4194 opt_codec("acodec", "mp2");
4195 opt_format("f", "vcd");
4197 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4198 opt_frame_rate("r", frame_rates[norm]);
4199 opt_default("g", norm == PAL ? "15" : "18");
4201 opt_default("b", "1150000");
4202 opt_default("maxrate", "1150000");
4203 opt_default("minrate", "1150000");
4204 opt_default("bufsize", "327680"); // 40*1024*8;
4206 opt_default("ab", "224000");
4207 audio_sample_rate = 44100;
4210 opt_default("packetsize", "2324");
4211 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4213 /* We have to offset the PTS, so that it is consistent with the SCR.
4214 SCR starts at 36000, but the first two packs contain only padding
4215 and the first pack from the other stream, respectively, may also have
4216 been written before.
4217 So the real data starts at SCR 36000+3*1200. */
4218 mux_preload= (36000+3*1200) / 90000.0; //0.44
4219 } else if(!strcmp(arg, "svcd")) {
4221 opt_codec("vcodec", "mpeg2video");
4222 opt_codec("acodec", "mp2");
4223 opt_format("f", "svcd");
4225 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4226 opt_frame_rate("r", frame_rates[norm]);
4227 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4228 opt_default("g", norm == PAL ? "15" : "18");
4230 opt_default("b", "2040000");
4231 opt_default("maxrate", "2516000");
4232 opt_default("minrate", "0"); //1145000;
4233 opt_default("bufsize", "1835008"); //224*1024*8;
4234 opt_default("flags", "+scan_offset");
4237 opt_default("ab", "224000");
4238 audio_sample_rate = 44100;
4240 opt_default("packetsize", "2324");
4242 } else if(!strcmp(arg, "dvd")) {
4244 opt_codec("vcodec", "mpeg2video");
4245 opt_codec("acodec", "ac3");
4246 opt_format("f", "dvd");
4248 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4249 opt_frame_rate("r", frame_rates[norm]);
4250 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4251 opt_default("g", norm == PAL ? "15" : "18");
4253 opt_default("b", "6000000");
4254 opt_default("maxrate", "9000000");
4255 opt_default("minrate", "0"); //1500000;
4256 opt_default("bufsize", "1835008"); //224*1024*8;
4258 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4259 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4261 opt_default("ab", "448000");
4262 audio_sample_rate = 48000;
4264 } else if(!strncmp(arg, "dv", 2)) {
4266 opt_format("f", "dv");
4268 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4269 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4270 norm == PAL ? "yuv420p" : "yuv411p");
4271 opt_frame_rate("r", frame_rates[norm]);
4273 audio_sample_rate = 48000;
4277 fprintf(stderr, "Unknown target: %s\n", arg);
4278 return AVERROR(EINVAL);
4283 static int opt_vstats_file(const char *opt, const char *arg)
4285 av_free (vstats_filename);
4286 vstats_filename=av_strdup (arg);
4290 static int opt_vstats(const char *opt, const char *arg)
4293 time_t today2 = time(NULL);
4294 struct tm *today = localtime(&today2);
4296 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4298 return opt_vstats_file(opt, filename);
4301 static int opt_bsf(const char *opt, const char *arg)
4303 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4304 AVBitStreamFilterContext **bsfp;
4307 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4311 bsfp= *opt == 'v' ? &video_bitstream_filters :
4312 *opt == 'a' ? &audio_bitstream_filters :
4313 &subtitle_bitstream_filters;
4315 bsfp= &(*bsfp)->next;
4322 static int opt_preset(const char *opt, const char *arg)
4325 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4326 char *codec_name = *opt == 'v' ? video_codec_name :
4327 *opt == 'a' ? audio_codec_name :
4328 subtitle_codec_name;
4330 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4331 fprintf(stderr, "File for preset '%s' not found\n", arg);
4336 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4337 if(line[0] == '#' && !e)
4339 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4341 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4344 if (!strcmp(tmp, "acodec") ||
4345 !strcmp(tmp, "vcodec") ||
4346 !strcmp(tmp, "scodec") ||
4347 !strcmp(tmp, "dcodec")) {
4348 opt_codec(tmp, tmp2);
4349 }else if(opt_default(tmp, tmp2) < 0){
4350 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4360 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4364 static int opt_passlogfile(const char *opt, const char *arg)
4366 pass_logfilename_prefix = arg;
4367 opt_default("passlogfile", arg);
4371 static const OptionDef options[] = {
4373 #include "cmdutils_common_opts.h"
4374 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4375 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4376 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4377 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4378 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4379 "outfile[,metadata]:infile[,metadata]" },
4380 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4381 "outfile[,metadata]:infile[,metadata]" },
4382 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4383 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4384 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4385 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4386 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4387 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4388 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4389 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4390 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4391 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4392 "add timings for benchmarking" },
4393 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4394 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4395 "dump each input packet" },
4396 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4397 "when dumping packets, also dump the payload" },
4398 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4399 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4400 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4401 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4402 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4403 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4404 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4405 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4406 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4407 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4408 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4409 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4410 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4411 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4412 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4413 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4416 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4417 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4418 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4419 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4420 { "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" },
4421 { "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" },
4422 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4423 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4424 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4425 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4426 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4427 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4428 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4429 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4430 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4431 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4432 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4433 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4434 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4435 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4436 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4437 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4438 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4439 "use same quantizer as source (implies VBR)" },
4440 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4441 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4442 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4443 "deinterlace pictures" },
4444 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4445 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4446 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4448 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4450 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4451 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4452 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4453 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4454 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4455 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4456 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4457 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4458 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4459 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4460 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4463 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4464 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4465 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4466 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4467 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4468 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4469 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4470 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4471 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4472 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4473 { "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" },
4475 /* subtitle options */
4476 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4477 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4478 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4479 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4480 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4483 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4484 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4485 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4488 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4489 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4491 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4492 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4493 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4495 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4496 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4497 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4498 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4499 /* data codec support */
4500 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4502 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4506 int main(int argc, char **argv)
4510 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4512 if(argc>1 && !strcmp(argv[1], "-d")){
4515 av_log_set_callback(log_callback_null);
4520 avcodec_register_all();
4522 avdevice_register_all();
4525 avfilter_register_all();
4530 if(isatty(STDIN_FILENO))
4531 avio_set_interrupt_cb(decode_interrupt_cb);
4540 parse_options(argc, argv, options, opt_output_file);
4542 if(nb_output_files <= 0 && nb_input_files == 0) {
4544 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4548 /* file converter / grab */
4549 if (nb_output_files <= 0) {
4550 fprintf(stderr, "At least one output file must be specified\n");
4554 if (nb_input_files == 0) {
4555 fprintf(stderr, "At least one input file must be specified\n");
4560 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4561 stream_maps, nb_stream_maps) < 0)
4563 ti = getutime() - ti;
4565 int maxrss = getmaxrss() / 1024;
4566 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4569 return ffmpeg_exit(0);