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 "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/avstring.h"
43 #include "libavutil/libm.h"
44 #include "libavformat/os_support.h"
47 # include "libavfilter/avfilter.h"
48 # include "libavfilter/avfiltergraph.h"
49 # include "libavfilter/graphparser.h"
50 # include "libavfilter/vsrc_buffer.h"
53 #if HAVE_SYS_RESOURCE_H
54 #include <sys/types.h>
56 #include <sys/resource.h>
57 #elif HAVE_GETPROCESSTIMES
60 #if HAVE_GETPROCESSMEMORYINFO
66 #include <sys/select.h>
71 #include <sys/ioctl.h>
84 const char program_name[] = "FFmpeg";
85 const int program_birth_year = 2000;
87 /* select an input stream for an output stream */
88 typedef struct AVStreamMap {
92 int sync_stream_index;
95 /** select an input file for an output file */
96 typedef struct AVMetaDataMap {
101 static const OptionDef options[];
103 #define MAX_FILES 100
105 static const char *last_asked_format = NULL;
106 static AVFormatContext *input_files[MAX_FILES];
107 static int64_t input_files_ts_offset[MAX_FILES];
108 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
109 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
110 static int nb_input_files = 0;
111 static int nb_icodecs;
113 static AVFormatContext *output_files[MAX_FILES];
114 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
115 static int nb_output_files = 0;
116 static int nb_ocodecs;
118 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
119 static int nb_stream_maps;
121 static AVMetaDataMap meta_data_maps[MAX_FILES];
122 static int nb_meta_data_maps;
124 static int frame_width = 0;
125 static int frame_height = 0;
126 static float frame_aspect_ratio = 0;
127 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
128 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
129 static int frame_topBand = 0;
130 static int frame_bottomBand = 0;
131 static int frame_leftBand = 0;
132 static int frame_rightBand = 0;
133 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
134 static AVRational frame_rate;
135 static float video_qscale = 0;
136 static uint16_t *intra_matrix = NULL;
137 static uint16_t *inter_matrix = NULL;
138 static const char *video_rc_override_string=NULL;
139 static int video_disable = 0;
140 static int video_discard = 0;
141 static char *video_codec_name = NULL;
142 static unsigned int video_codec_tag = 0;
143 static char *video_language = NULL;
144 static int same_quality = 0;
145 static int do_deinterlace = 0;
146 static int top_field_first = -1;
147 static int me_threshold = 0;
148 static int intra_dc_precision = 8;
149 static int loop_input = 0;
150 static int loop_output = AVFMT_NOOUTPUTLOOP;
151 static int qp_hist = 0;
153 static char *vfilters = NULL;
154 AVFilterGraph *graph = NULL;
157 static int intra_only = 0;
158 static int audio_sample_rate = 44100;
159 static int64_t channel_layout = 0;
160 #define QSCALE_NONE -99999
161 static float audio_qscale = QSCALE_NONE;
162 static int audio_disable = 0;
163 static int audio_channels = 1;
164 static char *audio_codec_name = NULL;
165 static unsigned int audio_codec_tag = 0;
166 static char *audio_language = NULL;
168 static int subtitle_disable = 0;
169 static char *subtitle_codec_name = NULL;
170 static char *subtitle_language = NULL;
171 static unsigned int subtitle_codec_tag = 0;
173 static float mux_preload= 0.5;
174 static float mux_max_delay= 0.7;
176 static int64_t recording_time = INT64_MAX;
177 static int64_t start_time = 0;
178 static int64_t rec_timestamp = 0;
179 static int64_t input_ts_offset = 0;
180 static int file_overwrite = 0;
181 static int metadata_count;
182 static AVMetadataTag *metadata;
183 static int do_benchmark = 0;
184 static int do_hex_dump = 0;
185 static int do_pkt_dump = 0;
186 static int do_psnr = 0;
187 static int do_pass = 0;
188 static char *pass_logfilename_prefix = NULL;
189 static int audio_stream_copy = 0;
190 static int video_stream_copy = 0;
191 static int subtitle_stream_copy = 0;
192 static int video_sync_method= -1;
193 static int audio_sync_method= 0;
194 static float audio_drift_threshold= 0.1;
195 static int copy_ts= 0;
196 static int opt_shortest = 0;
197 static int video_global_header = 0;
198 static char *vstats_filename;
199 static FILE *vstats_file;
200 static int opt_programid = 0;
201 static int copy_initial_nonkeyframes = 0;
203 static int rate_emu = 0;
205 static int video_channel = 0;
206 static char *video_standard;
208 static int audio_volume = 256;
210 static int exit_on_error = 0;
211 static int using_stdin = 0;
212 static int verbose = 1;
213 static int thread_count= 1;
214 static int q_pressed = 0;
215 static int64_t video_size = 0;
216 static int64_t audio_size = 0;
217 static int64_t extra_size = 0;
218 static int nb_frames_dup = 0;
219 static int nb_frames_drop = 0;
220 static int input_sync;
221 static uint64_t limit_filesize = 0;
222 static int force_fps = 0;
224 static int pgmyuv_compatibility_hack=0;
225 static float dts_delta_threshold = 10;
227 static unsigned int sws_flags = SWS_BICUBIC;
229 static int64_t timer_start;
231 static uint8_t *audio_buf;
232 static uint8_t *audio_out;
233 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
235 static short *samples;
237 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
238 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
239 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
240 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
242 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
244 struct AVInputStream;
246 typedef struct AVOutputStream {
247 int file_index; /* file index */
248 int index; /* stream index in the output file */
249 int source_index; /* AVInputStream index */
250 AVStream *st; /* stream in the output file */
251 int encoding_needed; /* true if encoding needed for this stream */
253 /* input pts and corresponding output pts
255 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
256 struct AVInputStream *sync_ist; /* input stream to sync against */
257 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
260 AVFrame pict_tmp; /* temporary image for resampling */
261 struct SwsContext *img_resample_ctx; /* for image resampling */
264 int resample_pix_fmt;
266 /* full frame size of first frame */
270 /* cropping area sizes */
277 /* cropping area of first frame */
278 int original_topBand;
279 int original_bottomBand;
280 int original_leftBand;
281 int original_rightBand;
285 ReSampleContext *resample; /* for audio resampling */
287 AVAudioConvert *reformat_ctx;
288 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
292 typedef struct AVInputStream {
296 int discard; /* true if stream data should be discarded */
297 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
298 int64_t sample_index; /* current sample */
300 int64_t start; /* time when read started */
301 int64_t next_pts; /* synthetic pts for cases where pkt.pts
303 int64_t pts; /* current pts */
304 int is_start; /* is 1 at the start and after a discontinuity */
305 int showed_multi_packet_warning;
306 int is_past_recording_time;
308 AVFilterContext *out_video_filter;
309 AVFilterContext *input_video_filter;
310 AVFrame *filter_frame;
311 int has_filter_frame;
312 AVFilterPicRef *picref;
316 typedef struct AVInputFile {
317 int eof_reached; /* true if eof reached */
318 int ist_index; /* index of first stream in ist_table */
319 int buffer_size; /* current total buffer size */
320 int nb_streams; /* nb streams we are aware of */
325 /* init terminal so that we can grab keys */
326 static struct termios oldtty;
335 static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
337 FilterOutPriv *priv = ctx->priv;
339 if(!opaque) return -1;
341 priv->pix_fmt = *((int *)opaque);
346 static void output_end_frame(AVFilterLink *link)
350 static int output_query_formats(AVFilterContext *ctx)
352 FilterOutPriv *priv = ctx->priv;
353 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
355 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
359 static int get_filtered_video_pic(AVFilterContext *ctx,
360 AVFilterPicRef **picref, AVFrame *pic2,
365 if(avfilter_request_frame(ctx->inputs[0]))
367 if(!(pic = ctx->inputs[0]->cur_pic))
370 ctx->inputs[0]->cur_pic = NULL;
374 memcpy(pic2->data, pic->data, sizeof(pic->data));
375 memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
376 pic2->interlaced_frame = pic->interlaced;
377 pic2->top_field_first = pic->top_field_first;
382 static AVFilter output_filter =
384 .name = "ffmpeg_output",
386 .priv_size = sizeof(FilterOutPriv),
389 .query_formats = output_query_formats,
391 .inputs = (AVFilterPad[]) {{ .name = "default",
392 .type = AVMEDIA_TYPE_VIDEO,
393 .end_frame = output_end_frame,
394 .min_perms = AV_PERM_READ, },
396 .outputs = (AVFilterPad[]) {{ .name = NULL }},
399 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
401 AVFilterContext *last_filter, *filter;
402 /** filter graph containing all filters including input & output */
403 AVCodecContext *codec = ost->st->codec;
404 AVCodecContext *icodec = ist->st->codec;
407 graph = av_mallocz(sizeof(AVFilterGraph));
409 if (!(ist->input_video_filter = avfilter_open(avfilter_get_by_name("buffer"), "src")))
411 if (!(ist->out_video_filter = avfilter_open(&output_filter, "out")))
414 snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
415 ist->st->codec->height, ist->st->codec->pix_fmt);
416 if (avfilter_init_filter(ist->input_video_filter, args, NULL))
418 if (avfilter_init_filter(ist->out_video_filter, NULL, &codec->pix_fmt))
421 /* add input and output filters to the overall graph */
422 avfilter_graph_add_filter(graph, ist->input_video_filter);
423 avfilter_graph_add_filter(graph, ist->out_video_filter);
425 last_filter = ist->input_video_filter;
427 if (ost->video_crop) {
428 snprintf(args, 255, "%d:%d:%d:%d", ost->leftBand, ost->topBand,
431 filter = avfilter_open(avfilter_get_by_name("crop"), NULL);
434 if (avfilter_init_filter(filter, args, NULL))
436 if (avfilter_link(last_filter, 0, filter, 0))
438 last_filter = filter;
439 avfilter_graph_add_filter(graph, last_filter);
443 icodec->width - (frame_leftBand + frame_rightBand)) ||
444 (codec->height != icodec->height - (frame_topBand + frame_bottomBand))) {
445 snprintf(args, 255, "%d:%d:flags=0x%X",
448 (int)av_get_int(sws_opts, "sws_flags", NULL));
449 filter = avfilter_open(avfilter_get_by_name("scale"), NULL);
452 if (avfilter_init_filter(filter, args, NULL))
454 if (avfilter_link(last_filter, 0, filter, 0))
456 last_filter = filter;
457 avfilter_graph_add_filter(graph, last_filter);
461 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
462 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
464 outputs->name = av_strdup("in");
465 outputs->filter = last_filter;
466 outputs->pad_idx = 0;
467 outputs->next = NULL;
469 inputs->name = av_strdup("out");
470 inputs->filter = ist->out_video_filter;
474 if (avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL) < 0)
478 if (avfilter_link(last_filter, 0, ist->out_video_filter, 0) < 0)
482 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
483 graph->scale_sws_opts = av_strdup(args);
485 /* configure all the filter links */
486 if (avfilter_graph_check_validity(graph, NULL))
488 if (avfilter_graph_config_formats(graph, NULL))
490 if (avfilter_graph_config_links(graph, NULL))
493 codec->width = ist->out_video_filter->inputs[0]->w;
494 codec->height = ist->out_video_filter->inputs[0]->h;
498 #endif /* CONFIG_AVFILTER */
500 static void term_exit(void)
503 tcsetattr (0, TCSANOW, &oldtty);
507 static volatile int received_sigterm = 0;
510 sigterm_handler(int sig)
512 received_sigterm = sig;
516 static void term_init(void)
525 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
526 |INLCR|IGNCR|ICRNL|IXON);
527 tty.c_oflag |= OPOST;
528 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
529 tty.c_cflag &= ~(CSIZE|PARENB);
534 tcsetattr (0, TCSANOW, &tty);
535 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
538 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
539 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
541 signal(SIGXCPU, sigterm_handler);
544 #if CONFIG_BEOS_NETSERVER
545 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
549 /* read a key without blocking */
550 static int read_key(void)
555 #if !CONFIG_BEOS_NETSERVER
563 n = select(1, &rfds, NULL, NULL, &tv);
579 static int decode_interrupt_cb(void)
581 return q_pressed || (q_pressed = read_key() == 'q');
584 static int av_exit(int ret)
589 for(i=0;i<nb_output_files;i++) {
590 /* maybe av_close_output_file ??? */
591 AVFormatContext *s = output_files[i];
593 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
595 for(j=0;j<s->nb_streams;j++) {
596 av_metadata_free(&s->streams[j]->metadata);
597 av_free(s->streams[j]->codec);
598 av_free(s->streams[j]);
600 for(j=0;j<s->nb_programs;j++) {
601 av_metadata_free(&s->programs[j]->metadata);
603 for(j=0;j<s->nb_chapters;j++) {
604 av_metadata_free(&s->chapters[j]->metadata);
606 av_metadata_free(&s->metadata);
609 for(i=0;i<nb_input_files;i++)
610 av_close_input_file(input_files[i]);
612 av_free(intra_matrix);
613 av_free(inter_matrix);
617 av_free(vstats_filename);
621 av_free(video_codec_name);
622 av_free(audio_codec_name);
623 av_free(subtitle_codec_name);
625 av_free(video_standard);
627 #if CONFIG_POWERPC_PERF
628 void powerpc_display_perf_report(void);
629 powerpc_display_perf_report();
630 #endif /* CONFIG_POWERPC_PERF */
632 for (i=0;i<AVMEDIA_TYPE_NB;i++)
633 av_free(avcodec_opts[i]);
634 av_free(avformat_opts);
638 allocated_audio_buf_size= allocated_audio_out_size= 0;
645 if (received_sigterm) {
647 "Received signal %d: terminating.\n",
648 (int) received_sigterm);
652 exit(ret); /* not all OS-es handle main() return value */
656 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
658 if(codec && codec->sample_fmts){
659 const enum SampleFormat *p= codec->sample_fmts;
661 if(*p == st->codec->sample_fmt)
665 st->codec->sample_fmt = codec->sample_fmts[0];
669 static void choose_sample_rate(AVStream *st, AVCodec *codec)
671 if(codec && codec->supported_samplerates){
672 const int *p= codec->supported_samplerates;
674 int best_dist=INT_MAX;
676 int dist= abs(st->codec->sample_rate - *p);
677 if(dist < best_dist){
683 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
685 st->codec->sample_rate= best;
689 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
691 if(codec && codec->pix_fmts){
692 const enum PixelFormat *p= codec->pix_fmts;
694 if(*p == st->codec->pix_fmt)
698 && !( st->codec->codec_id==CODEC_ID_MJPEG
699 && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL
700 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
701 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
702 st->codec->pix_fmt = codec->pix_fmts[0];
706 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
712 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
715 /* copy stream format */
716 s->nb_streams = ic->nb_streams;
717 for(i=0;i<ic->nb_streams;i++) {
721 // FIXME: a more elegant solution is needed
722 st = av_mallocz(sizeof(AVStream));
723 memcpy(st, ic->streams[i], sizeof(AVStream));
724 st->codec = avcodec_alloc_context();
726 print_error(filename, AVERROR(ENOMEM));
729 avcodec_copy_context(st->codec, ic->streams[i]->codec);
732 codec = avcodec_find_encoder(st->codec->codec_id);
733 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
734 if (audio_stream_copy) {
737 choose_sample_fmt(st, codec);
738 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
739 if (video_stream_copy) {
742 choose_pixel_fmt(st, codec);
745 if(!st->codec->thread_count)
746 st->codec->thread_count = 1;
747 if(st->codec->thread_count>1)
748 avcodec_thread_init(st->codec, st->codec->thread_count);
750 if(st->codec->flags & CODEC_FLAG_BITEXACT)
755 s->timestamp = av_gettime();
757 av_close_input_file(ic);
762 get_sync_ipts(const AVOutputStream *ost)
764 const AVInputStream *ist = ost->sync_ist;
765 return (double)(ist->pts - start_time)/AV_TIME_BASE;
768 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
772 AVPacket new_pkt= *pkt;
773 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
774 &new_pkt.data, &new_pkt.size,
775 pkt->data, pkt->size,
776 pkt->flags & AV_PKT_FLAG_KEY);
779 new_pkt.destruct= av_destruct_packet;
781 fprintf(stderr, "%s failed for stream %d, codec %s",
782 bsfc->filter->name, pkt->stream_index,
783 avctx->codec ? avctx->codec->name : "copy");
793 ret= av_interleaved_write_frame(s, pkt);
795 print_error("av_interleaved_write_frame()", ret);
800 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
802 static void do_audio_out(AVFormatContext *s,
805 unsigned char *buf, int size)
808 int64_t audio_out_size, audio_buf_size;
809 int64_t allocated_for_size= size;
811 int size_out, frame_bytes, ret;
812 AVCodecContext *enc= ost->st->codec;
813 AVCodecContext *dec= ist->st->codec;
814 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
815 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
816 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
819 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
820 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
821 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
822 audio_buf_size*= osize*enc->channels;
824 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
825 if(coded_bps > 8*osize)
826 audio_out_size= audio_out_size * coded_bps / (8*osize);
827 audio_out_size += FF_MIN_BUFFER_SIZE;
829 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
830 fprintf(stderr, "Buffer sizes too large\n");
834 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
835 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
836 if (!audio_buf || !audio_out){
837 fprintf(stderr, "Out of memory in do_audio_out\n");
841 if (enc->channels != dec->channels)
842 ost->audio_resample = 1;
844 if (ost->audio_resample && !ost->resample) {
845 if (dec->sample_fmt != SAMPLE_FMT_S16)
846 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
847 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
848 enc->sample_rate, dec->sample_rate,
849 enc->sample_fmt, dec->sample_fmt,
851 if (!ost->resample) {
852 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
853 dec->channels, dec->sample_rate,
854 enc->channels, enc->sample_rate);
859 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
860 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
861 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
862 if (ost->reformat_ctx)
863 av_audio_convert_free(ost->reformat_ctx);
864 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
865 dec->sample_fmt, 1, NULL, 0);
866 if (!ost->reformat_ctx) {
867 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
868 avcodec_get_sample_fmt_name(dec->sample_fmt),
869 avcodec_get_sample_fmt_name(enc->sample_fmt));
872 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
875 if(audio_sync_method){
876 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
877 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
878 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
879 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
881 //FIXME resample delay
882 if(fabs(delta) > 50){
883 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
885 byte_delta= FFMAX(byte_delta, -size);
889 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
894 static uint8_t *input_tmp= NULL;
895 input_tmp= av_realloc(input_tmp, byte_delta + size);
897 if(byte_delta > allocated_for_size - size){
898 allocated_for_size= byte_delta + (int64_t)size;
903 memset(input_tmp, 0, byte_delta);
904 memcpy(input_tmp + byte_delta, buf, size);
908 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
910 }else if(audio_sync_method>1){
911 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
912 assert(ost->audio_resample);
914 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
915 // 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));
916 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
920 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
921 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
923 if (ost->audio_resample) {
925 size_out = audio_resample(ost->resample,
926 (short *)buftmp, (short *)buf,
927 size / (ist->st->codec->channels * isize));
928 size_out = size_out * enc->channels * osize;
934 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
935 const void *ibuf[6]= {buftmp};
936 void *obuf[6]= {audio_buf};
937 int istride[6]= {isize};
938 int ostride[6]= {osize};
939 int len= size_out/istride[0];
940 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
941 printf("av_audio_convert() failed\n");
947 size_out = len*osize;
950 /* now encode as many frames as possible */
951 if (enc->frame_size > 1) {
952 /* output resampled raw samples */
953 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
954 fprintf(stderr, "av_fifo_realloc2() failed\n");
957 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
959 frame_bytes = enc->frame_size * osize * enc->channels;
961 while (av_fifo_size(ost->fifo) >= frame_bytes) {
963 av_init_packet(&pkt);
965 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
967 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
969 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
972 fprintf(stderr, "Audio encoding failed\n");
976 pkt.stream_index= ost->index;
979 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
980 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
981 pkt.flags |= AV_PKT_FLAG_KEY;
982 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
984 ost->sync_opts += enc->frame_size;
988 av_init_packet(&pkt);
990 ost->sync_opts += size_out / (osize * enc->channels);
992 /* output a pcm frame */
993 /* determine the size of the coded buffer */
996 size_out = size_out*coded_bps/8;
998 if(size_out > audio_out_size){
999 fprintf(stderr, "Internal error, buffer size too small\n");
1003 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1004 ret = avcodec_encode_audio(enc, audio_out, size_out,
1007 fprintf(stderr, "Audio encoding failed\n");
1011 pkt.stream_index= ost->index;
1012 pkt.data= audio_out;
1014 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1015 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1016 pkt.flags |= AV_PKT_FLAG_KEY;
1017 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1021 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1023 AVCodecContext *dec;
1024 AVPicture *picture2;
1025 AVPicture picture_tmp;
1028 dec = ist->st->codec;
1030 /* deinterlace : must be done before any resize */
1031 if (do_deinterlace) {
1034 /* create temporary picture */
1035 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1036 buf = av_malloc(size);
1040 picture2 = &picture_tmp;
1041 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1043 if(avpicture_deinterlace(picture2, picture,
1044 dec->pix_fmt, dec->width, dec->height) < 0) {
1045 /* if error, do not deinterlace */
1046 fprintf(stderr, "Deinterlacing failed\n");
1055 if (picture != picture2)
1056 *picture = *picture2;
1060 /* we begin to correct av delay at this threshold */
1061 #define AV_DELAY_MAX 0.100
1063 static void do_subtitle_out(AVFormatContext *s,
1064 AVOutputStream *ost,
1069 static uint8_t *subtitle_out = NULL;
1070 int subtitle_out_max_size = 1024 * 1024;
1071 int subtitle_out_size, nb, i;
1072 AVCodecContext *enc;
1075 if (pts == AV_NOPTS_VALUE) {
1076 fprintf(stderr, "Subtitle packets must have a pts\n");
1082 enc = ost->st->codec;
1084 if (!subtitle_out) {
1085 subtitle_out = av_malloc(subtitle_out_max_size);
1088 /* Note: DVB subtitle need one packet to draw them and one other
1089 packet to clear them */
1090 /* XXX: signal it in the codec context ? */
1091 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1096 for(i = 0; i < nb; i++) {
1097 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1098 // start_display_time is required to be 0
1099 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1100 sub->end_display_time -= sub->start_display_time;
1101 sub->start_display_time = 0;
1102 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1103 subtitle_out_max_size, sub);
1104 if (subtitle_out_size < 0) {
1105 fprintf(stderr, "Subtitle encoding failed\n");
1109 av_init_packet(&pkt);
1110 pkt.stream_index = ost->index;
1111 pkt.data = subtitle_out;
1112 pkt.size = subtitle_out_size;
1113 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1114 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1115 /* XXX: the pts correction is handled here. Maybe handling
1116 it in the codec would be better */
1118 pkt.pts += 90 * sub->start_display_time;
1120 pkt.pts += 90 * sub->end_display_time;
1122 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1126 static int bit_buffer_size= 1024*256;
1127 static uint8_t *bit_buffer= NULL;
1129 static void do_video_out(AVFormatContext *s,
1130 AVOutputStream *ost,
1132 AVFrame *in_picture,
1135 int nb_frames, i, ret;
1136 #if !CONFIG_AVFILTER
1137 int64_t topBand, bottomBand, leftBand, rightBand;
1139 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1140 AVFrame picture_crop_temp, picture_pad_temp;
1141 AVCodecContext *enc, *dec;
1144 avcodec_get_frame_defaults(&picture_crop_temp);
1145 avcodec_get_frame_defaults(&picture_pad_temp);
1147 enc = ost->st->codec;
1148 dec = ist->st->codec;
1150 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1152 /* by default, we output a single frame */
1157 if(video_sync_method){
1158 double vdelta = sync_ipts - ost->sync_opts;
1159 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1162 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1165 }else if(vdelta>0.6)
1166 ost->sync_opts= lrintf(sync_ipts);
1167 }else if (vdelta > 1.1)
1168 nb_frames = lrintf(vdelta);
1169 //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);
1170 if (nb_frames == 0){
1173 fprintf(stderr, "*** drop!\n");
1174 }else if (nb_frames > 1) {
1175 nb_frames_dup += nb_frames - 1;
1177 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1180 ost->sync_opts= lrintf(sync_ipts);
1182 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1187 formatted_picture = in_picture;
1189 if (ost->video_crop) {
1190 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1191 fprintf(stderr, "error cropping picture\n");
1196 formatted_picture = &picture_crop_temp;
1198 formatted_picture = in_picture;
1202 final_picture = formatted_picture;
1203 padding_src = formatted_picture;
1204 resampling_dst = &ost->pict_tmp;
1206 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1207 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1208 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1210 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));
1211 if(!ost->video_resample)
1215 #if !CONFIG_AVFILTER
1216 if (ost->video_resample) {
1218 final_picture = &ost->pict_tmp;
1219 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1220 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1221 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1223 /* keep bands proportional to the frame size */
1224 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
1225 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1226 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
1227 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
1229 /* sanity check to ensure no bad band sizes sneak in */
1230 assert(topBand <= INT_MAX && topBand >= 0);
1231 assert(bottomBand <= INT_MAX && bottomBand >= 0);
1232 assert(leftBand <= INT_MAX && leftBand >= 0);
1233 assert(rightBand <= INT_MAX && rightBand >= 0);
1235 ost->topBand = topBand;
1236 ost->bottomBand = bottomBand;
1237 ost->leftBand = leftBand;
1238 ost->rightBand = rightBand;
1240 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
1241 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
1242 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1244 /* initialize a new scaler context */
1245 sws_freeContext(ost->img_resample_ctx);
1246 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1247 ost->img_resample_ctx = sws_getContext(
1248 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1249 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1250 ist->st->codec->pix_fmt,
1251 ost->st->codec->width,
1252 ost->st->codec->height,
1253 ost->st->codec->pix_fmt,
1254 sws_flags, NULL, NULL, NULL);
1255 if (ost->img_resample_ctx == NULL) {
1256 fprintf(stderr, "Cannot get resampling context\n");
1260 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1261 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1265 /* duplicates frame if needed */
1266 for(i=0;i<nb_frames;i++) {
1268 av_init_packet(&pkt);
1269 pkt.stream_index= ost->index;
1271 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1272 /* raw pictures are written as AVPicture structure to
1273 avoid any copies. We support temorarily the older
1275 AVFrame* old_frame = enc->coded_frame;
1276 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1277 pkt.data= (uint8_t *)final_picture;
1278 pkt.size= sizeof(AVPicture);
1279 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1280 pkt.flags |= AV_PKT_FLAG_KEY;
1282 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1283 enc->coded_frame = old_frame;
1285 AVFrame big_picture;
1287 big_picture= *final_picture;
1288 /* better than nothing: use input picture interlaced
1290 big_picture.interlaced_frame = in_picture->interlaced_frame;
1291 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1292 if(top_field_first == -1)
1293 big_picture.top_field_first = in_picture->top_field_first;
1295 big_picture.top_field_first = top_field_first;
1298 /* handles sameq here. This is not correct because it may
1299 not be a global option */
1301 big_picture.quality = ist->st->quality;
1303 big_picture.quality = ost->st->quality;
1305 big_picture.pict_type = 0;
1306 // big_picture.pts = AV_NOPTS_VALUE;
1307 big_picture.pts= ost->sync_opts;
1308 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1309 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1310 ret = avcodec_encode_video(enc,
1311 bit_buffer, bit_buffer_size,
1314 fprintf(stderr, "Video encoding failed\n");
1319 pkt.data= bit_buffer;
1321 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1322 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1323 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1324 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1325 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1327 if(enc->coded_frame->key_frame)
1328 pkt.flags |= AV_PKT_FLAG_KEY;
1329 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1332 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1333 // enc->frame_number-1, ret, enc->pict_type);
1334 /* if two pass, output log */
1335 if (ost->logfile && enc->stats_out) {
1336 fprintf(ost->logfile, "%s", enc->stats_out);
1341 ost->frame_number++;
1345 static double psnr(double d){
1346 return -10.0*log(d)/log(10.0);
1349 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1352 AVCodecContext *enc;
1354 double ti1, bitrate, avg_bitrate;
1356 /* this is executed just the first time do_video_stats is called */
1358 vstats_file = fopen(vstats_filename, "w");
1365 enc = ost->st->codec;
1366 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1367 frame_number = ost->frame_number;
1368 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1369 if (enc->flags&CODEC_FLAG_PSNR)
1370 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1372 fprintf(vstats_file,"f_size= %6d ", frame_size);
1373 /* compute pts value */
1374 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1378 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1379 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1380 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1381 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1382 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1386 static void print_report(AVFormatContext **output_files,
1387 AVOutputStream **ost_table, int nb_ostreams,
1391 AVOutputStream *ost;
1392 AVFormatContext *oc;
1394 AVCodecContext *enc;
1395 int frame_number, vid, i;
1396 double bitrate, ti1, pts;
1397 static int64_t last_time = -1;
1398 static int qp_histogram[52];
1400 if (!is_last_report) {
1402 /* display the report every 0.5 seconds */
1403 cur_time = av_gettime();
1404 if (last_time == -1) {
1405 last_time = cur_time;
1408 if ((cur_time - last_time) < 500000)
1410 last_time = cur_time;
1414 oc = output_files[0];
1416 total_size = url_fsize(oc->pb);
1417 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1418 total_size= url_ftell(oc->pb);
1423 for(i=0;i<nb_ostreams;i++) {
1425 enc = ost->st->codec;
1426 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1427 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1428 !ost->st->stream_copy ?
1429 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1431 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1432 float t = (av_gettime()-timer_start) / 1000000.0;
1434 frame_number = ost->frame_number;
1435 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1436 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1437 !ost->st->stream_copy ?
1438 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1440 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1443 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1444 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1447 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1449 if (enc->flags&CODEC_FLAG_PSNR){
1451 double error, error_sum=0;
1452 double scale, scale_sum=0;
1453 char type[3]= {'Y','U','V'};
1454 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1457 error= enc->error[j];
1458 scale= enc->width*enc->height*255.0*255.0*frame_number;
1460 error= enc->coded_frame->error[j];
1461 scale= enc->width*enc->height*255.0*255.0;
1466 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1468 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1472 /* compute min output value */
1473 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1474 if ((pts < ti1) && (pts > 0))
1480 if (verbose || is_last_report) {
1481 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1483 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1484 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1485 (double)total_size / 1024, ti1, bitrate);
1487 if (nb_frames_dup || nb_frames_drop)
1488 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1489 nb_frames_dup, nb_frames_drop);
1492 fprintf(stderr, "%s \r", buf);
1497 if (is_last_report && verbose >= 0){
1498 int64_t raw= audio_size + video_size + extra_size;
1499 fprintf(stderr, "\n");
1500 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1504 100.0*(total_size - raw)/raw
1509 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1510 static int output_packet(AVInputStream *ist, int ist_index,
1511 AVOutputStream **ost_table, int nb_ostreams,
1512 const AVPacket *pkt)
1514 AVFormatContext *os;
1515 AVOutputStream *ost;
1519 void *buffer_to_free;
1520 static unsigned int samples_size= 0;
1521 AVSubtitle subtitle, *subtitle_to_free;
1524 int frame_available;
1528 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1530 if(ist->next_pts == AV_NOPTS_VALUE)
1531 ist->next_pts= ist->pts;
1535 av_init_packet(&avpkt);
1543 if(pkt->dts != AV_NOPTS_VALUE)
1544 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1546 //while we have more to decode or while the decoder did output something on EOF
1547 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1548 uint8_t *data_buf, *decoded_data_buf;
1549 int data_size, decoded_data_size;
1551 ist->pts= ist->next_pts;
1553 if(avpkt.size && avpkt.size != pkt->size &&
1554 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1555 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1556 ist->showed_multi_packet_warning=1;
1559 /* decode the packet if needed */
1560 decoded_data_buf = NULL; /* fail safe */
1561 decoded_data_size= 0;
1562 data_buf = avpkt.data;
1563 data_size = avpkt.size;
1564 subtitle_to_free = NULL;
1565 if (ist->decoding_needed) {
1566 switch(ist->st->codec->codec_type) {
1567 case AVMEDIA_TYPE_AUDIO:{
1568 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1569 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1571 samples= av_malloc(samples_size);
1573 decoded_data_size= samples_size;
1574 /* XXX: could avoid copy if PCM 16 bits with same
1575 endianness as CPU */
1576 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1583 /* Some bug in mpeg audio decoder gives */
1584 /* decoded_data_size < 0, it seems they are overflows */
1585 if (decoded_data_size <= 0) {
1586 /* no audio frame */
1589 decoded_data_buf = (uint8_t *)samples;
1590 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1591 (ist->st->codec->sample_rate * ist->st->codec->channels);
1593 case AVMEDIA_TYPE_VIDEO:
1594 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1595 /* XXX: allocate picture correctly */
1596 avcodec_get_frame_defaults(&picture);
1598 ret = avcodec_decode_video2(ist->st->codec,
1599 &picture, &got_picture, &avpkt);
1600 ist->st->quality= picture.quality;
1604 /* no picture yet */
1605 goto discard_packet;
1607 if (ist->st->codec->time_base.num != 0) {
1608 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1609 ist->next_pts += ((int64_t)AV_TIME_BASE *
1610 ist->st->codec->time_base.num * ticks) /
1611 ist->st->codec->time_base.den;
1615 case AVMEDIA_TYPE_SUBTITLE:
1616 ret = avcodec_decode_subtitle2(ist->st->codec,
1617 &subtitle, &got_subtitle, &avpkt);
1620 if (!got_subtitle) {
1621 goto discard_packet;
1623 subtitle_to_free = &subtitle;
1630 switch(ist->st->codec->codec_type) {
1631 case AVMEDIA_TYPE_AUDIO:
1632 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1633 ist->st->codec->sample_rate;
1635 case AVMEDIA_TYPE_VIDEO:
1636 if (ist->st->codec->time_base.num != 0) {
1637 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1638 ist->next_pts += ((int64_t)AV_TIME_BASE *
1639 ist->st->codec->time_base.num * ticks) /
1640 ist->st->codec->time_base.den;
1648 buffer_to_free = NULL;
1649 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1650 pre_process_video_frame(ist, (AVPicture *)&picture,
1655 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1656 // add it to be filtered
1657 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1659 ist->st->codec->sample_aspect_ratio);
1663 // preprocess audio (volume)
1664 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1665 if (audio_volume != 256) {
1668 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1669 int v = ((*volp) * audio_volume + 128) >> 8;
1670 if (v < -32768) v = -32768;
1671 if (v > 32767) v = 32767;
1677 /* frame rate emulation */
1679 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1680 int64_t now = av_gettime() - ist->start;
1685 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1686 !ist->out_video_filter || avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1688 /* if output time reached then transcode raw format,
1689 encode packets and output them */
1690 if (start_time == 0 || ist->pts >= start_time)
1692 while (frame_available) {
1693 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->out_video_filter)
1694 get_filtered_video_pic(ist->out_video_filter, &ist->picref, &picture, &ist->pts);
1696 for(i=0;i<nb_ostreams;i++) {
1700 if (ost->source_index == ist_index) {
1701 os = output_files[ost->file_index];
1703 /* set the input output pts pairs */
1704 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1706 if (ost->encoding_needed) {
1707 assert(ist->decoding_needed);
1708 switch(ost->st->codec->codec_type) {
1709 case AVMEDIA_TYPE_AUDIO:
1710 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1712 case AVMEDIA_TYPE_VIDEO:
1714 ost->st->codec->sample_aspect_ratio = ist->picref->pixel_aspect;
1716 do_video_out(os, ost, ist, &picture, &frame_size);
1717 if (vstats_filename && frame_size)
1718 do_video_stats(os, ost, frame_size);
1720 case AVMEDIA_TYPE_SUBTITLE:
1721 do_subtitle_out(os, ost, ist, &subtitle,
1728 AVFrame avframe; //FIXME/XXX remove this
1730 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1732 av_init_packet(&opkt);
1734 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1737 /* no reencoding needed : output the packet directly */
1738 /* force the input stream PTS */
1740 avcodec_get_frame_defaults(&avframe);
1741 ost->st->codec->coded_frame= &avframe;
1742 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1744 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1745 audio_size += data_size;
1746 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1747 video_size += data_size;
1751 opkt.stream_index= ost->index;
1752 if(pkt->pts != AV_NOPTS_VALUE)
1753 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1755 opkt.pts= AV_NOPTS_VALUE;
1757 if (pkt->dts == AV_NOPTS_VALUE)
1758 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1760 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1761 opkt.dts -= ost_tb_start_time;
1763 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1764 opkt.flags= pkt->flags;
1766 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1767 if( ost->st->codec->codec_id != CODEC_ID_H264
1768 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1769 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1771 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1772 opkt.destruct= av_destruct_packet;
1774 opkt.data = data_buf;
1775 opkt.size = data_size;
1778 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1779 ost->st->codec->frame_number++;
1780 ost->frame_number++;
1781 av_free_packet(&opkt);
1785 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1786 ist->out_video_filter && avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1792 avfilter_unref_pic(ist->picref);
1795 av_free(buffer_to_free);
1796 /* XXX: allocate the subtitles in the codec ? */
1797 if (subtitle_to_free) {
1798 if (subtitle_to_free->rects != NULL) {
1799 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1800 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1801 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1802 av_freep(&subtitle_to_free->rects[i]);
1804 av_freep(&subtitle_to_free->rects);
1806 subtitle_to_free->num_rects = 0;
1807 subtitle_to_free = NULL;
1814 for(i=0;i<nb_ostreams;i++) {
1816 if (ost->source_index == ist_index) {
1817 AVCodecContext *enc= ost->st->codec;
1818 os = output_files[ost->file_index];
1820 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1822 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1825 if (ost->encoding_needed) {
1829 av_init_packet(&pkt);
1830 pkt.stream_index= ost->index;
1832 switch(ost->st->codec->codec_type) {
1833 case AVMEDIA_TYPE_AUDIO:
1834 fifo_bytes = av_fifo_size(ost->fifo);
1836 /* encode any samples remaining in fifo */
1837 if (fifo_bytes > 0) {
1838 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1839 int fs_tmp = enc->frame_size;
1841 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1842 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1843 enc->frame_size = fifo_bytes / (osize * enc->channels);
1845 int frame_bytes = enc->frame_size*osize*enc->channels;
1846 if (samples_size < frame_bytes)
1848 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1851 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1852 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1853 ost->st->time_base.num, enc->sample_rate);
1854 enc->frame_size = fs_tmp;
1857 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1860 fprintf(stderr, "Audio encoding failed\n");
1864 pkt.flags |= AV_PKT_FLAG_KEY;
1866 case AVMEDIA_TYPE_VIDEO:
1867 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1869 fprintf(stderr, "Video encoding failed\n");
1873 if(enc->coded_frame && enc->coded_frame->key_frame)
1874 pkt.flags |= AV_PKT_FLAG_KEY;
1875 if (ost->logfile && enc->stats_out) {
1876 fprintf(ost->logfile, "%s", enc->stats_out);
1885 pkt.data= bit_buffer;
1887 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1888 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1889 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1901 static void print_sdp(AVFormatContext **avc, int n)
1905 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1906 printf("SDP:\n%s\n", sdp);
1910 static int copy_chapters(int infile, int outfile)
1912 AVFormatContext *is = input_files[infile];
1913 AVFormatContext *os = output_files[outfile];
1916 for (i = 0; i < is->nb_chapters; i++) {
1917 AVChapter *in_ch = is->chapters[i], *out_ch;
1918 AVMetadataTag *t = NULL;
1919 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1920 AV_TIME_BASE_Q, in_ch->time_base);
1921 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1922 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1925 if (in_ch->end < ts_off)
1927 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1930 out_ch = av_mallocz(sizeof(AVChapter));
1932 return AVERROR(ENOMEM);
1934 out_ch->id = in_ch->id;
1935 out_ch->time_base = in_ch->time_base;
1936 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1937 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1939 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1940 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1943 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1945 return AVERROR(ENOMEM);
1946 os->chapters[os->nb_chapters - 1] = out_ch;
1952 * The following code is the main loop of the file converter
1954 static int av_transcode(AVFormatContext **output_files,
1955 int nb_output_files,
1956 AVFormatContext **input_files,
1958 AVStreamMap *stream_maps, int nb_stream_maps)
1960 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1961 AVFormatContext *is, *os;
1962 AVCodecContext *codec, *icodec;
1963 AVOutputStream *ost, **ost_table = NULL;
1964 AVInputStream *ist, **ist_table = NULL;
1965 AVInputFile *file_table;
1969 uint8_t no_packet[MAX_FILES]={0};
1970 int no_packet_count=0;
1972 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1976 /* input stream init */
1978 for(i=0;i<nb_input_files;i++) {
1979 is = input_files[i];
1980 file_table[i].ist_index = j;
1981 file_table[i].nb_streams = is->nb_streams;
1982 j += is->nb_streams;
1986 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1990 for(i=0;i<nb_istreams;i++) {
1991 ist = av_mallocz(sizeof(AVInputStream));
1997 for(i=0;i<nb_input_files;i++) {
1998 is = input_files[i];
1999 for(k=0;k<is->nb_streams;k++) {
2000 ist = ist_table[j++];
2001 ist->st = is->streams[k];
2002 ist->file_index = i;
2004 ist->discard = 1; /* the stream is discarded by default
2008 ist->start = av_gettime();
2013 /* output stream init */
2015 for(i=0;i<nb_output_files;i++) {
2016 os = output_files[i];
2017 if (!os->nb_streams) {
2018 dump_format(output_files[i], i, output_files[i]->filename, 1);
2019 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2022 nb_ostreams += os->nb_streams;
2024 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2025 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2029 /* Sanity check the mapping args -- do the input files & streams exist? */
2030 for(i=0;i<nb_stream_maps;i++) {
2031 int fi = stream_maps[i].file_index;
2032 int si = stream_maps[i].stream_index;
2034 if (fi < 0 || fi > nb_input_files - 1 ||
2035 si < 0 || si > file_table[fi].nb_streams - 1) {
2036 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2039 fi = stream_maps[i].sync_file_index;
2040 si = stream_maps[i].sync_stream_index;
2041 if (fi < 0 || fi > nb_input_files - 1 ||
2042 si < 0 || si > file_table[fi].nb_streams - 1) {
2043 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2048 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2051 for(i=0;i<nb_ostreams;i++) {
2052 ost = av_mallocz(sizeof(AVOutputStream));
2059 for(k=0;k<nb_output_files;k++) {
2060 os = output_files[k];
2061 for(i=0;i<os->nb_streams;i++,n++) {
2064 ost->file_index = k;
2066 ost->st = os->streams[i];
2067 if (nb_stream_maps > 0) {
2068 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2069 stream_maps[n].stream_index;
2071 /* Sanity check that the stream types match */
2072 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2073 int i= ost->file_index;
2074 dump_format(output_files[i], i, output_files[i]->filename, 1);
2075 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2076 stream_maps[n].file_index, stream_maps[n].stream_index,
2077 ost->file_index, ost->index);
2082 int best_nb_frames=-1;
2083 /* get corresponding input stream index : we select the first one with the right type */
2085 for(j=0;j<nb_istreams;j++) {
2090 AVFormatContext *f= input_files[ ist->file_index ];
2092 for(pi=0; pi<f->nb_programs; pi++){
2093 AVProgram *p= f->programs[pi];
2094 if(p->id == opt_programid)
2095 for(si=0; si<p->nb_stream_indexes; si++){
2096 if(f->streams[ p->stream_index[si] ] == ist->st)
2101 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2102 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2103 if(best_nb_frames < ist->st->codec_info_nb_frames){
2104 best_nb_frames= ist->st->codec_info_nb_frames;
2105 ost->source_index = j;
2112 if(! opt_programid) {
2113 /* try again and reuse existing stream */
2114 for(j=0;j<nb_istreams;j++) {
2116 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2117 && ist->st->discard != AVDISCARD_ALL) {
2118 ost->source_index = j;
2124 int i= ost->file_index;
2125 dump_format(output_files[i], i, output_files[i]->filename, 1);
2126 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2127 ost->file_index, ost->index);
2132 ist = ist_table[ost->source_index];
2134 ost->sync_ist = (nb_stream_maps > 0) ?
2135 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2136 stream_maps[n].sync_stream_index] : ist;
2140 /* for each output stream, we compute the right encoding parameters */
2141 for(i=0;i<nb_ostreams;i++) {
2142 AVMetadataTag *t = NULL;
2144 os = output_files[ost->file_index];
2145 ist = ist_table[ost->source_index];
2147 codec = ost->st->codec;
2148 icodec = ist->st->codec;
2150 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2151 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2154 ost->st->disposition = ist->st->disposition;
2155 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2156 codec->chroma_sample_location = icodec->chroma_sample_location;
2158 if (ost->st->stream_copy) {
2159 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2161 if (extra_size > INT_MAX)
2164 /* if stream_copy is selected, no need to decode or encode */
2165 codec->codec_id = icodec->codec_id;
2166 codec->codec_type = icodec->codec_type;
2168 if(!codec->codec_tag){
2169 if( !os->oformat->codec_tag
2170 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2171 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2172 codec->codec_tag = icodec->codec_tag;
2175 codec->bit_rate = icodec->bit_rate;
2176 codec->extradata= av_mallocz(extra_size);
2177 if (!codec->extradata)
2179 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2180 codec->extradata_size= icodec->extradata_size;
2181 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){
2182 codec->time_base = icodec->time_base;
2183 codec->time_base.num *= icodec->ticks_per_frame;
2185 codec->time_base = ist->st->time_base;
2186 switch(codec->codec_type) {
2187 case AVMEDIA_TYPE_AUDIO:
2188 if(audio_volume != 256) {
2189 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2192 codec->channel_layout = icodec->channel_layout;
2193 codec->sample_rate = icodec->sample_rate;
2194 codec->channels = icodec->channels;
2195 codec->frame_size = icodec->frame_size;
2196 codec->block_align= icodec->block_align;
2197 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2198 codec->block_align= 0;
2199 if(codec->codec_id == CODEC_ID_AC3)
2200 codec->block_align= 0;
2202 case AVMEDIA_TYPE_VIDEO:
2203 codec->pix_fmt = icodec->pix_fmt;
2204 codec->width = icodec->width;
2205 codec->height = icodec->height;
2206 codec->has_b_frames = icodec->has_b_frames;
2208 case AVMEDIA_TYPE_SUBTITLE:
2209 codec->width = icodec->width;
2210 codec->height = icodec->height;
2216 switch(codec->codec_type) {
2217 case AVMEDIA_TYPE_AUDIO:
2218 ost->fifo= av_fifo_alloc(1024);
2221 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2222 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2223 icodec->request_channels = codec->channels;
2224 ist->decoding_needed = 1;
2225 ost->encoding_needed = 1;
2227 case AVMEDIA_TYPE_VIDEO:
2228 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2229 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2232 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2233 ost->video_resample = ((codec->width != icodec->width -
2234 (frame_leftBand + frame_rightBand)) ||
2235 (codec->height != icodec->height -
2236 (frame_topBand + frame_bottomBand)) ||
2237 (codec->pix_fmt != icodec->pix_fmt));
2238 if (ost->video_crop) {
2239 ost->topBand = ost->original_topBand = frame_topBand;
2240 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2241 ost->leftBand = ost->original_leftBand = frame_leftBand;
2242 ost->rightBand = ost->original_rightBand = frame_rightBand;
2244 if (ost->video_resample) {
2245 avcodec_get_frame_defaults(&ost->pict_tmp);
2246 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2247 codec->width, codec->height)) {
2248 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2251 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2252 ost->img_resample_ctx = sws_getContext(
2253 icodec->width - (frame_leftBand + frame_rightBand),
2254 icodec->height - (frame_topBand + frame_bottomBand),
2259 sws_flags, NULL, NULL, NULL);
2260 if (ost->img_resample_ctx == NULL) {
2261 fprintf(stderr, "Cannot get resampling context\n");
2265 #if !CONFIG_AVFILTER
2266 ost->original_height = icodec->height;
2267 ost->original_width = icodec->width;
2269 codec->bits_per_raw_sample= 0;
2271 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
2272 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
2273 ost->resample_pix_fmt= icodec->pix_fmt;
2274 ost->encoding_needed = 1;
2275 ist->decoding_needed = 1;
2278 if (configure_filters(ist, ost)) {
2279 fprintf(stderr, "Error opening filters!\n");
2284 case AVMEDIA_TYPE_SUBTITLE:
2285 ost->encoding_needed = 1;
2286 ist->decoding_needed = 1;
2293 if (ost->encoding_needed &&
2294 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2295 char logfilename[1024];
2298 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2299 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2301 if (codec->flags & CODEC_FLAG_PASS1) {
2302 f = fopen(logfilename, "wb");
2304 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2310 size_t logbuffer_size;
2311 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2312 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2315 codec->stats_in = logbuffer;
2319 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2320 int size= codec->width * codec->height;
2321 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2326 bit_buffer = av_malloc(bit_buffer_size);
2328 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2330 ret = AVERROR(ENOMEM);
2334 /* open each encoder */
2335 for(i=0;i<nb_ostreams;i++) {
2337 if (ost->encoding_needed) {
2338 AVCodec *codec = output_codecs[i];
2340 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2342 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2343 ost->st->codec->codec_id, ost->file_index, ost->index);
2344 ret = AVERROR(EINVAL);
2347 if (avcodec_open(ost->st->codec, codec) < 0) {
2348 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2349 ost->file_index, ost->index);
2350 ret = AVERROR(EINVAL);
2353 extra_size += ost->st->codec->extradata_size;
2357 /* open each decoder */
2358 for(i=0;i<nb_istreams;i++) {
2360 if (ist->decoding_needed) {
2361 AVCodec *codec = input_codecs[i];
2363 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2365 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2366 ist->st->codec->codec_id, ist->file_index, ist->index);
2367 ret = AVERROR(EINVAL);
2370 if (avcodec_open(ist->st->codec, codec) < 0) {
2371 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2372 ist->file_index, ist->index);
2373 ret = AVERROR(EINVAL);
2376 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2377 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2382 for(i=0;i<nb_istreams;i++) {
2386 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2387 ist->next_pts = AV_NOPTS_VALUE;
2391 /* set meta data information from input file if required */
2392 for (i=0;i<nb_meta_data_maps;i++) {
2393 AVFormatContext *out_file;
2394 AVFormatContext *in_file;
2395 AVMetadataTag *mtag;
2397 int out_file_index = meta_data_maps[i].out_file;
2398 int in_file_index = meta_data_maps[i].in_file;
2399 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2400 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2401 out_file_index, out_file_index, in_file_index);
2402 ret = AVERROR(EINVAL);
2405 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2406 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2407 in_file_index, out_file_index, in_file_index);
2408 ret = AVERROR(EINVAL);
2412 out_file = output_files[out_file_index];
2413 in_file = input_files[in_file_index];
2417 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2418 av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2419 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2420 in_file->iformat->metadata_conv);
2423 /* copy chapters from the first input file that has them*/
2424 for (i = 0; i < nb_input_files; i++) {
2425 if (!input_files[i]->nb_chapters)
2428 for (j = 0; j < nb_output_files; j++)
2429 if ((ret = copy_chapters(i, j)) < 0)
2433 /* open files and write file headers */
2434 for(i=0;i<nb_output_files;i++) {
2435 os = output_files[i];
2436 if (av_write_header(os) < 0) {
2437 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2438 ret = AVERROR(EINVAL);
2441 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2447 /* dump the file output parameters - cannot be done before in case
2449 for(i=0;i<nb_output_files;i++) {
2450 dump_format(output_files[i], i, output_files[i]->filename, 1);
2453 /* dump the stream mapping */
2455 fprintf(stderr, "Stream mapping:\n");
2456 for(i=0;i<nb_ostreams;i++) {
2458 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2459 ist_table[ost->source_index]->file_index,
2460 ist_table[ost->source_index]->index,
2463 if (ost->sync_ist != ist_table[ost->source_index])
2464 fprintf(stderr, " [sync #%d.%d]",
2465 ost->sync_ist->file_index,
2466 ost->sync_ist->index);
2467 fprintf(stderr, "\n");
2472 fprintf(stderr, "%s\n", error);
2477 print_sdp(output_files, nb_output_files);
2480 if (!using_stdin && verbose >= 0) {
2481 fprintf(stderr, "Press [q] to stop encoding\n");
2482 url_set_interrupt_cb(decode_interrupt_cb);
2486 timer_start = av_gettime();
2488 for(; received_sigterm == 0;) {
2489 int file_index, ist_index;
2497 /* if 'q' pressed, exits */
2501 /* read_key() returns 0 on EOF */
2507 /* select the stream that we must read now by looking at the
2508 smallest output pts */
2510 for(i=0;i<nb_ostreams;i++) {
2513 os = output_files[ost->file_index];
2514 ist = ist_table[ost->source_index];
2515 if(ist->is_past_recording_time || no_packet[ist->file_index])
2517 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2518 ipts = (double)ist->pts;
2519 if (!file_table[ist->file_index].eof_reached){
2520 if(ipts < ipts_min) {
2522 if(input_sync ) file_index = ist->file_index;
2524 if(opts < opts_min) {
2526 if(!input_sync) file_index = ist->file_index;
2529 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2534 /* if none, if is finished */
2535 if (file_index < 0) {
2536 if(no_packet_count){
2538 memset(no_packet, 0, sizeof(no_packet));
2545 /* finish if limit size exhausted */
2546 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2549 /* read a frame from it and output it in the fifo */
2550 is = input_files[file_index];
2551 ret= av_read_frame(is, &pkt);
2552 if(ret == AVERROR(EAGAIN)){
2553 no_packet[file_index]=1;
2558 file_table[file_index].eof_reached = 1;
2566 memset(no_packet, 0, sizeof(no_packet));
2569 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2571 /* the following test is needed in case new streams appear
2572 dynamically in stream : we ignore them */
2573 if (pkt.stream_index >= file_table[file_index].nb_streams)
2574 goto discard_packet;
2575 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2576 ist = ist_table[ist_index];
2578 goto discard_packet;
2580 if (pkt.dts != AV_NOPTS_VALUE)
2581 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2582 if (pkt.pts != AV_NOPTS_VALUE)
2583 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2585 if(input_files_ts_scale[file_index][pkt.stream_index]){
2586 if(pkt.pts != AV_NOPTS_VALUE)
2587 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2588 if(pkt.dts != AV_NOPTS_VALUE)
2589 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2592 // 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);
2593 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2594 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2595 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2596 int64_t delta= pkt_dts - ist->next_pts;
2597 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2598 input_files_ts_offset[ist->file_index]-= delta;
2600 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2601 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2602 if(pkt.pts != AV_NOPTS_VALUE)
2603 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2607 /* finish if recording time exhausted */
2608 if (recording_time != INT64_MAX &&
2609 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2610 ist->is_past_recording_time = 1;
2611 goto discard_packet;
2614 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2615 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2618 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2619 ist->file_index, ist->index);
2622 av_free_packet(&pkt);
2627 av_free_packet(&pkt);
2629 /* dump report by using the output first video and audio streams */
2630 print_report(output_files, ost_table, nb_ostreams, 0);
2633 /* at the end of stream, we must flush the decoder buffers */
2634 for(i=0;i<nb_istreams;i++) {
2636 if (ist->decoding_needed) {
2637 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2643 /* write the trailer if needed and close file */
2644 for(i=0;i<nb_output_files;i++) {
2645 os = output_files[i];
2646 av_write_trailer(os);
2649 /* dump report by using the first video and audio streams */
2650 print_report(output_files, ost_table, nb_ostreams, 1);
2652 /* close each encoder */
2653 for(i=0;i<nb_ostreams;i++) {
2655 if (ost->encoding_needed) {
2656 av_freep(&ost->st->codec->stats_in);
2657 avcodec_close(ost->st->codec);
2661 /* close each decoder */
2662 for(i=0;i<nb_istreams;i++) {
2664 if (ist->decoding_needed) {
2665 avcodec_close(ist->st->codec);
2670 avfilter_graph_destroy(graph);
2679 av_freep(&bit_buffer);
2680 av_free(file_table);
2683 for(i=0;i<nb_istreams;i++) {
2690 for(i=0;i<nb_ostreams;i++) {
2693 if (ost->st->stream_copy)
2694 av_freep(&ost->st->codec->extradata);
2696 fclose(ost->logfile);
2697 ost->logfile = NULL;
2699 av_fifo_free(ost->fifo); /* works even if fifo is not
2700 initialized but set to zero */
2701 av_free(ost->pict_tmp.data[0]);
2702 if (ost->video_resample)
2703 sws_freeContext(ost->img_resample_ctx);
2705 audio_resample_close(ost->resample);
2706 if (ost->reformat_ctx)
2707 av_audio_convert_free(ost->reformat_ctx);
2716 static void opt_format(const char *arg)
2718 /* compatibility stuff for pgmyuv */
2719 if (!strcmp(arg, "pgmyuv")) {
2720 pgmyuv_compatibility_hack=1;
2721 // opt_image_format(arg);
2723 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2726 last_asked_format = arg;
2729 static void opt_video_rc_override_string(const char *arg)
2731 video_rc_override_string = arg;
2734 static int opt_me_threshold(const char *opt, const char *arg)
2736 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2740 static int opt_verbose(const char *opt, const char *arg)
2742 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2746 static int opt_frame_rate(const char *opt, const char *arg)
2748 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2749 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2755 static int opt_bitrate(const char *opt, const char *arg)
2757 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2759 opt_default(opt, arg);
2761 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2762 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2767 static void opt_frame_crop_top(const char *arg)
2769 frame_topBand = atoi(arg);
2770 if (frame_topBand < 0) {
2771 fprintf(stderr, "Incorrect top crop size\n");
2774 if ((frame_topBand) >= frame_height){
2775 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2778 frame_height -= frame_topBand;
2781 static void opt_frame_crop_bottom(const char *arg)
2783 frame_bottomBand = atoi(arg);
2784 if (frame_bottomBand < 0) {
2785 fprintf(stderr, "Incorrect bottom crop size\n");
2788 if ((frame_bottomBand) >= frame_height){
2789 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2792 frame_height -= frame_bottomBand;
2795 static void opt_frame_crop_left(const char *arg)
2797 frame_leftBand = atoi(arg);
2798 if (frame_leftBand < 0) {
2799 fprintf(stderr, "Incorrect left crop size\n");
2802 if ((frame_leftBand) >= frame_width){
2803 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2806 frame_width -= frame_leftBand;
2809 static void opt_frame_crop_right(const char *arg)
2811 frame_rightBand = atoi(arg);
2812 if (frame_rightBand < 0) {
2813 fprintf(stderr, "Incorrect right crop size\n");
2816 if ((frame_rightBand) >= frame_width){
2817 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2820 frame_width -= frame_rightBand;
2823 static void opt_frame_size(const char *arg)
2825 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2826 fprintf(stderr, "Incorrect frame size\n");
2831 static void opt_pad(const char *arg) {
2832 fprintf(stderr, "Please use vf=pad\n");
2836 static void opt_frame_pix_fmt(const char *arg)
2838 if (strcmp(arg, "list")) {
2839 frame_pix_fmt = av_get_pix_fmt(arg);
2840 if (frame_pix_fmt == PIX_FMT_NONE) {
2841 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2850 static void opt_frame_aspect_ratio(const char *arg)
2857 p = strchr(arg, ':');
2859 x = strtol(arg, &end, 10);
2861 y = strtol(end+1, &end, 10);
2863 ar = (double)x / (double)y;
2865 ar = strtod(arg, NULL);
2868 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2871 frame_aspect_ratio = ar;
2874 static int opt_metadata(const char *opt, const char *arg)
2876 char *mid= strchr(arg, '=');
2879 fprintf(stderr, "Missing =\n");
2885 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2886 metadata[metadata_count-1].key = av_strdup(arg);
2887 metadata[metadata_count-1].value= av_strdup(mid);
2892 static void opt_qscale(const char *arg)
2894 video_qscale = atof(arg);
2895 if (video_qscale <= 0 ||
2896 video_qscale > 255) {
2897 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2902 static void opt_top_field_first(const char *arg)
2904 top_field_first= atoi(arg);
2907 static int opt_thread_count(const char *opt, const char *arg)
2909 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2912 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2917 static void opt_audio_sample_fmt(const char *arg)
2919 if (strcmp(arg, "list"))
2920 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2922 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2927 static int opt_audio_rate(const char *opt, const char *arg)
2929 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2933 static int opt_audio_channels(const char *opt, const char *arg)
2935 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2939 static void opt_video_channel(const char *arg)
2941 video_channel = strtol(arg, NULL, 0);
2944 static void opt_video_standard(const char *arg)
2946 video_standard = av_strdup(arg);
2949 static void opt_codec(int *pstream_copy, char **pcodec_name,
2950 int codec_type, const char *arg)
2952 av_freep(pcodec_name);
2953 if (!strcmp(arg, "copy")) {
2956 *pcodec_name = av_strdup(arg);
2960 static void opt_audio_codec(const char *arg)
2962 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2965 static void opt_audio_tag(const char *arg)
2968 audio_codec_tag= strtol(arg, &tail, 0);
2971 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2974 static void opt_video_tag(const char *arg)
2977 video_codec_tag= strtol(arg, &tail, 0);
2980 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2983 static void opt_video_codec(const char *arg)
2985 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2988 static void opt_subtitle_codec(const char *arg)
2990 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2993 static void opt_subtitle_tag(const char *arg)
2996 subtitle_codec_tag= strtol(arg, &tail, 0);
2999 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3002 static void opt_map(const char *arg)
3007 m = &stream_maps[nb_stream_maps++];
3009 m->file_index = strtol(arg, &p, 0);
3013 m->stream_index = strtol(p, &p, 0);
3016 m->sync_file_index = strtol(p, &p, 0);
3019 m->sync_stream_index = strtol(p, &p, 0);
3021 m->sync_file_index = m->file_index;
3022 m->sync_stream_index = m->stream_index;
3026 static void opt_map_meta_data(const char *arg)
3031 m = &meta_data_maps[nb_meta_data_maps++];
3033 m->out_file = strtol(arg, &p, 0);
3037 m->in_file = strtol(p, &p, 0);
3040 static void opt_input_ts_scale(const char *arg)
3042 unsigned int stream;
3046 stream = strtol(arg, &p, 0);
3049 scale= strtod(p, &p);
3051 if(stream >= MAX_STREAMS)
3054 input_files_ts_scale[nb_input_files][stream]= scale;
3057 static int opt_recording_time(const char *opt, const char *arg)
3059 recording_time = parse_time_or_die(opt, arg, 1);
3063 static int opt_start_time(const char *opt, const char *arg)
3065 start_time = parse_time_or_die(opt, arg, 1);
3069 static int opt_rec_timestamp(const char *opt, const char *arg)
3071 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3075 static int opt_input_ts_offset(const char *opt, const char *arg)
3077 input_ts_offset = parse_time_or_die(opt, arg, 1);
3081 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3083 const char *codec_string = encoder ? "encoder" : "decoder";
3087 return CODEC_ID_NONE;
3089 avcodec_find_encoder_by_name(name) :
3090 avcodec_find_decoder_by_name(name);
3092 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3095 if(codec->type != type) {
3096 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3099 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3100 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3101 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3102 "results.\nAdd '-strict experimental' if you want to use it.\n",
3103 codec_string, codec->name);
3105 avcodec_find_encoder(codec->id) :
3106 avcodec_find_decoder(codec->id);
3107 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3108 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3109 codec_string, codec->name);
3115 static void opt_input_file(const char *filename)
3117 AVFormatContext *ic;
3118 AVFormatParameters params, *ap = ¶ms;
3119 AVInputFormat *file_iformat = NULL;
3120 int err, i, ret, rfps, rfps_base;
3123 if (last_asked_format) {
3124 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3125 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3128 last_asked_format = NULL;
3131 if (!strcmp(filename, "-"))
3134 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3135 !strcmp(filename, "/dev/stdin");
3137 /* get default parameters from command line */
3138 ic = avformat_alloc_context();
3140 print_error(filename, AVERROR(ENOMEM));
3144 memset(ap, 0, sizeof(*ap));
3145 ap->prealloced_context = 1;
3146 ap->sample_rate = audio_sample_rate;
3147 ap->channels = audio_channels;
3148 ap->time_base.den = frame_rate.num;
3149 ap->time_base.num = frame_rate.den;
3150 ap->width = frame_width;
3151 ap->height = frame_height;
3152 ap->pix_fmt = frame_pix_fmt;
3153 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3154 ap->channel = video_channel;
3155 ap->standard = video_standard;
3157 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3159 ic->video_codec_id =
3160 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3161 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3162 ic->audio_codec_id =
3163 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3164 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3165 ic->subtitle_codec_id=
3166 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3167 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3168 ic->flags |= AVFMT_FLAG_NONBLOCK;
3170 if(pgmyuv_compatibility_hack)
3171 ic->video_codec_id= CODEC_ID_PGMYUV;
3173 /* open the input file with generic libav function */
3174 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3176 print_error(filename, err);
3182 for(i=0; i<ic->nb_streams; i++){
3183 ic->streams[i]->discard= AVDISCARD_ALL;
3185 for(i=0; i<ic->nb_programs; i++){
3186 AVProgram *p= ic->programs[i];
3187 if(p->id != opt_programid){
3188 p->discard = AVDISCARD_ALL;
3191 for(j=0; j<p->nb_stream_indexes; j++){
3192 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3197 fprintf(stderr, "Specified program id not found\n");
3203 ic->loop_input = loop_input;
3205 /* If not enough info to get the stream parameters, we decode the
3206 first frames to get it. (used in mpeg case for example) */
3207 ret = av_find_stream_info(ic);
3208 if (ret < 0 && verbose >= 0) {
3209 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3213 timestamp = start_time;
3214 /* add the stream start time */
3215 if (ic->start_time != AV_NOPTS_VALUE)
3216 timestamp += ic->start_time;
3218 /* if seeking requested, we execute it */
3219 if (start_time != 0) {
3220 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3222 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3223 filename, (double)timestamp / AV_TIME_BASE);
3225 /* reset seek info */
3229 /* update the current parameters so that they match the one of the input stream */
3230 for(i=0;i<ic->nb_streams;i++) {
3231 AVStream *st = ic->streams[i];
3232 AVCodecContext *enc = st->codec;
3233 avcodec_thread_init(enc, thread_count);
3234 switch(enc->codec_type) {
3235 case AVMEDIA_TYPE_AUDIO:
3236 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3237 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3238 channel_layout = enc->channel_layout;
3239 audio_channels = enc->channels;
3240 audio_sample_rate = enc->sample_rate;
3241 audio_sample_fmt = enc->sample_fmt;
3242 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3244 st->discard= AVDISCARD_ALL;
3246 case AVMEDIA_TYPE_VIDEO:
3247 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3248 frame_height = enc->height;
3249 frame_width = enc->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(enc->sample_aspect_ratio);
3254 frame_aspect_ratio *= (float) enc->width / enc->height;
3255 frame_pix_fmt = enc->pix_fmt;
3256 rfps = ic->streams[i]->r_frame_rate.num;
3257 rfps_base = ic->streams[i]->r_frame_rate.den;
3259 enc->flags |= CODEC_FLAG_EMU_EDGE;
3260 frame_height >>= enc->lowres;
3261 frame_width >>= enc->lowres;
3264 enc->debug |= FF_DEBUG_MV;
3266 if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->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)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->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;
3278 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3280 st->discard= AVDISCARD_ALL;
3281 else if(video_discard)
3282 st->discard= video_discard;
3284 case AVMEDIA_TYPE_DATA:
3286 case AVMEDIA_TYPE_SUBTITLE:
3287 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3288 if(subtitle_disable)
3289 st->discard = AVDISCARD_ALL;
3291 case AVMEDIA_TYPE_ATTACHMENT:
3292 case AVMEDIA_TYPE_UNKNOWN:
3300 input_files[nb_input_files] = ic;
3301 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3302 /* dump the file content */
3304 dump_format(ic, nb_input_files, filename, 0);
3310 av_freep(&video_codec_name);
3311 av_freep(&audio_codec_name);
3312 av_freep(&subtitle_codec_name);
3315 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3316 int *has_subtitle_ptr)
3318 int has_video, has_audio, has_subtitle, i, j;
3319 AVFormatContext *ic;
3324 for(j=0;j<nb_input_files;j++) {
3325 ic = input_files[j];
3326 for(i=0;i<ic->nb_streams;i++) {
3327 AVCodecContext *enc = ic->streams[i]->codec;
3328 switch(enc->codec_type) {
3329 case AVMEDIA_TYPE_AUDIO:
3332 case AVMEDIA_TYPE_VIDEO:
3335 case AVMEDIA_TYPE_SUBTITLE:
3338 case AVMEDIA_TYPE_DATA:
3339 case AVMEDIA_TYPE_ATTACHMENT:
3340 case AVMEDIA_TYPE_UNKNOWN:
3347 *has_video_ptr = has_video;
3348 *has_audio_ptr = has_audio;
3349 *has_subtitle_ptr = has_subtitle;
3352 static void new_video_stream(AVFormatContext *oc)
3355 AVCodecContext *video_enc;
3356 enum CodecID codec_id;
3358 st = av_new_stream(oc, oc->nb_streams);
3360 fprintf(stderr, "Could not alloc stream\n");
3363 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3364 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3365 video_bitstream_filters= NULL;
3367 avcodec_thread_init(st->codec, thread_count);
3369 video_enc = st->codec;
3372 video_enc->codec_tag= video_codec_tag;
3374 if( (video_global_header&1)
3375 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3376 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3377 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3379 if(video_global_header&2){
3380 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3381 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3384 if (video_stream_copy) {
3385 st->stream_copy = 1;
3386 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3387 video_enc->sample_aspect_ratio =
3388 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3393 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3395 if (video_codec_name) {
3396 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3397 video_enc->strict_std_compliance);
3398 codec = avcodec_find_encoder_by_name(video_codec_name);
3399 output_codecs[nb_ocodecs] = codec;
3401 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3402 codec = avcodec_find_encoder(codec_id);
3405 video_enc->codec_id = codec_id;
3407 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3409 if (codec && codec->supported_framerates && !force_fps)
3410 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3411 video_enc->time_base.den = fps.num;
3412 video_enc->time_base.num = fps.den;
3414 video_enc->width = frame_width;
3415 video_enc->height = frame_height;
3416 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3417 video_enc->pix_fmt = frame_pix_fmt;
3418 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3420 choose_pixel_fmt(st, codec);
3423 video_enc->gop_size = 0;
3424 if (video_qscale || same_quality) {
3425 video_enc->flags |= CODEC_FLAG_QSCALE;
3426 video_enc->global_quality=
3427 st->quality = FF_QP2LAMBDA * video_qscale;
3431 video_enc->intra_matrix = intra_matrix;
3433 video_enc->inter_matrix = inter_matrix;
3435 p= video_rc_override_string;
3438 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3440 fprintf(stderr, "error parsing rc_override\n");
3443 video_enc->rc_override=
3444 av_realloc(video_enc->rc_override,
3445 sizeof(RcOverride)*(i+1));
3446 video_enc->rc_override[i].start_frame= start;
3447 video_enc->rc_override[i].end_frame = end;
3449 video_enc->rc_override[i].qscale= q;
3450 video_enc->rc_override[i].quality_factor= 1.0;
3453 video_enc->rc_override[i].qscale= 0;
3454 video_enc->rc_override[i].quality_factor= -q/100.0;
3459 video_enc->rc_override_count=i;
3460 if (!video_enc->rc_initial_buffer_occupancy)
3461 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3462 video_enc->me_threshold= me_threshold;
3463 video_enc->intra_dc_precision= intra_dc_precision - 8;
3466 video_enc->flags|= CODEC_FLAG_PSNR;
3471 video_enc->flags |= CODEC_FLAG_PASS1;
3473 video_enc->flags |= CODEC_FLAG_PASS2;
3478 if (video_language) {
3479 av_metadata_set2(&st->metadata, "language", video_language, 0);
3480 av_freep(&video_language);
3483 /* reset some key parameters */
3485 av_freep(&video_codec_name);
3486 video_stream_copy = 0;
3487 frame_pix_fmt = PIX_FMT_NONE;
3490 static void new_audio_stream(AVFormatContext *oc)
3493 AVCodecContext *audio_enc;
3494 enum CodecID codec_id;
3496 st = av_new_stream(oc, oc->nb_streams);
3498 fprintf(stderr, "Could not alloc stream\n");
3501 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3503 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3504 audio_bitstream_filters= NULL;
3506 avcodec_thread_init(st->codec, thread_count);
3508 audio_enc = st->codec;
3509 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3512 audio_enc->codec_tag= audio_codec_tag;
3514 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3515 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3516 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3518 if (audio_stream_copy) {
3519 st->stream_copy = 1;
3520 audio_enc->channels = audio_channels;
3521 audio_enc->sample_rate = audio_sample_rate;
3525 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3527 if (audio_codec_name) {
3528 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3529 audio_enc->strict_std_compliance);
3530 codec = avcodec_find_encoder_by_name(audio_codec_name);
3531 output_codecs[nb_ocodecs] = codec;
3533 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3534 codec = avcodec_find_encoder(codec_id);
3536 audio_enc->codec_id = codec_id;
3538 if (audio_qscale > QSCALE_NONE) {
3539 audio_enc->flags |= CODEC_FLAG_QSCALE;
3540 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3542 audio_enc->channels = audio_channels;
3543 audio_enc->sample_fmt = audio_sample_fmt;
3544 audio_enc->sample_rate = audio_sample_rate;
3545 audio_enc->channel_layout = channel_layout;
3546 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3547 audio_enc->channel_layout = 0;
3548 choose_sample_fmt(st, codec);
3549 choose_sample_rate(st, codec);
3552 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3553 if (audio_language) {
3554 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3555 av_freep(&audio_language);
3558 /* reset some key parameters */
3560 av_freep(&audio_codec_name);
3561 audio_stream_copy = 0;
3564 static void new_subtitle_stream(AVFormatContext *oc)
3567 AVCodecContext *subtitle_enc;
3569 st = av_new_stream(oc, oc->nb_streams);
3571 fprintf(stderr, "Could not alloc stream\n");
3574 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3576 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3577 subtitle_bitstream_filters= NULL;
3579 subtitle_enc = st->codec;
3580 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3582 if(subtitle_codec_tag)
3583 subtitle_enc->codec_tag= subtitle_codec_tag;
3585 if (subtitle_stream_copy) {
3586 st->stream_copy = 1;
3588 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3589 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3590 subtitle_enc->strict_std_compliance);
3591 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3595 if (subtitle_language) {
3596 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3597 av_freep(&subtitle_language);
3600 subtitle_disable = 0;
3601 av_freep(&subtitle_codec_name);
3602 subtitle_stream_copy = 0;
3605 static void opt_new_audio_stream(void)
3607 AVFormatContext *oc;
3608 if (nb_output_files <= 0) {
3609 fprintf(stderr, "At least one output file must be specified\n");
3612 oc = output_files[nb_output_files - 1];
3613 new_audio_stream(oc);
3616 static void opt_new_video_stream(void)
3618 AVFormatContext *oc;
3619 if (nb_output_files <= 0) {
3620 fprintf(stderr, "At least one output file must be specified\n");
3623 oc = output_files[nb_output_files - 1];
3624 new_video_stream(oc);
3627 static void opt_new_subtitle_stream(void)
3629 AVFormatContext *oc;
3630 if (nb_output_files <= 0) {
3631 fprintf(stderr, "At least one output file must be specified\n");
3634 oc = output_files[nb_output_files - 1];
3635 new_subtitle_stream(oc);
3638 static void opt_output_file(const char *filename)
3640 AVFormatContext *oc;
3641 int err, use_video, use_audio, use_subtitle;
3642 int input_has_video, input_has_audio, input_has_subtitle;
3643 AVFormatParameters params, *ap = ¶ms;
3644 AVOutputFormat *file_oformat;
3646 if (!strcmp(filename, "-"))
3649 oc = avformat_alloc_context();
3651 print_error(filename, AVERROR(ENOMEM));
3655 if (last_asked_format) {
3656 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3657 if (!file_oformat) {
3658 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3661 last_asked_format = NULL;
3663 file_oformat = av_guess_format(NULL, filename, NULL);
3664 if (!file_oformat) {
3665 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3671 oc->oformat = file_oformat;
3672 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3674 if (!strcmp(file_oformat->name, "ffm") &&
3675 av_strstart(filename, "http:", NULL)) {
3676 /* special case for files sent to ffserver: we get the stream
3677 parameters from ffserver */
3678 int err = read_ffserver_streams(oc, filename);
3680 print_error(filename, err);
3684 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3685 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3686 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3688 /* disable if no corresponding type found and at least one
3690 if (nb_input_files > 0) {
3691 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3692 &input_has_subtitle);
3693 if (!input_has_video)
3695 if (!input_has_audio)
3697 if (!input_has_subtitle)
3701 /* manual disable */
3702 if (audio_disable) {
3705 if (video_disable) {
3708 if (subtitle_disable) {
3713 new_video_stream(oc);
3717 new_audio_stream(oc);
3721 new_subtitle_stream(oc);
3724 oc->timestamp = rec_timestamp;
3726 for(; metadata_count>0; metadata_count--){
3727 av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3728 metadata[metadata_count-1].value, 0);
3730 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3733 output_files[nb_output_files++] = oc;
3735 /* check filename in case of an image number is expected */
3736 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3737 if (!av_filename_number_test(oc->filename)) {
3738 print_error(oc->filename, AVERROR_NUMEXPECTED);
3743 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3744 /* test if it already exists to avoid loosing precious files */
3745 if (!file_overwrite &&
3746 (strchr(filename, ':') == NULL ||
3747 filename[1] == ':' ||
3748 av_strstart(filename, "file:", NULL))) {
3749 if (url_exist(filename)) {
3751 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3753 if (!read_yesno()) {
3754 fprintf(stderr, "Not overwriting - exiting\n");
3759 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3766 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3767 print_error(filename, err);
3772 memset(ap, 0, sizeof(*ap));
3773 if (av_set_parameters(oc, ap) < 0) {
3774 fprintf(stderr, "%s: Invalid encoding parameters\n",
3779 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3780 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3781 oc->loop_output = loop_output;
3782 oc->flags |= AVFMT_FLAG_NONBLOCK;
3784 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3787 /* same option as mencoder */
3788 static void opt_pass(const char *pass_str)
3791 pass = atoi(pass_str);
3792 if (pass != 1 && pass != 2) {
3793 fprintf(stderr, "pass number can be only 1 or 2\n");
3799 static int64_t getutime(void)
3802 struct rusage rusage;
3804 getrusage(RUSAGE_SELF, &rusage);
3805 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3806 #elif HAVE_GETPROCESSTIMES
3808 FILETIME c, e, k, u;
3809 proc = GetCurrentProcess();
3810 GetProcessTimes(proc, &c, &e, &k, &u);
3811 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3813 return av_gettime();
3817 static int64_t getmaxrss(void)
3819 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3820 struct rusage rusage;
3821 getrusage(RUSAGE_SELF, &rusage);
3822 return (int64_t)rusage.ru_maxrss * 1024;
3823 #elif HAVE_GETPROCESSMEMORYINFO
3825 PROCESS_MEMORY_COUNTERS memcounters;
3826 proc = GetCurrentProcess();
3827 memcounters.cb = sizeof(memcounters);
3828 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3829 return memcounters.PeakPagefileUsage;
3835 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3838 const char *p = str;
3845 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3852 static void opt_inter_matrix(const char *arg)
3854 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3855 parse_matrix_coeffs(inter_matrix, arg);
3858 static void opt_intra_matrix(const char *arg)
3860 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3861 parse_matrix_coeffs(intra_matrix, arg);
3865 * Trivial log callback.
3866 * Only suitable for show_help and similar since it lacks prefix handling.
3868 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3870 vfprintf(stdout, fmt, vl);
3873 static void show_usage(void)
3875 printf("Hyper fast Audio and Video encoder\n");
3876 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3880 static void show_help(void)
3882 av_log_set_callback(log_callback_help);
3884 show_help_options(options, "Main options:\n",
3885 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3886 show_help_options(options, "\nAdvanced options:\n",
3887 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3889 show_help_options(options, "\nVideo options:\n",
3890 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3892 show_help_options(options, "\nAdvanced Video options:\n",
3893 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3894 OPT_VIDEO | OPT_EXPERT);
3895 show_help_options(options, "\nAudio options:\n",
3896 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3898 show_help_options(options, "\nAdvanced Audio options:\n",
3899 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3900 OPT_AUDIO | OPT_EXPERT);
3901 show_help_options(options, "\nSubtitle options:\n",
3902 OPT_SUBTITLE | OPT_GRAB,
3904 show_help_options(options, "\nAudio/Video grab options:\n",
3908 av_opt_show(avcodec_opts[0], NULL);
3910 av_opt_show(avformat_opts, NULL);
3912 av_opt_show(sws_opts, NULL);
3915 static void opt_target(const char *arg)
3917 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3918 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3920 if(!strncmp(arg, "pal-", 4)) {
3923 } else if(!strncmp(arg, "ntsc-", 5)) {
3926 } else if(!strncmp(arg, "film-", 5)) {
3931 /* Calculate FR via float to avoid int overflow */
3932 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3935 } else if((fr == 29970) || (fr == 23976)) {
3938 /* Try to determine PAL/NTSC by peeking in the input files */
3939 if(nb_input_files) {
3941 for(j = 0; j < nb_input_files; j++) {
3942 for(i = 0; i < input_files[j]->nb_streams; i++) {
3943 AVCodecContext *c = input_files[j]->streams[i]->codec;
3944 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3946 fr = c->time_base.den * 1000 / c->time_base.num;
3950 } else if((fr == 29970) || (fr == 23976)) {
3960 if(verbose && norm != UNKNOWN)
3961 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3964 if(norm == UNKNOWN) {
3965 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3966 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3967 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3971 if(!strcmp(arg, "vcd")) {
3973 opt_video_codec("mpeg1video");
3974 opt_audio_codec("mp2");
3977 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3978 opt_frame_rate(NULL, frame_rates[norm]);
3979 opt_default("g", norm == PAL ? "15" : "18");
3981 opt_default("b", "1150000");
3982 opt_default("maxrate", "1150000");
3983 opt_default("minrate", "1150000");
3984 opt_default("bufsize", "327680"); // 40*1024*8;
3986 opt_default("ab", "224000");
3987 audio_sample_rate = 44100;
3990 opt_default("packetsize", "2324");
3991 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3993 /* We have to offset the PTS, so that it is consistent with the SCR.
3994 SCR starts at 36000, but the first two packs contain only padding
3995 and the first pack from the other stream, respectively, may also have
3996 been written before.
3997 So the real data starts at SCR 36000+3*1200. */
3998 mux_preload= (36000+3*1200) / 90000.0; //0.44
3999 } else if(!strcmp(arg, "svcd")) {
4001 opt_video_codec("mpeg2video");
4002 opt_audio_codec("mp2");
4005 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4006 opt_frame_rate(NULL, frame_rates[norm]);
4007 opt_default("g", norm == PAL ? "15" : "18");
4009 opt_default("b", "2040000");
4010 opt_default("maxrate", "2516000");
4011 opt_default("minrate", "0"); //1145000;
4012 opt_default("bufsize", "1835008"); //224*1024*8;
4013 opt_default("flags", "+scan_offset");
4016 opt_default("ab", "224000");
4017 audio_sample_rate = 44100;
4019 opt_default("packetsize", "2324");
4021 } else if(!strcmp(arg, "dvd")) {
4023 opt_video_codec("mpeg2video");
4024 opt_audio_codec("ac3");
4027 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4028 opt_frame_rate(NULL, frame_rates[norm]);
4029 opt_default("g", norm == PAL ? "15" : "18");
4031 opt_default("b", "6000000");
4032 opt_default("maxrate", "9000000");
4033 opt_default("minrate", "0"); //1500000;
4034 opt_default("bufsize", "1835008"); //224*1024*8;
4036 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4037 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4039 opt_default("ab", "448000");
4040 audio_sample_rate = 48000;
4042 } else if(!strncmp(arg, "dv", 2)) {
4046 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4047 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4048 (norm == PAL ? "yuv420p" : "yuv411p"));
4049 opt_frame_rate(NULL, frame_rates[norm]);
4051 audio_sample_rate = 48000;
4055 fprintf(stderr, "Unknown target: %s\n", arg);
4060 static void opt_vstats_file (const char *arg)
4062 av_free (vstats_filename);
4063 vstats_filename=av_strdup (arg);
4066 static void opt_vstats (void)
4069 time_t today2 = time(NULL);
4070 struct tm *today = localtime(&today2);
4072 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4074 opt_vstats_file(filename);
4077 static int opt_bsf(const char *opt, const char *arg)
4079 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4080 AVBitStreamFilterContext **bsfp;
4083 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4087 bsfp= *opt == 'v' ? &video_bitstream_filters :
4088 *opt == 'a' ? &audio_bitstream_filters :
4089 &subtitle_bitstream_filters;
4091 bsfp= &(*bsfp)->next;
4098 static int opt_preset(const char *opt, const char *arg)
4101 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4103 const char *base[3]= { getenv("FFMPEG_DATADIR"),
4109 for(i=0; i<3 && !f; i++){
4112 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4113 f= fopen(filename, "r");
4115 char *codec_name= *opt == 'v' ? video_codec_name :
4116 *opt == 'a' ? audio_codec_name :
4117 subtitle_codec_name;
4118 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4119 f= fopen(filename, "r");
4123 av_strlcpy(filename, arg, sizeof(filename));
4124 f= fopen(filename, "r");
4128 fprintf(stderr, "File for preset '%s' not found\n", arg);
4133 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4134 if(line[0] == '#' && !e)
4136 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4138 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4141 if(!strcmp(tmp, "acodec")){
4142 opt_audio_codec(tmp2);
4143 }else if(!strcmp(tmp, "vcodec")){
4144 opt_video_codec(tmp2);
4145 }else if(!strcmp(tmp, "scodec")){
4146 opt_subtitle_codec(tmp2);
4147 }else if(opt_default(tmp, tmp2) < 0){
4148 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4158 static const OptionDef options[] = {
4160 #include "cmdutils_common_opts.h"
4161 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4162 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4163 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4164 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4165 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4166 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4167 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4168 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4169 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4170 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4171 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
4172 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4173 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4174 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4175 "add timings for benchmarking" },
4176 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4177 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4178 "dump each input packet" },
4179 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4180 "when dumping packets, also dump the payload" },
4181 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4182 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4183 { "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)", "" },
4184 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4185 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4186 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4187 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4188 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4189 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4190 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4191 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4192 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4193 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4194 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4195 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4196 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4199 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4200 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4201 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4202 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4203 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4204 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4205 { "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" },
4206 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4207 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4208 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4209 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4210 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set top pad band size (in pixels)", "size" },
4211 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set bottom pad band size (in pixels)", "size" },
4212 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set left pad band size (in pixels)", "size" },
4213 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set right pad band size (in pixels)", "size" },
4214 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4215 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4216 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4217 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4218 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4219 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4220 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4221 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4222 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4223 "use same video quality as source (implies VBR)" },
4224 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4225 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4226 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4227 "deinterlace pictures" },
4228 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4229 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4230 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4232 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4234 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4235 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4236 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4237 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4238 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4239 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4240 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4241 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4242 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4245 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4246 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4247 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4248 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4249 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4250 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4251 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4252 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4253 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4254 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4255 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4256 { "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" },
4258 /* subtitle options */
4259 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4260 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4261 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4262 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4263 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4266 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4267 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4268 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4271 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4272 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4274 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4275 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4276 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4278 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4279 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4280 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4281 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4283 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4287 int main(int argc, char **argv)
4292 avcodec_register_all();
4294 avdevice_register_all();
4297 avfilter_register_all();
4302 if(isatty(STDIN_FILENO))
4303 url_set_interrupt_cb(decode_interrupt_cb);
4306 for(i=0; i<AVMEDIA_TYPE_NB; i++){
4307 avcodec_opts[i]= avcodec_alloc_context2(i);
4309 avformat_opts = avformat_alloc_context();
4310 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4315 parse_options(argc, argv, options, opt_output_file);
4317 if(nb_output_files <= 0 && nb_input_files == 0) {
4319 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4323 /* file converter / grab */
4324 if (nb_output_files <= 0) {
4325 fprintf(stderr, "At least one output file must be specified\n");
4329 if (nb_input_files == 0) {
4330 fprintf(stderr, "At least one input file must be specified\n");
4335 if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4336 stream_maps, nb_stream_maps) < 0)
4338 ti = getutime() - ti;
4340 int maxrss = getmaxrss() / 1024;
4341 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);