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/audioconvert.h"
40 #include "libavcore/parseutils.h"
41 #include "libavcore/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/libm.h"
48 #include "libavformat/os_support.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
74 #include <sys/ioctl.h>
84 #include "libavutil/avassert.h"
86 const char program_name[] = "FFmpeg";
87 const int program_birth_year = 2000;
89 /* select an input stream for an output stream */
90 typedef struct AVStreamMap {
94 int sync_stream_index;
98 * select an input file for an output file
100 typedef struct AVMetaDataMap {
101 int file; //< file index
102 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103 int index; //< stream/chapter/program number
106 typedef struct AVChapterMap {
111 static const OptionDef options[];
113 #define MAX_FILES 100
114 #if !FF_API_MAX_STREAMS
115 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static AVFormatContext *input_files[MAX_FILES];
120 static int64_t input_files_ts_offset[MAX_FILES];
121 static double *input_files_ts_scale[MAX_FILES] = {NULL};
122 static AVCodec **input_codecs = NULL;
123 static int nb_input_files = 0;
124 static int nb_input_codecs = 0;
125 static int nb_input_files_ts_scale[MAX_FILES] = {0};
127 static AVFormatContext *output_files[MAX_FILES];
128 static AVCodec **output_codecs = NULL;
129 static int nb_output_files = 0;
130 static int nb_output_codecs = 0;
132 static AVStreamMap *stream_maps = NULL;
133 static int nb_stream_maps;
135 /* first item specifies output metadata, second is input */
136 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137 static int nb_meta_data_maps;
138 static int metadata_global_autocopy = 1;
139 static int metadata_streams_autocopy = 1;
140 static int metadata_chapters_autocopy = 1;
142 static AVChapterMap *chapter_maps = NULL;
143 static int nb_chapter_maps;
145 /* indexed by output file stream index */
146 static int *streamid_map = NULL;
147 static int nb_streamid_map = 0;
149 static int frame_width = 0;
150 static int frame_height = 0;
151 static float frame_aspect_ratio = 0;
152 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155 static AVRational frame_rate;
156 static float video_qscale = 0;
157 static uint16_t *intra_matrix = NULL;
158 static uint16_t *inter_matrix = NULL;
159 static const char *video_rc_override_string=NULL;
160 static int video_disable = 0;
161 static int video_discard = 0;
162 static char *video_codec_name = NULL;
163 static unsigned int video_codec_tag = 0;
164 static char *video_language = NULL;
165 static int same_quality = 0;
166 static int do_deinterlace = 0;
167 static int top_field_first = -1;
168 static int me_threshold = 0;
169 static int intra_dc_precision = 8;
170 static int loop_input = 0;
171 static int loop_output = AVFMT_NOOUTPUTLOOP;
172 static int qp_hist = 0;
174 static char *vfilters = NULL;
175 AVFilterGraph *graph = NULL;
178 static int intra_only = 0;
179 static int audio_sample_rate = 44100;
180 static int64_t channel_layout = 0;
181 #define QSCALE_NONE -99999
182 static float audio_qscale = QSCALE_NONE;
183 static int audio_disable = 0;
184 static int audio_channels = 1;
185 static char *audio_codec_name = NULL;
186 static unsigned int audio_codec_tag = 0;
187 static char *audio_language = NULL;
189 static int subtitle_disable = 0;
190 static char *subtitle_codec_name = NULL;
191 static char *subtitle_language = NULL;
192 static unsigned int subtitle_codec_tag = 0;
194 static float mux_preload= 0.5;
195 static float mux_max_delay= 0.7;
197 static int64_t recording_time = INT64_MAX;
198 static int64_t start_time = 0;
199 static int64_t recording_timestamp = 0;
200 static int64_t input_ts_offset = 0;
201 static int file_overwrite = 0;
202 static AVMetadata *metadata;
203 static int do_benchmark = 0;
204 static int do_hex_dump = 0;
205 static int do_pkt_dump = 0;
206 static int do_psnr = 0;
207 static int do_pass = 0;
208 static char *pass_logfilename_prefix = NULL;
209 static int audio_stream_copy = 0;
210 static int video_stream_copy = 0;
211 static int subtitle_stream_copy = 0;
212 static int video_sync_method= -1;
213 static int audio_sync_method= 0;
214 static float audio_drift_threshold= 0.1;
215 static int copy_ts= 0;
216 static int opt_shortest = 0;
217 static int video_global_header = 0;
218 static char *vstats_filename;
219 static FILE *vstats_file;
220 static int opt_programid = 0;
221 static int copy_initial_nonkeyframes = 0;
223 static int rate_emu = 0;
225 static int video_channel = 0;
226 static char *video_standard;
228 static int audio_volume = 256;
230 static int exit_on_error = 0;
231 static int using_stdin = 0;
232 static int verbose = 1;
233 static int thread_count= 1;
234 static int q_pressed = 0;
235 static int64_t video_size = 0;
236 static int64_t audio_size = 0;
237 static int64_t extra_size = 0;
238 static int nb_frames_dup = 0;
239 static int nb_frames_drop = 0;
240 static int input_sync;
241 static uint64_t limit_filesize = 0;
242 static int force_fps = 0;
243 static char *forced_key_frames = NULL;
245 static float dts_delta_threshold = 10;
247 static unsigned int sws_flags = SWS_BICUBIC;
249 static int64_t timer_start;
251 static uint8_t *audio_buf;
252 static uint8_t *audio_out;
253 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
255 static short *samples;
257 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
258 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
261 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263 struct AVInputStream;
265 typedef struct AVOutputStream {
266 int file_index; /* file index */
267 int index; /* stream index in the output file */
268 int source_index; /* AVInputStream index */
269 AVStream *st; /* stream in the output file */
270 int encoding_needed; /* true if encoding needed for this stream */
272 /* input pts and corresponding output pts
274 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
275 struct AVInputStream *sync_ist; /* input stream to sync against */
276 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
277 AVBitStreamFilterContext *bitstream_filters;
280 AVFrame pict_tmp; /* temporary image for resampling */
281 struct SwsContext *img_resample_ctx; /* for image resampling */
284 int resample_pix_fmt;
286 /* full frame size of first frame */
290 /* forced key frames */
291 int64_t *forced_kf_pts;
297 ReSampleContext *resample; /* for audio resampling */
299 AVAudioConvert *reformat_ctx;
300 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
304 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
305 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
307 typedef struct AVInputStream {
311 int discard; /* true if stream data should be discarded */
312 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
313 int64_t sample_index; /* current sample */
315 int64_t start; /* time when read started */
316 int64_t next_pts; /* synthetic pts for cases where pkt.pts
318 int64_t pts; /* current pts */
319 PtsCorrectionContext pts_ctx;
320 int is_start; /* is 1 at the start and after a discontinuity */
321 int showed_multi_packet_warning;
322 int is_past_recording_time;
324 AVFilterContext *output_video_filter;
325 AVFilterContext *input_video_filter;
326 AVFrame *filter_frame;
327 int has_filter_frame;
328 AVFilterBufferRef *picref;
332 typedef struct AVInputFile {
333 int eof_reached; /* true if eof reached */
334 int ist_index; /* index of first stream in ist_table */
335 int buffer_size; /* current total buffer size */
336 int nb_streams; /* nb streams we are aware of */
341 /* init terminal so that we can grab keys */
342 static struct termios oldtty;
347 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
349 AVFilterContext *last_filter, *filter;
350 /** filter graph containing all filters including input & output */
351 AVCodecContext *codec = ost->st->codec;
352 AVCodecContext *icodec = ist->st->codec;
353 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
357 graph = avfilter_graph_alloc();
359 if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
361 if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
364 snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
365 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
366 if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
368 if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
371 /* add input and output filters to the overall graph */
372 avfilter_graph_add_filter(graph, ist->input_video_filter);
373 avfilter_graph_add_filter(graph, ist->output_video_filter);
375 last_filter = ist->input_video_filter;
377 if (codec->width != icodec->width || codec->height != icodec->height) {
378 snprintf(args, 255, "%d:%d:flags=0x%X",
381 (int)av_get_int(sws_opts, "sws_flags", NULL));
382 if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
384 if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
386 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
388 last_filter = filter;
389 avfilter_graph_add_filter(graph, last_filter);
392 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
393 graph->scale_sws_opts = av_strdup(args);
396 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
397 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
399 outputs->name = av_strdup("in");
400 outputs->filter_ctx = last_filter;
401 outputs->pad_idx = 0;
402 outputs->next = NULL;
404 inputs->name = av_strdup("out");
405 inputs->filter_ctx = ist->output_video_filter;
409 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
413 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
417 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
420 codec->width = ist->output_video_filter->inputs[0]->w;
421 codec->height = ist->output_video_filter->inputs[0]->h;
425 #endif /* CONFIG_AVFILTER */
427 static void term_exit(void)
429 av_log(NULL, AV_LOG_QUIET, "");
431 tcsetattr (0, TCSANOW, &oldtty);
435 static volatile int received_sigterm = 0;
438 sigterm_handler(int sig)
440 received_sigterm = sig;
444 static void term_init(void)
453 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
454 |INLCR|IGNCR|ICRNL|IXON);
455 tty.c_oflag |= OPOST;
456 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
457 tty.c_cflag &= ~(CSIZE|PARENB);
462 tcsetattr (0, TCSANOW, &tty);
463 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
466 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
467 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
469 signal(SIGXCPU, sigterm_handler);
473 /* read a key without blocking */
474 static int read_key(void)
486 n = select(1, &rfds, NULL, NULL, &tv);
501 static int decode_interrupt_cb(void)
503 return q_pressed || (q_pressed = read_key() == 'q');
506 static int ffmpeg_exit(int ret)
511 for(i=0;i<nb_output_files;i++) {
512 /* maybe av_close_output_file ??? */
513 AVFormatContext *s = output_files[i];
515 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
517 for(j=0;j<s->nb_streams;j++) {
518 av_metadata_free(&s->streams[j]->metadata);
519 av_free(s->streams[j]->codec);
520 av_free(s->streams[j]->info);
521 av_free(s->streams[j]);
523 for(j=0;j<s->nb_programs;j++) {
524 av_metadata_free(&s->programs[j]->metadata);
526 for(j=0;j<s->nb_chapters;j++) {
527 av_metadata_free(&s->chapters[j]->metadata);
529 av_metadata_free(&s->metadata);
531 av_free(output_streams_for_file[i]);
533 for(i=0;i<nb_input_files;i++) {
534 av_close_input_file(input_files[i]);
535 av_free(input_files_ts_scale[i]);
538 av_free(intra_matrix);
539 av_free(inter_matrix);
543 av_free(vstats_filename);
546 av_free(streamid_map);
547 av_free(input_codecs);
548 av_free(output_codecs);
549 av_free(stream_maps);
550 av_free(meta_data_maps);
552 av_free(video_codec_name);
553 av_free(audio_codec_name);
554 av_free(subtitle_codec_name);
556 av_free(video_standard);
561 allocated_audio_buf_size= allocated_audio_out_size= 0;
568 if (received_sigterm) {
570 "Received signal %d: terminating.\n",
571 (int) received_sigterm);
575 exit(ret); /* not all OS-es handle main() return value */
579 /* similar to ff_dynarray_add() and av_fast_realloc() */
580 static void *grow_array(void *array, int elem_size, int *size, int new_size)
582 if (new_size >= INT_MAX / elem_size) {
583 fprintf(stderr, "Array too big.\n");
586 if (*size < new_size) {
587 uint8_t *tmp = av_realloc(array, new_size*elem_size);
589 fprintf(stderr, "Could not alloc buffer.\n");
592 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
599 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
601 if(codec && codec->sample_fmts){
602 const enum AVSampleFormat *p= codec->sample_fmts;
604 if(*p == st->codec->sample_fmt)
608 st->codec->sample_fmt = codec->sample_fmts[0];
612 static void choose_sample_rate(AVStream *st, AVCodec *codec)
614 if(codec && codec->supported_samplerates){
615 const int *p= codec->supported_samplerates;
617 int best_dist=INT_MAX;
619 int dist= abs(st->codec->sample_rate - *p);
620 if(dist < best_dist){
626 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
628 st->codec->sample_rate= best;
632 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
634 if(codec && codec->pix_fmts){
635 const enum PixelFormat *p= codec->pix_fmts;
637 if(*p == st->codec->pix_fmt)
641 && !( st->codec->codec_id==CODEC_ID_MJPEG
642 && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
643 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
644 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
645 st->codec->pix_fmt = codec->pix_fmts[0];
649 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
651 int idx = oc->nb_streams - 1;
654 output_streams_for_file[file_idx] =
655 grow_array(output_streams_for_file[file_idx],
656 sizeof(*output_streams_for_file[file_idx]),
657 &nb_output_streams_for_file[file_idx],
659 ost = output_streams_for_file[file_idx][idx] =
660 av_mallocz(sizeof(AVOutputStream));
662 fprintf(stderr, "Could not alloc output stream\n");
665 ost->file_index = file_idx;
670 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
676 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
679 /* copy stream format */
681 for(i=0;i<ic->nb_streams;i++) {
687 // FIXME: a more elegant solution is needed
688 st = av_mallocz(sizeof(AVStream));
689 memcpy(st, ic->streams[i], sizeof(AVStream));
690 st->codec = avcodec_alloc_context();
692 print_error(filename, AVERROR(ENOMEM));
695 avcodec_copy_context(st->codec, ic->streams[i]->codec);
698 codec = avcodec_find_encoder(st->codec->codec_id);
699 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
700 if (audio_stream_copy) {
703 choose_sample_fmt(st, codec);
704 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
705 if (video_stream_copy) {
708 choose_pixel_fmt(st, codec);
711 if(!st->codec->thread_count)
712 st->codec->thread_count = 1;
713 if(st->codec->thread_count>1)
714 avcodec_thread_init(st->codec, st->codec->thread_count);
716 if(st->codec->flags & CODEC_FLAG_BITEXACT)
719 new_output_stream(s, nb_output_files);
723 s->timestamp = av_gettime();
725 av_close_input_file(ic);
730 get_sync_ipts(const AVOutputStream *ost)
732 const AVInputStream *ist = ost->sync_ist;
733 return (double)(ist->pts - start_time)/AV_TIME_BASE;
736 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
740 AVPacket new_pkt= *pkt;
741 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
742 &new_pkt.data, &new_pkt.size,
743 pkt->data, pkt->size,
744 pkt->flags & AV_PKT_FLAG_KEY);
747 new_pkt.destruct= av_destruct_packet;
749 fprintf(stderr, "%s failed for stream %d, codec %s",
750 bsfc->filter->name, pkt->stream_index,
751 avctx->codec ? avctx->codec->name : "copy");
761 ret= av_interleaved_write_frame(s, pkt);
763 print_error("av_interleaved_write_frame()", ret);
768 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
770 static void do_audio_out(AVFormatContext *s,
773 unsigned char *buf, int size)
776 int64_t audio_out_size, audio_buf_size;
777 int64_t allocated_for_size= size;
779 int size_out, frame_bytes, ret;
780 AVCodecContext *enc= ost->st->codec;
781 AVCodecContext *dec= ist->st->codec;
782 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
783 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
784 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
787 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
788 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
789 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
790 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
791 audio_buf_size*= osize*enc->channels;
793 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
794 if(coded_bps > 8*osize)
795 audio_out_size= audio_out_size * coded_bps / (8*osize);
796 audio_out_size += FF_MIN_BUFFER_SIZE;
798 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
799 fprintf(stderr, "Buffer sizes too large\n");
803 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
804 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
805 if (!audio_buf || !audio_out){
806 fprintf(stderr, "Out of memory in do_audio_out\n");
810 if (enc->channels != dec->channels)
811 ost->audio_resample = 1;
813 if (ost->audio_resample && !ost->resample) {
814 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
815 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
816 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
817 enc->sample_rate, dec->sample_rate,
818 enc->sample_fmt, dec->sample_fmt,
820 if (!ost->resample) {
821 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
822 dec->channels, dec->sample_rate,
823 enc->channels, enc->sample_rate);
828 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
829 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
830 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
831 if (ost->reformat_ctx)
832 av_audio_convert_free(ost->reformat_ctx);
833 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
834 dec->sample_fmt, 1, NULL, 0);
835 if (!ost->reformat_ctx) {
836 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
837 av_get_sample_fmt_name(dec->sample_fmt),
838 av_get_sample_fmt_name(enc->sample_fmt));
841 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
844 if(audio_sync_method){
845 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
846 - av_fifo_size(ost->fifo)/(enc->channels * 2);
847 double idelta= delta*dec->sample_rate / enc->sample_rate;
848 int byte_delta= ((int)idelta)*2*dec->channels;
850 //FIXME resample delay
851 if(fabs(delta) > 50){
852 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
854 byte_delta= FFMAX(byte_delta, -size);
858 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
863 static uint8_t *input_tmp= NULL;
864 input_tmp= av_realloc(input_tmp, byte_delta + size);
866 if(byte_delta > allocated_for_size - size){
867 allocated_for_size= byte_delta + (int64_t)size;
872 memset(input_tmp, 0, byte_delta);
873 memcpy(input_tmp + byte_delta, buf, size);
877 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
879 }else if(audio_sync_method>1){
880 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
881 av_assert0(ost->audio_resample);
883 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
884 // 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));
885 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
889 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
890 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
892 if (ost->audio_resample) {
894 size_out = audio_resample(ost->resample,
895 (short *)buftmp, (short *)buf,
896 size / (dec->channels * isize));
897 size_out = size_out * enc->channels * osize;
903 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
904 const void *ibuf[6]= {buftmp};
905 void *obuf[6]= {audio_buf};
906 int istride[6]= {isize};
907 int ostride[6]= {osize};
908 int len= size_out/istride[0];
909 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
910 printf("av_audio_convert() failed\n");
916 size_out = len*osize;
919 /* now encode as many frames as possible */
920 if (enc->frame_size > 1) {
921 /* output resampled raw samples */
922 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
923 fprintf(stderr, "av_fifo_realloc2() failed\n");
926 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
928 frame_bytes = enc->frame_size * osize * enc->channels;
930 while (av_fifo_size(ost->fifo) >= frame_bytes) {
932 av_init_packet(&pkt);
934 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
936 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
938 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
941 fprintf(stderr, "Audio encoding failed\n");
945 pkt.stream_index= ost->index;
948 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
949 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
950 pkt.flags |= AV_PKT_FLAG_KEY;
951 write_frame(s, &pkt, enc, ost->bitstream_filters);
953 ost->sync_opts += enc->frame_size;
957 av_init_packet(&pkt);
959 ost->sync_opts += size_out / (osize * enc->channels);
961 /* output a pcm frame */
962 /* determine the size of the coded buffer */
965 size_out = size_out*coded_bps/8;
967 if(size_out > audio_out_size){
968 fprintf(stderr, "Internal error, buffer size too small\n");
972 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
973 ret = avcodec_encode_audio(enc, audio_out, size_out,
976 fprintf(stderr, "Audio encoding failed\n");
980 pkt.stream_index= ost->index;
983 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
984 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
985 pkt.flags |= AV_PKT_FLAG_KEY;
986 write_frame(s, &pkt, enc, ost->bitstream_filters);
990 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
994 AVPicture picture_tmp;
997 dec = ist->st->codec;
999 /* deinterlace : must be done before any resize */
1000 if (do_deinterlace) {
1003 /* create temporary picture */
1004 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1005 buf = av_malloc(size);
1009 picture2 = &picture_tmp;
1010 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1012 if(avpicture_deinterlace(picture2, picture,
1013 dec->pix_fmt, dec->width, dec->height) < 0) {
1014 /* if error, do not deinterlace */
1015 fprintf(stderr, "Deinterlacing failed\n");
1024 if (picture != picture2)
1025 *picture = *picture2;
1029 /* we begin to correct av delay at this threshold */
1030 #define AV_DELAY_MAX 0.100
1032 static void do_subtitle_out(AVFormatContext *s,
1033 AVOutputStream *ost,
1038 static uint8_t *subtitle_out = NULL;
1039 int subtitle_out_max_size = 1024 * 1024;
1040 int subtitle_out_size, nb, i;
1041 AVCodecContext *enc;
1044 if (pts == AV_NOPTS_VALUE) {
1045 fprintf(stderr, "Subtitle packets must have a pts\n");
1051 enc = ost->st->codec;
1053 if (!subtitle_out) {
1054 subtitle_out = av_malloc(subtitle_out_max_size);
1057 /* Note: DVB subtitle need one packet to draw them and one other
1058 packet to clear them */
1059 /* XXX: signal it in the codec context ? */
1060 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1065 for(i = 0; i < nb; i++) {
1066 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1067 // start_display_time is required to be 0
1068 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1069 sub->end_display_time -= sub->start_display_time;
1070 sub->start_display_time = 0;
1071 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1072 subtitle_out_max_size, sub);
1073 if (subtitle_out_size < 0) {
1074 fprintf(stderr, "Subtitle encoding failed\n");
1078 av_init_packet(&pkt);
1079 pkt.stream_index = ost->index;
1080 pkt.data = subtitle_out;
1081 pkt.size = subtitle_out_size;
1082 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1083 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1084 /* XXX: the pts correction is handled here. Maybe handling
1085 it in the codec would be better */
1087 pkt.pts += 90 * sub->start_display_time;
1089 pkt.pts += 90 * sub->end_display_time;
1091 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1095 static int bit_buffer_size= 1024*256;
1096 static uint8_t *bit_buffer= NULL;
1098 static void do_video_out(AVFormatContext *s,
1099 AVOutputStream *ost,
1101 AVFrame *in_picture,
1104 int nb_frames, i, ret;
1105 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1106 AVCodecContext *enc, *dec;
1109 enc = ost->st->codec;
1110 dec = ist->st->codec;
1112 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1114 /* by default, we output a single frame */
1119 if(video_sync_method){
1120 double vdelta = sync_ipts - ost->sync_opts;
1121 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1124 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1127 }else if(vdelta>0.6)
1128 ost->sync_opts= lrintf(sync_ipts);
1129 }else if (vdelta > 1.1)
1130 nb_frames = lrintf(vdelta);
1131 //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);
1132 if (nb_frames == 0){
1135 fprintf(stderr, "*** drop!\n");
1136 }else if (nb_frames > 1) {
1137 nb_frames_dup += nb_frames - 1;
1139 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1142 ost->sync_opts= lrintf(sync_ipts);
1144 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1148 formatted_picture = in_picture;
1149 final_picture = formatted_picture;
1150 padding_src = formatted_picture;
1151 resampling_dst = &ost->pict_tmp;
1153 if ( ost->resample_height != ist->st->codec->height
1154 || ost->resample_width != ist->st->codec->width
1155 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1157 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));
1158 if(!ost->video_resample)
1162 #if !CONFIG_AVFILTER
1163 if (ost->video_resample) {
1165 final_picture = &ost->pict_tmp;
1166 if( ost->resample_height != ist->st->codec->height
1167 || ost->resample_width != ist->st->codec->width
1168 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1170 /* initialize a new scaler context */
1171 sws_freeContext(ost->img_resample_ctx);
1172 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1173 ost->img_resample_ctx = sws_getContext(
1174 ist->st->codec->width,
1175 ist->st->codec->height,
1176 ist->st->codec->pix_fmt,
1177 ost->st->codec->width,
1178 ost->st->codec->height,
1179 ost->st->codec->pix_fmt,
1180 sws_flags, NULL, NULL, NULL);
1181 if (ost->img_resample_ctx == NULL) {
1182 fprintf(stderr, "Cannot get resampling context\n");
1186 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1187 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1191 /* duplicates frame if needed */
1192 for(i=0;i<nb_frames;i++) {
1194 av_init_packet(&pkt);
1195 pkt.stream_index= ost->index;
1197 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1198 /* raw pictures are written as AVPicture structure to
1199 avoid any copies. We support temorarily the older
1201 AVFrame* old_frame = enc->coded_frame;
1202 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1203 pkt.data= (uint8_t *)final_picture;
1204 pkt.size= sizeof(AVPicture);
1205 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1206 pkt.flags |= AV_PKT_FLAG_KEY;
1208 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1209 enc->coded_frame = old_frame;
1211 AVFrame big_picture;
1213 big_picture= *final_picture;
1214 /* better than nothing: use input picture interlaced
1216 big_picture.interlaced_frame = in_picture->interlaced_frame;
1217 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1218 if(top_field_first == -1)
1219 big_picture.top_field_first = in_picture->top_field_first;
1221 big_picture.top_field_first = top_field_first;
1224 /* handles sameq here. This is not correct because it may
1225 not be a global option */
1226 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1228 big_picture.pict_type = 0;
1229 // big_picture.pts = AV_NOPTS_VALUE;
1230 big_picture.pts= ost->sync_opts;
1231 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1232 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1233 if (ost->forced_kf_index < ost->forced_kf_count &&
1234 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1235 big_picture.pict_type = FF_I_TYPE;
1236 ost->forced_kf_index++;
1238 ret = avcodec_encode_video(enc,
1239 bit_buffer, bit_buffer_size,
1242 fprintf(stderr, "Video encoding failed\n");
1247 pkt.data= bit_buffer;
1249 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1250 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1251 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1252 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1253 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1255 if(enc->coded_frame->key_frame)
1256 pkt.flags |= AV_PKT_FLAG_KEY;
1257 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1260 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1261 // enc->frame_number-1, ret, enc->pict_type);
1262 /* if two pass, output log */
1263 if (ost->logfile && enc->stats_out) {
1264 fprintf(ost->logfile, "%s", enc->stats_out);
1269 ost->frame_number++;
1273 static double psnr(double d){
1274 return -10.0*log(d)/log(10.0);
1277 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1280 AVCodecContext *enc;
1282 double ti1, bitrate, avg_bitrate;
1284 /* this is executed just the first time do_video_stats is called */
1286 vstats_file = fopen(vstats_filename, "w");
1293 enc = ost->st->codec;
1294 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1295 frame_number = ost->frame_number;
1296 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1297 if (enc->flags&CODEC_FLAG_PSNR)
1298 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1300 fprintf(vstats_file,"f_size= %6d ", frame_size);
1301 /* compute pts value */
1302 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1306 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1307 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1308 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1309 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1310 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1314 static void print_report(AVFormatContext **output_files,
1315 AVOutputStream **ost_table, int nb_ostreams,
1319 AVOutputStream *ost;
1320 AVFormatContext *oc;
1322 AVCodecContext *enc;
1323 int frame_number, vid, i;
1324 double bitrate, ti1, pts;
1325 static int64_t last_time = -1;
1326 static int qp_histogram[52];
1328 if (!is_last_report) {
1330 /* display the report every 0.5 seconds */
1331 cur_time = av_gettime();
1332 if (last_time == -1) {
1333 last_time = cur_time;
1336 if ((cur_time - last_time) < 500000)
1338 last_time = cur_time;
1342 oc = output_files[0];
1344 total_size = url_fsize(oc->pb);
1345 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1346 total_size= url_ftell(oc->pb);
1351 for(i=0;i<nb_ostreams;i++) {
1353 enc = ost->st->codec;
1354 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1355 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1356 !ost->st->stream_copy ?
1357 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1359 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1360 float t = (av_gettime()-timer_start) / 1000000.0;
1362 frame_number = ost->frame_number;
1363 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1364 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1365 !ost->st->stream_copy ?
1366 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1368 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1371 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1372 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1375 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1377 if (enc->flags&CODEC_FLAG_PSNR){
1379 double error, error_sum=0;
1380 double scale, scale_sum=0;
1381 char type[3]= {'Y','U','V'};
1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1385 error= enc->error[j];
1386 scale= enc->width*enc->height*255.0*255.0*frame_number;
1388 error= enc->coded_frame->error[j];
1389 scale= enc->width*enc->height*255.0*255.0;
1394 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1396 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1400 /* compute min output value */
1401 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1402 if ((pts < ti1) && (pts > 0))
1408 if (verbose || is_last_report) {
1409 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1411 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1412 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1413 (double)total_size / 1024, ti1, bitrate);
1415 if (nb_frames_dup || nb_frames_drop)
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1417 nb_frames_dup, nb_frames_drop);
1420 fprintf(stderr, "%s \r", buf);
1425 if (is_last_report && verbose >= 0){
1426 int64_t raw= audio_size + video_size + extra_size;
1427 fprintf(stderr, "\n");
1428 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1432 100.0*(total_size - raw)/raw
1437 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1438 static int output_packet(AVInputStream *ist, int ist_index,
1439 AVOutputStream **ost_table, int nb_ostreams,
1440 const AVPacket *pkt)
1442 AVFormatContext *os;
1443 AVOutputStream *ost;
1447 void *buffer_to_free;
1448 static unsigned int samples_size= 0;
1449 AVSubtitle subtitle, *subtitle_to_free;
1450 int64_t pkt_pts = AV_NOPTS_VALUE;
1452 int frame_available;
1456 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1458 if(ist->next_pts == AV_NOPTS_VALUE)
1459 ist->next_pts= ist->pts;
1463 av_init_packet(&avpkt);
1471 if(pkt->dts != AV_NOPTS_VALUE)
1472 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1473 if(pkt->pts != AV_NOPTS_VALUE)
1474 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1476 //while we have more to decode or while the decoder did output something on EOF
1477 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1478 uint8_t *data_buf, *decoded_data_buf;
1479 int data_size, decoded_data_size;
1481 ist->pts= ist->next_pts;
1483 if(avpkt.size && avpkt.size != pkt->size &&
1484 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1485 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1486 ist->showed_multi_packet_warning=1;
1489 /* decode the packet if needed */
1490 decoded_data_buf = NULL; /* fail safe */
1491 decoded_data_size= 0;
1492 data_buf = avpkt.data;
1493 data_size = avpkt.size;
1494 subtitle_to_free = NULL;
1495 if (ist->decoding_needed) {
1496 switch(ist->st->codec->codec_type) {
1497 case AVMEDIA_TYPE_AUDIO:{
1498 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1499 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1501 samples= av_malloc(samples_size);
1503 decoded_data_size= samples_size;
1504 /* XXX: could avoid copy if PCM 16 bits with same
1505 endianness as CPU */
1506 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1513 /* Some bug in mpeg audio decoder gives */
1514 /* decoded_data_size < 0, it seems they are overflows */
1515 if (decoded_data_size <= 0) {
1516 /* no audio frame */
1519 decoded_data_buf = (uint8_t *)samples;
1520 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1521 (ist->st->codec->sample_rate * ist->st->codec->channels);
1523 case AVMEDIA_TYPE_VIDEO:
1524 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1525 /* XXX: allocate picture correctly */
1526 avcodec_get_frame_defaults(&picture);
1527 ist->st->codec->reordered_opaque = pkt_pts;
1528 pkt_pts = AV_NOPTS_VALUE;
1530 ret = avcodec_decode_video2(ist->st->codec,
1531 &picture, &got_picture, &avpkt);
1532 ist->st->quality= picture.quality;
1536 /* no picture yet */
1537 goto discard_packet;
1539 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1540 if (ist->st->codec->time_base.num != 0) {
1541 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1542 ist->next_pts += ((int64_t)AV_TIME_BASE *
1543 ist->st->codec->time_base.num * ticks) /
1544 ist->st->codec->time_base.den;
1548 case AVMEDIA_TYPE_SUBTITLE:
1549 ret = avcodec_decode_subtitle2(ist->st->codec,
1550 &subtitle, &got_picture, &avpkt);
1554 goto discard_packet;
1556 subtitle_to_free = &subtitle;
1563 switch(ist->st->codec->codec_type) {
1564 case AVMEDIA_TYPE_AUDIO:
1565 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1566 ist->st->codec->sample_rate;
1568 case AVMEDIA_TYPE_VIDEO:
1569 if (ist->st->codec->time_base.num != 0) {
1570 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1571 ist->next_pts += ((int64_t)AV_TIME_BASE *
1572 ist->st->codec->time_base.num * ticks) /
1573 ist->st->codec->time_base.den;
1581 buffer_to_free = NULL;
1582 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1583 pre_process_video_frame(ist, (AVPicture *)&picture,
1588 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1589 // add it to be filtered
1590 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1592 ist->st->codec->sample_aspect_ratio);
1596 // preprocess audio (volume)
1597 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1598 if (audio_volume != 256) {
1601 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1602 int v = ((*volp) * audio_volume + 128) >> 8;
1603 if (v < -32768) v = -32768;
1604 if (v > 32767) v = 32767;
1610 /* frame rate emulation */
1612 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1613 int64_t now = av_gettime() - ist->start;
1618 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1619 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1621 /* if output time reached then transcode raw format,
1622 encode packets and output them */
1623 if (start_time == 0 || ist->pts >= start_time)
1625 while (frame_available) {
1626 AVRational ist_pts_tb;
1627 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1628 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1630 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1632 for(i=0;i<nb_ostreams;i++) {
1636 if (ost->source_index == ist_index) {
1637 os = output_files[ost->file_index];
1639 /* set the input output pts pairs */
1640 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1642 if (ost->encoding_needed) {
1643 av_assert0(ist->decoding_needed);
1644 switch(ost->st->codec->codec_type) {
1645 case AVMEDIA_TYPE_AUDIO:
1646 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1648 case AVMEDIA_TYPE_VIDEO:
1650 if (ist->picref->video)
1651 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1653 do_video_out(os, ost, ist, &picture, &frame_size);
1654 if (vstats_filename && frame_size)
1655 do_video_stats(os, ost, frame_size);
1657 case AVMEDIA_TYPE_SUBTITLE:
1658 do_subtitle_out(os, ost, ist, &subtitle,
1665 AVFrame avframe; //FIXME/XXX remove this
1667 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1669 av_init_packet(&opkt);
1671 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1674 /* no reencoding needed : output the packet directly */
1675 /* force the input stream PTS */
1677 avcodec_get_frame_defaults(&avframe);
1678 ost->st->codec->coded_frame= &avframe;
1679 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1681 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1682 audio_size += data_size;
1683 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1684 video_size += data_size;
1688 opkt.stream_index= ost->index;
1689 if(pkt->pts != AV_NOPTS_VALUE)
1690 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1692 opkt.pts= AV_NOPTS_VALUE;
1694 if (pkt->dts == AV_NOPTS_VALUE)
1695 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1697 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1698 opkt.dts -= ost_tb_start_time;
1700 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1701 opkt.flags= pkt->flags;
1703 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1704 if( ost->st->codec->codec_id != CODEC_ID_H264
1705 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1706 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1708 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1709 opkt.destruct= av_destruct_packet;
1711 opkt.data = data_buf;
1712 opkt.size = data_size;
1715 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1716 ost->st->codec->frame_number++;
1717 ost->frame_number++;
1718 av_free_packet(&opkt);
1724 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1725 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1727 avfilter_unref_buffer(ist->picref);
1730 av_free(buffer_to_free);
1731 /* XXX: allocate the subtitles in the codec ? */
1732 if (subtitle_to_free) {
1733 if (subtitle_to_free->rects != NULL) {
1734 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1735 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1736 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1737 av_freep(&subtitle_to_free->rects[i]);
1739 av_freep(&subtitle_to_free->rects);
1741 subtitle_to_free->num_rects = 0;
1742 subtitle_to_free = NULL;
1749 for(i=0;i<nb_ostreams;i++) {
1751 if (ost->source_index == ist_index) {
1752 AVCodecContext *enc= ost->st->codec;
1753 os = output_files[ost->file_index];
1755 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1757 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1760 if (ost->encoding_needed) {
1764 av_init_packet(&pkt);
1765 pkt.stream_index= ost->index;
1767 switch(ost->st->codec->codec_type) {
1768 case AVMEDIA_TYPE_AUDIO:
1769 fifo_bytes = av_fifo_size(ost->fifo);
1771 /* encode any samples remaining in fifo */
1772 if (fifo_bytes > 0) {
1773 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1774 int fs_tmp = enc->frame_size;
1776 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1777 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1778 enc->frame_size = fifo_bytes / (osize * enc->channels);
1780 int frame_bytes = enc->frame_size*osize*enc->channels;
1781 if (allocated_audio_buf_size < frame_bytes)
1783 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1786 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1787 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1788 ost->st->time_base.num, enc->sample_rate);
1789 enc->frame_size = fs_tmp;
1792 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1795 fprintf(stderr, "Audio encoding failed\n");
1799 pkt.flags |= AV_PKT_FLAG_KEY;
1801 case AVMEDIA_TYPE_VIDEO:
1802 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1804 fprintf(stderr, "Video encoding failed\n");
1808 if(enc->coded_frame && enc->coded_frame->key_frame)
1809 pkt.flags |= AV_PKT_FLAG_KEY;
1810 if (ost->logfile && enc->stats_out) {
1811 fprintf(ost->logfile, "%s", enc->stats_out);
1820 pkt.data= bit_buffer;
1822 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1823 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1824 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1836 static void print_sdp(AVFormatContext **avc, int n)
1840 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1841 printf("SDP:\n%s\n", sdp);
1845 static int copy_chapters(int infile, int outfile)
1847 AVFormatContext *is = input_files[infile];
1848 AVFormatContext *os = output_files[outfile];
1851 for (i = 0; i < is->nb_chapters; i++) {
1852 AVChapter *in_ch = is->chapters[i], *out_ch;
1853 AVMetadataTag *t = NULL;
1854 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1855 AV_TIME_BASE_Q, in_ch->time_base);
1856 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1857 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1860 if (in_ch->end < ts_off)
1862 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1865 out_ch = av_mallocz(sizeof(AVChapter));
1867 return AVERROR(ENOMEM);
1869 out_ch->id = in_ch->id;
1870 out_ch->time_base = in_ch->time_base;
1871 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1872 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1874 if (metadata_chapters_autocopy)
1875 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1876 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1879 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1881 return AVERROR(ENOMEM);
1882 os->chapters[os->nb_chapters - 1] = out_ch;
1887 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1888 AVCodecContext *avctx)
1894 for (p = kf; *p; p++)
1897 ost->forced_kf_count = n;
1898 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1899 if (!ost->forced_kf_pts) {
1900 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1903 for (i = 0; i < n; i++) {
1904 p = i ? strchr(p, ',') + 1 : kf;
1905 t = parse_time_or_die("force_key_frames", p, 1);
1906 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1911 * The following code is the main loop of the file converter
1913 static int transcode(AVFormatContext **output_files,
1914 int nb_output_files,
1915 AVFormatContext **input_files,
1917 AVStreamMap *stream_maps, int nb_stream_maps)
1919 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1920 AVFormatContext *is, *os;
1921 AVCodecContext *codec, *icodec;
1922 AVOutputStream *ost, **ost_table = NULL;
1923 AVInputStream *ist, **ist_table = NULL;
1924 AVInputFile *file_table;
1928 uint8_t no_packet[MAX_FILES]={0};
1929 int no_packet_count=0;
1931 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1935 /* input stream init */
1937 for(i=0;i<nb_input_files;i++) {
1938 is = input_files[i];
1939 file_table[i].ist_index = j;
1940 file_table[i].nb_streams = is->nb_streams;
1941 j += is->nb_streams;
1945 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1949 for(i=0;i<nb_istreams;i++) {
1950 ist = av_mallocz(sizeof(AVInputStream));
1956 for(i=0;i<nb_input_files;i++) {
1957 is = input_files[i];
1958 for(k=0;k<is->nb_streams;k++) {
1959 ist = ist_table[j++];
1960 ist->st = is->streams[k];
1961 ist->file_index = i;
1963 ist->discard = 1; /* the stream is discarded by default
1967 ist->start = av_gettime();
1972 /* output stream init */
1974 for(i=0;i<nb_output_files;i++) {
1975 os = output_files[i];
1976 if (!os->nb_streams) {
1977 dump_format(output_files[i], i, output_files[i]->filename, 1);
1978 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1979 ret = AVERROR(EINVAL);
1982 nb_ostreams += os->nb_streams;
1984 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1985 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1986 ret = AVERROR(EINVAL);
1990 /* Sanity check the mapping args -- do the input files & streams exist? */
1991 for(i=0;i<nb_stream_maps;i++) {
1992 int fi = stream_maps[i].file_index;
1993 int si = stream_maps[i].stream_index;
1995 if (fi < 0 || fi > nb_input_files - 1 ||
1996 si < 0 || si > file_table[fi].nb_streams - 1) {
1997 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1998 ret = AVERROR(EINVAL);
2001 fi = stream_maps[i].sync_file_index;
2002 si = stream_maps[i].sync_stream_index;
2003 if (fi < 0 || fi > nb_input_files - 1 ||
2004 si < 0 || si > file_table[fi].nb_streams - 1) {
2005 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2006 ret = AVERROR(EINVAL);
2011 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2015 for(k=0;k<nb_output_files;k++) {
2016 os = output_files[k];
2017 for(i=0;i<os->nb_streams;i++,n++) {
2019 ost = ost_table[n] = output_streams_for_file[k][i];
2020 ost->st = os->streams[i];
2021 if (nb_stream_maps > 0) {
2022 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2023 stream_maps[n].stream_index;
2025 /* Sanity check that the stream types match */
2026 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2027 int i= ost->file_index;
2028 dump_format(output_files[i], i, output_files[i]->filename, 1);
2029 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2030 stream_maps[n].file_index, stream_maps[n].stream_index,
2031 ost->file_index, ost->index);
2036 int best_nb_frames=-1;
2037 /* get corresponding input stream index : we select the first one with the right type */
2039 for(j=0;j<nb_istreams;j++) {
2044 AVFormatContext *f= input_files[ ist->file_index ];
2046 for(pi=0; pi<f->nb_programs; pi++){
2047 AVProgram *p= f->programs[pi];
2048 if(p->id == opt_programid)
2049 for(si=0; si<p->nb_stream_indexes; si++){
2050 if(f->streams[ p->stream_index[si] ] == ist->st)
2055 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2056 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2057 if(best_nb_frames < ist->st->codec_info_nb_frames){
2058 best_nb_frames= ist->st->codec_info_nb_frames;
2059 ost->source_index = j;
2066 if(! opt_programid) {
2067 /* try again and reuse existing stream */
2068 for(j=0;j<nb_istreams;j++) {
2070 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2071 && ist->st->discard != AVDISCARD_ALL) {
2072 ost->source_index = j;
2078 int i= ost->file_index;
2079 dump_format(output_files[i], i, output_files[i]->filename, 1);
2080 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2081 ost->file_index, ost->index);
2086 ist = ist_table[ost->source_index];
2088 ost->sync_ist = (nb_stream_maps > 0) ?
2089 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2090 stream_maps[n].sync_stream_index] : ist;
2094 /* for each output stream, we compute the right encoding parameters */
2095 for(i=0;i<nb_ostreams;i++) {
2096 AVMetadataTag *t = NULL;
2098 os = output_files[ost->file_index];
2099 ist = ist_table[ost->source_index];
2101 codec = ost->st->codec;
2102 icodec = ist->st->codec;
2104 if (metadata_streams_autocopy)
2105 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2106 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2109 ost->st->disposition = ist->st->disposition;
2110 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2111 codec->chroma_sample_location = icodec->chroma_sample_location;
2113 if (ost->st->stream_copy) {
2114 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2116 if (extra_size > INT_MAX)
2119 /* if stream_copy is selected, no need to decode or encode */
2120 codec->codec_id = icodec->codec_id;
2121 codec->codec_type = icodec->codec_type;
2123 if(!codec->codec_tag){
2124 if( !os->oformat->codec_tag
2125 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2126 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2127 codec->codec_tag = icodec->codec_tag;
2130 codec->bit_rate = icodec->bit_rate;
2131 codec->rc_max_rate = icodec->rc_max_rate;
2132 codec->rc_buffer_size = icodec->rc_buffer_size;
2133 codec->extradata= av_mallocz(extra_size);
2134 if (!codec->extradata)
2136 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2137 codec->extradata_size= icodec->extradata_size;
2138 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2139 codec->time_base = icodec->time_base;
2140 codec->time_base.num *= icodec->ticks_per_frame;
2141 av_reduce(&codec->time_base.num, &codec->time_base.den,
2142 codec->time_base.num, codec->time_base.den, INT_MAX);
2144 codec->time_base = ist->st->time_base;
2145 switch(codec->codec_type) {
2146 case AVMEDIA_TYPE_AUDIO:
2147 if(audio_volume != 256) {
2148 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2151 codec->channel_layout = icodec->channel_layout;
2152 codec->sample_rate = icodec->sample_rate;
2153 codec->channels = icodec->channels;
2154 codec->frame_size = icodec->frame_size;
2155 codec->block_align= icodec->block_align;
2156 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2157 codec->block_align= 0;
2158 if(codec->codec_id == CODEC_ID_AC3)
2159 codec->block_align= 0;
2161 case AVMEDIA_TYPE_VIDEO:
2162 codec->pix_fmt = icodec->pix_fmt;
2163 codec->width = icodec->width;
2164 codec->height = icodec->height;
2165 codec->has_b_frames = icodec->has_b_frames;
2167 case AVMEDIA_TYPE_SUBTITLE:
2168 codec->width = icodec->width;
2169 codec->height = icodec->height;
2175 switch(codec->codec_type) {
2176 case AVMEDIA_TYPE_AUDIO:
2177 ost->fifo= av_fifo_alloc(1024);
2180 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2181 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2182 icodec->request_channels = codec->channels;
2183 ist->decoding_needed = 1;
2184 ost->encoding_needed = 1;
2186 case AVMEDIA_TYPE_VIDEO:
2187 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2188 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2191 ost->video_resample = (codec->width != icodec->width ||
2192 codec->height != icodec->height ||
2193 (codec->pix_fmt != icodec->pix_fmt));
2194 if (ost->video_resample) {
2195 avcodec_get_frame_defaults(&ost->pict_tmp);
2196 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2197 codec->width, codec->height)) {
2198 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2201 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2202 ost->img_resample_ctx = sws_getContext(
2209 sws_flags, NULL, NULL, NULL);
2210 if (ost->img_resample_ctx == NULL) {
2211 fprintf(stderr, "Cannot get resampling context\n");
2215 #if !CONFIG_AVFILTER
2216 ost->original_height = icodec->height;
2217 ost->original_width = icodec->width;
2219 codec->bits_per_raw_sample= 0;
2221 ost->resample_height = icodec->height;
2222 ost->resample_width = icodec->width;
2223 ost->resample_pix_fmt= icodec->pix_fmt;
2224 ost->encoding_needed = 1;
2225 ist->decoding_needed = 1;
2228 if (configure_filters(ist, ost)) {
2229 fprintf(stderr, "Error opening filters!\n");
2234 case AVMEDIA_TYPE_SUBTITLE:
2235 ost->encoding_needed = 1;
2236 ist->decoding_needed = 1;
2243 if (ost->encoding_needed &&
2244 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2245 char logfilename[1024];
2248 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2249 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2251 if (codec->flags & CODEC_FLAG_PASS1) {
2252 f = fopen(logfilename, "wb");
2254 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2260 size_t logbuffer_size;
2261 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2262 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2265 codec->stats_in = logbuffer;
2269 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2270 int size= codec->width * codec->height;
2271 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2276 bit_buffer = av_malloc(bit_buffer_size);
2278 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2280 ret = AVERROR(ENOMEM);
2284 /* open each encoder */
2285 for(i=0;i<nb_ostreams;i++) {
2287 if (ost->encoding_needed) {
2288 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2289 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2291 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2293 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2294 ost->st->codec->codec_id, ost->file_index, ost->index);
2295 ret = AVERROR(EINVAL);
2298 if (dec->subtitle_header) {
2299 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2300 if (!ost->st->codec->subtitle_header) {
2301 ret = AVERROR(ENOMEM);
2304 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2305 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2307 if (avcodec_open(ost->st->codec, codec) < 0) {
2308 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2309 ost->file_index, ost->index);
2310 ret = AVERROR(EINVAL);
2313 extra_size += ost->st->codec->extradata_size;
2317 /* open each decoder */
2318 for(i=0;i<nb_istreams;i++) {
2320 if (ist->decoding_needed) {
2321 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2323 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2325 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2326 ist->st->codec->codec_id, ist->file_index, ist->index);
2327 ret = AVERROR(EINVAL);
2330 if (avcodec_open(ist->st->codec, codec) < 0) {
2331 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2332 ist->file_index, ist->index);
2333 ret = AVERROR(EINVAL);
2336 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2337 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2342 for(i=0;i<nb_istreams;i++) {
2346 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2347 ist->next_pts = AV_NOPTS_VALUE;
2348 init_pts_correction(&ist->pts_ctx);
2352 /* set meta data information from input file if required */
2353 for (i=0;i<nb_meta_data_maps;i++) {
2354 AVFormatContext *files[2];
2355 AVMetadata **meta[2];
2356 AVMetadataTag *mtag;
2359 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2360 if ((index) < 0 || (index) >= (nb_elems)) {\
2361 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2363 ret = AVERROR(EINVAL);\
2367 int out_file_index = meta_data_maps[i][0].file;
2368 int in_file_index = meta_data_maps[i][1].file;
2369 if (in_file_index < 0 || out_file_index < 0)
2371 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2372 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2374 files[0] = output_files[out_file_index];
2375 files[1] = input_files[in_file_index];
2377 for (j = 0; j < 2; j++) {
2378 AVMetaDataMap *map = &meta_data_maps[i][j];
2380 switch (map->type) {
2382 meta[j] = &files[j]->metadata;
2385 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2386 meta[j] = &files[j]->streams[map->index]->metadata;
2389 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2390 meta[j] = &files[j]->chapters[map->index]->metadata;
2393 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2394 meta[j] = &files[j]->programs[map->index]->metadata;
2400 while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2401 av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2404 /* copy global metadata by default */
2405 if (metadata_global_autocopy) {
2406 AVMetadataTag *t = NULL;
2408 while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
2409 for (i = 0; i < nb_output_files; i++)
2410 av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2413 /* copy chapters according to chapter maps */
2414 for (i = 0; i < nb_chapter_maps; i++) {
2415 int infile = chapter_maps[i].in_file;
2416 int outfile = chapter_maps[i].out_file;
2418 if (infile < 0 || outfile < 0)
2420 if (infile >= nb_input_files) {
2421 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2422 ret = AVERROR(EINVAL);
2425 if (outfile >= nb_output_files) {
2426 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2427 ret = AVERROR(EINVAL);
2430 copy_chapters(infile, outfile);
2433 /* copy chapters from the first input file that has them*/
2434 if (!nb_chapter_maps)
2435 for (i = 0; i < nb_input_files; i++) {
2436 if (!input_files[i]->nb_chapters)
2439 for (j = 0; j < nb_output_files; j++)
2440 if ((ret = copy_chapters(i, j)) < 0)
2445 /* open files and write file headers */
2446 for(i=0;i<nb_output_files;i++) {
2447 os = output_files[i];
2448 if (av_write_header(os) < 0) {
2449 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2450 ret = AVERROR(EINVAL);
2453 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2459 /* dump the file output parameters - cannot be done before in case
2461 for(i=0;i<nb_output_files;i++) {
2462 dump_format(output_files[i], i, output_files[i]->filename, 1);
2465 /* dump the stream mapping */
2467 fprintf(stderr, "Stream mapping:\n");
2468 for(i=0;i<nb_ostreams;i++) {
2470 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2471 ist_table[ost->source_index]->file_index,
2472 ist_table[ost->source_index]->index,
2475 if (ost->sync_ist != ist_table[ost->source_index])
2476 fprintf(stderr, " [sync #%d.%d]",
2477 ost->sync_ist->file_index,
2478 ost->sync_ist->index);
2479 fprintf(stderr, "\n");
2484 fprintf(stderr, "%s\n", error);
2489 print_sdp(output_files, nb_output_files);
2492 if (!using_stdin && verbose >= 0) {
2493 fprintf(stderr, "Press [q] to stop encoding\n");
2494 url_set_interrupt_cb(decode_interrupt_cb);
2498 timer_start = av_gettime();
2500 for(; received_sigterm == 0;) {
2501 int file_index, ist_index;
2509 /* if 'q' pressed, exits */
2513 /* read_key() returns 0 on EOF */
2519 /* select the stream that we must read now by looking at the
2520 smallest output pts */
2522 for(i=0;i<nb_ostreams;i++) {
2525 os = output_files[ost->file_index];
2526 ist = ist_table[ost->source_index];
2527 if(ist->is_past_recording_time || no_packet[ist->file_index])
2529 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2530 ipts = (double)ist->pts;
2531 if (!file_table[ist->file_index].eof_reached){
2532 if(ipts < ipts_min) {
2534 if(input_sync ) file_index = ist->file_index;
2536 if(opts < opts_min) {
2538 if(!input_sync) file_index = ist->file_index;
2541 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2546 /* if none, if is finished */
2547 if (file_index < 0) {
2548 if(no_packet_count){
2550 memset(no_packet, 0, sizeof(no_packet));
2557 /* finish if limit size exhausted */
2558 if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2561 /* read a frame from it and output it in the fifo */
2562 is = input_files[file_index];
2563 ret= av_read_frame(is, &pkt);
2564 if(ret == AVERROR(EAGAIN)){
2565 no_packet[file_index]=1;
2570 file_table[file_index].eof_reached = 1;
2578 memset(no_packet, 0, sizeof(no_packet));
2581 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2583 /* the following test is needed in case new streams appear
2584 dynamically in stream : we ignore them */
2585 if (pkt.stream_index >= file_table[file_index].nb_streams)
2586 goto discard_packet;
2587 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2588 ist = ist_table[ist_index];
2590 goto discard_packet;
2592 if (pkt.dts != AV_NOPTS_VALUE)
2593 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2594 if (pkt.pts != AV_NOPTS_VALUE)
2595 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2597 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2598 && input_files_ts_scale[file_index][pkt.stream_index]){
2599 if(pkt.pts != AV_NOPTS_VALUE)
2600 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2601 if(pkt.dts != AV_NOPTS_VALUE)
2602 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2605 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2606 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2607 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2608 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2609 int64_t delta= pkt_dts - ist->next_pts;
2610 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2611 input_files_ts_offset[ist->file_index]-= delta;
2613 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2614 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2615 if(pkt.pts != AV_NOPTS_VALUE)
2616 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2620 /* finish if recording time exhausted */
2621 if (recording_time != INT64_MAX &&
2622 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2623 ist->is_past_recording_time = 1;
2624 goto discard_packet;
2627 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2628 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2631 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2632 ist->file_index, ist->index);
2635 av_free_packet(&pkt);
2640 av_free_packet(&pkt);
2642 /* dump report by using the output first video and audio streams */
2643 print_report(output_files, ost_table, nb_ostreams, 0);
2646 /* at the end of stream, we must flush the decoder buffers */
2647 for(i=0;i<nb_istreams;i++) {
2649 if (ist->decoding_needed) {
2650 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2656 /* write the trailer if needed and close file */
2657 for(i=0;i<nb_output_files;i++) {
2658 os = output_files[i];
2659 av_write_trailer(os);
2662 /* dump report by using the first video and audio streams */
2663 print_report(output_files, ost_table, nb_ostreams, 1);
2665 /* close each encoder */
2666 for(i=0;i<nb_ostreams;i++) {
2668 if (ost->encoding_needed) {
2669 av_freep(&ost->st->codec->stats_in);
2670 avcodec_close(ost->st->codec);
2674 /* close each decoder */
2675 for(i=0;i<nb_istreams;i++) {
2677 if (ist->decoding_needed) {
2678 avcodec_close(ist->st->codec);
2683 avfilter_graph_free(graph);
2692 av_freep(&bit_buffer);
2693 av_free(file_table);
2696 for(i=0;i<nb_istreams;i++) {
2703 for(i=0;i<nb_ostreams;i++) {
2706 if (ost->st->stream_copy)
2707 av_freep(&ost->st->codec->extradata);
2709 fclose(ost->logfile);
2710 ost->logfile = NULL;
2712 av_fifo_free(ost->fifo); /* works even if fifo is not
2713 initialized but set to zero */
2714 av_freep(&ost->st->codec->subtitle_header);
2715 av_free(ost->pict_tmp.data[0]);
2716 av_free(ost->forced_kf_pts);
2717 if (ost->video_resample)
2718 sws_freeContext(ost->img_resample_ctx);
2720 audio_resample_close(ost->resample);
2721 if (ost->reformat_ctx)
2722 av_audio_convert_free(ost->reformat_ctx);
2731 static void opt_format(const char *arg)
2733 last_asked_format = arg;
2736 static void opt_video_rc_override_string(const char *arg)
2738 video_rc_override_string = arg;
2741 static int opt_me_threshold(const char *opt, const char *arg)
2743 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2747 static int opt_verbose(const char *opt, const char *arg)
2749 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2753 static int opt_frame_rate(const char *opt, const char *arg)
2755 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2756 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2762 static int opt_bitrate(const char *opt, const char *arg)
2764 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2766 opt_default(opt, arg);
2768 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2769 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2774 static int opt_frame_crop(const char *opt, const char *arg)
2776 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2777 return AVERROR(EINVAL);
2780 static void opt_frame_size(const char *arg)
2782 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2783 fprintf(stderr, "Incorrect frame size\n");
2788 static int opt_pad(const char *opt, const char *arg) {
2789 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2793 static void opt_frame_pix_fmt(const char *arg)
2795 if (strcmp(arg, "list")) {
2796 frame_pix_fmt = av_get_pix_fmt(arg);
2797 if (frame_pix_fmt == PIX_FMT_NONE) {
2798 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2807 static void opt_frame_aspect_ratio(const char *arg)
2814 p = strchr(arg, ':');
2816 x = strtol(arg, &end, 10);
2818 y = strtol(end+1, &end, 10);
2820 ar = (double)x / (double)y;
2822 ar = strtod(arg, NULL);
2825 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2828 frame_aspect_ratio = ar;
2831 static int opt_metadata(const char *opt, const char *arg)
2833 char *mid= strchr(arg, '=');
2836 fprintf(stderr, "Missing =\n");
2841 av_metadata_set2(&metadata, arg, mid, 0);
2846 static void opt_qscale(const char *arg)
2848 video_qscale = atof(arg);
2849 if (video_qscale <= 0 ||
2850 video_qscale > 255) {
2851 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2856 static void opt_top_field_first(const char *arg)
2858 top_field_first= atoi(arg);
2861 static int opt_thread_count(const char *opt, const char *arg)
2863 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2866 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2871 static void opt_audio_sample_fmt(const char *arg)
2873 if (strcmp(arg, "list"))
2874 audio_sample_fmt = av_get_sample_fmt(arg);
2876 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2881 static int opt_audio_rate(const char *opt, const char *arg)
2883 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2887 static int opt_audio_channels(const char *opt, const char *arg)
2889 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2893 static void opt_video_channel(const char *arg)
2895 video_channel = strtol(arg, NULL, 0);
2898 static void opt_video_standard(const char *arg)
2900 video_standard = av_strdup(arg);
2903 static void opt_codec(int *pstream_copy, char **pcodec_name,
2904 int codec_type, const char *arg)
2906 av_freep(pcodec_name);
2907 if (!strcmp(arg, "copy")) {
2910 *pcodec_name = av_strdup(arg);
2914 static void opt_audio_codec(const char *arg)
2916 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2919 static void opt_video_codec(const char *arg)
2921 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2924 static void opt_subtitle_codec(const char *arg)
2926 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2929 static int opt_codec_tag(const char *opt, const char *arg)
2932 uint32_t *codec_tag;
2934 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2935 !strcmp(opt, "vtag") ? &video_codec_tag :
2936 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2940 *codec_tag = strtol(arg, &tail, 0);
2942 *codec_tag = AV_RL32(arg);
2947 static void opt_map(const char *arg)
2952 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2953 m = &stream_maps[nb_stream_maps-1];
2955 m->file_index = strtol(arg, &p, 0);
2959 m->stream_index = strtol(p, &p, 0);
2962 m->sync_file_index = strtol(p, &p, 0);
2965 m->sync_stream_index = strtol(p, &p, 0);
2967 m->sync_file_index = m->file_index;
2968 m->sync_stream_index = m->stream_index;
2972 static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
2983 *index = strtol(++arg, endptr, 0);
2986 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2993 static void opt_map_meta_data(const char *arg)
2995 AVMetaDataMap *m, *m1;
2998 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2999 &nb_meta_data_maps, nb_meta_data_maps + 1);
3001 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3002 m->file = strtol(arg, &p, 0);
3003 parse_meta_type(p, &m->type, &m->index, &p);
3007 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3008 m1->file = strtol(p, &p, 0);
3009 parse_meta_type(p, &m1->type, &m1->index, &p);
3011 if (m->type == 'g' || m1->type == 'g')
3012 metadata_global_autocopy = 0;
3013 if (m->type == 's' || m1->type == 's')
3014 metadata_streams_autocopy = 0;
3015 if (m->type == 'c' || m1->type == 'c')
3016 metadata_chapters_autocopy = 0;
3019 static void opt_map_chapters(const char *arg)
3024 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3025 nb_chapter_maps + 1);
3026 c = &chapter_maps[nb_chapter_maps - 1];
3027 c->out_file = strtol(arg, &p, 0);
3031 c->in_file = strtol(p, &p, 0);
3034 static void opt_input_ts_scale(const char *arg)
3036 unsigned int stream;
3040 stream = strtol(arg, &p, 0);
3043 scale= strtod(p, &p);
3045 if(stream >= MAX_STREAMS)
3048 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);
3049 input_files_ts_scale[nb_input_files][stream]= scale;
3052 static int opt_recording_time(const char *opt, const char *arg)
3054 recording_time = parse_time_or_die(opt, arg, 1);
3058 static int opt_start_time(const char *opt, const char *arg)
3060 start_time = parse_time_or_die(opt, arg, 1);
3064 static int opt_recording_timestamp(const char *opt, const char *arg)
3066 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3070 static int opt_input_ts_offset(const char *opt, const char *arg)
3072 input_ts_offset = parse_time_or_die(opt, arg, 1);
3076 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3078 const char *codec_string = encoder ? "encoder" : "decoder";
3082 return CODEC_ID_NONE;
3084 avcodec_find_encoder_by_name(name) :
3085 avcodec_find_decoder_by_name(name);
3087 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3090 if(codec->type != type) {
3091 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3094 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3095 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3096 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3097 "results.\nAdd '-strict experimental' if you want to use it.\n",
3098 codec_string, codec->name);
3100 avcodec_find_encoder(codec->id) :
3101 avcodec_find_decoder(codec->id);
3102 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3103 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3104 codec_string, codec->name);
3110 static void opt_input_file(const char *filename)
3112 AVFormatContext *ic;
3113 AVFormatParameters params, *ap = ¶ms;
3114 AVInputFormat *file_iformat = NULL;
3115 int err, i, ret, rfps, rfps_base;
3118 if (last_asked_format) {
3119 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3120 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3123 last_asked_format = NULL;
3126 if (!strcmp(filename, "-"))
3129 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3130 !strcmp(filename, "/dev/stdin");
3132 /* get default parameters from command line */
3133 ic = avformat_alloc_context();
3135 print_error(filename, AVERROR(ENOMEM));
3139 memset(ap, 0, sizeof(*ap));
3140 ap->prealloced_context = 1;
3141 ap->sample_rate = audio_sample_rate;
3142 ap->channels = audio_channels;
3143 ap->time_base.den = frame_rate.num;
3144 ap->time_base.num = frame_rate.den;
3145 ap->width = frame_width;
3146 ap->height = frame_height;
3147 ap->pix_fmt = frame_pix_fmt;
3148 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3149 ap->channel = video_channel;
3150 ap->standard = video_standard;
3152 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3154 ic->video_codec_id =
3155 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3156 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3157 ic->audio_codec_id =
3158 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3159 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3160 ic->subtitle_codec_id=
3161 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3162 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3163 ic->flags |= AVFMT_FLAG_NONBLOCK;
3165 /* open the input file with generic libav function */
3166 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3168 print_error(filename, err);
3174 for(i=0; i<ic->nb_streams; i++){
3175 ic->streams[i]->discard= AVDISCARD_ALL;
3177 for(i=0; i<ic->nb_programs; i++){
3178 AVProgram *p= ic->programs[i];
3179 if(p->id != opt_programid){
3180 p->discard = AVDISCARD_ALL;
3183 for(j=0; j<p->nb_stream_indexes; j++){
3184 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3189 fprintf(stderr, "Specified program id not found\n");
3195 ic->loop_input = loop_input;
3197 /* If not enough info to get the stream parameters, we decode the
3198 first frames to get it. (used in mpeg case for example) */
3199 ret = av_find_stream_info(ic);
3200 if (ret < 0 && verbose >= 0) {
3201 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3202 av_close_input_file(ic);
3206 timestamp = start_time;
3207 /* add the stream start time */
3208 if (ic->start_time != AV_NOPTS_VALUE)
3209 timestamp += ic->start_time;
3211 /* if seeking requested, we execute it */
3212 if (start_time != 0) {
3213 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3215 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3216 filename, (double)timestamp / AV_TIME_BASE);
3218 /* reset seek info */
3222 /* update the current parameters so that they match the one of the input stream */
3223 for(i=0;i<ic->nb_streams;i++) {
3224 AVStream *st = ic->streams[i];
3225 AVCodecContext *dec = st->codec;
3226 avcodec_thread_init(dec, thread_count);
3227 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3228 switch (dec->codec_type) {
3229 case AVMEDIA_TYPE_AUDIO:
3230 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3231 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]);
3232 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3233 channel_layout = dec->channel_layout;
3234 audio_channels = dec->channels;
3235 audio_sample_rate = dec->sample_rate;
3236 audio_sample_fmt = dec->sample_fmt;
3238 st->discard= AVDISCARD_ALL;
3239 /* Note that av_find_stream_info can add more streams, and we
3240 * currently have no chance of setting up lowres decoding
3241 * early enough for them. */
3243 audio_sample_rate >>= dec->lowres;
3245 case AVMEDIA_TYPE_VIDEO:
3246 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3247 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]);
3248 frame_height = dec->height;
3249 frame_width = dec->width;
3250 if(ic->streams[i]->sample_aspect_ratio.num)
3251 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3253 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3254 frame_aspect_ratio *= (float) dec->width / dec->height;
3255 frame_pix_fmt = dec->pix_fmt;
3256 rfps = ic->streams[i]->r_frame_rate.num;
3257 rfps_base = ic->streams[i]->r_frame_rate.den;
3259 dec->flags |= CODEC_FLAG_EMU_EDGE;
3260 frame_height >>= dec->lowres;
3261 frame_width >>= dec->lowres;
3264 dec->debug |= FF_DEBUG_MV;
3266 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3269 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3270 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3272 (float)rfps / rfps_base, rfps, rfps_base);
3274 /* update the current frame rate to match the stream frame rate */
3275 frame_rate.num = rfps;
3276 frame_rate.den = rfps_base;
3279 st->discard= AVDISCARD_ALL;
3280 else if(video_discard)
3281 st->discard= video_discard;
3283 case AVMEDIA_TYPE_DATA:
3285 case AVMEDIA_TYPE_SUBTITLE:
3286 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3287 if(subtitle_disable)
3288 st->discard = AVDISCARD_ALL;
3290 case AVMEDIA_TYPE_ATTACHMENT:
3291 case AVMEDIA_TYPE_UNKNOWN:
3298 input_files[nb_input_files] = ic;
3299 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3300 /* dump the file content */
3302 dump_format(ic, nb_input_files, filename, 0);
3308 av_freep(&video_codec_name);
3309 av_freep(&audio_codec_name);
3310 av_freep(&subtitle_codec_name);
3313 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3314 int *has_subtitle_ptr)
3316 int has_video, has_audio, has_subtitle, i, j;
3317 AVFormatContext *ic;
3322 for(j=0;j<nb_input_files;j++) {
3323 ic = input_files[j];
3324 for(i=0;i<ic->nb_streams;i++) {
3325 AVCodecContext *enc = ic->streams[i]->codec;
3326 switch(enc->codec_type) {
3327 case AVMEDIA_TYPE_AUDIO:
3330 case AVMEDIA_TYPE_VIDEO:
3333 case AVMEDIA_TYPE_SUBTITLE:
3336 case AVMEDIA_TYPE_DATA:
3337 case AVMEDIA_TYPE_ATTACHMENT:
3338 case AVMEDIA_TYPE_UNKNOWN:
3345 *has_video_ptr = has_video;
3346 *has_audio_ptr = has_audio;
3347 *has_subtitle_ptr = has_subtitle;
3350 static void new_video_stream(AVFormatContext *oc, int file_idx)
3353 AVOutputStream *ost;
3354 AVCodecContext *video_enc;
3355 enum CodecID codec_id;
3356 AVCodec *codec= NULL;
3358 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3360 fprintf(stderr, "Could not alloc stream\n");
3363 ost = new_output_stream(oc, file_idx);
3365 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3366 if(!video_stream_copy){
3367 if (video_codec_name) {
3368 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3369 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3370 codec = avcodec_find_encoder_by_name(video_codec_name);
3371 output_codecs[nb_output_codecs-1] = codec;
3373 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3374 codec = avcodec_find_encoder(codec_id);
3378 avcodec_get_context_defaults3(st->codec, codec);
3379 ost->bitstream_filters = video_bitstream_filters;
3380 video_bitstream_filters= NULL;
3382 avcodec_thread_init(st->codec, thread_count);
3384 video_enc = st->codec;
3387 video_enc->codec_tag= video_codec_tag;
3389 if( (video_global_header&1)
3390 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3391 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3392 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3394 if(video_global_header&2){
3395 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3396 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3399 if (video_stream_copy) {
3400 st->stream_copy = 1;
3401 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3402 video_enc->sample_aspect_ratio =
3403 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3407 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3409 video_enc->codec_id = codec_id;
3410 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3412 if (codec && codec->supported_framerates && !force_fps)
3413 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3414 video_enc->time_base.den = fps.num;
3415 video_enc->time_base.num = fps.den;
3417 video_enc->width = frame_width;
3418 video_enc->height = frame_height;
3419 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3420 video_enc->pix_fmt = frame_pix_fmt;
3421 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3423 choose_pixel_fmt(st, codec);
3426 video_enc->gop_size = 0;
3427 if (video_qscale || same_quality) {
3428 video_enc->flags |= CODEC_FLAG_QSCALE;
3429 video_enc->global_quality=
3430 st->quality = FF_QP2LAMBDA * video_qscale;
3434 video_enc->intra_matrix = intra_matrix;
3436 video_enc->inter_matrix = inter_matrix;
3438 p= video_rc_override_string;
3441 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3443 fprintf(stderr, "error parsing rc_override\n");
3446 video_enc->rc_override=
3447 av_realloc(video_enc->rc_override,
3448 sizeof(RcOverride)*(i+1));
3449 video_enc->rc_override[i].start_frame= start;
3450 video_enc->rc_override[i].end_frame = end;
3452 video_enc->rc_override[i].qscale= q;
3453 video_enc->rc_override[i].quality_factor= 1.0;
3456 video_enc->rc_override[i].qscale= 0;
3457 video_enc->rc_override[i].quality_factor= -q/100.0;
3462 video_enc->rc_override_count=i;
3463 if (!video_enc->rc_initial_buffer_occupancy)
3464 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3465 video_enc->me_threshold= me_threshold;
3466 video_enc->intra_dc_precision= intra_dc_precision - 8;
3469 video_enc->flags|= CODEC_FLAG_PSNR;
3474 video_enc->flags |= CODEC_FLAG_PASS1;
3476 video_enc->flags |= CODEC_FLAG_PASS2;
3480 if (forced_key_frames)
3481 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3483 if (video_language) {
3484 av_metadata_set2(&st->metadata, "language", video_language, 0);
3485 av_freep(&video_language);
3488 /* reset some key parameters */
3490 av_freep(&video_codec_name);
3491 av_freep(&forced_key_frames);
3492 video_stream_copy = 0;
3493 frame_pix_fmt = PIX_FMT_NONE;
3496 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3499 AVOutputStream *ost;
3500 AVCodec *codec= NULL;
3501 AVCodecContext *audio_enc;
3502 enum CodecID codec_id;
3504 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3506 fprintf(stderr, "Could not alloc stream\n");
3509 ost = new_output_stream(oc, file_idx);
3511 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3512 if(!audio_stream_copy){
3513 if (audio_codec_name) {
3514 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3515 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3516 codec = avcodec_find_encoder_by_name(audio_codec_name);
3517 output_codecs[nb_output_codecs-1] = codec;
3519 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3520 codec = avcodec_find_encoder(codec_id);
3524 avcodec_get_context_defaults3(st->codec, codec);
3526 ost->bitstream_filters = audio_bitstream_filters;
3527 audio_bitstream_filters= NULL;
3529 avcodec_thread_init(st->codec, thread_count);
3531 audio_enc = st->codec;
3532 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3535 audio_enc->codec_tag= audio_codec_tag;
3537 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3538 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3539 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3541 if (audio_stream_copy) {
3542 st->stream_copy = 1;
3543 audio_enc->channels = audio_channels;
3544 audio_enc->sample_rate = audio_sample_rate;
3546 audio_enc->codec_id = codec_id;
3547 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3549 if (audio_qscale > QSCALE_NONE) {
3550 audio_enc->flags |= CODEC_FLAG_QSCALE;
3551 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3553 audio_enc->channels = audio_channels;
3554 audio_enc->sample_fmt = audio_sample_fmt;
3555 audio_enc->sample_rate = audio_sample_rate;
3556 audio_enc->channel_layout = channel_layout;
3557 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3558 audio_enc->channel_layout = 0;
3559 choose_sample_fmt(st, codec);
3560 choose_sample_rate(st, codec);
3562 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3563 if (audio_language) {
3564 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3565 av_freep(&audio_language);
3568 /* reset some key parameters */
3570 av_freep(&audio_codec_name);
3571 audio_stream_copy = 0;
3574 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3577 AVOutputStream *ost;
3578 AVCodec *codec=NULL;
3579 AVCodecContext *subtitle_enc;
3581 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3583 fprintf(stderr, "Could not alloc stream\n");
3586 ost = new_output_stream(oc, file_idx);
3587 subtitle_enc = st->codec;
3588 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3589 if(!subtitle_stream_copy){
3590 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3591 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3592 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3594 avcodec_get_context_defaults3(st->codec, codec);
3596 ost->bitstream_filters = subtitle_bitstream_filters;
3597 subtitle_bitstream_filters= NULL;
3599 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3601 if(subtitle_codec_tag)
3602 subtitle_enc->codec_tag= subtitle_codec_tag;
3604 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3605 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3606 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3608 if (subtitle_stream_copy) {
3609 st->stream_copy = 1;
3611 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3614 if (subtitle_language) {
3615 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3616 av_freep(&subtitle_language);
3619 subtitle_disable = 0;
3620 av_freep(&subtitle_codec_name);
3621 subtitle_stream_copy = 0;
3624 static int opt_new_stream(const char *opt, const char *arg)
3626 AVFormatContext *oc;
3627 int file_idx = nb_output_files - 1;
3628 if (nb_output_files <= 0) {
3629 fprintf(stderr, "At least one output file must be specified\n");
3632 oc = output_files[file_idx];
3634 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3635 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3636 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3641 /* arg format is "output-stream-index:streamid-value". */
3642 static int opt_streamid(const char *opt, const char *arg)
3648 strncpy(idx_str, arg, sizeof(idx_str));
3649 idx_str[sizeof(idx_str)-1] = '\0';
3650 p = strchr(idx_str, ':');
3653 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3658 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3659 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3660 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3664 static void opt_output_file(const char *filename)
3666 AVFormatContext *oc;
3667 int err, use_video, use_audio, use_subtitle;
3668 int input_has_video, input_has_audio, input_has_subtitle;
3669 AVFormatParameters params, *ap = ¶ms;
3670 AVOutputFormat *file_oformat;
3671 AVMetadataTag *tag = NULL;
3673 if (!strcmp(filename, "-"))
3676 oc = avformat_alloc_context();
3678 print_error(filename, AVERROR(ENOMEM));
3682 if (last_asked_format) {
3683 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3684 if (!file_oformat) {
3685 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3688 last_asked_format = NULL;
3690 file_oformat = av_guess_format(NULL, filename, NULL);
3691 if (!file_oformat) {
3692 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3698 oc->oformat = file_oformat;
3699 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3701 if (!strcmp(file_oformat->name, "ffm") &&
3702 av_strstart(filename, "http:", NULL)) {
3703 /* special case for files sent to ffserver: we get the stream
3704 parameters from ffserver */
3705 int err = read_ffserver_streams(oc, filename);
3707 print_error(filename, err);
3711 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3712 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3713 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3715 /* disable if no corresponding type found and at least one
3717 if (nb_input_files > 0) {
3718 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3719 &input_has_subtitle);
3720 if (!input_has_video)
3722 if (!input_has_audio)
3724 if (!input_has_subtitle)
3728 /* manual disable */
3729 if (audio_disable) use_audio = 0;
3730 if (video_disable) use_video = 0;
3731 if (subtitle_disable) use_subtitle = 0;
3733 if (use_video) new_video_stream(oc, nb_output_files);
3734 if (use_audio) new_audio_stream(oc, nb_output_files);
3735 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3737 oc->timestamp = recording_timestamp;
3739 while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3740 av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3741 av_metadata_free(&metadata);
3744 output_files[nb_output_files++] = oc;
3746 /* check filename in case of an image number is expected */
3747 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3748 if (!av_filename_number_test(oc->filename)) {
3749 print_error(oc->filename, AVERROR_NUMEXPECTED);
3754 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3755 /* test if it already exists to avoid loosing precious files */
3756 if (!file_overwrite &&
3757 (strchr(filename, ':') == NULL ||
3758 filename[1] == ':' ||
3759 av_strstart(filename, "file:", NULL))) {
3760 if (url_exist(filename)) {
3762 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3764 if (!read_yesno()) {
3765 fprintf(stderr, "Not overwriting - exiting\n");
3770 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3777 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3778 print_error(filename, err);
3783 memset(ap, 0, sizeof(*ap));
3784 if (av_set_parameters(oc, ap) < 0) {
3785 fprintf(stderr, "%s: Invalid encoding parameters\n",
3790 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3791 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3792 oc->loop_output = loop_output;
3793 oc->flags |= AVFMT_FLAG_NONBLOCK;
3795 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3797 nb_streamid_map = 0;
3798 av_freep(&forced_key_frames);
3801 /* same option as mencoder */
3802 static void opt_pass(const char *pass_str)
3805 pass = atoi(pass_str);
3806 if (pass != 1 && pass != 2) {
3807 fprintf(stderr, "pass number can be only 1 or 2\n");
3813 static int64_t getutime(void)
3816 struct rusage rusage;
3818 getrusage(RUSAGE_SELF, &rusage);
3819 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3820 #elif HAVE_GETPROCESSTIMES
3822 FILETIME c, e, k, u;
3823 proc = GetCurrentProcess();
3824 GetProcessTimes(proc, &c, &e, &k, &u);
3825 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3827 return av_gettime();
3831 static int64_t getmaxrss(void)
3833 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3834 struct rusage rusage;
3835 getrusage(RUSAGE_SELF, &rusage);
3836 return (int64_t)rusage.ru_maxrss * 1024;
3837 #elif HAVE_GETPROCESSMEMORYINFO
3839 PROCESS_MEMORY_COUNTERS memcounters;
3840 proc = GetCurrentProcess();
3841 memcounters.cb = sizeof(memcounters);
3842 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3843 return memcounters.PeakPagefileUsage;
3849 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3852 const char *p = str;
3859 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3866 static void opt_inter_matrix(const char *arg)
3868 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3869 parse_matrix_coeffs(inter_matrix, arg);
3872 static void opt_intra_matrix(const char *arg)
3874 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3875 parse_matrix_coeffs(intra_matrix, arg);
3878 static void show_usage(void)
3880 printf("Hyper fast Audio and Video encoder\n");
3881 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3885 static void show_help(void)
3887 av_log_set_callback(log_callback_help);
3889 show_help_options(options, "Main options:\n",
3890 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3891 show_help_options(options, "\nAdvanced options:\n",
3892 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3894 show_help_options(options, "\nVideo options:\n",
3895 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3897 show_help_options(options, "\nAdvanced Video options:\n",
3898 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3899 OPT_VIDEO | OPT_EXPERT);
3900 show_help_options(options, "\nAudio options:\n",
3901 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3903 show_help_options(options, "\nAdvanced Audio options:\n",
3904 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3905 OPT_AUDIO | OPT_EXPERT);
3906 show_help_options(options, "\nSubtitle options:\n",
3907 OPT_SUBTITLE | OPT_GRAB,
3909 show_help_options(options, "\nAudio/Video grab options:\n",
3913 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3915 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3917 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3920 static void opt_target(const char *arg)
3922 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3923 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3925 if(!strncmp(arg, "pal-", 4)) {
3928 } else if(!strncmp(arg, "ntsc-", 5)) {
3931 } else if(!strncmp(arg, "film-", 5)) {
3936 /* Calculate FR via float to avoid int overflow */
3937 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3940 } else if((fr == 29970) || (fr == 23976)) {
3943 /* Try to determine PAL/NTSC by peeking in the input files */
3944 if(nb_input_files) {
3946 for(j = 0; j < nb_input_files; j++) {
3947 for(i = 0; i < input_files[j]->nb_streams; i++) {
3948 AVCodecContext *c = input_files[j]->streams[i]->codec;
3949 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3951 fr = c->time_base.den * 1000 / c->time_base.num;
3955 } else if((fr == 29970) || (fr == 23976)) {
3965 if(verbose && norm != UNKNOWN)
3966 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3969 if(norm == UNKNOWN) {
3970 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3971 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3972 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3976 if(!strcmp(arg, "vcd")) {
3978 opt_video_codec("mpeg1video");
3979 opt_audio_codec("mp2");
3982 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3983 opt_frame_rate(NULL, frame_rates[norm]);
3984 opt_default("g", norm == PAL ? "15" : "18");
3986 opt_default("b", "1150000");
3987 opt_default("maxrate", "1150000");
3988 opt_default("minrate", "1150000");
3989 opt_default("bufsize", "327680"); // 40*1024*8;
3991 opt_default("ab", "224000");
3992 audio_sample_rate = 44100;
3995 opt_default("packetsize", "2324");
3996 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3998 /* We have to offset the PTS, so that it is consistent with the SCR.
3999 SCR starts at 36000, but the first two packs contain only padding
4000 and the first pack from the other stream, respectively, may also have
4001 been written before.
4002 So the real data starts at SCR 36000+3*1200. */
4003 mux_preload= (36000+3*1200) / 90000.0; //0.44
4004 } else if(!strcmp(arg, "svcd")) {
4006 opt_video_codec("mpeg2video");
4007 opt_audio_codec("mp2");
4010 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4011 opt_frame_rate(NULL, frame_rates[norm]);
4012 opt_default("g", norm == PAL ? "15" : "18");
4014 opt_default("b", "2040000");
4015 opt_default("maxrate", "2516000");
4016 opt_default("minrate", "0"); //1145000;
4017 opt_default("bufsize", "1835008"); //224*1024*8;
4018 opt_default("flags", "+scan_offset");
4021 opt_default("ab", "224000");
4022 audio_sample_rate = 44100;
4024 opt_default("packetsize", "2324");
4026 } else if(!strcmp(arg, "dvd")) {
4028 opt_video_codec("mpeg2video");
4029 opt_audio_codec("ac3");
4032 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4033 opt_frame_rate(NULL, frame_rates[norm]);
4034 opt_default("g", norm == PAL ? "15" : "18");
4036 opt_default("b", "6000000");
4037 opt_default("maxrate", "9000000");
4038 opt_default("minrate", "0"); //1500000;
4039 opt_default("bufsize", "1835008"); //224*1024*8;
4041 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4042 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4044 opt_default("ab", "448000");
4045 audio_sample_rate = 48000;
4047 } else if(!strncmp(arg, "dv", 2)) {
4051 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4052 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4053 (norm == PAL ? "yuv420p" : "yuv411p"));
4054 opt_frame_rate(NULL, frame_rates[norm]);
4056 audio_sample_rate = 48000;
4060 fprintf(stderr, "Unknown target: %s\n", arg);
4065 static void opt_vstats_file (const char *arg)
4067 av_free (vstats_filename);
4068 vstats_filename=av_strdup (arg);
4071 static void opt_vstats (void)
4074 time_t today2 = time(NULL);
4075 struct tm *today = localtime(&today2);
4077 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4079 opt_vstats_file(filename);
4082 static int opt_bsf(const char *opt, const char *arg)
4084 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4085 AVBitStreamFilterContext **bsfp;
4088 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4092 bsfp= *opt == 'v' ? &video_bitstream_filters :
4093 *opt == 'a' ? &audio_bitstream_filters :
4094 &subtitle_bitstream_filters;
4096 bsfp= &(*bsfp)->next;
4103 static int opt_preset(const char *opt, const char *arg)
4106 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4107 char *codec_name = *opt == 'v' ? video_codec_name :
4108 *opt == 'a' ? audio_codec_name :
4109 subtitle_codec_name;
4111 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4112 fprintf(stderr, "File for preset '%s' not found\n", arg);
4117 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4118 if(line[0] == '#' && !e)
4120 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4122 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4125 if(!strcmp(tmp, "acodec")){
4126 opt_audio_codec(tmp2);
4127 }else if(!strcmp(tmp, "vcodec")){
4128 opt_video_codec(tmp2);
4129 }else if(!strcmp(tmp, "scodec")){
4130 opt_subtitle_codec(tmp2);
4131 }else if(opt_default(tmp, tmp2) < 0){
4132 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4142 static const OptionDef options[] = {
4144 #include "cmdutils_common_opts.h"
4145 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4146 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4147 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4148 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4149 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4150 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4151 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4152 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4153 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4154 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4155 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4156 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4157 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4158 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4159 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4160 "add timings for benchmarking" },
4161 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4162 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4163 "dump each input packet" },
4164 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4165 "when dumping packets, also dump the payload" },
4166 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4167 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4168 { "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)", "" },
4169 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4170 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4171 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4172 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4173 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4174 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4175 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4176 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4177 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4178 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4179 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4180 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4181 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4184 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4185 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4186 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4187 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4188 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4189 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4190 { "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" },
4191 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4192 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4193 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4194 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4195 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4196 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4197 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4198 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4199 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4200 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4201 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4202 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4203 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4204 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4205 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4206 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4207 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4208 "use same video quality as source (implies VBR)" },
4209 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4210 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4211 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4212 "deinterlace pictures" },
4213 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4214 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4215 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4217 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4219 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4220 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4221 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4222 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4223 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4224 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4225 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4226 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4227 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4228 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4229 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4232 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4233 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4234 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4235 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4236 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4237 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4238 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4239 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4240 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4241 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4242 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4243 { "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" },
4245 /* subtitle options */
4246 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4247 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4248 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4249 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4250 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4253 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4254 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4255 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4258 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4259 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4261 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4262 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4263 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4265 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4266 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4267 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4268 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4270 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4274 int main(int argc, char **argv)
4278 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4280 avcodec_register_all();
4282 avdevice_register_all();
4285 avfilter_register_all();
4290 if(isatty(STDIN_FILENO))
4291 url_set_interrupt_cb(decode_interrupt_cb);
4299 parse_options(argc, argv, options, opt_output_file);
4301 if(nb_output_files <= 0 && nb_input_files == 0) {
4303 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4307 /* file converter / grab */
4308 if (nb_output_files <= 0) {
4309 fprintf(stderr, "At least one output file must be specified\n");
4313 if (nb_input_files == 0) {
4314 fprintf(stderr, "At least one input file must be specified\n");
4319 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4320 stream_maps, nb_stream_maps) < 0)
4322 ti = getutime() - ti;
4324 int maxrss = getmaxrss() / 1024;
4325 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4328 return ffmpeg_exit(0);