3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavutil/audioconvert.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/libm.h"
48 #include "libavformat/os_support.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
74 #include <sys/ioctl.h>
84 #include "libavutil/avassert.h"
86 const char program_name[] = "FFmpeg";
87 const int program_birth_year = 2000;
89 /* select an input stream for an output stream */
90 typedef struct AVStreamMap {
94 int sync_stream_index;
98 * select an input file for an output file
100 typedef struct AVMetaDataMap {
101 int file; //< file index
102 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103 int index; //< stream/chapter/program number
106 typedef struct AVChapterMap {
111 static const OptionDef options[];
113 #define MAX_FILES 100
114 #if !FF_API_MAX_STREAMS
115 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static AVFormatContext *input_files[MAX_FILES];
120 static int64_t input_files_ts_offset[MAX_FILES];
121 static double *input_files_ts_scale[MAX_FILES] = {NULL};
122 static AVCodec **input_codecs = NULL;
123 static int nb_input_files = 0;
124 static int nb_input_codecs = 0;
125 static int nb_input_files_ts_scale[MAX_FILES] = {0};
127 static AVFormatContext *output_files[MAX_FILES];
128 static AVCodec **output_codecs = NULL;
129 static int nb_output_files = 0;
130 static int nb_output_codecs = 0;
132 static AVStreamMap *stream_maps = NULL;
133 static int nb_stream_maps;
135 /* first item specifies output metadata, second is input */
136 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137 static int nb_meta_data_maps;
138 static int metadata_global_autocopy = 1;
139 static int metadata_streams_autocopy = 1;
140 static int metadata_chapters_autocopy = 1;
142 static AVChapterMap *chapter_maps = NULL;
143 static int nb_chapter_maps;
145 /* indexed by output file stream index */
146 static int *streamid_map = NULL;
147 static int nb_streamid_map = 0;
149 static int frame_width = 0;
150 static int frame_height = 0;
151 static float frame_aspect_ratio = 0;
152 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155 static AVRational frame_rate;
156 static float video_qscale = 0;
157 static uint16_t *intra_matrix = NULL;
158 static uint16_t *inter_matrix = NULL;
159 static const char *video_rc_override_string=NULL;
160 static int video_disable = 0;
161 static int video_discard = 0;
162 static char *video_codec_name = NULL;
163 static unsigned int video_codec_tag = 0;
164 static char *video_language = NULL;
165 static int same_quality = 0;
166 static int do_deinterlace = 0;
167 static int top_field_first = -1;
168 static int me_threshold = 0;
169 static int intra_dc_precision = 8;
170 static int loop_input = 0;
171 static int loop_output = AVFMT_NOOUTPUTLOOP;
172 static int qp_hist = 0;
174 static char *vfilters = NULL;
175 static AVFilterGraph *graph = NULL;
178 static int intra_only = 0;
179 static int audio_sample_rate = 44100;
180 static int64_t channel_layout = 0;
181 #define QSCALE_NONE -99999
182 static float audio_qscale = QSCALE_NONE;
183 static int audio_disable = 0;
184 static int audio_channels = 1;
185 static char *audio_codec_name = NULL;
186 static unsigned int audio_codec_tag = 0;
187 static char *audio_language = NULL;
189 static int subtitle_disable = 0;
190 static char *subtitle_codec_name = NULL;
191 static char *subtitle_language = NULL;
192 static unsigned int subtitle_codec_tag = 0;
194 static float mux_preload= 0.5;
195 static float mux_max_delay= 0.7;
197 static int64_t recording_time = INT64_MAX;
198 static int64_t start_time = 0;
199 static int64_t recording_timestamp = 0;
200 static int64_t input_ts_offset = 0;
201 static int file_overwrite = 0;
202 static AVMetadata *metadata;
203 static int do_benchmark = 0;
204 static int do_hex_dump = 0;
205 static int do_pkt_dump = 0;
206 static int do_psnr = 0;
207 static int do_pass = 0;
208 static char *pass_logfilename_prefix = NULL;
209 static int audio_stream_copy = 0;
210 static int video_stream_copy = 0;
211 static int subtitle_stream_copy = 0;
212 static int video_sync_method= -1;
213 static int audio_sync_method= 0;
214 static float audio_drift_threshold= 0.1;
215 static int copy_ts= 0;
217 static int opt_shortest = 0;
218 static int video_global_header = 0;
219 static char *vstats_filename;
220 static FILE *vstats_file;
221 static int opt_programid = 0;
222 static int copy_initial_nonkeyframes = 0;
224 static int rate_emu = 0;
226 static int video_channel = 0;
227 static char *video_standard;
229 static int audio_volume = 256;
231 static int exit_on_error = 0;
232 static int using_stdin = 0;
233 static int verbose = 1;
234 static int thread_count= 1;
235 static int q_pressed = 0;
236 static int64_t video_size = 0;
237 static int64_t audio_size = 0;
238 static int64_t extra_size = 0;
239 static int nb_frames_dup = 0;
240 static int nb_frames_drop = 0;
241 static int input_sync;
242 static uint64_t limit_filesize = 0;
243 static int force_fps = 0;
244 static char *forced_key_frames = NULL;
246 static float dts_delta_threshold = 10;
248 static unsigned int sws_flags = SWS_BICUBIC;
250 static int64_t timer_start;
252 static uint8_t *audio_buf;
253 static uint8_t *audio_out;
254 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
256 static short *samples;
258 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
260 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
262 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
264 struct AVInputStream;
266 typedef struct AVOutputStream {
267 int file_index; /* file index */
268 int index; /* stream index in the output file */
269 int source_index; /* AVInputStream index */
270 AVStream *st; /* stream in the output file */
271 int encoding_needed; /* true if encoding needed for this stream */
273 /* input pts and corresponding output pts
275 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
276 struct AVInputStream *sync_ist; /* input stream to sync against */
277 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
278 AVBitStreamFilterContext *bitstream_filters;
281 AVFrame pict_tmp; /* temporary image for resampling */
282 struct SwsContext *img_resample_ctx; /* for image resampling */
285 int resample_pix_fmt;
287 /* full frame size of first frame */
291 /* forced key frames */
292 int64_t *forced_kf_pts;
298 ReSampleContext *resample; /* for audio resampling */
299 int resample_sample_fmt;
300 int resample_channels;
301 int resample_sample_rate;
303 AVAudioConvert *reformat_ctx;
304 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
308 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
311 typedef struct AVInputStream {
315 int discard; /* true if stream data should be discarded */
316 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
317 int64_t sample_index; /* current sample */
319 int64_t start; /* time when read started */
320 int64_t next_pts; /* synthetic pts for cases where pkt.pts
322 int64_t pts; /* current pts */
323 PtsCorrectionContext pts_ctx;
324 int is_start; /* is 1 at the start and after a discontinuity */
325 int showed_multi_packet_warning;
326 int is_past_recording_time;
328 AVFilterContext *output_video_filter;
329 AVFilterContext *input_video_filter;
330 AVFrame *filter_frame;
331 int has_filter_frame;
332 AVFilterBufferRef *picref;
336 typedef struct AVInputFile {
337 int eof_reached; /* true if eof reached */
338 int ist_index; /* index of first stream in ist_table */
339 int buffer_size; /* current total buffer size */
340 int nb_streams; /* nb streams we are aware of */
345 /* init terminal so that we can grab keys */
346 static struct termios oldtty;
351 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
353 AVFilterContext *last_filter, *filter;
354 /** filter graph containing all filters including input & output */
355 AVCodecContext *codec = ost->st->codec;
356 AVCodecContext *icodec = ist->st->codec;
357 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
361 graph = avfilter_graph_alloc();
363 snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
364 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
365 ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
366 "src", args, NULL, graph);
369 ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
370 "out", NULL, &ffsink_ctx, graph);
373 last_filter = ist->input_video_filter;
375 if (codec->width != icodec->width || codec->height != icodec->height) {
376 snprintf(args, 255, "%d:%d:flags=0x%X",
379 (int)av_get_int(sws_opts, "sws_flags", NULL));
380 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
381 NULL, args, NULL, graph)) < 0)
383 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
385 last_filter = filter;
388 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
389 graph->scale_sws_opts = av_strdup(args);
392 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
395 outputs->name = av_strdup("in");
396 outputs->filter_ctx = last_filter;
397 outputs->pad_idx = 0;
398 outputs->next = NULL;
400 inputs->name = av_strdup("out");
401 inputs->filter_ctx = ist->output_video_filter;
405 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
409 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
413 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
416 codec->width = ist->output_video_filter->inputs[0]->w;
417 codec->height = ist->output_video_filter->inputs[0]->h;
421 #endif /* CONFIG_AVFILTER */
423 static void term_exit(void)
425 av_log(NULL, AV_LOG_QUIET, "");
427 tcsetattr (0, TCSANOW, &oldtty);
431 static volatile int received_sigterm = 0;
434 sigterm_handler(int sig)
436 received_sigterm = sig;
440 static void term_init(void)
449 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
450 |INLCR|IGNCR|ICRNL|IXON);
451 tty.c_oflag |= OPOST;
452 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
453 tty.c_cflag &= ~(CSIZE|PARENB);
458 tcsetattr (0, TCSANOW, &tty);
459 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
462 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
463 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
465 signal(SIGXCPU, sigterm_handler);
469 /* read a key without blocking */
470 static int read_key(void)
482 n = select(1, &rfds, NULL, NULL, &tv);
497 static int decode_interrupt_cb(void)
499 return q_pressed || (q_pressed = read_key() == 'q');
502 static int ffmpeg_exit(int ret)
507 for(i=0;i<nb_output_files;i++) {
508 AVFormatContext *s = output_files[i];
509 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
511 avformat_free_context(s);
512 av_free(output_streams_for_file[i]);
514 for(i=0;i<nb_input_files;i++) {
515 av_close_input_file(input_files[i]);
516 av_free(input_files_ts_scale[i]);
519 av_free(intra_matrix);
520 av_free(inter_matrix);
524 av_free(vstats_filename);
526 av_free(streamid_map);
527 av_free(input_codecs);
528 av_free(output_codecs);
529 av_free(stream_maps);
530 av_free(meta_data_maps);
532 av_free(video_codec_name);
533 av_free(audio_codec_name);
534 av_free(subtitle_codec_name);
536 av_free(video_standard);
541 allocated_audio_buf_size= allocated_audio_out_size= 0;
548 if (received_sigterm) {
550 "Received signal %d: terminating.\n",
551 (int) received_sigterm);
555 exit(ret); /* not all OS-es handle main() return value */
559 /* similar to ff_dynarray_add() and av_fast_realloc() */
560 static void *grow_array(void *array, int elem_size, int *size, int new_size)
562 if (new_size >= INT_MAX / elem_size) {
563 fprintf(stderr, "Array too big.\n");
566 if (*size < new_size) {
567 uint8_t *tmp = av_realloc(array, new_size*elem_size);
569 fprintf(stderr, "Could not alloc buffer.\n");
572 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
579 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
581 if(codec && codec->sample_fmts){
582 const enum AVSampleFormat *p= codec->sample_fmts;
584 if(*p == st->codec->sample_fmt)
588 av_log(NULL, AV_LOG_WARNING,
589 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
590 av_get_sample_fmt_name(st->codec->sample_fmt),
592 av_get_sample_fmt_name(codec->sample_fmts[0]));
593 st->codec->sample_fmt = codec->sample_fmts[0];
598 static void choose_sample_rate(AVStream *st, AVCodec *codec)
600 if(codec && codec->supported_samplerates){
601 const int *p= codec->supported_samplerates;
603 int best_dist=INT_MAX;
605 int dist= abs(st->codec->sample_rate - *p);
606 if(dist < best_dist){
612 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
614 st->codec->sample_rate= best;
618 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
620 if(codec && codec->pix_fmts){
621 const enum PixelFormat *p= codec->pix_fmts;
622 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
623 if(st->codec->codec_id==CODEC_ID_MJPEG){
624 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
625 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
626 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};
630 if(*p == st->codec->pix_fmt)
634 st->codec->pix_fmt = codec->pix_fmts[0];
638 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
640 int idx = oc->nb_streams - 1;
643 output_streams_for_file[file_idx] =
644 grow_array(output_streams_for_file[file_idx],
645 sizeof(*output_streams_for_file[file_idx]),
646 &nb_output_streams_for_file[file_idx],
648 ost = output_streams_for_file[file_idx][idx] =
649 av_mallocz(sizeof(AVOutputStream));
651 fprintf(stderr, "Could not alloc output stream\n");
654 ost->file_index = file_idx;
659 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
665 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
668 /* copy stream format */
670 for(i=0;i<ic->nb_streams;i++) {
676 // FIXME: a more elegant solution is needed
677 st = av_mallocz(sizeof(AVStream));
678 memcpy(st, ic->streams[i], sizeof(AVStream));
679 st->codec = avcodec_alloc_context();
681 print_error(filename, AVERROR(ENOMEM));
684 avcodec_copy_context(st->codec, ic->streams[i]->codec);
687 codec = avcodec_find_encoder(st->codec->codec_id);
688 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
689 if (audio_stream_copy) {
692 choose_sample_fmt(st, codec);
693 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
694 if (video_stream_copy) {
697 choose_pixel_fmt(st, codec);
700 if(st->codec->flags & CODEC_FLAG_BITEXACT)
703 new_output_stream(s, nb_output_files);
707 s->timestamp = av_gettime();
709 av_close_input_file(ic);
714 get_sync_ipts(const AVOutputStream *ost)
716 const AVInputStream *ist = ost->sync_ist;
717 return (double)(ist->pts - start_time)/AV_TIME_BASE;
720 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
724 AVPacket new_pkt= *pkt;
725 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
726 &new_pkt.data, &new_pkt.size,
727 pkt->data, pkt->size,
728 pkt->flags & AV_PKT_FLAG_KEY);
731 new_pkt.destruct= av_destruct_packet;
733 fprintf(stderr, "%s failed for stream %d, codec %s",
734 bsfc->filter->name, pkt->stream_index,
735 avctx->codec ? avctx->codec->name : "copy");
745 ret= av_interleaved_write_frame(s, pkt);
747 print_error("av_interleaved_write_frame()", ret);
752 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
754 static void do_audio_out(AVFormatContext *s,
757 unsigned char *buf, int size)
760 int64_t audio_out_size, audio_buf_size;
761 int64_t allocated_for_size= size;
763 int size_out, frame_bytes, ret, resample_changed;
764 AVCodecContext *enc= ost->st->codec;
765 AVCodecContext *dec= ist->st->codec;
766 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
767 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
768 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
771 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
772 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
773 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
774 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
775 audio_buf_size*= osize*enc->channels;
777 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
778 if(coded_bps > 8*osize)
779 audio_out_size= audio_out_size * coded_bps / (8*osize);
780 audio_out_size += FF_MIN_BUFFER_SIZE;
782 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
783 fprintf(stderr, "Buffer sizes too large\n");
787 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
788 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
789 if (!audio_buf || !audio_out){
790 fprintf(stderr, "Out of memory in do_audio_out\n");
794 if (enc->channels != dec->channels)
795 ost->audio_resample = 1;
797 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
798 ost->resample_channels != dec->channels ||
799 ost->resample_sample_rate != dec->sample_rate;
801 if ((ost->audio_resample && !ost->resample) || resample_changed) {
802 if (resample_changed) {
803 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",
804 ist->file_index, ist->index,
805 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
806 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
807 ost->resample_sample_fmt = dec->sample_fmt;
808 ost->resample_channels = dec->channels;
809 ost->resample_sample_rate = dec->sample_rate;
811 audio_resample_close(ost->resample);
813 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
814 if (audio_sync_method <= 1 &&
815 ost->resample_sample_fmt == enc->sample_fmt &&
816 ost->resample_channels == enc->channels &&
817 ost->resample_sample_rate == enc->sample_rate) {
818 ost->resample = NULL;
819 ost->audio_resample = 0;
821 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
822 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
823 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
824 enc->sample_rate, dec->sample_rate,
825 enc->sample_fmt, dec->sample_fmt,
827 if (!ost->resample) {
828 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
829 dec->channels, dec->sample_rate,
830 enc->channels, enc->sample_rate);
836 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
837 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
838 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
839 if (ost->reformat_ctx)
840 av_audio_convert_free(ost->reformat_ctx);
841 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
842 dec->sample_fmt, 1, NULL, 0);
843 if (!ost->reformat_ctx) {
844 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
845 av_get_sample_fmt_name(dec->sample_fmt),
846 av_get_sample_fmt_name(enc->sample_fmt));
849 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
852 if(audio_sync_method){
853 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
854 - av_fifo_size(ost->fifo)/(enc->channels * 2);
855 double idelta= delta*dec->sample_rate / enc->sample_rate;
856 int byte_delta= ((int)idelta)*2*dec->channels;
858 //FIXME resample delay
859 if(fabs(delta) > 50){
860 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
862 byte_delta= FFMAX(byte_delta, -size);
866 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
871 static uint8_t *input_tmp= NULL;
872 input_tmp= av_realloc(input_tmp, byte_delta + size);
874 if(byte_delta > allocated_for_size - size){
875 allocated_for_size= byte_delta + (int64_t)size;
880 memset(input_tmp, 0, byte_delta);
881 memcpy(input_tmp + byte_delta, buf, size);
885 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
887 }else if(audio_sync_method>1){
888 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
889 av_assert0(ost->audio_resample);
891 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
892 // 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));
893 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
897 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
898 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
900 if (ost->audio_resample) {
902 size_out = audio_resample(ost->resample,
903 (short *)buftmp, (short *)buf,
904 size / (dec->channels * isize));
905 size_out = size_out * enc->channels * osize;
911 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
912 const void *ibuf[6]= {buftmp};
913 void *obuf[6]= {audio_buf};
914 int istride[6]= {isize};
915 int ostride[6]= {osize};
916 int len= size_out/istride[0];
917 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
918 printf("av_audio_convert() failed\n");
924 size_out = len*osize;
927 /* now encode as many frames as possible */
928 if (enc->frame_size > 1) {
929 /* output resampled raw samples */
930 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
931 fprintf(stderr, "av_fifo_realloc2() failed\n");
934 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
936 frame_bytes = enc->frame_size * osize * enc->channels;
938 while (av_fifo_size(ost->fifo) >= frame_bytes) {
940 av_init_packet(&pkt);
942 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
944 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
946 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
949 fprintf(stderr, "Audio encoding failed\n");
953 pkt.stream_index= ost->index;
956 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
957 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
958 pkt.flags |= AV_PKT_FLAG_KEY;
959 write_frame(s, &pkt, enc, ost->bitstream_filters);
961 ost->sync_opts += enc->frame_size;
965 av_init_packet(&pkt);
967 ost->sync_opts += size_out / (osize * enc->channels);
969 /* output a pcm frame */
970 /* determine the size of the coded buffer */
973 size_out = size_out*coded_bps/8;
975 if(size_out > audio_out_size){
976 fprintf(stderr, "Internal error, buffer size too small\n");
980 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
981 ret = avcodec_encode_audio(enc, audio_out, size_out,
984 fprintf(stderr, "Audio encoding failed\n");
988 pkt.stream_index= ost->index;
991 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
992 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
993 pkt.flags |= AV_PKT_FLAG_KEY;
994 write_frame(s, &pkt, enc, ost->bitstream_filters);
998 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1000 AVCodecContext *dec;
1001 AVPicture *picture2;
1002 AVPicture picture_tmp;
1005 dec = ist->st->codec;
1007 /* deinterlace : must be done before any resize */
1008 if (do_deinterlace) {
1011 /* create temporary picture */
1012 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1013 buf = av_malloc(size);
1017 picture2 = &picture_tmp;
1018 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1020 if(avpicture_deinterlace(picture2, picture,
1021 dec->pix_fmt, dec->width, dec->height) < 0) {
1022 /* if error, do not deinterlace */
1023 fprintf(stderr, "Deinterlacing failed\n");
1032 if (picture != picture2)
1033 *picture = *picture2;
1037 /* we begin to correct av delay at this threshold */
1038 #define AV_DELAY_MAX 0.100
1040 static void do_subtitle_out(AVFormatContext *s,
1041 AVOutputStream *ost,
1046 static uint8_t *subtitle_out = NULL;
1047 int subtitle_out_max_size = 1024 * 1024;
1048 int subtitle_out_size, nb, i;
1049 AVCodecContext *enc;
1052 if (pts == AV_NOPTS_VALUE) {
1053 fprintf(stderr, "Subtitle packets must have a pts\n");
1059 enc = ost->st->codec;
1061 if (!subtitle_out) {
1062 subtitle_out = av_malloc(subtitle_out_max_size);
1065 /* Note: DVB subtitle need one packet to draw them and one other
1066 packet to clear them */
1067 /* XXX: signal it in the codec context ? */
1068 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1073 for(i = 0; i < nb; i++) {
1074 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1075 // start_display_time is required to be 0
1076 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1077 sub->end_display_time -= sub->start_display_time;
1078 sub->start_display_time = 0;
1079 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1080 subtitle_out_max_size, sub);
1081 if (subtitle_out_size < 0) {
1082 fprintf(stderr, "Subtitle encoding failed\n");
1086 av_init_packet(&pkt);
1087 pkt.stream_index = ost->index;
1088 pkt.data = subtitle_out;
1089 pkt.size = subtitle_out_size;
1090 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1091 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1092 /* XXX: the pts correction is handled here. Maybe handling
1093 it in the codec would be better */
1095 pkt.pts += 90 * sub->start_display_time;
1097 pkt.pts += 90 * sub->end_display_time;
1099 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1103 static int bit_buffer_size= 1024*256;
1104 static uint8_t *bit_buffer= NULL;
1106 static void do_video_out(AVFormatContext *s,
1107 AVOutputStream *ost,
1109 AVFrame *in_picture,
1112 int nb_frames, i, ret;
1113 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1114 AVCodecContext *enc, *dec;
1117 enc = ost->st->codec;
1118 dec = ist->st->codec;
1120 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1122 /* by default, we output a single frame */
1127 if(video_sync_method){
1128 double vdelta = sync_ipts - ost->sync_opts;
1129 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1132 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1135 }else if(vdelta>0.6)
1136 ost->sync_opts= lrintf(sync_ipts);
1137 }else if (vdelta > 1.1)
1138 nb_frames = lrintf(vdelta);
1139 //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);
1140 if (nb_frames == 0){
1143 fprintf(stderr, "*** drop!\n");
1144 }else if (nb_frames > 1) {
1145 nb_frames_dup += nb_frames - 1;
1147 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1150 ost->sync_opts= lrintf(sync_ipts);
1152 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1156 formatted_picture = in_picture;
1157 final_picture = formatted_picture;
1158 padding_src = formatted_picture;
1159 resampling_dst = &ost->pict_tmp;
1161 if ( ost->resample_height != ist->st->codec->height
1162 || ost->resample_width != ist->st->codec->width
1163 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1165 fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1166 if(!ost->video_resample)
1170 #if !CONFIG_AVFILTER
1171 if (ost->video_resample) {
1173 final_picture = &ost->pict_tmp;
1174 if( ost->resample_height != ist->st->codec->height
1175 || ost->resample_width != ist->st->codec->width
1176 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1178 /* initialize a new scaler context */
1179 sws_freeContext(ost->img_resample_ctx);
1180 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1181 ost->img_resample_ctx = sws_getContext(
1182 ist->st->codec->width,
1183 ist->st->codec->height,
1184 ist->st->codec->pix_fmt,
1185 ost->st->codec->width,
1186 ost->st->codec->height,
1187 ost->st->codec->pix_fmt,
1188 sws_flags, NULL, NULL, NULL);
1189 if (ost->img_resample_ctx == NULL) {
1190 fprintf(stderr, "Cannot get resampling context\n");
1194 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1195 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1199 /* duplicates frame if needed */
1200 for(i=0;i<nb_frames;i++) {
1202 av_init_packet(&pkt);
1203 pkt.stream_index= ost->index;
1205 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1206 /* raw pictures are written as AVPicture structure to
1207 avoid any copies. We support temorarily the older
1209 AVFrame* old_frame = enc->coded_frame;
1210 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1211 pkt.data= (uint8_t *)final_picture;
1212 pkt.size= sizeof(AVPicture);
1213 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1214 pkt.flags |= AV_PKT_FLAG_KEY;
1216 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1217 enc->coded_frame = old_frame;
1219 AVFrame big_picture;
1221 big_picture= *final_picture;
1222 /* better than nothing: use input picture interlaced
1224 big_picture.interlaced_frame = in_picture->interlaced_frame;
1225 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1226 if(top_field_first == -1)
1227 big_picture.top_field_first = in_picture->top_field_first;
1229 big_picture.top_field_first = top_field_first;
1232 /* handles sameq here. This is not correct because it may
1233 not be a global option */
1234 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1236 big_picture.pict_type = 0;
1237 // big_picture.pts = AV_NOPTS_VALUE;
1238 big_picture.pts= ost->sync_opts;
1239 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1240 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1241 if (ost->forced_kf_index < ost->forced_kf_count &&
1242 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1243 big_picture.pict_type = FF_I_TYPE;
1244 ost->forced_kf_index++;
1246 ret = avcodec_encode_video(enc,
1247 bit_buffer, bit_buffer_size,
1250 fprintf(stderr, "Video encoding failed\n");
1255 pkt.data= bit_buffer;
1257 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1258 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1259 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1260 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1261 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1263 if(enc->coded_frame->key_frame)
1264 pkt.flags |= AV_PKT_FLAG_KEY;
1265 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1268 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1269 // enc->frame_number-1, ret, enc->pict_type);
1270 /* if two pass, output log */
1271 if (ost->logfile && enc->stats_out) {
1272 fprintf(ost->logfile, "%s", enc->stats_out);
1277 ost->frame_number++;
1281 static double psnr(double d){
1282 return -10.0*log(d)/log(10.0);
1285 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1288 AVCodecContext *enc;
1290 double ti1, bitrate, avg_bitrate;
1292 /* this is executed just the first time do_video_stats is called */
1294 vstats_file = fopen(vstats_filename, "w");
1301 enc = ost->st->codec;
1302 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1303 frame_number = ost->frame_number;
1304 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1305 if (enc->flags&CODEC_FLAG_PSNR)
1306 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1308 fprintf(vstats_file,"f_size= %6d ", frame_size);
1309 /* compute pts value */
1310 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1314 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1315 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1316 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1317 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1318 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1322 static void print_report(AVFormatContext **output_files,
1323 AVOutputStream **ost_table, int nb_ostreams,
1327 AVOutputStream *ost;
1328 AVFormatContext *oc;
1330 AVCodecContext *enc;
1331 int frame_number, vid, i;
1332 double bitrate, ti1, pts;
1333 static int64_t last_time = -1;
1334 static int qp_histogram[52];
1336 if (!is_last_report) {
1338 /* display the report every 0.5 seconds */
1339 cur_time = av_gettime();
1340 if (last_time == -1) {
1341 last_time = cur_time;
1344 if ((cur_time - last_time) < 500000)
1346 last_time = cur_time;
1350 oc = output_files[0];
1352 total_size = avio_size(oc->pb);
1353 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1354 total_size= avio_tell(oc->pb);
1359 for(i=0;i<nb_ostreams;i++) {
1361 enc = ost->st->codec;
1362 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1363 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1364 !ost->st->stream_copy ?
1365 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1367 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1368 float t = (av_gettime()-timer_start) / 1000000.0;
1370 frame_number = ost->frame_number;
1371 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1372 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1373 !ost->st->stream_copy ?
1374 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1376 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1379 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1380 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1383 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1385 if (enc->flags&CODEC_FLAG_PSNR){
1387 double error, error_sum=0;
1388 double scale, scale_sum=0;
1389 char type[3]= {'Y','U','V'};
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1393 error= enc->error[j];
1394 scale= enc->width*enc->height*255.0*255.0*frame_number;
1396 error= enc->coded_frame->error[j];
1397 scale= enc->width*enc->height*255.0*255.0;
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1404 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1408 /* compute min output value */
1409 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1410 if ((pts < ti1) && (pts > 0))
1416 if (verbose || is_last_report) {
1417 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1420 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1421 (double)total_size / 1024, ti1, bitrate);
1423 if (nb_frames_dup || nb_frames_drop)
1424 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1425 nb_frames_dup, nb_frames_drop);
1428 fprintf(stderr, "%s \r", buf);
1433 if (is_last_report && verbose >= 0){
1434 int64_t raw= audio_size + video_size + extra_size;
1435 fprintf(stderr, "\n");
1436 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1440 100.0*(total_size - raw)/raw
1445 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1446 static int output_packet(AVInputStream *ist, int ist_index,
1447 AVOutputStream **ost_table, int nb_ostreams,
1448 const AVPacket *pkt)
1450 AVFormatContext *os;
1451 AVOutputStream *ost;
1455 void *buffer_to_free;
1456 static unsigned int samples_size= 0;
1457 AVSubtitle subtitle, *subtitle_to_free;
1458 int64_t pkt_pts = AV_NOPTS_VALUE;
1460 int frame_available;
1464 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1466 if(ist->next_pts == AV_NOPTS_VALUE)
1467 ist->next_pts= ist->pts;
1471 av_init_packet(&avpkt);
1479 if(pkt->dts != AV_NOPTS_VALUE)
1480 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1481 if(pkt->pts != AV_NOPTS_VALUE)
1482 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1484 //while we have more to decode or while the decoder did output something on EOF
1485 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1486 uint8_t *data_buf, *decoded_data_buf;
1487 int data_size, decoded_data_size;
1489 ist->pts= ist->next_pts;
1491 if(avpkt.size && avpkt.size != pkt->size &&
1492 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1493 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1494 ist->showed_multi_packet_warning=1;
1497 /* decode the packet if needed */
1498 decoded_data_buf = NULL; /* fail safe */
1499 decoded_data_size= 0;
1500 data_buf = avpkt.data;
1501 data_size = avpkt.size;
1502 subtitle_to_free = NULL;
1503 if (ist->decoding_needed) {
1504 switch(ist->st->codec->codec_type) {
1505 case AVMEDIA_TYPE_AUDIO:{
1506 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1507 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1509 samples= av_malloc(samples_size);
1511 decoded_data_size= samples_size;
1512 /* XXX: could avoid copy if PCM 16 bits with same
1513 endianness as CPU */
1514 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1521 /* Some bug in mpeg audio decoder gives */
1522 /* decoded_data_size < 0, it seems they are overflows */
1523 if (decoded_data_size <= 0) {
1524 /* no audio frame */
1527 decoded_data_buf = (uint8_t *)samples;
1528 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1529 (ist->st->codec->sample_rate * ist->st->codec->channels);
1531 case AVMEDIA_TYPE_VIDEO:
1532 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1533 /* XXX: allocate picture correctly */
1534 avcodec_get_frame_defaults(&picture);
1535 avpkt.pts = pkt_pts;
1536 avpkt.dts = ist->pts;
1537 pkt_pts = AV_NOPTS_VALUE;
1539 ret = avcodec_decode_video2(ist->st->codec,
1540 &picture, &got_picture, &avpkt);
1541 ist->st->quality= picture.quality;
1545 /* no picture yet */
1546 goto discard_packet;
1548 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1549 if (ist->st->codec->time_base.num != 0) {
1550 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1551 ist->next_pts += ((int64_t)AV_TIME_BASE *
1552 ist->st->codec->time_base.num * ticks) /
1553 ist->st->codec->time_base.den;
1557 case AVMEDIA_TYPE_SUBTITLE:
1558 ret = avcodec_decode_subtitle2(ist->st->codec,
1559 &subtitle, &got_picture, &avpkt);
1563 goto discard_packet;
1565 subtitle_to_free = &subtitle;
1572 switch(ist->st->codec->codec_type) {
1573 case AVMEDIA_TYPE_AUDIO:
1574 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1575 ist->st->codec->sample_rate;
1577 case AVMEDIA_TYPE_VIDEO:
1578 if (ist->st->codec->time_base.num != 0) {
1579 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1580 ist->next_pts += ((int64_t)AV_TIME_BASE *
1581 ist->st->codec->time_base.num * ticks) /
1582 ist->st->codec->time_base.den;
1590 buffer_to_free = NULL;
1591 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1592 pre_process_video_frame(ist, (AVPicture *)&picture,
1597 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1599 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1600 else sar = ist->st->codec->sample_aspect_ratio;
1601 // add it to be filtered
1602 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1608 // preprocess audio (volume)
1609 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1610 if (audio_volume != 256) {
1613 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1614 int v = ((*volp) * audio_volume + 128) >> 8;
1615 if (v < -32768) v = -32768;
1616 if (v > 32767) v = 32767;
1622 /* frame rate emulation */
1624 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1625 int64_t now = av_gettime() - ist->start;
1630 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1631 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1633 /* if output time reached then transcode raw format,
1634 encode packets and output them */
1635 if (start_time == 0 || ist->pts >= start_time)
1637 while (frame_available) {
1638 AVRational ist_pts_tb;
1639 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1640 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1642 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1644 for(i=0;i<nb_ostreams;i++) {
1648 if (ost->source_index == ist_index) {
1649 os = output_files[ost->file_index];
1651 /* set the input output pts pairs */
1652 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1654 if (ost->encoding_needed) {
1655 av_assert0(ist->decoding_needed);
1656 switch(ost->st->codec->codec_type) {
1657 case AVMEDIA_TYPE_AUDIO:
1658 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1660 case AVMEDIA_TYPE_VIDEO:
1662 if (ist->picref->video)
1663 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1665 do_video_out(os, ost, ist, &picture, &frame_size);
1666 if (vstats_filename && frame_size)
1667 do_video_stats(os, ost, frame_size);
1669 case AVMEDIA_TYPE_SUBTITLE:
1670 do_subtitle_out(os, ost, ist, &subtitle,
1677 AVFrame avframe; //FIXME/XXX remove this
1679 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1681 av_init_packet(&opkt);
1683 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1686 /* no reencoding needed : output the packet directly */
1687 /* force the input stream PTS */
1689 avcodec_get_frame_defaults(&avframe);
1690 ost->st->codec->coded_frame= &avframe;
1691 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1693 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1694 audio_size += data_size;
1695 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1696 video_size += data_size;
1700 opkt.stream_index= ost->index;
1701 if(pkt->pts != AV_NOPTS_VALUE)
1702 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1704 opkt.pts= AV_NOPTS_VALUE;
1706 if (pkt->dts == AV_NOPTS_VALUE)
1707 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1709 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1710 opkt.dts -= ost_tb_start_time;
1712 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1713 opkt.flags= pkt->flags;
1715 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1716 if( ost->st->codec->codec_id != CODEC_ID_H264
1717 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1718 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1720 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1721 opkt.destruct= av_destruct_packet;
1723 opkt.data = data_buf;
1724 opkt.size = data_size;
1727 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1728 ost->st->codec->frame_number++;
1729 ost->frame_number++;
1730 av_free_packet(&opkt);
1736 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1737 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1739 avfilter_unref_buffer(ist->picref);
1742 av_free(buffer_to_free);
1743 /* XXX: allocate the subtitles in the codec ? */
1744 if (subtitle_to_free) {
1745 avsubtitle_free(subtitle_to_free);
1746 subtitle_to_free = NULL;
1753 for(i=0;i<nb_ostreams;i++) {
1755 if (ost->source_index == ist_index) {
1756 AVCodecContext *enc= ost->st->codec;
1757 os = output_files[ost->file_index];
1759 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1761 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1764 if (ost->encoding_needed) {
1768 av_init_packet(&pkt);
1769 pkt.stream_index= ost->index;
1771 switch(ost->st->codec->codec_type) {
1772 case AVMEDIA_TYPE_AUDIO:
1773 fifo_bytes = av_fifo_size(ost->fifo);
1775 /* encode any samples remaining in fifo */
1776 if (fifo_bytes > 0) {
1777 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1778 int fs_tmp = enc->frame_size;
1780 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1781 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1782 enc->frame_size = fifo_bytes / (osize * enc->channels);
1784 int frame_bytes = enc->frame_size*osize*enc->channels;
1785 if (allocated_audio_buf_size < frame_bytes)
1787 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1790 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1791 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1792 ost->st->time_base.num, enc->sample_rate);
1793 enc->frame_size = fs_tmp;
1796 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1799 fprintf(stderr, "Audio encoding failed\n");
1803 pkt.flags |= AV_PKT_FLAG_KEY;
1805 case AVMEDIA_TYPE_VIDEO:
1806 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1808 fprintf(stderr, "Video encoding failed\n");
1812 if(enc->coded_frame && enc->coded_frame->key_frame)
1813 pkt.flags |= AV_PKT_FLAG_KEY;
1814 if (ost->logfile && enc->stats_out) {
1815 fprintf(ost->logfile, "%s", enc->stats_out);
1824 pkt.data= bit_buffer;
1826 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1827 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1828 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1840 static void print_sdp(AVFormatContext **avc, int n)
1844 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1845 printf("SDP:\n%s\n", sdp);
1849 static int copy_chapters(int infile, int outfile)
1851 AVFormatContext *is = input_files[infile];
1852 AVFormatContext *os = output_files[outfile];
1855 for (i = 0; i < is->nb_chapters; i++) {
1856 AVChapter *in_ch = is->chapters[i], *out_ch;
1857 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1858 AV_TIME_BASE_Q, in_ch->time_base);
1859 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1860 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1863 if (in_ch->end < ts_off)
1865 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1868 out_ch = av_mallocz(sizeof(AVChapter));
1870 return AVERROR(ENOMEM);
1872 out_ch->id = in_ch->id;
1873 out_ch->time_base = in_ch->time_base;
1874 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1875 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1877 if (metadata_chapters_autocopy)
1878 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1881 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1883 return AVERROR(ENOMEM);
1884 os->chapters[os->nb_chapters - 1] = out_ch;
1889 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1890 AVCodecContext *avctx)
1896 for (p = kf; *p; p++)
1899 ost->forced_kf_count = n;
1900 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1901 if (!ost->forced_kf_pts) {
1902 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1905 for (i = 0; i < n; i++) {
1906 p = i ? strchr(p, ',') + 1 : kf;
1907 t = parse_time_or_die("force_key_frames", p, 1);
1908 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1913 * The following code is the main loop of the file converter
1915 static int transcode(AVFormatContext **output_files,
1916 int nb_output_files,
1917 AVFormatContext **input_files,
1919 AVStreamMap *stream_maps, int nb_stream_maps)
1921 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1922 AVFormatContext *is, *os;
1923 AVCodecContext *codec, *icodec;
1924 AVOutputStream *ost, **ost_table = NULL;
1925 AVInputStream *ist, **ist_table = NULL;
1926 AVInputFile *file_table;
1930 uint8_t no_packet[MAX_FILES]={0};
1931 int no_packet_count=0;
1933 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1937 /* input stream init */
1939 for(i=0;i<nb_input_files;i++) {
1940 is = input_files[i];
1941 file_table[i].ist_index = j;
1942 file_table[i].nb_streams = is->nb_streams;
1943 j += is->nb_streams;
1947 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1951 for(i=0;i<nb_istreams;i++) {
1952 ist = av_mallocz(sizeof(AVInputStream));
1958 for(i=0;i<nb_input_files;i++) {
1959 is = input_files[i];
1960 for(k=0;k<is->nb_streams;k++) {
1961 ist = ist_table[j++];
1962 ist->st = is->streams[k];
1963 ist->file_index = i;
1965 ist->discard = 1; /* the stream is discarded by default
1969 ist->start = av_gettime();
1974 /* output stream init */
1976 for(i=0;i<nb_output_files;i++) {
1977 os = output_files[i];
1978 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1979 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1980 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1981 ret = AVERROR(EINVAL);
1984 nb_ostreams += os->nb_streams;
1986 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1987 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1988 ret = AVERROR(EINVAL);
1992 /* Sanity check the mapping args -- do the input files & streams exist? */
1993 for(i=0;i<nb_stream_maps;i++) {
1994 int fi = stream_maps[i].file_index;
1995 int si = stream_maps[i].stream_index;
1997 if (fi < 0 || fi > nb_input_files - 1 ||
1998 si < 0 || si > file_table[fi].nb_streams - 1) {
1999 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2000 ret = AVERROR(EINVAL);
2003 fi = stream_maps[i].sync_file_index;
2004 si = stream_maps[i].sync_stream_index;
2005 if (fi < 0 || fi > nb_input_files - 1 ||
2006 si < 0 || si > file_table[fi].nb_streams - 1) {
2007 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2008 ret = AVERROR(EINVAL);
2013 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2017 for(k=0;k<nb_output_files;k++) {
2018 os = output_files[k];
2019 for(i=0;i<os->nb_streams;i++,n++) {
2021 ost = ost_table[n] = output_streams_for_file[k][i];
2022 ost->st = os->streams[i];
2023 if (nb_stream_maps > 0) {
2024 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2025 stream_maps[n].stream_index;
2027 /* Sanity check that the stream types match */
2028 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2029 int i= ost->file_index;
2030 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2031 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2032 stream_maps[n].file_index, stream_maps[n].stream_index,
2033 ost->file_index, ost->index);
2038 int best_nb_frames=-1;
2039 /* get corresponding input stream index : we select the first one with the right type */
2041 for(j=0;j<nb_istreams;j++) {
2046 AVFormatContext *f= input_files[ ist->file_index ];
2048 for(pi=0; pi<f->nb_programs; pi++){
2049 AVProgram *p= f->programs[pi];
2050 if(p->id == opt_programid)
2051 for(si=0; si<p->nb_stream_indexes; si++){
2052 if(f->streams[ p->stream_index[si] ] == ist->st)
2057 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2058 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2059 if(best_nb_frames < ist->st->codec_info_nb_frames){
2060 best_nb_frames= ist->st->codec_info_nb_frames;
2061 ost->source_index = j;
2068 if(! opt_programid) {
2069 /* try again and reuse existing stream */
2070 for(j=0;j<nb_istreams;j++) {
2072 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2073 && ist->st->discard != AVDISCARD_ALL) {
2074 ost->source_index = j;
2080 int i= ost->file_index;
2081 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2082 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2083 ost->file_index, ost->index);
2088 ist = ist_table[ost->source_index];
2090 ost->sync_ist = (nb_stream_maps > 0) ?
2091 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2092 stream_maps[n].sync_stream_index] : ist;
2096 /* for each output stream, we compute the right encoding parameters */
2097 for(i=0;i<nb_ostreams;i++) {
2099 os = output_files[ost->file_index];
2100 ist = ist_table[ost->source_index];
2102 codec = ost->st->codec;
2103 icodec = ist->st->codec;
2105 if (metadata_streams_autocopy)
2106 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2107 AV_METADATA_DONT_OVERWRITE);
2109 ost->st->disposition = ist->st->disposition;
2110 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2111 codec->chroma_sample_location = icodec->chroma_sample_location;
2113 if (ost->st->stream_copy) {
2114 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2116 if (extra_size > INT_MAX)
2119 /* if stream_copy is selected, no need to decode or encode */
2120 codec->codec_id = icodec->codec_id;
2121 codec->codec_type = icodec->codec_type;
2123 if(!codec->codec_tag){
2124 if( !os->oformat->codec_tag
2125 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2126 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2127 codec->codec_tag = icodec->codec_tag;
2130 codec->bit_rate = icodec->bit_rate;
2131 codec->rc_max_rate = icodec->rc_max_rate;
2132 codec->rc_buffer_size = icodec->rc_buffer_size;
2133 codec->extradata= av_mallocz(extra_size);
2134 if (!codec->extradata)
2136 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2137 codec->extradata_size= icodec->extradata_size;
2138 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){
2139 codec->time_base = icodec->time_base;
2140 codec->time_base.num *= icodec->ticks_per_frame;
2141 av_reduce(&codec->time_base.num, &codec->time_base.den,
2142 codec->time_base.num, codec->time_base.den, INT_MAX);
2144 codec->time_base = ist->st->time_base;
2145 switch(codec->codec_type) {
2146 case AVMEDIA_TYPE_AUDIO:
2147 if(audio_volume != 256) {
2148 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2151 codec->channel_layout = icodec->channel_layout;
2152 codec->sample_rate = icodec->sample_rate;
2153 codec->channels = icodec->channels;
2154 codec->frame_size = icodec->frame_size;
2155 codec->block_align= icodec->block_align;
2156 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2157 codec->block_align= 0;
2158 if(codec->codec_id == CODEC_ID_AC3)
2159 codec->block_align= 0;
2161 case AVMEDIA_TYPE_VIDEO:
2162 codec->pix_fmt = icodec->pix_fmt;
2163 codec->width = icodec->width;
2164 codec->height = icodec->height;
2165 codec->has_b_frames = icodec->has_b_frames;
2167 case AVMEDIA_TYPE_SUBTITLE:
2168 codec->width = icodec->width;
2169 codec->height = icodec->height;
2175 switch(codec->codec_type) {
2176 case AVMEDIA_TYPE_AUDIO:
2177 ost->fifo= av_fifo_alloc(1024);
2180 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2181 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2182 icodec->request_channels = codec->channels;
2183 ist->decoding_needed = 1;
2184 ost->encoding_needed = 1;
2185 ost->resample_sample_fmt = icodec->sample_fmt;
2186 ost->resample_sample_rate = icodec->sample_rate;
2187 ost->resample_channels = icodec->channels;
2189 case AVMEDIA_TYPE_VIDEO:
2190 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2191 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2194 ost->video_resample = (codec->width != icodec->width ||
2195 codec->height != icodec->height ||
2196 (codec->pix_fmt != icodec->pix_fmt));
2197 if (ost->video_resample) {
2198 #if !CONFIG_AVFILTER
2199 avcodec_get_frame_defaults(&ost->pict_tmp);
2200 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2201 codec->width, codec->height)) {
2202 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2205 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2206 ost->img_resample_ctx = sws_getContext(
2213 sws_flags, NULL, NULL, NULL);
2214 if (ost->img_resample_ctx == NULL) {
2215 fprintf(stderr, "Cannot get resampling context\n");
2219 ost->original_height = icodec->height;
2220 ost->original_width = icodec->width;
2222 codec->bits_per_raw_sample= 0;
2224 ost->resample_height = icodec->height;
2225 ost->resample_width = icodec->width;
2226 ost->resample_pix_fmt= icodec->pix_fmt;
2227 ost->encoding_needed = 1;
2228 ist->decoding_needed = 1;
2231 if (configure_filters(ist, ost)) {
2232 fprintf(stderr, "Error opening filters!\n");
2237 case AVMEDIA_TYPE_SUBTITLE:
2238 ost->encoding_needed = 1;
2239 ist->decoding_needed = 1;
2246 if (ost->encoding_needed &&
2247 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2248 char logfilename[1024];
2251 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2252 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2254 if (codec->flags & CODEC_FLAG_PASS1) {
2255 f = fopen(logfilename, "wb");
2257 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2263 size_t logbuffer_size;
2264 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2265 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2268 codec->stats_in = logbuffer;
2272 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2273 int size= codec->width * codec->height;
2274 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2279 bit_buffer = av_malloc(bit_buffer_size);
2281 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2283 ret = AVERROR(ENOMEM);
2287 /* open each encoder */
2288 for(i=0;i<nb_ostreams;i++) {
2290 if (ost->encoding_needed) {
2291 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2292 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2294 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2296 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2297 ost->st->codec->codec_id, ost->file_index, ost->index);
2298 ret = AVERROR(EINVAL);
2301 if (dec->subtitle_header) {
2302 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2303 if (!ost->st->codec->subtitle_header) {
2304 ret = AVERROR(ENOMEM);
2307 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2308 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2310 if (avcodec_open(ost->st->codec, codec) < 0) {
2311 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2312 ost->file_index, ost->index);
2313 ret = AVERROR(EINVAL);
2316 extra_size += ost->st->codec->extradata_size;
2320 /* open each decoder */
2321 for(i=0;i<nb_istreams;i++) {
2323 if (ist->decoding_needed) {
2324 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2326 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2328 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2329 ist->st->codec->codec_id, ist->file_index, ist->index);
2330 ret = AVERROR(EINVAL);
2333 if (avcodec_open(ist->st->codec, codec) < 0) {
2334 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2335 ist->file_index, ist->index);
2336 ret = AVERROR(EINVAL);
2339 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2340 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2345 for(i=0;i<nb_istreams;i++) {
2349 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2350 ist->next_pts = AV_NOPTS_VALUE;
2351 init_pts_correction(&ist->pts_ctx);
2355 /* set meta data information from input file if required */
2356 for (i=0;i<nb_meta_data_maps;i++) {
2357 AVFormatContext *files[2];
2358 AVMetadata **meta[2];
2361 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2362 if ((index) < 0 || (index) >= (nb_elems)) {\
2363 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2365 ret = AVERROR(EINVAL);\
2369 int out_file_index = meta_data_maps[i][0].file;
2370 int in_file_index = meta_data_maps[i][1].file;
2371 if (in_file_index < 0 || out_file_index < 0)
2373 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2374 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2376 files[0] = output_files[out_file_index];
2377 files[1] = input_files[in_file_index];
2379 for (j = 0; j < 2; j++) {
2380 AVMetaDataMap *map = &meta_data_maps[i][j];
2382 switch (map->type) {
2384 meta[j] = &files[j]->metadata;
2387 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2388 meta[j] = &files[j]->streams[map->index]->metadata;
2391 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2392 meta[j] = &files[j]->chapters[map->index]->metadata;
2395 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2396 meta[j] = &files[j]->programs[map->index]->metadata;
2401 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2404 /* copy global metadata by default */
2405 if (metadata_global_autocopy) {
2407 for (i = 0; i < nb_output_files; i++)
2408 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2409 AV_METADATA_DONT_OVERWRITE);
2412 /* copy chapters according to chapter maps */
2413 for (i = 0; i < nb_chapter_maps; i++) {
2414 int infile = chapter_maps[i].in_file;
2415 int outfile = chapter_maps[i].out_file;
2417 if (infile < 0 || outfile < 0)
2419 if (infile >= nb_input_files) {
2420 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2421 ret = AVERROR(EINVAL);
2424 if (outfile >= nb_output_files) {
2425 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2426 ret = AVERROR(EINVAL);
2429 copy_chapters(infile, outfile);
2432 /* copy chapters from the first input file that has them*/
2433 if (!nb_chapter_maps)
2434 for (i = 0; i < nb_input_files; i++) {
2435 if (!input_files[i]->nb_chapters)
2438 for (j = 0; j < nb_output_files; j++)
2439 if ((ret = copy_chapters(i, j)) < 0)
2444 /* open files and write file headers */
2445 for(i=0;i<nb_output_files;i++) {
2446 os = output_files[i];
2447 if (av_write_header(os) < 0) {
2448 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2449 ret = AVERROR(EINVAL);
2452 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2458 /* dump the file output parameters - cannot be done before in case
2460 for(i=0;i<nb_output_files;i++) {
2461 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2464 /* dump the stream mapping */
2466 fprintf(stderr, "Stream mapping:\n");
2467 for(i=0;i<nb_ostreams;i++) {
2469 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2470 ist_table[ost->source_index]->file_index,
2471 ist_table[ost->source_index]->index,
2474 if (ost->sync_ist != ist_table[ost->source_index])
2475 fprintf(stderr, " [sync #%d.%d]",
2476 ost->sync_ist->file_index,
2477 ost->sync_ist->index);
2478 fprintf(stderr, "\n");
2483 fprintf(stderr, "%s\n", error);
2488 print_sdp(output_files, nb_output_files);
2491 if (!using_stdin && verbose >= 0) {
2492 fprintf(stderr, "Press [q] to stop encoding\n");
2493 url_set_interrupt_cb(decode_interrupt_cb);
2497 timer_start = av_gettime();
2499 for(; received_sigterm == 0;) {
2500 int file_index, ist_index;
2508 /* if 'q' pressed, exits */
2512 /* read_key() returns 0 on EOF */
2518 /* select the stream that we must read now by looking at the
2519 smallest output pts */
2521 for(i=0;i<nb_ostreams;i++) {
2524 os = output_files[ost->file_index];
2525 ist = ist_table[ost->source_index];
2526 if(ist->is_past_recording_time || no_packet[ist->file_index])
2528 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2529 ipts = (double)ist->pts;
2530 if (!file_table[ist->file_index].eof_reached){
2531 if(ipts < ipts_min) {
2533 if(input_sync ) file_index = ist->file_index;
2535 if(opts < opts_min) {
2537 if(!input_sync) file_index = ist->file_index;
2540 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2545 /* if none, if is finished */
2546 if (file_index < 0) {
2547 if(no_packet_count){
2549 memset(no_packet, 0, sizeof(no_packet));
2556 /* finish if limit size exhausted */
2557 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2560 /* read a frame from it and output it in the fifo */
2561 is = input_files[file_index];
2562 ret= av_read_frame(is, &pkt);
2563 if(ret == AVERROR(EAGAIN)){
2564 no_packet[file_index]=1;
2569 file_table[file_index].eof_reached = 1;
2577 memset(no_packet, 0, sizeof(no_packet));
2580 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2581 is->streams[pkt.stream_index]);
2583 /* the following test is needed in case new streams appear
2584 dynamically in stream : we ignore them */
2585 if (pkt.stream_index >= file_table[file_index].nb_streams)
2586 goto discard_packet;
2587 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2588 ist = ist_table[ist_index];
2590 goto discard_packet;
2592 if (pkt.dts != AV_NOPTS_VALUE)
2593 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2594 if (pkt.pts != AV_NOPTS_VALUE)
2595 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2597 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2598 && input_files_ts_scale[file_index][pkt.stream_index]){
2599 if(pkt.pts != AV_NOPTS_VALUE)
2600 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2601 if(pkt.dts != AV_NOPTS_VALUE)
2602 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2605 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2606 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2607 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2608 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2609 int64_t delta= pkt_dts - ist->next_pts;
2610 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2611 input_files_ts_offset[ist->file_index]-= delta;
2613 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2614 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2615 if(pkt.pts != AV_NOPTS_VALUE)
2616 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2620 /* finish if recording time exhausted */
2621 if (recording_time != INT64_MAX &&
2622 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2623 ist->is_past_recording_time = 1;
2624 goto discard_packet;
2627 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2628 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2631 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2632 ist->file_index, ist->index);
2635 av_free_packet(&pkt);
2640 av_free_packet(&pkt);
2642 /* dump report by using the output first video and audio streams */
2643 print_report(output_files, ost_table, nb_ostreams, 0);
2646 /* at the end of stream, we must flush the decoder buffers */
2647 for(i=0;i<nb_istreams;i++) {
2649 if (ist->decoding_needed) {
2650 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2656 /* write the trailer if needed and close file */
2657 for(i=0;i<nb_output_files;i++) {
2658 os = output_files[i];
2659 av_write_trailer(os);
2662 /* dump report by using the first video and audio streams */
2663 print_report(output_files, ost_table, nb_ostreams, 1);
2665 /* close each encoder */
2666 for(i=0;i<nb_ostreams;i++) {
2668 if (ost->encoding_needed) {
2669 av_freep(&ost->st->codec->stats_in);
2670 avcodec_close(ost->st->codec);
2674 /* close each decoder */
2675 for(i=0;i<nb_istreams;i++) {
2677 if (ist->decoding_needed) {
2678 avcodec_close(ist->st->codec);
2682 avfilter_graph_free(&graph);
2689 av_freep(&bit_buffer);
2690 av_free(file_table);
2693 for(i=0;i<nb_istreams;i++) {
2700 for(i=0;i<nb_ostreams;i++) {
2703 if (ost->st->stream_copy)
2704 av_freep(&ost->st->codec->extradata);
2706 fclose(ost->logfile);
2707 ost->logfile = NULL;
2709 av_fifo_free(ost->fifo); /* works even if fifo is not
2710 initialized but set to zero */
2711 av_freep(&ost->st->codec->subtitle_header);
2712 av_free(ost->pict_tmp.data[0]);
2713 av_free(ost->forced_kf_pts);
2714 if (ost->video_resample)
2715 sws_freeContext(ost->img_resample_ctx);
2717 audio_resample_close(ost->resample);
2718 if (ost->reformat_ctx)
2719 av_audio_convert_free(ost->reformat_ctx);
2728 static void opt_format(const char *arg)
2730 last_asked_format = arg;
2733 static void opt_video_rc_override_string(const char *arg)
2735 video_rc_override_string = arg;
2738 static int opt_me_threshold(const char *opt, const char *arg)
2740 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2744 static int opt_verbose(const char *opt, const char *arg)
2746 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2750 static int opt_frame_rate(const char *opt, const char *arg)
2752 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2753 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2759 static int opt_bitrate(const char *opt, const char *arg)
2761 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2763 opt_default(opt, arg);
2765 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2766 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2771 static int opt_frame_crop(const char *opt, const char *arg)
2773 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2774 return AVERROR(EINVAL);
2777 static void opt_frame_size(const char *arg)
2779 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2780 fprintf(stderr, "Incorrect frame size\n");
2785 static int opt_pad(const char *opt, const char *arg) {
2786 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2790 static void opt_frame_pix_fmt(const char *arg)
2792 if (strcmp(arg, "list")) {
2793 frame_pix_fmt = av_get_pix_fmt(arg);
2794 if (frame_pix_fmt == PIX_FMT_NONE) {
2795 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2804 static void opt_frame_aspect_ratio(const char *arg)
2811 p = strchr(arg, ':');
2813 x = strtol(arg, &end, 10);
2815 y = strtol(end+1, &end, 10);
2817 ar = (double)x / (double)y;
2819 ar = strtod(arg, NULL);
2822 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2825 frame_aspect_ratio = ar;
2828 static int opt_metadata(const char *opt, const char *arg)
2830 char *mid= strchr(arg, '=');
2833 fprintf(stderr, "Missing =\n");
2838 av_metadata_set2(&metadata, arg, mid, 0);
2843 static void opt_qscale(const char *arg)
2845 video_qscale = atof(arg);
2846 if (video_qscale <= 0 ||
2847 video_qscale > 255) {
2848 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2853 static void opt_top_field_first(const char *arg)
2855 top_field_first= atoi(arg);
2858 static int opt_thread_count(const char *opt, const char *arg)
2860 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2863 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2868 static void opt_audio_sample_fmt(const char *arg)
2870 if (strcmp(arg, "list")) {
2871 audio_sample_fmt = av_get_sample_fmt(arg);
2872 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2873 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2877 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2882 static int opt_audio_rate(const char *opt, const char *arg)
2884 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2888 static int opt_audio_channels(const char *opt, const char *arg)
2890 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2894 static void opt_video_channel(const char *arg)
2896 video_channel = strtol(arg, NULL, 0);
2899 static void opt_video_standard(const char *arg)
2901 video_standard = av_strdup(arg);
2904 static void opt_codec(int *pstream_copy, char **pcodec_name,
2905 int codec_type, const char *arg)
2907 av_freep(pcodec_name);
2908 if (!strcmp(arg, "copy")) {
2911 *pcodec_name = av_strdup(arg);
2915 static void opt_audio_codec(const char *arg)
2917 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2920 static void opt_video_codec(const char *arg)
2922 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2925 static void opt_subtitle_codec(const char *arg)
2927 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2930 static int opt_codec_tag(const char *opt, const char *arg)
2933 uint32_t *codec_tag;
2935 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2936 !strcmp(opt, "vtag") ? &video_codec_tag :
2937 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2941 *codec_tag = strtol(arg, &tail, 0);
2943 *codec_tag = AV_RL32(arg);
2948 static void opt_map(const char *arg)
2953 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2954 m = &stream_maps[nb_stream_maps-1];
2956 m->file_index = strtol(arg, &p, 0);
2960 m->stream_index = strtol(p, &p, 0);
2963 m->sync_file_index = strtol(p, &p, 0);
2966 m->sync_stream_index = strtol(p, &p, 0);
2968 m->sync_file_index = m->file_index;
2969 m->sync_stream_index = m->stream_index;
2973 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2984 *index = strtol(++arg, endptr, 0);
2987 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2994 static void opt_map_metadata(const char *arg)
2996 AVMetaDataMap *m, *m1;
2999 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3000 &nb_meta_data_maps, nb_meta_data_maps + 1);
3002 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3003 m->file = strtol(arg, &p, 0);
3004 parse_meta_type(p, &m->type, &m->index, &p);
3008 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3009 m1->file = strtol(p, &p, 0);
3010 parse_meta_type(p, &m1->type, &m1->index, &p);
3012 if (m->type == 'g' || m1->type == 'g')
3013 metadata_global_autocopy = 0;
3014 if (m->type == 's' || m1->type == 's')
3015 metadata_streams_autocopy = 0;
3016 if (m->type == 'c' || m1->type == 'c')
3017 metadata_chapters_autocopy = 0;
3020 static void opt_map_meta_data(const char *arg)
3022 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3023 "Use -map_metadata instead.\n");
3024 opt_map_metadata(arg);
3027 static void opt_map_chapters(const char *arg)
3032 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3033 nb_chapter_maps + 1);
3034 c = &chapter_maps[nb_chapter_maps - 1];
3035 c->out_file = strtol(arg, &p, 0);
3039 c->in_file = strtol(p, &p, 0);
3042 static void opt_input_ts_scale(const char *arg)
3044 unsigned int stream;
3048 stream = strtol(arg, &p, 0);
3051 scale= strtod(p, &p);
3053 if(stream >= MAX_STREAMS)
3056 input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3057 input_files_ts_scale[nb_input_files][stream]= scale;
3060 static int opt_recording_time(const char *opt, const char *arg)
3062 recording_time = parse_time_or_die(opt, arg, 1);
3066 static int opt_start_time(const char *opt, const char *arg)
3068 start_time = parse_time_or_die(opt, arg, 1);
3072 static int opt_recording_timestamp(const char *opt, const char *arg)
3074 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3078 static int opt_input_ts_offset(const char *opt, const char *arg)
3080 input_ts_offset = parse_time_or_die(opt, arg, 1);
3084 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3086 const char *codec_string = encoder ? "encoder" : "decoder";
3090 return CODEC_ID_NONE;
3092 avcodec_find_encoder_by_name(name) :
3093 avcodec_find_decoder_by_name(name);
3095 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3098 if(codec->type != type) {
3099 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3102 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3103 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3104 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3105 "results.\nAdd '-strict experimental' if you want to use it.\n",
3106 codec_string, codec->name);
3108 avcodec_find_encoder(codec->id) :
3109 avcodec_find_decoder(codec->id);
3110 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3111 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3112 codec_string, codec->name);
3118 static void opt_input_file(const char *filename)
3120 AVFormatContext *ic;
3121 AVFormatParameters params, *ap = ¶ms;
3122 AVInputFormat *file_iformat = NULL;
3123 int err, i, ret, rfps, rfps_base;
3126 if (last_asked_format) {
3127 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3128 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3131 last_asked_format = NULL;
3134 if (!strcmp(filename, "-"))
3137 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3138 !strcmp(filename, "/dev/stdin");
3140 /* get default parameters from command line */
3141 ic = avformat_alloc_context();
3143 print_error(filename, AVERROR(ENOMEM));
3147 memset(ap, 0, sizeof(*ap));
3148 ap->prealloced_context = 1;
3149 ap->sample_rate = audio_sample_rate;
3150 ap->channels = audio_channels;
3151 ap->time_base.den = frame_rate.num;
3152 ap->time_base.num = frame_rate.den;
3153 ap->width = frame_width;
3154 ap->height = frame_height;
3155 ap->pix_fmt = frame_pix_fmt;
3156 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3157 ap->channel = video_channel;
3158 ap->standard = video_standard;
3160 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3162 ic->video_codec_id =
3163 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3164 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3165 ic->audio_codec_id =
3166 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3167 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3168 ic->subtitle_codec_id=
3169 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3170 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3171 ic->flags |= AVFMT_FLAG_NONBLOCK;
3173 /* open the input file with generic libav function */
3174 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3176 print_error(filename, err);
3182 for(i=0; i<ic->nb_streams; i++){
3183 ic->streams[i]->discard= AVDISCARD_ALL;
3185 for(i=0; i<ic->nb_programs; i++){
3186 AVProgram *p= ic->programs[i];
3187 if(p->id != opt_programid){
3188 p->discard = AVDISCARD_ALL;
3191 for(j=0; j<p->nb_stream_indexes; j++){
3192 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3197 fprintf(stderr, "Specified program id not found\n");
3203 ic->loop_input = loop_input;
3205 /* If not enough info to get the stream parameters, we decode the
3206 first frames to get it. (used in mpeg case for example) */
3207 ret = av_find_stream_info(ic);
3208 if (ret < 0 && verbose >= 0) {
3209 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3210 av_close_input_file(ic);
3214 timestamp = start_time;
3215 /* add the stream start time */
3216 if (ic->start_time != AV_NOPTS_VALUE)
3217 timestamp += ic->start_time;
3219 /* if seeking requested, we execute it */
3220 if (start_time != 0) {
3221 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3223 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3224 filename, (double)timestamp / AV_TIME_BASE);
3226 /* reset seek info */
3230 /* update the current parameters so that they match the one of the input stream */
3231 for(i=0;i<ic->nb_streams;i++) {
3232 AVStream *st = ic->streams[i];
3233 AVCodecContext *dec = st->codec;
3234 dec->thread_count = thread_count;
3235 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3236 switch (dec->codec_type) {
3237 case AVMEDIA_TYPE_AUDIO:
3238 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3239 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3240 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3241 channel_layout = dec->channel_layout;
3242 audio_channels = dec->channels;
3243 audio_sample_rate = dec->sample_rate;
3244 audio_sample_fmt = dec->sample_fmt;
3246 st->discard= AVDISCARD_ALL;
3247 /* Note that av_find_stream_info can add more streams, and we
3248 * currently have no chance of setting up lowres decoding
3249 * early enough for them. */
3251 audio_sample_rate >>= dec->lowres;
3253 case AVMEDIA_TYPE_VIDEO:
3254 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3255 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3256 frame_height = dec->height;
3257 frame_width = dec->width;
3258 if(ic->streams[i]->sample_aspect_ratio.num)
3259 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3261 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3262 frame_aspect_ratio *= (float) dec->width / dec->height;
3263 frame_pix_fmt = dec->pix_fmt;
3264 rfps = ic->streams[i]->r_frame_rate.num;
3265 rfps_base = ic->streams[i]->r_frame_rate.den;
3267 dec->flags |= CODEC_FLAG_EMU_EDGE;
3268 frame_height >>= dec->lowres;
3269 frame_width >>= dec->lowres;
3270 dec->height = frame_height;
3271 dec->width = frame_width;
3274 dec->debug |= FF_DEBUG_MV;
3276 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3279 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3280 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3282 (float)rfps / rfps_base, rfps, rfps_base);
3284 /* update the current frame rate to match the stream frame rate */
3285 frame_rate.num = rfps;
3286 frame_rate.den = rfps_base;
3289 st->discard= AVDISCARD_ALL;
3290 else if(video_discard)
3291 st->discard= video_discard;
3293 case AVMEDIA_TYPE_DATA:
3295 case AVMEDIA_TYPE_SUBTITLE:
3296 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3297 if(subtitle_disable)
3298 st->discard = AVDISCARD_ALL;
3300 case AVMEDIA_TYPE_ATTACHMENT:
3301 case AVMEDIA_TYPE_UNKNOWN:
3308 input_files[nb_input_files] = ic;
3309 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3310 /* dump the file content */
3312 av_dump_format(ic, nb_input_files, filename, 0);
3318 av_freep(&video_codec_name);
3319 av_freep(&audio_codec_name);
3320 av_freep(&subtitle_codec_name);
3323 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3324 int *has_subtitle_ptr)
3326 int has_video, has_audio, has_subtitle, i, j;
3327 AVFormatContext *ic;
3332 for(j=0;j<nb_input_files;j++) {
3333 ic = input_files[j];
3334 for(i=0;i<ic->nb_streams;i++) {
3335 AVCodecContext *enc = ic->streams[i]->codec;
3336 switch(enc->codec_type) {
3337 case AVMEDIA_TYPE_AUDIO:
3340 case AVMEDIA_TYPE_VIDEO:
3343 case AVMEDIA_TYPE_SUBTITLE:
3346 case AVMEDIA_TYPE_DATA:
3347 case AVMEDIA_TYPE_ATTACHMENT:
3348 case AVMEDIA_TYPE_UNKNOWN:
3355 *has_video_ptr = has_video;
3356 *has_audio_ptr = has_audio;
3357 *has_subtitle_ptr = has_subtitle;
3360 static void new_video_stream(AVFormatContext *oc, int file_idx)
3363 AVOutputStream *ost;
3364 AVCodecContext *video_enc;
3365 enum CodecID codec_id = CODEC_ID_NONE;
3366 AVCodec *codec= NULL;
3368 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3370 fprintf(stderr, "Could not alloc stream\n");
3373 ost = new_output_stream(oc, file_idx);
3375 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3376 if(!video_stream_copy){
3377 if (video_codec_name) {
3378 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3379 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3380 codec = avcodec_find_encoder_by_name(video_codec_name);
3381 output_codecs[nb_output_codecs-1] = codec;
3383 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3384 codec = avcodec_find_encoder(codec_id);
3388 avcodec_get_context_defaults3(st->codec, codec);
3389 ost->bitstream_filters = video_bitstream_filters;
3390 video_bitstream_filters= NULL;
3392 st->codec->thread_count= thread_count;
3394 video_enc = st->codec;
3397 video_enc->codec_tag= video_codec_tag;
3399 if( (video_global_header&1)
3400 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3401 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3402 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3404 if(video_global_header&2){
3405 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3406 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3409 if (video_stream_copy) {
3410 st->stream_copy = 1;
3411 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3412 video_enc->sample_aspect_ratio =
3413 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3417 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3419 video_enc->codec_id = codec_id;
3420 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3422 if (codec && codec->supported_framerates && !force_fps)
3423 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3424 video_enc->time_base.den = fps.num;
3425 video_enc->time_base.num = fps.den;
3427 video_enc->width = frame_width;
3428 video_enc->height = frame_height;
3429 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3430 video_enc->pix_fmt = frame_pix_fmt;
3431 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3433 choose_pixel_fmt(st, codec);
3436 video_enc->gop_size = 0;
3437 if (video_qscale || same_quality) {
3438 video_enc->flags |= CODEC_FLAG_QSCALE;
3439 video_enc->global_quality=
3440 st->quality = FF_QP2LAMBDA * video_qscale;
3444 video_enc->intra_matrix = intra_matrix;
3446 video_enc->inter_matrix = inter_matrix;
3448 p= video_rc_override_string;
3451 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3453 fprintf(stderr, "error parsing rc_override\n");
3456 video_enc->rc_override=
3457 av_realloc(video_enc->rc_override,
3458 sizeof(RcOverride)*(i+1));
3459 video_enc->rc_override[i].start_frame= start;
3460 video_enc->rc_override[i].end_frame = end;
3462 video_enc->rc_override[i].qscale= q;
3463 video_enc->rc_override[i].quality_factor= 1.0;
3466 video_enc->rc_override[i].qscale= 0;
3467 video_enc->rc_override[i].quality_factor= -q/100.0;
3472 video_enc->rc_override_count=i;
3473 if (!video_enc->rc_initial_buffer_occupancy)
3474 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3475 video_enc->me_threshold= me_threshold;
3476 video_enc->intra_dc_precision= intra_dc_precision - 8;
3479 video_enc->flags|= CODEC_FLAG_PSNR;
3484 video_enc->flags |= CODEC_FLAG_PASS1;
3486 video_enc->flags |= CODEC_FLAG_PASS2;
3490 if (forced_key_frames)
3491 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3493 if (video_language) {
3494 av_metadata_set2(&st->metadata, "language", video_language, 0);
3495 av_freep(&video_language);
3498 /* reset some key parameters */
3500 av_freep(&video_codec_name);
3501 av_freep(&forced_key_frames);
3502 video_stream_copy = 0;
3503 frame_pix_fmt = PIX_FMT_NONE;
3506 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3509 AVOutputStream *ost;
3510 AVCodec *codec= NULL;
3511 AVCodecContext *audio_enc;
3512 enum CodecID codec_id = CODEC_ID_NONE;
3514 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3516 fprintf(stderr, "Could not alloc stream\n");
3519 ost = new_output_stream(oc, file_idx);
3521 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3522 if(!audio_stream_copy){
3523 if (audio_codec_name) {
3524 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3525 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3526 codec = avcodec_find_encoder_by_name(audio_codec_name);
3527 output_codecs[nb_output_codecs-1] = codec;
3529 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3530 codec = avcodec_find_encoder(codec_id);
3534 avcodec_get_context_defaults3(st->codec, codec);
3536 ost->bitstream_filters = audio_bitstream_filters;
3537 audio_bitstream_filters= NULL;
3539 st->codec->thread_count= thread_count;
3541 audio_enc = st->codec;
3542 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3545 audio_enc->codec_tag= audio_codec_tag;
3547 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3548 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3549 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3551 if (audio_stream_copy) {
3552 st->stream_copy = 1;
3553 audio_enc->channels = audio_channels;
3554 audio_enc->sample_rate = audio_sample_rate;
3556 audio_enc->codec_id = codec_id;
3557 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3559 if (audio_qscale > QSCALE_NONE) {
3560 audio_enc->flags |= CODEC_FLAG_QSCALE;
3561 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3563 audio_enc->channels = audio_channels;
3564 audio_enc->sample_fmt = audio_sample_fmt;
3565 audio_enc->sample_rate = audio_sample_rate;
3566 audio_enc->channel_layout = channel_layout;
3567 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3568 audio_enc->channel_layout = 0;
3569 choose_sample_fmt(st, codec);
3570 choose_sample_rate(st, codec);
3572 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3573 if (audio_language) {
3574 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3575 av_freep(&audio_language);
3578 /* reset some key parameters */
3580 av_freep(&audio_codec_name);
3581 audio_stream_copy = 0;
3584 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3587 AVOutputStream *ost;
3588 AVCodec *codec=NULL;
3589 AVCodecContext *subtitle_enc;
3590 enum CodecID codec_id = CODEC_ID_NONE;
3592 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3594 fprintf(stderr, "Could not alloc stream\n");
3597 ost = new_output_stream(oc, file_idx);
3598 subtitle_enc = st->codec;
3599 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3600 if(!subtitle_stream_copy){
3601 if (subtitle_codec_name) {
3602 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3603 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3604 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3606 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3607 codec = avcodec_find_encoder(codec_id);
3610 avcodec_get_context_defaults3(st->codec, codec);
3612 ost->bitstream_filters = subtitle_bitstream_filters;
3613 subtitle_bitstream_filters= NULL;
3615 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3617 if(subtitle_codec_tag)
3618 subtitle_enc->codec_tag= subtitle_codec_tag;
3620 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3621 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3622 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3624 if (subtitle_stream_copy) {
3625 st->stream_copy = 1;
3627 subtitle_enc->codec_id = codec_id;
3628 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3631 if (subtitle_language) {
3632 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3633 av_freep(&subtitle_language);
3636 subtitle_disable = 0;
3637 av_freep(&subtitle_codec_name);
3638 subtitle_stream_copy = 0;
3641 static int opt_new_stream(const char *opt, const char *arg)
3643 AVFormatContext *oc;
3644 int file_idx = nb_output_files - 1;
3645 if (nb_output_files <= 0) {
3646 fprintf(stderr, "At least one output file must be specified\n");
3649 oc = output_files[file_idx];
3651 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3652 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3653 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3658 /* arg format is "output-stream-index:streamid-value". */
3659 static int opt_streamid(const char *opt, const char *arg)
3665 strncpy(idx_str, arg, sizeof(idx_str));
3666 idx_str[sizeof(idx_str)-1] = '\0';
3667 p = strchr(idx_str, ':');
3670 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3675 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3676 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3677 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3681 static void opt_output_file(const char *filename)
3683 AVFormatContext *oc;
3684 int err, use_video, use_audio, use_subtitle;
3685 int input_has_video, input_has_audio, input_has_subtitle;
3686 AVFormatParameters params, *ap = ¶ms;
3687 AVOutputFormat *file_oformat;
3689 if (!strcmp(filename, "-"))
3692 oc = avformat_alloc_context();
3694 print_error(filename, AVERROR(ENOMEM));
3698 if (last_asked_format) {
3699 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3700 if (!file_oformat) {
3701 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3704 last_asked_format = NULL;
3706 file_oformat = av_guess_format(NULL, filename, NULL);
3707 if (!file_oformat) {
3708 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3714 oc->oformat = file_oformat;
3715 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3717 if (!strcmp(file_oformat->name, "ffm") &&
3718 av_strstart(filename, "http:", NULL)) {
3719 /* special case for files sent to ffserver: we get the stream
3720 parameters from ffserver */
3721 int err = read_ffserver_streams(oc, filename);
3723 print_error(filename, err);
3727 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3728 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3729 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3731 /* disable if no corresponding type found and at least one
3733 if (nb_input_files > 0) {
3734 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3735 &input_has_subtitle);
3736 if (!input_has_video)
3738 if (!input_has_audio)
3740 if (!input_has_subtitle)
3744 /* manual disable */
3745 if (audio_disable) use_audio = 0;
3746 if (video_disable) use_video = 0;
3747 if (subtitle_disable) use_subtitle = 0;
3749 if (use_video) new_video_stream(oc, nb_output_files);
3750 if (use_audio) new_audio_stream(oc, nb_output_files);
3751 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3753 oc->timestamp = recording_timestamp;
3755 av_metadata_copy(&oc->metadata, metadata, 0);
3756 av_metadata_free(&metadata);
3759 output_files[nb_output_files++] = oc;
3761 /* check filename in case of an image number is expected */
3762 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3763 if (!av_filename_number_test(oc->filename)) {
3764 print_error(oc->filename, AVERROR_NUMEXPECTED);
3769 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3770 /* test if it already exists to avoid loosing precious files */
3771 if (!file_overwrite &&
3772 (strchr(filename, ':') == NULL ||
3773 filename[1] == ':' ||
3774 av_strstart(filename, "file:", NULL))) {
3775 if (url_exist(filename)) {
3777 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3779 if (!read_yesno()) {
3780 fprintf(stderr, "Not overwriting - exiting\n");
3785 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3792 if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3793 print_error(filename, err);
3798 memset(ap, 0, sizeof(*ap));
3799 if (av_set_parameters(oc, ap) < 0) {
3800 fprintf(stderr, "%s: Invalid encoding parameters\n",
3805 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3806 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3807 oc->loop_output = loop_output;
3808 oc->flags |= AVFMT_FLAG_NONBLOCK;
3810 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3812 av_freep(&forced_key_frames);
3815 /* same option as mencoder */
3816 static void opt_pass(const char *pass_str)
3819 pass = atoi(pass_str);
3820 if (pass != 1 && pass != 2) {
3821 fprintf(stderr, "pass number can be only 1 or 2\n");
3827 static int64_t getutime(void)
3830 struct rusage rusage;
3832 getrusage(RUSAGE_SELF, &rusage);
3833 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3834 #elif HAVE_GETPROCESSTIMES
3836 FILETIME c, e, k, u;
3837 proc = GetCurrentProcess();
3838 GetProcessTimes(proc, &c, &e, &k, &u);
3839 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3841 return av_gettime();
3845 static int64_t getmaxrss(void)
3847 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3848 struct rusage rusage;
3849 getrusage(RUSAGE_SELF, &rusage);
3850 return (int64_t)rusage.ru_maxrss * 1024;
3851 #elif HAVE_GETPROCESSMEMORYINFO
3853 PROCESS_MEMORY_COUNTERS memcounters;
3854 proc = GetCurrentProcess();
3855 memcounters.cb = sizeof(memcounters);
3856 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3857 return memcounters.PeakPagefileUsage;
3863 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3866 const char *p = str;
3873 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3880 static void opt_inter_matrix(const char *arg)
3882 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3883 parse_matrix_coeffs(inter_matrix, arg);
3886 static void opt_intra_matrix(const char *arg)
3888 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3889 parse_matrix_coeffs(intra_matrix, arg);
3892 static void show_usage(void)
3894 printf("Hyper fast Audio and Video encoder\n");
3895 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3899 static void show_help(void)
3902 AVOutputFormat *oformat = NULL;
3904 av_log_set_callback(log_callback_help);
3906 show_help_options(options, "Main options:\n",
3907 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3908 show_help_options(options, "\nAdvanced options:\n",
3909 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3911 show_help_options(options, "\nVideo options:\n",
3912 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3914 show_help_options(options, "\nAdvanced Video options:\n",
3915 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3916 OPT_VIDEO | OPT_EXPERT);
3917 show_help_options(options, "\nAudio options:\n",
3918 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3920 show_help_options(options, "\nAdvanced Audio options:\n",
3921 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3922 OPT_AUDIO | OPT_EXPERT);
3923 show_help_options(options, "\nSubtitle options:\n",
3924 OPT_SUBTITLE | OPT_GRAB,
3926 show_help_options(options, "\nAudio/Video grab options:\n",
3930 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3933 /* individual codec options */
3935 while ((c = av_codec_next(c))) {
3936 if (c->priv_class) {
3937 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3942 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3945 /* individual muxer options */
3946 while ((oformat = av_oformat_next(oformat))) {
3947 if (oformat->priv_class) {
3948 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3953 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3956 static void opt_target(const char *arg)
3958 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3959 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3961 if(!strncmp(arg, "pal-", 4)) {
3964 } else if(!strncmp(arg, "ntsc-", 5)) {
3967 } else if(!strncmp(arg, "film-", 5)) {
3972 /* Calculate FR via float to avoid int overflow */
3973 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3976 } else if((fr == 29970) || (fr == 23976)) {
3979 /* Try to determine PAL/NTSC by peeking in the input files */
3980 if(nb_input_files) {
3982 for(j = 0; j < nb_input_files; j++) {
3983 for(i = 0; i < input_files[j]->nb_streams; i++) {
3984 AVCodecContext *c = input_files[j]->streams[i]->codec;
3985 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3987 fr = c->time_base.den * 1000 / c->time_base.num;
3991 } else if((fr == 29970) || (fr == 23976)) {
4001 if(verbose && norm != UNKNOWN)
4002 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4005 if(norm == UNKNOWN) {
4006 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4007 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4008 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4012 if(!strcmp(arg, "vcd")) {
4014 opt_video_codec("mpeg1video");
4015 opt_audio_codec("mp2");
4018 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4019 opt_frame_rate(NULL, frame_rates[norm]);
4020 opt_default("g", norm == PAL ? "15" : "18");
4022 opt_default("b", "1150000");
4023 opt_default("maxrate", "1150000");
4024 opt_default("minrate", "1150000");
4025 opt_default("bufsize", "327680"); // 40*1024*8;
4027 opt_default("ab", "224000");
4028 audio_sample_rate = 44100;
4031 opt_default("packetsize", "2324");
4032 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4034 /* We have to offset the PTS, so that it is consistent with the SCR.
4035 SCR starts at 36000, but the first two packs contain only padding
4036 and the first pack from the other stream, respectively, may also have
4037 been written before.
4038 So the real data starts at SCR 36000+3*1200. */
4039 mux_preload= (36000+3*1200) / 90000.0; //0.44
4040 } else if(!strcmp(arg, "svcd")) {
4042 opt_video_codec("mpeg2video");
4043 opt_audio_codec("mp2");
4046 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4047 opt_frame_rate(NULL, frame_rates[norm]);
4048 opt_default("g", norm == PAL ? "15" : "18");
4050 opt_default("b", "2040000");
4051 opt_default("maxrate", "2516000");
4052 opt_default("minrate", "0"); //1145000;
4053 opt_default("bufsize", "1835008"); //224*1024*8;
4054 opt_default("flags", "+scan_offset");
4057 opt_default("ab", "224000");
4058 audio_sample_rate = 44100;
4060 opt_default("packetsize", "2324");
4062 } else if(!strcmp(arg, "dvd")) {
4064 opt_video_codec("mpeg2video");
4065 opt_audio_codec("ac3");
4068 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4069 opt_frame_rate(NULL, frame_rates[norm]);
4070 opt_default("g", norm == PAL ? "15" : "18");
4072 opt_default("b", "6000000");
4073 opt_default("maxrate", "9000000");
4074 opt_default("minrate", "0"); //1500000;
4075 opt_default("bufsize", "1835008"); //224*1024*8;
4077 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4078 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4080 opt_default("ab", "448000");
4081 audio_sample_rate = 48000;
4083 } else if(!strncmp(arg, "dv", 2)) {
4087 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4088 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4089 (norm == PAL ? "yuv420p" : "yuv411p"));
4090 opt_frame_rate(NULL, frame_rates[norm]);
4092 audio_sample_rate = 48000;
4096 fprintf(stderr, "Unknown target: %s\n", arg);
4101 static void opt_vstats_file (const char *arg)
4103 av_free (vstats_filename);
4104 vstats_filename=av_strdup (arg);
4107 static void opt_vstats (void)
4110 time_t today2 = time(NULL);
4111 struct tm *today = localtime(&today2);
4113 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4115 opt_vstats_file(filename);
4118 static int opt_bsf(const char *opt, const char *arg)
4120 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4121 AVBitStreamFilterContext **bsfp;
4124 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4128 bsfp= *opt == 'v' ? &video_bitstream_filters :
4129 *opt == 'a' ? &audio_bitstream_filters :
4130 &subtitle_bitstream_filters;
4132 bsfp= &(*bsfp)->next;
4139 static int opt_preset(const char *opt, const char *arg)
4142 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4143 char *codec_name = *opt == 'v' ? video_codec_name :
4144 *opt == 'a' ? audio_codec_name :
4145 subtitle_codec_name;
4147 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4148 fprintf(stderr, "File for preset '%s' not found\n", arg);
4153 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4154 if(line[0] == '#' && !e)
4156 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4158 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4161 if(!strcmp(tmp, "acodec")){
4162 opt_audio_codec(tmp2);
4163 }else if(!strcmp(tmp, "vcodec")){
4164 opt_video_codec(tmp2);
4165 }else if(!strcmp(tmp, "scodec")){
4166 opt_subtitle_codec(tmp2);
4167 }else if(opt_default(tmp, tmp2) < 0){
4168 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4178 static const OptionDef options[] = {
4180 #include "cmdutils_common_opts.h"
4181 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4182 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4183 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4184 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4185 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4186 "outfile[,metadata]:infile[,metadata]" },
4187 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4188 "outfile[,metadata]:infile[,metadata]" },
4189 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4190 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4191 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4192 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4193 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4194 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4195 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4196 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4197 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4198 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4199 "add timings for benchmarking" },
4200 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4201 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4202 "dump each input packet" },
4203 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4204 "when dumping packets, also dump the payload" },
4205 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4206 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4207 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4208 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4209 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4210 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4211 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4212 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4213 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4214 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4215 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4216 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4217 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4218 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4219 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4220 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4221 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4224 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4225 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4226 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4227 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4228 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4229 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4230 { "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" },
4231 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4232 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4233 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4234 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4235 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4236 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4237 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4238 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4239 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4240 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4241 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4242 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4243 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4244 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4245 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4246 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4247 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4248 "use same video quality as source (implies VBR)" },
4249 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4250 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4251 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4252 "deinterlace pictures" },
4253 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4254 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4255 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4257 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4259 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4260 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4261 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4262 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4263 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4264 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4265 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4266 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4267 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4268 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4269 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4272 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4273 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4274 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4275 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4276 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4277 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4278 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4279 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4280 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4281 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4282 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4283 { "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" },
4285 /* subtitle options */
4286 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4287 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4288 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4289 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4290 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4293 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4294 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4295 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4298 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4299 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4301 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4302 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4303 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4305 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4306 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4307 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4308 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4310 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4314 int main(int argc, char **argv)
4318 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4320 avcodec_register_all();
4322 avdevice_register_all();
4325 avfilter_register_all();
4330 if(isatty(STDIN_FILENO))
4331 url_set_interrupt_cb(decode_interrupt_cb);
4339 parse_options(argc, argv, options, opt_output_file);
4341 if(nb_output_files <= 0 && nb_input_files == 0) {
4343 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4347 /* file converter / grab */
4348 if (nb_output_files <= 0) {
4349 fprintf(stderr, "At least one output file must be specified\n");
4353 if (nb_input_files == 0) {
4354 fprintf(stderr, "At least one input file must be specified\n");
4359 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4360 stream_maps, nb_stream_maps) < 0)
4362 ti = getutime() - ti;
4364 int maxrss = getmaxrss() / 1024;
4365 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4368 return ffmpeg_exit(0);