3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcore/parseutils.h"
40 #include "libavcore/samplefmt.h"
41 #include "libavutil/colorspace.h"
42 #include "libavutil/fifo.h"
43 #include "libavutil/intreadwrite.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/graphparser.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 static const OptionDef options[];
108 #define MAX_FILES 100
109 #if !FF_API_MAX_STREAMS
110 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
113 static const char *last_asked_format = NULL;
114 static AVFormatContext *input_files[MAX_FILES];
115 static int64_t input_files_ts_offset[MAX_FILES];
116 static double *input_files_ts_scale[MAX_FILES] = {NULL};
117 static AVCodec **input_codecs = NULL;
118 static int nb_input_files = 0;
119 static int nb_input_codecs = 0;
120 static int nb_input_files_ts_scale[MAX_FILES] = {0};
122 static AVFormatContext *output_files[MAX_FILES];
123 static AVCodec **output_codecs = NULL;
124 static int nb_output_files = 0;
125 static int nb_output_codecs = 0;
127 static AVStreamMap *stream_maps = NULL;
128 static int nb_stream_maps;
130 /* first item specifies output metadata, second is input */
131 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
132 static int nb_meta_data_maps;
133 static int metadata_streams_autocopy = 1;
134 static int metadata_chapters_autocopy = 1;
136 /* indexed by output file stream index */
137 static int *streamid_map = NULL;
138 static int nb_streamid_map = 0;
140 static int frame_width = 0;
141 static int frame_height = 0;
142 static float frame_aspect_ratio = 0;
143 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
144 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
145 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
146 static AVRational frame_rate;
147 static float video_qscale = 0;
148 static uint16_t *intra_matrix = NULL;
149 static uint16_t *inter_matrix = NULL;
150 static const char *video_rc_override_string=NULL;
151 static int video_disable = 0;
152 static int video_discard = 0;
153 static char *video_codec_name = NULL;
154 static unsigned int video_codec_tag = 0;
155 static char *video_language = NULL;
156 static int same_quality = 0;
157 static int do_deinterlace = 0;
158 static int top_field_first = -1;
159 static int me_threshold = 0;
160 static int intra_dc_precision = 8;
161 static int loop_input = 0;
162 static int loop_output = AVFMT_NOOUTPUTLOOP;
163 static int qp_hist = 0;
165 static char *vfilters = NULL;
166 AVFilterGraph *graph = NULL;
169 static int intra_only = 0;
170 static int audio_sample_rate = 44100;
171 static int64_t channel_layout = 0;
172 #define QSCALE_NONE -99999
173 static float audio_qscale = QSCALE_NONE;
174 static int audio_disable = 0;
175 static int audio_channels = 1;
176 static char *audio_codec_name = NULL;
177 static unsigned int audio_codec_tag = 0;
178 static char *audio_language = NULL;
180 static int subtitle_disable = 0;
181 static char *subtitle_codec_name = NULL;
182 static char *subtitle_language = NULL;
183 static unsigned int subtitle_codec_tag = 0;
185 static float mux_preload= 0.5;
186 static float mux_max_delay= 0.7;
188 static int64_t recording_time = INT64_MAX;
189 static int64_t start_time = 0;
190 static int64_t recording_timestamp = 0;
191 static int64_t input_ts_offset = 0;
192 static int file_overwrite = 0;
193 static AVMetadata *metadata;
194 static int do_benchmark = 0;
195 static int do_hex_dump = 0;
196 static int do_pkt_dump = 0;
197 static int do_psnr = 0;
198 static int do_pass = 0;
199 static char *pass_logfilename_prefix = NULL;
200 static int audio_stream_copy = 0;
201 static int video_stream_copy = 0;
202 static int subtitle_stream_copy = 0;
203 static int video_sync_method= -1;
204 static int audio_sync_method= 0;
205 static float audio_drift_threshold= 0.1;
206 static int copy_ts= 0;
207 static int opt_shortest = 0;
208 static int video_global_header = 0;
209 static char *vstats_filename;
210 static FILE *vstats_file;
211 static int opt_programid = 0;
212 static int copy_initial_nonkeyframes = 0;
214 static int rate_emu = 0;
216 static int video_channel = 0;
217 static char *video_standard;
219 static int audio_volume = 256;
221 static int exit_on_error = 0;
222 static int using_stdin = 0;
223 static int verbose = 1;
224 static int thread_count= 1;
225 static int q_pressed = 0;
226 static int64_t video_size = 0;
227 static int64_t audio_size = 0;
228 static int64_t extra_size = 0;
229 static int nb_frames_dup = 0;
230 static int nb_frames_drop = 0;
231 static int input_sync;
232 static uint64_t limit_filesize = 0;
233 static int force_fps = 0;
234 static char *forced_key_frames = NULL;
236 static float dts_delta_threshold = 10;
238 static unsigned int sws_flags = SWS_BICUBIC;
240 static int64_t timer_start;
242 static uint8_t *audio_buf;
243 static uint8_t *audio_out;
244 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
246 static short *samples;
248 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
249 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
250 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
252 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
254 struct AVInputStream;
256 typedef struct AVOutputStream {
257 int file_index; /* file index */
258 int index; /* stream index in the output file */
259 int source_index; /* AVInputStream index */
260 AVStream *st; /* stream in the output file */
261 int encoding_needed; /* true if encoding needed for this stream */
263 /* input pts and corresponding output pts
265 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
266 struct AVInputStream *sync_ist; /* input stream to sync against */
267 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
268 AVBitStreamFilterContext *bitstream_filters;
271 AVFrame pict_tmp; /* temporary image for resampling */
272 struct SwsContext *img_resample_ctx; /* for image resampling */
275 int resample_pix_fmt;
277 /* full frame size of first frame */
281 /* forced key frames */
282 int64_t *forced_kf_pts;
288 ReSampleContext *resample; /* for audio resampling */
290 AVAudioConvert *reformat_ctx;
291 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
295 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
296 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
298 typedef struct AVInputStream {
302 int discard; /* true if stream data should be discarded */
303 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
304 int64_t sample_index; /* current sample */
306 int64_t start; /* time when read started */
307 int64_t next_pts; /* synthetic pts for cases where pkt.pts
309 int64_t pts; /* current pts */
310 PtsCorrectionContext pts_ctx;
311 int is_start; /* is 1 at the start and after a discontinuity */
312 int showed_multi_packet_warning;
313 int is_past_recording_time;
315 AVFilterContext *output_video_filter;
316 AVFilterContext *input_video_filter;
317 AVFrame *filter_frame;
318 int has_filter_frame;
319 AVFilterBufferRef *picref;
323 typedef struct AVInputFile {
324 int eof_reached; /* true if eof reached */
325 int ist_index; /* index of first stream in ist_table */
326 int buffer_size; /* current total buffer size */
327 int nb_streams; /* nb streams we are aware of */
332 /* init terminal so that we can grab keys */
333 static struct termios oldtty;
338 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
340 AVFilterContext *last_filter, *filter;
341 /** filter graph containing all filters including input & output */
342 AVCodecContext *codec = ost->st->codec;
343 AVCodecContext *icodec = ist->st->codec;
344 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
348 graph = av_mallocz(sizeof(AVFilterGraph));
350 if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
352 if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
355 snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
356 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
357 if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
359 if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
362 /* add input and output filters to the overall graph */
363 avfilter_graph_add_filter(graph, ist->input_video_filter);
364 avfilter_graph_add_filter(graph, ist->output_video_filter);
366 last_filter = ist->input_video_filter;
368 if (codec->width != icodec->width || codec->height != icodec->height) {
369 snprintf(args, 255, "%d:%d:flags=0x%X",
372 (int)av_get_int(sws_opts, "sws_flags", NULL));
373 if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
375 if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
377 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
379 last_filter = filter;
380 avfilter_graph_add_filter(graph, last_filter);
383 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
384 graph->scale_sws_opts = av_strdup(args);
387 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
388 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
390 outputs->name = av_strdup("in");
391 outputs->filter = last_filter;
392 outputs->pad_idx = 0;
393 outputs->next = NULL;
395 inputs->name = av_strdup("out");
396 inputs->filter = ist->output_video_filter;
400 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
404 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
408 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
411 codec->width = ist->output_video_filter->inputs[0]->w;
412 codec->height = ist->output_video_filter->inputs[0]->h;
416 #endif /* CONFIG_AVFILTER */
418 static void term_exit(void)
420 av_log(NULL, AV_LOG_QUIET, "");
422 tcsetattr (0, TCSANOW, &oldtty);
426 static volatile int received_sigterm = 0;
429 sigterm_handler(int sig)
431 received_sigterm = sig;
435 static void term_init(void)
444 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
445 |INLCR|IGNCR|ICRNL|IXON);
446 tty.c_oflag |= OPOST;
447 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
448 tty.c_cflag &= ~(CSIZE|PARENB);
453 tcsetattr (0, TCSANOW, &tty);
454 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
457 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
458 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
460 signal(SIGXCPU, sigterm_handler);
464 /* read a key without blocking */
465 static int read_key(void)
477 n = select(1, &rfds, NULL, NULL, &tv);
492 static int decode_interrupt_cb(void)
494 return q_pressed || (q_pressed = read_key() == 'q');
497 static int ffmpeg_exit(int ret)
502 for(i=0;i<nb_output_files;i++) {
503 /* maybe av_close_output_file ??? */
504 AVFormatContext *s = output_files[i];
506 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
508 for(j=0;j<s->nb_streams;j++) {
509 av_metadata_free(&s->streams[j]->metadata);
510 av_free(s->streams[j]->codec);
511 av_free(s->streams[j]->info);
512 av_free(s->streams[j]);
514 for(j=0;j<s->nb_programs;j++) {
515 av_metadata_free(&s->programs[j]->metadata);
517 for(j=0;j<s->nb_chapters;j++) {
518 av_metadata_free(&s->chapters[j]->metadata);
520 av_metadata_free(&s->metadata);
522 av_free(output_streams_for_file[i]);
524 for(i=0;i<nb_input_files;i++) {
525 av_close_input_file(input_files[i]);
526 av_free(input_files_ts_scale[i]);
529 av_free(intra_matrix);
530 av_free(inter_matrix);
534 av_free(vstats_filename);
537 av_free(streamid_map);
538 av_free(input_codecs);
539 av_free(output_codecs);
540 av_free(stream_maps);
541 av_free(meta_data_maps);
543 av_free(video_codec_name);
544 av_free(audio_codec_name);
545 av_free(subtitle_codec_name);
547 av_free(video_standard);
552 allocated_audio_buf_size= allocated_audio_out_size= 0;
559 if (received_sigterm) {
561 "Received signal %d: terminating.\n",
562 (int) received_sigterm);
566 exit(ret); /* not all OS-es handle main() return value */
570 /* similar to ff_dynarray_add() and av_fast_realloc() */
571 static void *grow_array(void *array, int elem_size, int *size, int new_size)
573 if (new_size >= INT_MAX / elem_size) {
574 fprintf(stderr, "Array too big.\n");
577 if (*size < new_size) {
578 uint8_t *tmp = av_realloc(array, new_size*elem_size);
580 fprintf(stderr, "Could not alloc buffer.\n");
583 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
590 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
592 if(codec && codec->sample_fmts){
593 const enum SampleFormat *p= codec->sample_fmts;
595 if(*p == st->codec->sample_fmt)
599 st->codec->sample_fmt = codec->sample_fmts[0];
603 static void choose_sample_rate(AVStream *st, AVCodec *codec)
605 if(codec && codec->supported_samplerates){
606 const int *p= codec->supported_samplerates;
608 int best_dist=INT_MAX;
610 int dist= abs(st->codec->sample_rate - *p);
611 if(dist < best_dist){
617 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
619 st->codec->sample_rate= best;
623 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
625 if(codec && codec->pix_fmts){
626 const enum PixelFormat *p= codec->pix_fmts;
628 if(*p == st->codec->pix_fmt)
632 && !( st->codec->codec_id==CODEC_ID_MJPEG
633 && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
634 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
635 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
636 st->codec->pix_fmt = codec->pix_fmts[0];
640 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
642 int idx = oc->nb_streams - 1;
645 output_streams_for_file[file_idx] =
646 grow_array(output_streams_for_file[file_idx],
647 sizeof(*output_streams_for_file[file_idx]),
648 &nb_output_streams_for_file[file_idx],
650 ost = output_streams_for_file[file_idx][idx] =
651 av_mallocz(sizeof(AVOutputStream));
653 fprintf(stderr, "Could not alloc output stream\n");
656 ost->file_index = file_idx;
661 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
667 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
670 /* copy stream format */
672 for(i=0;i<ic->nb_streams;i++) {
678 // FIXME: a more elegant solution is needed
679 st = av_mallocz(sizeof(AVStream));
680 memcpy(st, ic->streams[i], sizeof(AVStream));
681 st->codec = avcodec_alloc_context();
683 print_error(filename, AVERROR(ENOMEM));
686 avcodec_copy_context(st->codec, ic->streams[i]->codec);
689 codec = avcodec_find_encoder(st->codec->codec_id);
690 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
691 if (audio_stream_copy) {
694 choose_sample_fmt(st, codec);
695 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
696 if (video_stream_copy) {
699 choose_pixel_fmt(st, codec);
702 if(!st->codec->thread_count)
703 st->codec->thread_count = 1;
704 if(st->codec->thread_count>1)
705 avcodec_thread_init(st->codec, st->codec->thread_count);
707 if(st->codec->flags & CODEC_FLAG_BITEXACT)
710 new_output_stream(s, nb_output_files);
714 s->timestamp = av_gettime();
716 av_close_input_file(ic);
721 get_sync_ipts(const AVOutputStream *ost)
723 const AVInputStream *ist = ost->sync_ist;
724 return (double)(ist->pts - start_time)/AV_TIME_BASE;
727 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
731 AVPacket new_pkt= *pkt;
732 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
733 &new_pkt.data, &new_pkt.size,
734 pkt->data, pkt->size,
735 pkt->flags & AV_PKT_FLAG_KEY);
738 new_pkt.destruct= av_destruct_packet;
740 fprintf(stderr, "%s failed for stream %d, codec %s",
741 bsfc->filter->name, pkt->stream_index,
742 avctx->codec ? avctx->codec->name : "copy");
752 ret= av_interleaved_write_frame(s, pkt);
754 print_error("av_interleaved_write_frame()", ret);
759 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
761 static void do_audio_out(AVFormatContext *s,
764 unsigned char *buf, int size)
767 int64_t audio_out_size, audio_buf_size;
768 int64_t allocated_for_size= size;
770 int size_out, frame_bytes, ret;
771 AVCodecContext *enc= ost->st->codec;
772 AVCodecContext *dec= ist->st->codec;
773 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
774 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
775 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
778 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
779 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
780 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
781 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
782 audio_buf_size*= osize*enc->channels;
784 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
785 if(coded_bps > 8*osize)
786 audio_out_size= audio_out_size * coded_bps / (8*osize);
787 audio_out_size += FF_MIN_BUFFER_SIZE;
789 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
790 fprintf(stderr, "Buffer sizes too large\n");
794 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
795 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
796 if (!audio_buf || !audio_out){
797 fprintf(stderr, "Out of memory in do_audio_out\n");
801 if (enc->channels != dec->channels)
802 ost->audio_resample = 1;
804 if (ost->audio_resample && !ost->resample) {
805 if (dec->sample_fmt != SAMPLE_FMT_S16)
806 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
807 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
808 enc->sample_rate, dec->sample_rate,
809 enc->sample_fmt, dec->sample_fmt,
811 if (!ost->resample) {
812 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
813 dec->channels, dec->sample_rate,
814 enc->channels, enc->sample_rate);
819 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
820 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
821 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
822 if (ost->reformat_ctx)
823 av_audio_convert_free(ost->reformat_ctx);
824 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
825 dec->sample_fmt, 1, NULL, 0);
826 if (!ost->reformat_ctx) {
827 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
828 av_get_sample_fmt_name(dec->sample_fmt),
829 av_get_sample_fmt_name(enc->sample_fmt));
832 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
835 if(audio_sync_method){
836 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
837 - av_fifo_size(ost->fifo)/(enc->channels * 2);
838 double idelta= delta*dec->sample_rate / enc->sample_rate;
839 int byte_delta= ((int)idelta)*2*dec->channels;
841 //FIXME resample delay
842 if(fabs(delta) > 50){
843 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
845 byte_delta= FFMAX(byte_delta, -size);
849 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
854 static uint8_t *input_tmp= NULL;
855 input_tmp= av_realloc(input_tmp, byte_delta + size);
857 if(byte_delta > allocated_for_size - size){
858 allocated_for_size= byte_delta + (int64_t)size;
863 memset(input_tmp, 0, byte_delta);
864 memcpy(input_tmp + byte_delta, buf, size);
868 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
870 }else if(audio_sync_method>1){
871 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
872 av_assert0(ost->audio_resample);
874 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
875 // 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));
876 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
880 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
881 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
883 if (ost->audio_resample) {
885 size_out = audio_resample(ost->resample,
886 (short *)buftmp, (short *)buf,
887 size / (dec->channels * isize));
888 size_out = size_out * enc->channels * osize;
894 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
895 const void *ibuf[6]= {buftmp};
896 void *obuf[6]= {audio_buf};
897 int istride[6]= {isize};
898 int ostride[6]= {osize};
899 int len= size_out/istride[0];
900 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
901 printf("av_audio_convert() failed\n");
907 size_out = len*osize;
910 /* now encode as many frames as possible */
911 if (enc->frame_size > 1) {
912 /* output resampled raw samples */
913 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
914 fprintf(stderr, "av_fifo_realloc2() failed\n");
917 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
919 frame_bytes = enc->frame_size * osize * enc->channels;
921 while (av_fifo_size(ost->fifo) >= frame_bytes) {
923 av_init_packet(&pkt);
925 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
927 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
929 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
932 fprintf(stderr, "Audio encoding failed\n");
936 pkt.stream_index= ost->index;
939 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
940 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
941 pkt.flags |= AV_PKT_FLAG_KEY;
942 write_frame(s, &pkt, enc, ost->bitstream_filters);
944 ost->sync_opts += enc->frame_size;
948 av_init_packet(&pkt);
950 ost->sync_opts += size_out / (osize * enc->channels);
952 /* output a pcm frame */
953 /* determine the size of the coded buffer */
956 size_out = size_out*coded_bps/8;
958 if(size_out > audio_out_size){
959 fprintf(stderr, "Internal error, buffer size too small\n");
963 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
964 ret = avcodec_encode_audio(enc, audio_out, size_out,
967 fprintf(stderr, "Audio encoding failed\n");
971 pkt.stream_index= ost->index;
974 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
975 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
976 pkt.flags |= AV_PKT_FLAG_KEY;
977 write_frame(s, &pkt, enc, ost->bitstream_filters);
981 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
985 AVPicture picture_tmp;
988 dec = ist->st->codec;
990 /* deinterlace : must be done before any resize */
991 if (do_deinterlace) {
994 /* create temporary picture */
995 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
996 buf = av_malloc(size);
1000 picture2 = &picture_tmp;
1001 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1003 if(avpicture_deinterlace(picture2, picture,
1004 dec->pix_fmt, dec->width, dec->height) < 0) {
1005 /* if error, do not deinterlace */
1006 fprintf(stderr, "Deinterlacing failed\n");
1015 if (picture != picture2)
1016 *picture = *picture2;
1020 /* we begin to correct av delay at this threshold */
1021 #define AV_DELAY_MAX 0.100
1023 static void do_subtitle_out(AVFormatContext *s,
1024 AVOutputStream *ost,
1029 static uint8_t *subtitle_out = NULL;
1030 int subtitle_out_max_size = 1024 * 1024;
1031 int subtitle_out_size, nb, i;
1032 AVCodecContext *enc;
1035 if (pts == AV_NOPTS_VALUE) {
1036 fprintf(stderr, "Subtitle packets must have a pts\n");
1042 enc = ost->st->codec;
1044 if (!subtitle_out) {
1045 subtitle_out = av_malloc(subtitle_out_max_size);
1048 /* Note: DVB subtitle need one packet to draw them and one other
1049 packet to clear them */
1050 /* XXX: signal it in the codec context ? */
1051 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1056 for(i = 0; i < nb; i++) {
1057 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1058 // start_display_time is required to be 0
1059 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1060 sub->end_display_time -= sub->start_display_time;
1061 sub->start_display_time = 0;
1062 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1063 subtitle_out_max_size, sub);
1064 if (subtitle_out_size < 0) {
1065 fprintf(stderr, "Subtitle encoding failed\n");
1069 av_init_packet(&pkt);
1070 pkt.stream_index = ost->index;
1071 pkt.data = subtitle_out;
1072 pkt.size = subtitle_out_size;
1073 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1074 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1075 /* XXX: the pts correction is handled here. Maybe handling
1076 it in the codec would be better */
1078 pkt.pts += 90 * sub->start_display_time;
1080 pkt.pts += 90 * sub->end_display_time;
1082 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1086 static int bit_buffer_size= 1024*256;
1087 static uint8_t *bit_buffer= NULL;
1089 static void do_video_out(AVFormatContext *s,
1090 AVOutputStream *ost,
1092 AVFrame *in_picture,
1095 int nb_frames, i, ret;
1096 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1097 AVCodecContext *enc, *dec;
1100 enc = ost->st->codec;
1101 dec = ist->st->codec;
1103 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1105 /* by default, we output a single frame */
1110 if(video_sync_method){
1111 double vdelta = sync_ipts - ost->sync_opts;
1112 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1115 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1118 }else if(vdelta>0.6)
1119 ost->sync_opts= lrintf(sync_ipts);
1120 }else if (vdelta > 1.1)
1121 nb_frames = lrintf(vdelta);
1122 //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);
1123 if (nb_frames == 0){
1126 fprintf(stderr, "*** drop!\n");
1127 }else if (nb_frames > 1) {
1128 nb_frames_dup += nb_frames - 1;
1130 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1133 ost->sync_opts= lrintf(sync_ipts);
1135 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1139 formatted_picture = in_picture;
1140 final_picture = formatted_picture;
1141 padding_src = formatted_picture;
1142 resampling_dst = &ost->pict_tmp;
1144 if ( ost->resample_height != ist->st->codec->height
1145 || ost->resample_width != ist->st->codec->width
1146 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1148 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));
1149 if(!ost->video_resample)
1153 #if !CONFIG_AVFILTER
1154 if (ost->video_resample) {
1156 final_picture = &ost->pict_tmp;
1157 if( ost->resample_height != ist->st->codec->height
1158 || ost->resample_width != ist->st->codec->width
1159 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1161 /* initialize a new scaler context */
1162 sws_freeContext(ost->img_resample_ctx);
1163 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1164 ost->img_resample_ctx = sws_getContext(
1165 ist->st->codec->width,
1166 ist->st->codec->height,
1167 ist->st->codec->pix_fmt,
1168 ost->st->codec->width,
1169 ost->st->codec->height,
1170 ost->st->codec->pix_fmt,
1171 sws_flags, NULL, NULL, NULL);
1172 if (ost->img_resample_ctx == NULL) {
1173 fprintf(stderr, "Cannot get resampling context\n");
1177 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1178 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1182 /* duplicates frame if needed */
1183 for(i=0;i<nb_frames;i++) {
1185 av_init_packet(&pkt);
1186 pkt.stream_index= ost->index;
1188 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1189 /* raw pictures are written as AVPicture structure to
1190 avoid any copies. We support temorarily the older
1192 AVFrame* old_frame = enc->coded_frame;
1193 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1194 pkt.data= (uint8_t *)final_picture;
1195 pkt.size= sizeof(AVPicture);
1196 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1197 pkt.flags |= AV_PKT_FLAG_KEY;
1199 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1200 enc->coded_frame = old_frame;
1202 AVFrame big_picture;
1204 big_picture= *final_picture;
1205 /* better than nothing: use input picture interlaced
1207 big_picture.interlaced_frame = in_picture->interlaced_frame;
1208 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1209 if(top_field_first == -1)
1210 big_picture.top_field_first = in_picture->top_field_first;
1212 big_picture.top_field_first = top_field_first;
1215 /* handles sameq here. This is not correct because it may
1216 not be a global option */
1217 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1219 big_picture.pict_type = 0;
1220 // big_picture.pts = AV_NOPTS_VALUE;
1221 big_picture.pts= ost->sync_opts;
1222 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1223 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1224 if (ost->forced_kf_index < ost->forced_kf_count &&
1225 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1226 big_picture.pict_type = FF_I_TYPE;
1227 ost->forced_kf_index++;
1229 ret = avcodec_encode_video(enc,
1230 bit_buffer, bit_buffer_size,
1233 fprintf(stderr, "Video encoding failed\n");
1238 pkt.data= bit_buffer;
1240 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1241 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1242 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1243 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1244 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1246 if(enc->coded_frame->key_frame)
1247 pkt.flags |= AV_PKT_FLAG_KEY;
1248 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1251 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1252 // enc->frame_number-1, ret, enc->pict_type);
1253 /* if two pass, output log */
1254 if (ost->logfile && enc->stats_out) {
1255 fprintf(ost->logfile, "%s", enc->stats_out);
1260 ost->frame_number++;
1264 static double psnr(double d){
1265 return -10.0*log(d)/log(10.0);
1268 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1271 AVCodecContext *enc;
1273 double ti1, bitrate, avg_bitrate;
1275 /* this is executed just the first time do_video_stats is called */
1277 vstats_file = fopen(vstats_filename, "w");
1284 enc = ost->st->codec;
1285 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1286 frame_number = ost->frame_number;
1287 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1288 if (enc->flags&CODEC_FLAG_PSNR)
1289 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1291 fprintf(vstats_file,"f_size= %6d ", frame_size);
1292 /* compute pts value */
1293 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1297 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1298 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1299 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1300 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1301 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1305 static void print_report(AVFormatContext **output_files,
1306 AVOutputStream **ost_table, int nb_ostreams,
1310 AVOutputStream *ost;
1311 AVFormatContext *oc;
1313 AVCodecContext *enc;
1314 int frame_number, vid, i;
1315 double bitrate, ti1, pts;
1316 static int64_t last_time = -1;
1317 static int qp_histogram[52];
1319 if (!is_last_report) {
1321 /* display the report every 0.5 seconds */
1322 cur_time = av_gettime();
1323 if (last_time == -1) {
1324 last_time = cur_time;
1327 if ((cur_time - last_time) < 500000)
1329 last_time = cur_time;
1333 oc = output_files[0];
1335 total_size = url_fsize(oc->pb);
1336 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1337 total_size= url_ftell(oc->pb);
1342 for(i=0;i<nb_ostreams;i++) {
1344 enc = ost->st->codec;
1345 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1347 !ost->st->stream_copy ?
1348 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1350 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1351 float t = (av_gettime()-timer_start) / 1000000.0;
1353 frame_number = ost->frame_number;
1354 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1355 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1356 !ost->st->stream_copy ?
1357 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1359 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1362 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1363 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1368 if (enc->flags&CODEC_FLAG_PSNR){
1370 double error, error_sum=0;
1371 double scale, scale_sum=0;
1372 char type[3]= {'Y','U','V'};
1373 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1376 error= enc->error[j];
1377 scale= enc->width*enc->height*255.0*255.0*frame_number;
1379 error= enc->coded_frame->error[j];
1380 scale= enc->width*enc->height*255.0*255.0;
1385 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1391 /* compute min output value */
1392 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1393 if ((pts < ti1) && (pts > 0))
1399 if (verbose || is_last_report) {
1400 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1403 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1404 (double)total_size / 1024, ti1, bitrate);
1406 if (nb_frames_dup || nb_frames_drop)
1407 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1408 nb_frames_dup, nb_frames_drop);
1411 fprintf(stderr, "%s \r", buf);
1416 if (is_last_report && verbose >= 0){
1417 int64_t raw= audio_size + video_size + extra_size;
1418 fprintf(stderr, "\n");
1419 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1423 100.0*(total_size - raw)/raw
1428 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1429 static int output_packet(AVInputStream *ist, int ist_index,
1430 AVOutputStream **ost_table, int nb_ostreams,
1431 const AVPacket *pkt)
1433 AVFormatContext *os;
1434 AVOutputStream *ost;
1438 void *buffer_to_free;
1439 static unsigned int samples_size= 0;
1440 AVSubtitle subtitle, *subtitle_to_free;
1441 int64_t pkt_pts = AV_NOPTS_VALUE;
1443 int frame_available;
1447 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1449 if(ist->next_pts == AV_NOPTS_VALUE)
1450 ist->next_pts= ist->pts;
1454 av_init_packet(&avpkt);
1462 if(pkt->dts != AV_NOPTS_VALUE)
1463 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1464 if(pkt->pts != AV_NOPTS_VALUE)
1465 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1467 //while we have more to decode or while the decoder did output something on EOF
1468 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1469 uint8_t *data_buf, *decoded_data_buf;
1470 int data_size, decoded_data_size;
1472 ist->pts= ist->next_pts;
1474 if(avpkt.size && avpkt.size != pkt->size &&
1475 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1476 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1477 ist->showed_multi_packet_warning=1;
1480 /* decode the packet if needed */
1481 decoded_data_buf = NULL; /* fail safe */
1482 decoded_data_size= 0;
1483 data_buf = avpkt.data;
1484 data_size = avpkt.size;
1485 subtitle_to_free = NULL;
1486 if (ist->decoding_needed) {
1487 switch(ist->st->codec->codec_type) {
1488 case AVMEDIA_TYPE_AUDIO:{
1489 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1490 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1492 samples= av_malloc(samples_size);
1494 decoded_data_size= samples_size;
1495 /* XXX: could avoid copy if PCM 16 bits with same
1496 endianness as CPU */
1497 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1504 /* Some bug in mpeg audio decoder gives */
1505 /* decoded_data_size < 0, it seems they are overflows */
1506 if (decoded_data_size <= 0) {
1507 /* no audio frame */
1510 decoded_data_buf = (uint8_t *)samples;
1511 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1512 (ist->st->codec->sample_rate * ist->st->codec->channels);
1514 case AVMEDIA_TYPE_VIDEO:
1515 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1516 /* XXX: allocate picture correctly */
1517 avcodec_get_frame_defaults(&picture);
1518 ist->st->codec->reordered_opaque = pkt_pts;
1519 pkt_pts = AV_NOPTS_VALUE;
1521 ret = avcodec_decode_video2(ist->st->codec,
1522 &picture, &got_picture, &avpkt);
1523 ist->st->quality= picture.quality;
1527 /* no picture yet */
1528 goto discard_packet;
1530 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1531 if (ist->st->codec->time_base.num != 0) {
1532 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1533 ist->next_pts += ((int64_t)AV_TIME_BASE *
1534 ist->st->codec->time_base.num * ticks) /
1535 ist->st->codec->time_base.den;
1539 case AVMEDIA_TYPE_SUBTITLE:
1540 ret = avcodec_decode_subtitle2(ist->st->codec,
1541 &subtitle, &got_picture, &avpkt);
1545 goto discard_packet;
1547 subtitle_to_free = &subtitle;
1554 switch(ist->st->codec->codec_type) {
1555 case AVMEDIA_TYPE_AUDIO:
1556 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1557 ist->st->codec->sample_rate;
1559 case AVMEDIA_TYPE_VIDEO:
1560 if (ist->st->codec->time_base.num != 0) {
1561 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1562 ist->next_pts += ((int64_t)AV_TIME_BASE *
1563 ist->st->codec->time_base.num * ticks) /
1564 ist->st->codec->time_base.den;
1572 buffer_to_free = NULL;
1573 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1574 pre_process_video_frame(ist, (AVPicture *)&picture,
1579 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1580 // add it to be filtered
1581 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1583 ist->st->codec->sample_aspect_ratio);
1587 // preprocess audio (volume)
1588 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1589 if (audio_volume != 256) {
1592 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1593 int v = ((*volp) * audio_volume + 128) >> 8;
1594 if (v < -32768) v = -32768;
1595 if (v > 32767) v = 32767;
1601 /* frame rate emulation */
1603 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1604 int64_t now = av_gettime() - ist->start;
1609 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1610 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1612 /* if output time reached then transcode raw format,
1613 encode packets and output them */
1614 if (start_time == 0 || ist->pts >= start_time)
1616 while (frame_available) {
1617 AVRational ist_pts_tb;
1618 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1619 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1621 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1623 for(i=0;i<nb_ostreams;i++) {
1627 if (ost->source_index == ist_index) {
1628 os = output_files[ost->file_index];
1630 /* set the input output pts pairs */
1631 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1633 if (ost->encoding_needed) {
1634 av_assert0(ist->decoding_needed);
1635 switch(ost->st->codec->codec_type) {
1636 case AVMEDIA_TYPE_AUDIO:
1637 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1639 case AVMEDIA_TYPE_VIDEO:
1641 if (ist->picref->video)
1642 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1644 do_video_out(os, ost, ist, &picture, &frame_size);
1645 if (vstats_filename && frame_size)
1646 do_video_stats(os, ost, frame_size);
1648 case AVMEDIA_TYPE_SUBTITLE:
1649 do_subtitle_out(os, ost, ist, &subtitle,
1656 AVFrame avframe; //FIXME/XXX remove this
1658 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1660 av_init_packet(&opkt);
1662 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1665 /* no reencoding needed : output the packet directly */
1666 /* force the input stream PTS */
1668 avcodec_get_frame_defaults(&avframe);
1669 ost->st->codec->coded_frame= &avframe;
1670 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1672 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1673 audio_size += data_size;
1674 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1675 video_size += data_size;
1679 opkt.stream_index= ost->index;
1680 if(pkt->pts != AV_NOPTS_VALUE)
1681 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1683 opkt.pts= AV_NOPTS_VALUE;
1685 if (pkt->dts == AV_NOPTS_VALUE)
1686 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1688 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1689 opkt.dts -= ost_tb_start_time;
1691 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1692 opkt.flags= pkt->flags;
1694 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1695 if( ost->st->codec->codec_id != CODEC_ID_H264
1696 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1697 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1699 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1700 opkt.destruct= av_destruct_packet;
1702 opkt.data = data_buf;
1703 opkt.size = data_size;
1706 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1707 ost->st->codec->frame_number++;
1708 ost->frame_number++;
1709 av_free_packet(&opkt);
1715 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1716 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1718 avfilter_unref_buffer(ist->picref);
1721 av_free(buffer_to_free);
1722 /* XXX: allocate the subtitles in the codec ? */
1723 if (subtitle_to_free) {
1724 if (subtitle_to_free->rects != NULL) {
1725 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1726 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1727 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1728 av_freep(&subtitle_to_free->rects[i]);
1730 av_freep(&subtitle_to_free->rects);
1732 subtitle_to_free->num_rects = 0;
1733 subtitle_to_free = NULL;
1740 for(i=0;i<nb_ostreams;i++) {
1742 if (ost->source_index == ist_index) {
1743 AVCodecContext *enc= ost->st->codec;
1744 os = output_files[ost->file_index];
1746 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1748 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1751 if (ost->encoding_needed) {
1755 av_init_packet(&pkt);
1756 pkt.stream_index= ost->index;
1758 switch(ost->st->codec->codec_type) {
1759 case AVMEDIA_TYPE_AUDIO:
1760 fifo_bytes = av_fifo_size(ost->fifo);
1762 /* encode any samples remaining in fifo */
1763 if (fifo_bytes > 0) {
1764 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1765 int fs_tmp = enc->frame_size;
1767 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1768 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1769 enc->frame_size = fifo_bytes / (osize * enc->channels);
1771 int frame_bytes = enc->frame_size*osize*enc->channels;
1772 if (allocated_audio_buf_size < frame_bytes)
1774 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1777 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1778 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1779 ost->st->time_base.num, enc->sample_rate);
1780 enc->frame_size = fs_tmp;
1783 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1786 fprintf(stderr, "Audio encoding failed\n");
1790 pkt.flags |= AV_PKT_FLAG_KEY;
1792 case AVMEDIA_TYPE_VIDEO:
1793 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1795 fprintf(stderr, "Video encoding failed\n");
1799 if(enc->coded_frame && enc->coded_frame->key_frame)
1800 pkt.flags |= AV_PKT_FLAG_KEY;
1801 if (ost->logfile && enc->stats_out) {
1802 fprintf(ost->logfile, "%s", enc->stats_out);
1811 pkt.data= bit_buffer;
1813 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1814 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1815 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1827 static void print_sdp(AVFormatContext **avc, int n)
1831 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1832 printf("SDP:\n%s\n", sdp);
1836 static int copy_chapters(int infile, int outfile)
1838 AVFormatContext *is = input_files[infile];
1839 AVFormatContext *os = output_files[outfile];
1842 for (i = 0; i < is->nb_chapters; i++) {
1843 AVChapter *in_ch = is->chapters[i], *out_ch;
1844 AVMetadataTag *t = NULL;
1845 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1846 AV_TIME_BASE_Q, in_ch->time_base);
1847 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1848 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1851 if (in_ch->end < ts_off)
1853 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1856 out_ch = av_mallocz(sizeof(AVChapter));
1858 return AVERROR(ENOMEM);
1860 out_ch->id = in_ch->id;
1861 out_ch->time_base = in_ch->time_base;
1862 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1863 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1865 if (metadata_chapters_autocopy)
1866 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1867 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1870 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1872 return AVERROR(ENOMEM);
1873 os->chapters[os->nb_chapters - 1] = out_ch;
1878 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1879 AVCodecContext *avctx)
1885 for (p = kf; *p; p++)
1888 ost->forced_kf_count = n;
1889 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1890 if (!ost->forced_kf_pts) {
1891 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1894 for (i = 0; i < n; i++) {
1895 p = i ? strchr(p, ',') + 1 : kf;
1896 t = parse_time_or_die("force_key_frames", p, 1);
1897 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1902 * The following code is the main loop of the file converter
1904 static int transcode(AVFormatContext **output_files,
1905 int nb_output_files,
1906 AVFormatContext **input_files,
1908 AVStreamMap *stream_maps, int nb_stream_maps)
1910 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1911 AVFormatContext *is, *os;
1912 AVCodecContext *codec, *icodec;
1913 AVOutputStream *ost, **ost_table = NULL;
1914 AVInputStream *ist, **ist_table = NULL;
1915 AVInputFile *file_table;
1919 uint8_t no_packet[MAX_FILES]={0};
1920 int no_packet_count=0;
1922 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1926 /* input stream init */
1928 for(i=0;i<nb_input_files;i++) {
1929 is = input_files[i];
1930 file_table[i].ist_index = j;
1931 file_table[i].nb_streams = is->nb_streams;
1932 j += is->nb_streams;
1936 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1940 for(i=0;i<nb_istreams;i++) {
1941 ist = av_mallocz(sizeof(AVInputStream));
1947 for(i=0;i<nb_input_files;i++) {
1948 is = input_files[i];
1949 for(k=0;k<is->nb_streams;k++) {
1950 ist = ist_table[j++];
1951 ist->st = is->streams[k];
1952 ist->file_index = i;
1954 ist->discard = 1; /* the stream is discarded by default
1958 ist->start = av_gettime();
1963 /* output stream init */
1965 for(i=0;i<nb_output_files;i++) {
1966 os = output_files[i];
1967 if (!os->nb_streams) {
1968 dump_format(output_files[i], i, output_files[i]->filename, 1);
1969 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1970 ret = AVERROR(EINVAL);
1973 nb_ostreams += os->nb_streams;
1975 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1976 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1977 ret = AVERROR(EINVAL);
1981 /* Sanity check the mapping args -- do the input files & streams exist? */
1982 for(i=0;i<nb_stream_maps;i++) {
1983 int fi = stream_maps[i].file_index;
1984 int si = stream_maps[i].stream_index;
1986 if (fi < 0 || fi > nb_input_files - 1 ||
1987 si < 0 || si > file_table[fi].nb_streams - 1) {
1988 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1989 ret = AVERROR(EINVAL);
1992 fi = stream_maps[i].sync_file_index;
1993 si = stream_maps[i].sync_stream_index;
1994 if (fi < 0 || fi > nb_input_files - 1 ||
1995 si < 0 || si > file_table[fi].nb_streams - 1) {
1996 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1997 ret = AVERROR(EINVAL);
2002 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2006 for(k=0;k<nb_output_files;k++) {
2007 os = output_files[k];
2008 for(i=0;i<os->nb_streams;i++,n++) {
2010 ost = ost_table[n] = output_streams_for_file[k][i];
2011 ost->st = os->streams[i];
2012 if (nb_stream_maps > 0) {
2013 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2014 stream_maps[n].stream_index;
2016 /* Sanity check that the stream types match */
2017 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2018 int i= ost->file_index;
2019 dump_format(output_files[i], i, output_files[i]->filename, 1);
2020 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2021 stream_maps[n].file_index, stream_maps[n].stream_index,
2022 ost->file_index, ost->index);
2027 int best_nb_frames=-1;
2028 /* get corresponding input stream index : we select the first one with the right type */
2030 for(j=0;j<nb_istreams;j++) {
2035 AVFormatContext *f= input_files[ ist->file_index ];
2037 for(pi=0; pi<f->nb_programs; pi++){
2038 AVProgram *p= f->programs[pi];
2039 if(p->id == opt_programid)
2040 for(si=0; si<p->nb_stream_indexes; si++){
2041 if(f->streams[ p->stream_index[si] ] == ist->st)
2046 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2047 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2048 if(best_nb_frames < ist->st->codec_info_nb_frames){
2049 best_nb_frames= ist->st->codec_info_nb_frames;
2050 ost->source_index = j;
2057 if(! opt_programid) {
2058 /* try again and reuse existing stream */
2059 for(j=0;j<nb_istreams;j++) {
2061 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2062 && ist->st->discard != AVDISCARD_ALL) {
2063 ost->source_index = j;
2069 int i= ost->file_index;
2070 dump_format(output_files[i], i, output_files[i]->filename, 1);
2071 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2072 ost->file_index, ost->index);
2077 ist = ist_table[ost->source_index];
2079 ost->sync_ist = (nb_stream_maps > 0) ?
2080 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2081 stream_maps[n].sync_stream_index] : ist;
2085 /* for each output stream, we compute the right encoding parameters */
2086 for(i=0;i<nb_ostreams;i++) {
2087 AVMetadataTag *t = NULL;
2089 os = output_files[ost->file_index];
2090 ist = ist_table[ost->source_index];
2092 codec = ost->st->codec;
2093 icodec = ist->st->codec;
2095 if (metadata_streams_autocopy)
2096 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2097 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2100 ost->st->disposition = ist->st->disposition;
2101 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2102 codec->chroma_sample_location = icodec->chroma_sample_location;
2104 if (ost->st->stream_copy) {
2105 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2107 if (extra_size > INT_MAX)
2110 /* if stream_copy is selected, no need to decode or encode */
2111 codec->codec_id = icodec->codec_id;
2112 codec->codec_type = icodec->codec_type;
2114 if(!codec->codec_tag){
2115 if( !os->oformat->codec_tag
2116 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2117 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2118 codec->codec_tag = icodec->codec_tag;
2121 codec->bit_rate = icodec->bit_rate;
2122 codec->rc_max_rate = icodec->rc_max_rate;
2123 codec->rc_buffer_size = icodec->rc_buffer_size;
2124 codec->extradata= av_mallocz(extra_size);
2125 if (!codec->extradata)
2127 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2128 codec->extradata_size= icodec->extradata_size;
2129 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2130 codec->time_base = icodec->time_base;
2131 codec->time_base.num *= icodec->ticks_per_frame;
2132 av_reduce(&codec->time_base.num, &codec->time_base.den,
2133 codec->time_base.num, codec->time_base.den, INT_MAX);
2135 codec->time_base = ist->st->time_base;
2136 switch(codec->codec_type) {
2137 case AVMEDIA_TYPE_AUDIO:
2138 if(audio_volume != 256) {
2139 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2142 codec->channel_layout = icodec->channel_layout;
2143 codec->sample_rate = icodec->sample_rate;
2144 codec->channels = icodec->channels;
2145 codec->frame_size = icodec->frame_size;
2146 codec->block_align= icodec->block_align;
2147 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2148 codec->block_align= 0;
2149 if(codec->codec_id == CODEC_ID_AC3)
2150 codec->block_align= 0;
2152 case AVMEDIA_TYPE_VIDEO:
2153 codec->pix_fmt = icodec->pix_fmt;
2154 codec->width = icodec->width;
2155 codec->height = icodec->height;
2156 codec->has_b_frames = icodec->has_b_frames;
2158 case AVMEDIA_TYPE_SUBTITLE:
2159 codec->width = icodec->width;
2160 codec->height = icodec->height;
2166 switch(codec->codec_type) {
2167 case AVMEDIA_TYPE_AUDIO:
2168 ost->fifo= av_fifo_alloc(1024);
2171 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2172 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2173 icodec->request_channels = codec->channels;
2174 ist->decoding_needed = 1;
2175 ost->encoding_needed = 1;
2177 case AVMEDIA_TYPE_VIDEO:
2178 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2179 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2182 ost->video_resample = (codec->width != icodec->width ||
2183 codec->height != icodec->height ||
2184 (codec->pix_fmt != icodec->pix_fmt));
2185 if (ost->video_resample) {
2186 avcodec_get_frame_defaults(&ost->pict_tmp);
2187 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2188 codec->width, codec->height)) {
2189 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2192 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2193 ost->img_resample_ctx = sws_getContext(
2200 sws_flags, NULL, NULL, NULL);
2201 if (ost->img_resample_ctx == NULL) {
2202 fprintf(stderr, "Cannot get resampling context\n");
2206 #if !CONFIG_AVFILTER
2207 ost->original_height = icodec->height;
2208 ost->original_width = icodec->width;
2210 codec->bits_per_raw_sample= 0;
2212 ost->resample_height = icodec->height;
2213 ost->resample_width = icodec->width;
2214 ost->resample_pix_fmt= icodec->pix_fmt;
2215 ost->encoding_needed = 1;
2216 ist->decoding_needed = 1;
2219 if (configure_filters(ist, ost)) {
2220 fprintf(stderr, "Error opening filters!\n");
2225 case AVMEDIA_TYPE_SUBTITLE:
2226 ost->encoding_needed = 1;
2227 ist->decoding_needed = 1;
2234 if (ost->encoding_needed &&
2235 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2236 char logfilename[1024];
2239 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2240 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2242 if (codec->flags & CODEC_FLAG_PASS1) {
2243 f = fopen(logfilename, "wb");
2245 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2251 size_t logbuffer_size;
2252 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2253 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2256 codec->stats_in = logbuffer;
2260 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2261 int size= codec->width * codec->height;
2262 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2267 bit_buffer = av_malloc(bit_buffer_size);
2269 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2271 ret = AVERROR(ENOMEM);
2275 /* open each encoder */
2276 for(i=0;i<nb_ostreams;i++) {
2278 if (ost->encoding_needed) {
2279 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2281 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2283 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2284 ost->st->codec->codec_id, ost->file_index, ost->index);
2285 ret = AVERROR(EINVAL);
2288 if (avcodec_open(ost->st->codec, codec) < 0) {
2289 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2290 ost->file_index, ost->index);
2291 ret = AVERROR(EINVAL);
2294 extra_size += ost->st->codec->extradata_size;
2298 /* open each decoder */
2299 for(i=0;i<nb_istreams;i++) {
2301 if (ist->decoding_needed) {
2302 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2304 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2306 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2307 ist->st->codec->codec_id, ist->file_index, ist->index);
2308 ret = AVERROR(EINVAL);
2311 if (avcodec_open(ist->st->codec, codec) < 0) {
2312 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2313 ist->file_index, ist->index);
2314 ret = AVERROR(EINVAL);
2317 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2318 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2323 for(i=0;i<nb_istreams;i++) {
2327 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2328 ist->next_pts = AV_NOPTS_VALUE;
2329 init_pts_correction(&ist->pts_ctx);
2333 /* set meta data information from input file if required */
2334 for (i=0;i<nb_meta_data_maps;i++) {
2335 AVFormatContext *files[2];
2336 AVMetadata **meta[2];
2337 AVMetadataTag *mtag;
2340 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2341 if ((index) < 0 || (index) >= (nb_elems)) {\
2342 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2344 ret = AVERROR(EINVAL);\
2348 int out_file_index = meta_data_maps[i][0].file;
2349 int in_file_index = meta_data_maps[i][1].file;
2350 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2351 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2353 files[0] = output_files[out_file_index];
2354 files[1] = input_files[in_file_index];
2356 for (j = 0; j < 2; j++) {
2357 AVMetaDataMap *map = &meta_data_maps[i][j];
2359 switch (map->type) {
2361 meta[j] = &files[j]->metadata;
2364 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2365 meta[j] = &files[j]->streams[map->index]->metadata;
2368 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2369 meta[j] = &files[j]->chapters[map->index]->metadata;
2372 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2373 meta[j] = &files[j]->programs[map->index]->metadata;
2379 while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2380 av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2383 /* copy chapters from the first input file that has them*/
2384 for (i = 0; i < nb_input_files; i++) {
2385 if (!input_files[i]->nb_chapters)
2388 for (j = 0; j < nb_output_files; j++)
2389 if ((ret = copy_chapters(i, j)) < 0)
2393 /* open files and write file headers */
2394 for(i=0;i<nb_output_files;i++) {
2395 os = output_files[i];
2396 if (av_write_header(os) < 0) {
2397 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2398 ret = AVERROR(EINVAL);
2401 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2407 /* dump the file output parameters - cannot be done before in case
2409 for(i=0;i<nb_output_files;i++) {
2410 dump_format(output_files[i], i, output_files[i]->filename, 1);
2413 /* dump the stream mapping */
2415 fprintf(stderr, "Stream mapping:\n");
2416 for(i=0;i<nb_ostreams;i++) {
2418 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2419 ist_table[ost->source_index]->file_index,
2420 ist_table[ost->source_index]->index,
2423 if (ost->sync_ist != ist_table[ost->source_index])
2424 fprintf(stderr, " [sync #%d.%d]",
2425 ost->sync_ist->file_index,
2426 ost->sync_ist->index);
2427 fprintf(stderr, "\n");
2432 fprintf(stderr, "%s\n", error);
2437 print_sdp(output_files, nb_output_files);
2440 if (!using_stdin && verbose >= 0) {
2441 fprintf(stderr, "Press [q] to stop encoding\n");
2442 url_set_interrupt_cb(decode_interrupt_cb);
2446 timer_start = av_gettime();
2448 for(; received_sigterm == 0;) {
2449 int file_index, ist_index;
2457 /* if 'q' pressed, exits */
2461 /* read_key() returns 0 on EOF */
2467 /* select the stream that we must read now by looking at the
2468 smallest output pts */
2470 for(i=0;i<nb_ostreams;i++) {
2473 os = output_files[ost->file_index];
2474 ist = ist_table[ost->source_index];
2475 if(ist->is_past_recording_time || no_packet[ist->file_index])
2477 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2478 ipts = (double)ist->pts;
2479 if (!file_table[ist->file_index].eof_reached){
2480 if(ipts < ipts_min) {
2482 if(input_sync ) file_index = ist->file_index;
2484 if(opts < opts_min) {
2486 if(!input_sync) file_index = ist->file_index;
2489 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2494 /* if none, if is finished */
2495 if (file_index < 0) {
2496 if(no_packet_count){
2498 memset(no_packet, 0, sizeof(no_packet));
2505 /* finish if limit size exhausted */
2506 if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2509 /* read a frame from it and output it in the fifo */
2510 is = input_files[file_index];
2511 ret= av_read_frame(is, &pkt);
2512 if(ret == AVERROR(EAGAIN)){
2513 no_packet[file_index]=1;
2518 file_table[file_index].eof_reached = 1;
2526 memset(no_packet, 0, sizeof(no_packet));
2529 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2531 /* the following test is needed in case new streams appear
2532 dynamically in stream : we ignore them */
2533 if (pkt.stream_index >= file_table[file_index].nb_streams)
2534 goto discard_packet;
2535 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2536 ist = ist_table[ist_index];
2538 goto discard_packet;
2540 if (pkt.dts != AV_NOPTS_VALUE)
2541 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2542 if (pkt.pts != AV_NOPTS_VALUE)
2543 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2545 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2546 && input_files_ts_scale[file_index][pkt.stream_index]){
2547 if(pkt.pts != AV_NOPTS_VALUE)
2548 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2549 if(pkt.dts != AV_NOPTS_VALUE)
2550 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2553 // 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);
2554 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2555 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2556 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2557 int64_t delta= pkt_dts - ist->next_pts;
2558 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2559 input_files_ts_offset[ist->file_index]-= delta;
2561 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2562 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2563 if(pkt.pts != AV_NOPTS_VALUE)
2564 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2568 /* finish if recording time exhausted */
2569 if (recording_time != INT64_MAX &&
2570 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2571 ist->is_past_recording_time = 1;
2572 goto discard_packet;
2575 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2576 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2579 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2580 ist->file_index, ist->index);
2583 av_free_packet(&pkt);
2588 av_free_packet(&pkt);
2590 /* dump report by using the output first video and audio streams */
2591 print_report(output_files, ost_table, nb_ostreams, 0);
2594 /* at the end of stream, we must flush the decoder buffers */
2595 for(i=0;i<nb_istreams;i++) {
2597 if (ist->decoding_needed) {
2598 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2604 /* write the trailer if needed and close file */
2605 for(i=0;i<nb_output_files;i++) {
2606 os = output_files[i];
2607 av_write_trailer(os);
2610 /* dump report by using the first video and audio streams */
2611 print_report(output_files, ost_table, nb_ostreams, 1);
2613 /* close each encoder */
2614 for(i=0;i<nb_ostreams;i++) {
2616 if (ost->encoding_needed) {
2617 av_freep(&ost->st->codec->stats_in);
2618 avcodec_close(ost->st->codec);
2622 /* close each decoder */
2623 for(i=0;i<nb_istreams;i++) {
2625 if (ist->decoding_needed) {
2626 avcodec_close(ist->st->codec);
2631 avfilter_graph_destroy(graph);
2640 av_freep(&bit_buffer);
2641 av_free(file_table);
2644 for(i=0;i<nb_istreams;i++) {
2651 for(i=0;i<nb_ostreams;i++) {
2654 if (ost->st->stream_copy)
2655 av_freep(&ost->st->codec->extradata);
2657 fclose(ost->logfile);
2658 ost->logfile = NULL;
2660 av_fifo_free(ost->fifo); /* works even if fifo is not
2661 initialized but set to zero */
2662 av_free(ost->pict_tmp.data[0]);
2663 av_free(ost->forced_kf_pts);
2664 if (ost->video_resample)
2665 sws_freeContext(ost->img_resample_ctx);
2667 audio_resample_close(ost->resample);
2668 if (ost->reformat_ctx)
2669 av_audio_convert_free(ost->reformat_ctx);
2678 static void opt_format(const char *arg)
2680 last_asked_format = arg;
2683 static void opt_video_rc_override_string(const char *arg)
2685 video_rc_override_string = arg;
2688 static int opt_me_threshold(const char *opt, const char *arg)
2690 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2694 static int opt_verbose(const char *opt, const char *arg)
2696 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2700 static int opt_frame_rate(const char *opt, const char *arg)
2702 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2703 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2709 static int opt_bitrate(const char *opt, const char *arg)
2711 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2713 opt_default(opt, arg);
2715 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2716 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2721 static int opt_frame_crop(const char *opt, const char *arg)
2723 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2724 return AVERROR(EINVAL);
2727 static void opt_frame_size(const char *arg)
2729 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2730 fprintf(stderr, "Incorrect frame size\n");
2735 static int opt_pad(const char *opt, const char *arg) {
2736 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2740 static void opt_frame_pix_fmt(const char *arg)
2742 if (strcmp(arg, "list")) {
2743 frame_pix_fmt = av_get_pix_fmt(arg);
2744 if (frame_pix_fmt == PIX_FMT_NONE) {
2745 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2754 static void opt_frame_aspect_ratio(const char *arg)
2761 p = strchr(arg, ':');
2763 x = strtol(arg, &end, 10);
2765 y = strtol(end+1, &end, 10);
2767 ar = (double)x / (double)y;
2769 ar = strtod(arg, NULL);
2772 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2775 frame_aspect_ratio = ar;
2778 static int opt_metadata(const char *opt, const char *arg)
2780 char *mid= strchr(arg, '=');
2783 fprintf(stderr, "Missing =\n");
2788 av_metadata_set2(&metadata, arg, mid, 0);
2793 static void opt_qscale(const char *arg)
2795 video_qscale = atof(arg);
2796 if (video_qscale <= 0 ||
2797 video_qscale > 255) {
2798 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2803 static void opt_top_field_first(const char *arg)
2805 top_field_first= atoi(arg);
2808 static int opt_thread_count(const char *opt, const char *arg)
2810 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2813 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2818 static void opt_audio_sample_fmt(const char *arg)
2820 if (strcmp(arg, "list"))
2821 audio_sample_fmt = av_get_sample_fmt(arg);
2823 list_fmts(av_get_sample_fmt_string, SAMPLE_FMT_NB);
2828 static int opt_audio_rate(const char *opt, const char *arg)
2830 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2834 static int opt_audio_channels(const char *opt, const char *arg)
2836 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2840 static void opt_video_channel(const char *arg)
2842 video_channel = strtol(arg, NULL, 0);
2845 static void opt_video_standard(const char *arg)
2847 video_standard = av_strdup(arg);
2850 static void opt_codec(int *pstream_copy, char **pcodec_name,
2851 int codec_type, const char *arg)
2853 av_freep(pcodec_name);
2854 if (!strcmp(arg, "copy")) {
2857 *pcodec_name = av_strdup(arg);
2861 static void opt_audio_codec(const char *arg)
2863 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2866 static void opt_video_codec(const char *arg)
2868 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2871 static void opt_subtitle_codec(const char *arg)
2873 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2876 static int opt_codec_tag(const char *opt, const char *arg)
2879 uint32_t *codec_tag;
2881 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2882 !strcmp(opt, "vtag") ? &video_codec_tag :
2883 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2887 *codec_tag = strtol(arg, &tail, 0);
2889 *codec_tag = AV_RL32(arg);
2894 static void opt_map(const char *arg)
2899 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2900 m = &stream_maps[nb_stream_maps-1];
2902 m->file_index = strtol(arg, &p, 0);
2906 m->stream_index = strtol(p, &p, 0);
2909 m->sync_file_index = strtol(p, &p, 0);
2912 m->sync_stream_index = strtol(p, &p, 0);
2914 m->sync_file_index = m->file_index;
2915 m->sync_stream_index = m->stream_index;
2919 static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
2930 *index = strtol(++arg, endptr, 0);
2933 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2940 static void opt_map_meta_data(const char *arg)
2942 AVMetaDataMap *m, *m1;
2945 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2946 &nb_meta_data_maps, nb_meta_data_maps + 1);
2948 m = &meta_data_maps[nb_meta_data_maps - 1][0];
2949 m->file = strtol(arg, &p, 0);
2950 parse_meta_type(p, &m->type, &m->index, &p);
2954 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2955 m1->file = strtol(p, &p, 0);
2956 parse_meta_type(p, &m1->type, &m1->index, &p);
2958 if (m->type == 's' || m1->type == 's')
2959 metadata_streams_autocopy = 0;
2960 if (m->type == 'c' || m1->type == 'c')
2961 metadata_chapters_autocopy = 0;
2964 static void opt_input_ts_scale(const char *arg)
2966 unsigned int stream;
2970 stream = strtol(arg, &p, 0);
2973 scale= strtod(p, &p);
2975 if(stream >= MAX_STREAMS)
2978 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);
2979 input_files_ts_scale[nb_input_files][stream]= scale;
2982 static int opt_recording_time(const char *opt, const char *arg)
2984 recording_time = parse_time_or_die(opt, arg, 1);
2988 static int opt_start_time(const char *opt, const char *arg)
2990 start_time = parse_time_or_die(opt, arg, 1);
2994 static int opt_recording_timestamp(const char *opt, const char *arg)
2996 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3000 static int opt_input_ts_offset(const char *opt, const char *arg)
3002 input_ts_offset = parse_time_or_die(opt, arg, 1);
3006 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3008 const char *codec_string = encoder ? "encoder" : "decoder";
3012 return CODEC_ID_NONE;
3014 avcodec_find_encoder_by_name(name) :
3015 avcodec_find_decoder_by_name(name);
3017 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3020 if(codec->type != type) {
3021 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3024 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3025 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3026 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3027 "results.\nAdd '-strict experimental' if you want to use it.\n",
3028 codec_string, codec->name);
3030 avcodec_find_encoder(codec->id) :
3031 avcodec_find_decoder(codec->id);
3032 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3033 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3034 codec_string, codec->name);
3040 static void opt_input_file(const char *filename)
3042 AVFormatContext *ic;
3043 AVFormatParameters params, *ap = ¶ms;
3044 AVInputFormat *file_iformat = NULL;
3045 int err, i, ret, rfps, rfps_base;
3048 if (last_asked_format) {
3049 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3050 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3053 last_asked_format = NULL;
3056 if (!strcmp(filename, "-"))
3059 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3060 !strcmp(filename, "/dev/stdin");
3062 /* get default parameters from command line */
3063 ic = avformat_alloc_context();
3065 print_error(filename, AVERROR(ENOMEM));
3069 memset(ap, 0, sizeof(*ap));
3070 ap->prealloced_context = 1;
3071 ap->sample_rate = audio_sample_rate;
3072 ap->channels = audio_channels;
3073 ap->time_base.den = frame_rate.num;
3074 ap->time_base.num = frame_rate.den;
3075 ap->width = frame_width;
3076 ap->height = frame_height;
3077 ap->pix_fmt = frame_pix_fmt;
3078 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3079 ap->channel = video_channel;
3080 ap->standard = video_standard;
3082 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3084 ic->video_codec_id =
3085 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3086 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3087 ic->audio_codec_id =
3088 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3089 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3090 ic->subtitle_codec_id=
3091 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3092 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3093 ic->flags |= AVFMT_FLAG_NONBLOCK;
3095 /* open the input file with generic libav function */
3096 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3098 print_error(filename, err);
3104 for(i=0; i<ic->nb_streams; i++){
3105 ic->streams[i]->discard= AVDISCARD_ALL;
3107 for(i=0; i<ic->nb_programs; i++){
3108 AVProgram *p= ic->programs[i];
3109 if(p->id != opt_programid){
3110 p->discard = AVDISCARD_ALL;
3113 for(j=0; j<p->nb_stream_indexes; j++){
3114 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3119 fprintf(stderr, "Specified program id not found\n");
3125 ic->loop_input = loop_input;
3127 /* If not enough info to get the stream parameters, we decode the
3128 first frames to get it. (used in mpeg case for example) */
3129 ret = av_find_stream_info(ic);
3130 if (ret < 0 && verbose >= 0) {
3131 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3132 av_close_input_file(ic);
3136 timestamp = start_time;
3137 /* add the stream start time */
3138 if (ic->start_time != AV_NOPTS_VALUE)
3139 timestamp += ic->start_time;
3141 /* if seeking requested, we execute it */
3142 if (start_time != 0) {
3143 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3145 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3146 filename, (double)timestamp / AV_TIME_BASE);
3148 /* reset seek info */
3152 /* update the current parameters so that they match the one of the input stream */
3153 for(i=0;i<ic->nb_streams;i++) {
3154 AVStream *st = ic->streams[i];
3155 AVCodecContext *dec = st->codec;
3156 avcodec_thread_init(dec, thread_count);
3157 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3158 switch (dec->codec_type) {
3159 case AVMEDIA_TYPE_AUDIO:
3160 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3161 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]);
3162 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3163 channel_layout = dec->channel_layout;
3164 audio_channels = dec->channels;
3165 audio_sample_rate = dec->sample_rate;
3166 audio_sample_fmt = dec->sample_fmt;
3168 st->discard= AVDISCARD_ALL;
3169 /* Note that av_find_stream_info can add more streams, and we
3170 * currently have no chance of setting up lowres decoding
3171 * early enough for them. */
3173 audio_sample_rate >>= dec->lowres;
3175 case AVMEDIA_TYPE_VIDEO:
3176 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3177 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]);
3178 frame_height = dec->height;
3179 frame_width = dec->width;
3180 if(ic->streams[i]->sample_aspect_ratio.num)
3181 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3183 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3184 frame_aspect_ratio *= (float) dec->width / dec->height;
3185 frame_pix_fmt = dec->pix_fmt;
3186 rfps = ic->streams[i]->r_frame_rate.num;
3187 rfps_base = ic->streams[i]->r_frame_rate.den;
3189 dec->flags |= CODEC_FLAG_EMU_EDGE;
3190 frame_height >>= dec->lowres;
3191 frame_width >>= dec->lowres;
3194 dec->debug |= FF_DEBUG_MV;
3196 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3199 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3200 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3202 (float)rfps / rfps_base, rfps, rfps_base);
3204 /* update the current frame rate to match the stream frame rate */
3205 frame_rate.num = rfps;
3206 frame_rate.den = rfps_base;
3209 st->discard= AVDISCARD_ALL;
3210 else if(video_discard)
3211 st->discard= video_discard;
3213 case AVMEDIA_TYPE_DATA:
3215 case AVMEDIA_TYPE_SUBTITLE:
3216 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3217 if(subtitle_disable)
3218 st->discard = AVDISCARD_ALL;
3220 case AVMEDIA_TYPE_ATTACHMENT:
3221 case AVMEDIA_TYPE_UNKNOWN:
3228 input_files[nb_input_files] = ic;
3229 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3230 /* dump the file content */
3232 dump_format(ic, nb_input_files, filename, 0);
3238 av_freep(&video_codec_name);
3239 av_freep(&audio_codec_name);
3240 av_freep(&subtitle_codec_name);
3243 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3244 int *has_subtitle_ptr)
3246 int has_video, has_audio, has_subtitle, i, j;
3247 AVFormatContext *ic;
3252 for(j=0;j<nb_input_files;j++) {
3253 ic = input_files[j];
3254 for(i=0;i<ic->nb_streams;i++) {
3255 AVCodecContext *enc = ic->streams[i]->codec;
3256 switch(enc->codec_type) {
3257 case AVMEDIA_TYPE_AUDIO:
3260 case AVMEDIA_TYPE_VIDEO:
3263 case AVMEDIA_TYPE_SUBTITLE:
3266 case AVMEDIA_TYPE_DATA:
3267 case AVMEDIA_TYPE_ATTACHMENT:
3268 case AVMEDIA_TYPE_UNKNOWN:
3275 *has_video_ptr = has_video;
3276 *has_audio_ptr = has_audio;
3277 *has_subtitle_ptr = has_subtitle;
3280 static void new_video_stream(AVFormatContext *oc, int file_idx)
3283 AVOutputStream *ost;
3284 AVCodecContext *video_enc;
3285 enum CodecID codec_id;
3286 AVCodec *codec= NULL;
3288 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3290 fprintf(stderr, "Could not alloc stream\n");
3293 ost = new_output_stream(oc, file_idx);
3295 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3296 if(!video_stream_copy){
3297 if (video_codec_name) {
3298 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3299 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3300 codec = avcodec_find_encoder_by_name(video_codec_name);
3301 output_codecs[nb_output_codecs-1] = codec;
3303 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3304 codec = avcodec_find_encoder(codec_id);
3308 avcodec_get_context_defaults3(st->codec, codec);
3309 ost->bitstream_filters = video_bitstream_filters;
3310 video_bitstream_filters= NULL;
3312 avcodec_thread_init(st->codec, thread_count);
3314 video_enc = st->codec;
3317 video_enc->codec_tag= video_codec_tag;
3319 if( (video_global_header&1)
3320 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3321 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3322 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3324 if(video_global_header&2){
3325 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3326 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3329 if (video_stream_copy) {
3330 st->stream_copy = 1;
3331 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3332 video_enc->sample_aspect_ratio =
3333 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3337 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3339 video_enc->codec_id = codec_id;
3340 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3342 if (codec && codec->supported_framerates && !force_fps)
3343 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3344 video_enc->time_base.den = fps.num;
3345 video_enc->time_base.num = fps.den;
3347 video_enc->width = frame_width;
3348 video_enc->height = frame_height;
3349 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3350 video_enc->pix_fmt = frame_pix_fmt;
3351 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3353 choose_pixel_fmt(st, codec);
3356 video_enc->gop_size = 0;
3357 if (video_qscale || same_quality) {
3358 video_enc->flags |= CODEC_FLAG_QSCALE;
3359 video_enc->global_quality=
3360 st->quality = FF_QP2LAMBDA * video_qscale;
3364 video_enc->intra_matrix = intra_matrix;
3366 video_enc->inter_matrix = inter_matrix;
3368 p= video_rc_override_string;
3371 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3373 fprintf(stderr, "error parsing rc_override\n");
3376 video_enc->rc_override=
3377 av_realloc(video_enc->rc_override,
3378 sizeof(RcOverride)*(i+1));
3379 video_enc->rc_override[i].start_frame= start;
3380 video_enc->rc_override[i].end_frame = end;
3382 video_enc->rc_override[i].qscale= q;
3383 video_enc->rc_override[i].quality_factor= 1.0;
3386 video_enc->rc_override[i].qscale= 0;
3387 video_enc->rc_override[i].quality_factor= -q/100.0;
3392 video_enc->rc_override_count=i;
3393 if (!video_enc->rc_initial_buffer_occupancy)
3394 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3395 video_enc->me_threshold= me_threshold;
3396 video_enc->intra_dc_precision= intra_dc_precision - 8;
3399 video_enc->flags|= CODEC_FLAG_PSNR;
3404 video_enc->flags |= CODEC_FLAG_PASS1;
3406 video_enc->flags |= CODEC_FLAG_PASS2;
3410 if (forced_key_frames)
3411 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3413 if (video_language) {
3414 av_metadata_set2(&st->metadata, "language", video_language, 0);
3415 av_freep(&video_language);
3418 /* reset some key parameters */
3420 av_freep(&video_codec_name);
3421 av_freep(&forced_key_frames);
3422 video_stream_copy = 0;
3423 frame_pix_fmt = PIX_FMT_NONE;
3426 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3429 AVOutputStream *ost;
3430 AVCodec *codec= NULL;
3431 AVCodecContext *audio_enc;
3432 enum CodecID codec_id;
3434 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3436 fprintf(stderr, "Could not alloc stream\n");
3439 ost = new_output_stream(oc, file_idx);
3441 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3442 if(!audio_stream_copy){
3443 if (audio_codec_name) {
3444 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3445 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3446 codec = avcodec_find_encoder_by_name(audio_codec_name);
3447 output_codecs[nb_output_codecs-1] = codec;
3449 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3450 codec = avcodec_find_encoder(codec_id);
3454 avcodec_get_context_defaults3(st->codec, codec);
3456 ost->bitstream_filters = audio_bitstream_filters;
3457 audio_bitstream_filters= NULL;
3459 avcodec_thread_init(st->codec, thread_count);
3461 audio_enc = st->codec;
3462 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3465 audio_enc->codec_tag= audio_codec_tag;
3467 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3468 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3469 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3471 if (audio_stream_copy) {
3472 st->stream_copy = 1;
3473 audio_enc->channels = audio_channels;
3474 audio_enc->sample_rate = audio_sample_rate;
3476 audio_enc->codec_id = codec_id;
3477 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3479 if (audio_qscale > QSCALE_NONE) {
3480 audio_enc->flags |= CODEC_FLAG_QSCALE;
3481 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3483 audio_enc->channels = audio_channels;
3484 audio_enc->sample_fmt = audio_sample_fmt;
3485 audio_enc->sample_rate = audio_sample_rate;
3486 audio_enc->channel_layout = channel_layout;
3487 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3488 audio_enc->channel_layout = 0;
3489 choose_sample_fmt(st, codec);
3490 choose_sample_rate(st, codec);
3492 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3493 if (audio_language) {
3494 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3495 av_freep(&audio_language);
3498 /* reset some key parameters */
3500 av_freep(&audio_codec_name);
3501 audio_stream_copy = 0;
3504 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3507 AVOutputStream *ost;
3508 AVCodec *codec=NULL;
3509 AVCodecContext *subtitle_enc;
3511 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3513 fprintf(stderr, "Could not alloc stream\n");
3516 ost = new_output_stream(oc, file_idx);
3517 subtitle_enc = st->codec;
3518 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3519 if(!subtitle_stream_copy){
3520 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3521 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3522 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3524 avcodec_get_context_defaults3(st->codec, codec);
3526 ost->bitstream_filters = subtitle_bitstream_filters;
3527 subtitle_bitstream_filters= NULL;
3529 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3531 if(subtitle_codec_tag)
3532 subtitle_enc->codec_tag= subtitle_codec_tag;
3534 if (subtitle_stream_copy) {
3535 st->stream_copy = 1;
3537 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3540 if (subtitle_language) {
3541 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3542 av_freep(&subtitle_language);
3545 subtitle_disable = 0;
3546 av_freep(&subtitle_codec_name);
3547 subtitle_stream_copy = 0;
3550 static int opt_new_stream(const char *opt, const char *arg)
3552 AVFormatContext *oc;
3553 int file_idx = nb_output_files - 1;
3554 if (nb_output_files <= 0) {
3555 fprintf(stderr, "At least one output file must be specified\n");
3558 oc = output_files[file_idx];
3560 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3561 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3562 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3567 /* arg format is "output-stream-index:streamid-value". */
3568 static int opt_streamid(const char *opt, const char *arg)
3574 strncpy(idx_str, arg, sizeof(idx_str));
3575 idx_str[sizeof(idx_str)-1] = '\0';
3576 p = strchr(idx_str, ':');
3579 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3584 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3585 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3586 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3590 static void opt_output_file(const char *filename)
3592 AVFormatContext *oc;
3593 int err, use_video, use_audio, use_subtitle;
3594 int input_has_video, input_has_audio, input_has_subtitle;
3595 AVFormatParameters params, *ap = ¶ms;
3596 AVOutputFormat *file_oformat;
3597 AVMetadataTag *tag = NULL;
3599 if (!strcmp(filename, "-"))
3602 oc = avformat_alloc_context();
3604 print_error(filename, AVERROR(ENOMEM));
3608 if (last_asked_format) {
3609 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3610 if (!file_oformat) {
3611 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3614 last_asked_format = NULL;
3616 file_oformat = av_guess_format(NULL, filename, NULL);
3617 if (!file_oformat) {
3618 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3624 oc->oformat = file_oformat;
3625 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3627 if (!strcmp(file_oformat->name, "ffm") &&
3628 av_strstart(filename, "http:", NULL)) {
3629 /* special case for files sent to ffserver: we get the stream
3630 parameters from ffserver */
3631 int err = read_ffserver_streams(oc, filename);
3633 print_error(filename, err);
3637 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3638 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3639 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3641 /* disable if no corresponding type found and at least one
3643 if (nb_input_files > 0) {
3644 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3645 &input_has_subtitle);
3646 if (!input_has_video)
3648 if (!input_has_audio)
3650 if (!input_has_subtitle)
3654 /* manual disable */
3655 if (audio_disable) use_audio = 0;
3656 if (video_disable) use_video = 0;
3657 if (subtitle_disable) use_subtitle = 0;
3659 if (use_video) new_video_stream(oc, nb_output_files);
3660 if (use_audio) new_audio_stream(oc, nb_output_files);
3661 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3663 oc->timestamp = recording_timestamp;
3665 while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3666 av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3667 av_metadata_free(&metadata);
3670 output_files[nb_output_files++] = oc;
3672 /* check filename in case of an image number is expected */
3673 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3674 if (!av_filename_number_test(oc->filename)) {
3675 print_error(oc->filename, AVERROR_NUMEXPECTED);
3680 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3681 /* test if it already exists to avoid loosing precious files */
3682 if (!file_overwrite &&
3683 (strchr(filename, ':') == NULL ||
3684 filename[1] == ':' ||
3685 av_strstart(filename, "file:", NULL))) {
3686 if (url_exist(filename)) {
3688 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3690 if (!read_yesno()) {
3691 fprintf(stderr, "Not overwriting - exiting\n");
3696 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3703 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3704 print_error(filename, err);
3709 memset(ap, 0, sizeof(*ap));
3710 if (av_set_parameters(oc, ap) < 0) {
3711 fprintf(stderr, "%s: Invalid encoding parameters\n",
3716 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3717 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3718 oc->loop_output = loop_output;
3719 oc->flags |= AVFMT_FLAG_NONBLOCK;
3721 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3723 nb_streamid_map = 0;
3724 av_freep(&forced_key_frames);
3727 /* same option as mencoder */
3728 static void opt_pass(const char *pass_str)
3731 pass = atoi(pass_str);
3732 if (pass != 1 && pass != 2) {
3733 fprintf(stderr, "pass number can be only 1 or 2\n");
3739 static int64_t getutime(void)
3742 struct rusage rusage;
3744 getrusage(RUSAGE_SELF, &rusage);
3745 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3746 #elif HAVE_GETPROCESSTIMES
3748 FILETIME c, e, k, u;
3749 proc = GetCurrentProcess();
3750 GetProcessTimes(proc, &c, &e, &k, &u);
3751 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3753 return av_gettime();
3757 static int64_t getmaxrss(void)
3759 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3760 struct rusage rusage;
3761 getrusage(RUSAGE_SELF, &rusage);
3762 return (int64_t)rusage.ru_maxrss * 1024;
3763 #elif HAVE_GETPROCESSMEMORYINFO
3765 PROCESS_MEMORY_COUNTERS memcounters;
3766 proc = GetCurrentProcess();
3767 memcounters.cb = sizeof(memcounters);
3768 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3769 return memcounters.PeakPagefileUsage;
3775 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3778 const char *p = str;
3785 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3792 static void opt_inter_matrix(const char *arg)
3794 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3795 parse_matrix_coeffs(inter_matrix, arg);
3798 static void opt_intra_matrix(const char *arg)
3800 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3801 parse_matrix_coeffs(intra_matrix, arg);
3804 static void show_usage(void)
3806 printf("Hyper fast Audio and Video encoder\n");
3807 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3811 static void show_help(void)
3813 av_log_set_callback(log_callback_help);
3815 show_help_options(options, "Main options:\n",
3816 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3817 show_help_options(options, "\nAdvanced options:\n",
3818 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3820 show_help_options(options, "\nVideo options:\n",
3821 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3823 show_help_options(options, "\nAdvanced Video options:\n",
3824 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3825 OPT_VIDEO | OPT_EXPERT);
3826 show_help_options(options, "\nAudio options:\n",
3827 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3829 show_help_options(options, "\nAdvanced Audio options:\n",
3830 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3831 OPT_AUDIO | OPT_EXPERT);
3832 show_help_options(options, "\nSubtitle options:\n",
3833 OPT_SUBTITLE | OPT_GRAB,
3835 show_help_options(options, "\nAudio/Video grab options:\n",
3839 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3841 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3843 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3846 static void opt_target(const char *arg)
3848 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3849 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3851 if(!strncmp(arg, "pal-", 4)) {
3854 } else if(!strncmp(arg, "ntsc-", 5)) {
3857 } else if(!strncmp(arg, "film-", 5)) {
3862 /* Calculate FR via float to avoid int overflow */
3863 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3866 } else if((fr == 29970) || (fr == 23976)) {
3869 /* Try to determine PAL/NTSC by peeking in the input files */
3870 if(nb_input_files) {
3872 for(j = 0; j < nb_input_files; j++) {
3873 for(i = 0; i < input_files[j]->nb_streams; i++) {
3874 AVCodecContext *c = input_files[j]->streams[i]->codec;
3875 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3877 fr = c->time_base.den * 1000 / c->time_base.num;
3881 } else if((fr == 29970) || (fr == 23976)) {
3891 if(verbose && norm != UNKNOWN)
3892 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3895 if(norm == UNKNOWN) {
3896 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3897 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3898 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3902 if(!strcmp(arg, "vcd")) {
3904 opt_video_codec("mpeg1video");
3905 opt_audio_codec("mp2");
3908 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3909 opt_frame_rate(NULL, frame_rates[norm]);
3910 opt_default("g", norm == PAL ? "15" : "18");
3912 opt_default("b", "1150000");
3913 opt_default("maxrate", "1150000");
3914 opt_default("minrate", "1150000");
3915 opt_default("bufsize", "327680"); // 40*1024*8;
3917 opt_default("ab", "224000");
3918 audio_sample_rate = 44100;
3921 opt_default("packetsize", "2324");
3922 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3924 /* We have to offset the PTS, so that it is consistent with the SCR.
3925 SCR starts at 36000, but the first two packs contain only padding
3926 and the first pack from the other stream, respectively, may also have
3927 been written before.
3928 So the real data starts at SCR 36000+3*1200. */
3929 mux_preload= (36000+3*1200) / 90000.0; //0.44
3930 } else if(!strcmp(arg, "svcd")) {
3932 opt_video_codec("mpeg2video");
3933 opt_audio_codec("mp2");
3936 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3937 opt_frame_rate(NULL, frame_rates[norm]);
3938 opt_default("g", norm == PAL ? "15" : "18");
3940 opt_default("b", "2040000");
3941 opt_default("maxrate", "2516000");
3942 opt_default("minrate", "0"); //1145000;
3943 opt_default("bufsize", "1835008"); //224*1024*8;
3944 opt_default("flags", "+scan_offset");
3947 opt_default("ab", "224000");
3948 audio_sample_rate = 44100;
3950 opt_default("packetsize", "2324");
3952 } else if(!strcmp(arg, "dvd")) {
3954 opt_video_codec("mpeg2video");
3955 opt_audio_codec("ac3");
3958 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3959 opt_frame_rate(NULL, frame_rates[norm]);
3960 opt_default("g", norm == PAL ? "15" : "18");
3962 opt_default("b", "6000000");
3963 opt_default("maxrate", "9000000");
3964 opt_default("minrate", "0"); //1500000;
3965 opt_default("bufsize", "1835008"); //224*1024*8;
3967 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3968 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3970 opt_default("ab", "448000");
3971 audio_sample_rate = 48000;
3973 } else if(!strncmp(arg, "dv", 2)) {
3977 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3978 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3979 (norm == PAL ? "yuv420p" : "yuv411p"));
3980 opt_frame_rate(NULL, frame_rates[norm]);
3982 audio_sample_rate = 48000;
3986 fprintf(stderr, "Unknown target: %s\n", arg);
3991 static void opt_vstats_file (const char *arg)
3993 av_free (vstats_filename);
3994 vstats_filename=av_strdup (arg);
3997 static void opt_vstats (void)
4000 time_t today2 = time(NULL);
4001 struct tm *today = localtime(&today2);
4003 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4005 opt_vstats_file(filename);
4008 static int opt_bsf(const char *opt, const char *arg)
4010 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4011 AVBitStreamFilterContext **bsfp;
4014 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4018 bsfp= *opt == 'v' ? &video_bitstream_filters :
4019 *opt == 'a' ? &audio_bitstream_filters :
4020 &subtitle_bitstream_filters;
4022 bsfp= &(*bsfp)->next;
4029 static int opt_preset(const char *opt, const char *arg)
4032 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4034 const char *base[3]= { getenv("FFMPEG_DATADIR"),
4040 for(i=0; i<3 && !f; i++){
4043 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4044 f= fopen(filename, "r");
4046 char *codec_name= *opt == 'v' ? video_codec_name :
4047 *opt == 'a' ? audio_codec_name :
4048 subtitle_codec_name;
4049 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4050 f= fopen(filename, "r");
4054 av_strlcpy(filename, arg, sizeof(filename));
4055 f= fopen(filename, "r");
4059 fprintf(stderr, "File for preset '%s' not found\n", arg);
4064 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4065 if(line[0] == '#' && !e)
4067 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4069 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4072 if(!strcmp(tmp, "acodec")){
4073 opt_audio_codec(tmp2);
4074 }else if(!strcmp(tmp, "vcodec")){
4075 opt_video_codec(tmp2);
4076 }else if(!strcmp(tmp, "scodec")){
4077 opt_subtitle_codec(tmp2);
4078 }else if(opt_default(tmp, tmp2) < 0){
4079 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4089 static const OptionDef options[] = {
4091 #include "cmdutils_common_opts.h"
4092 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4093 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4094 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4095 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4096 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4097 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4098 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4099 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4100 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4101 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4102 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4103 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4104 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4105 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4106 "add timings for benchmarking" },
4107 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4108 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4109 "dump each input packet" },
4110 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4111 "when dumping packets, also dump the payload" },
4112 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4113 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4114 { "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)", "" },
4115 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4116 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4117 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4118 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4119 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4120 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4121 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4122 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4123 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4124 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4125 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4126 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4127 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4130 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4131 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4132 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4133 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4134 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4135 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4136 { "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" },
4137 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4138 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4139 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4140 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4141 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4142 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4143 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4144 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4145 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4146 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4147 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4148 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4149 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4150 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4151 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4152 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4153 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4154 "use same video quality as source (implies VBR)" },
4155 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4156 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4157 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4158 "deinterlace pictures" },
4159 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4160 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4161 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4163 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4165 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4166 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4167 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4168 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4169 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4170 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4171 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4172 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4173 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4174 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4175 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4178 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4179 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4180 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4181 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4182 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4183 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4184 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4185 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4186 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4187 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4188 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4189 { "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" },
4191 /* subtitle options */
4192 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4193 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4194 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4195 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4196 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4199 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4200 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4201 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4204 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4205 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4207 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4208 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4209 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4211 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4212 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4213 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4214 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4216 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4220 int main(int argc, char **argv)
4224 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4226 avcodec_register_all();
4228 avdevice_register_all();
4231 avfilter_register_all();
4236 if(isatty(STDIN_FILENO))
4237 url_set_interrupt_cb(decode_interrupt_cb);
4245 parse_options(argc, argv, options, opt_output_file);
4247 if(nb_output_files <= 0 && nb_input_files == 0) {
4249 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4253 /* file converter / grab */
4254 if (nb_output_files <= 0) {
4255 fprintf(stderr, "At least one output file must be specified\n");
4259 if (nb_input_files == 0) {
4260 fprintf(stderr, "At least one input file must be specified\n");
4265 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4266 stream_maps, nb_stream_maps) < 0)
4268 ti = getutime() - ti;
4270 int maxrss = getmaxrss() / 1024;
4271 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4274 return ffmpeg_exit(0);