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 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 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 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 /* if stream_copy is selected, no need to decode or encode */
2160 codec->codec_id = icodec->codec_id;
2161 codec->codec_type = icodec->codec_type;
2163 if(!codec->codec_tag){
2164 if( !os->oformat->codec_tag
2165 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2166 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2167 codec->codec_tag = icodec->codec_tag;
2170 codec->bit_rate = icodec->bit_rate;
2171 codec->extradata= icodec->extradata;
2172 codec->extradata_size= icodec->extradata_size;
2173 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){
2174 codec->time_base = icodec->time_base;
2175 codec->time_base.num *= icodec->ticks_per_frame;
2177 codec->time_base = ist->st->time_base;
2178 switch(codec->codec_type) {
2179 case AVMEDIA_TYPE_AUDIO:
2180 if(audio_volume != 256) {
2181 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2184 codec->channel_layout = icodec->channel_layout;
2185 codec->sample_rate = icodec->sample_rate;
2186 codec->channels = icodec->channels;
2187 codec->frame_size = icodec->frame_size;
2188 codec->block_align= icodec->block_align;
2189 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2190 codec->block_align= 0;
2191 if(codec->codec_id == CODEC_ID_AC3)
2192 codec->block_align= 0;
2194 case AVMEDIA_TYPE_VIDEO:
2195 codec->pix_fmt = icodec->pix_fmt;
2196 codec->width = icodec->width;
2197 codec->height = icodec->height;
2198 codec->has_b_frames = icodec->has_b_frames;
2200 case AVMEDIA_TYPE_SUBTITLE:
2201 codec->width = icodec->width;
2202 codec->height = icodec->height;
2208 switch(codec->codec_type) {
2209 case AVMEDIA_TYPE_AUDIO:
2210 ost->fifo= av_fifo_alloc(1024);
2213 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2214 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2215 icodec->request_channels = codec->channels;
2216 ist->decoding_needed = 1;
2217 ost->encoding_needed = 1;
2219 case AVMEDIA_TYPE_VIDEO:
2220 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2221 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2224 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2225 ost->video_resample = ((codec->width != icodec->width -
2226 (frame_leftBand + frame_rightBand)) ||
2227 (codec->height != icodec->height -
2228 (frame_topBand + frame_bottomBand)) ||
2229 (codec->pix_fmt != icodec->pix_fmt));
2230 if (ost->video_crop) {
2231 ost->topBand = ost->original_topBand = frame_topBand;
2232 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2233 ost->leftBand = ost->original_leftBand = frame_leftBand;
2234 ost->rightBand = ost->original_rightBand = frame_rightBand;
2236 if (ost->video_resample) {
2237 avcodec_get_frame_defaults(&ost->pict_tmp);
2238 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2239 codec->width, codec->height)) {
2240 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2243 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2244 ost->img_resample_ctx = sws_getContext(
2245 icodec->width - (frame_leftBand + frame_rightBand),
2246 icodec->height - (frame_topBand + frame_bottomBand),
2251 sws_flags, NULL, NULL, NULL);
2252 if (ost->img_resample_ctx == NULL) {
2253 fprintf(stderr, "Cannot get resampling context\n");
2257 #if !CONFIG_AVFILTER
2258 ost->original_height = icodec->height;
2259 ost->original_width = icodec->width;
2261 codec->bits_per_raw_sample= 0;
2263 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
2264 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
2265 ost->resample_pix_fmt= icodec->pix_fmt;
2266 ost->encoding_needed = 1;
2267 ist->decoding_needed = 1;
2270 if (configure_filters(ist, ost)) {
2271 fprintf(stderr, "Error opening filters!\n");
2276 case AVMEDIA_TYPE_SUBTITLE:
2277 ost->encoding_needed = 1;
2278 ist->decoding_needed = 1;
2285 if (ost->encoding_needed &&
2286 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2287 char logfilename[1024];
2290 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2291 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2293 if (codec->flags & CODEC_FLAG_PASS1) {
2294 f = fopen(logfilename, "wb");
2296 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2302 size_t logbuffer_size;
2303 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2304 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2307 codec->stats_in = logbuffer;
2311 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2312 int size= codec->width * codec->height;
2313 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2318 bit_buffer = av_malloc(bit_buffer_size);
2320 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2322 ret = AVERROR(ENOMEM);
2326 /* open each encoder */
2327 for(i=0;i<nb_ostreams;i++) {
2329 if (ost->encoding_needed) {
2330 AVCodec *codec = output_codecs[i];
2332 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2334 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2335 ost->st->codec->codec_id, ost->file_index, ost->index);
2336 ret = AVERROR(EINVAL);
2339 if (avcodec_open(ost->st->codec, codec) < 0) {
2340 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2341 ost->file_index, ost->index);
2342 ret = AVERROR(EINVAL);
2345 extra_size += ost->st->codec->extradata_size;
2349 /* open each decoder */
2350 for(i=0;i<nb_istreams;i++) {
2352 if (ist->decoding_needed) {
2353 AVCodec *codec = input_codecs[i];
2355 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2357 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2358 ist->st->codec->codec_id, ist->file_index, ist->index);
2359 ret = AVERROR(EINVAL);
2362 if (avcodec_open(ist->st->codec, codec) < 0) {
2363 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2364 ist->file_index, ist->index);
2365 ret = AVERROR(EINVAL);
2368 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2369 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2374 for(i=0;i<nb_istreams;i++) {
2378 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2379 ist->next_pts = AV_NOPTS_VALUE;
2383 /* set meta data information from input file if required */
2384 for (i=0;i<nb_meta_data_maps;i++) {
2385 AVFormatContext *out_file;
2386 AVFormatContext *in_file;
2387 AVMetadataTag *mtag;
2389 int out_file_index = meta_data_maps[i].out_file;
2390 int in_file_index = meta_data_maps[i].in_file;
2391 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2392 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2393 out_file_index, out_file_index, in_file_index);
2394 ret = AVERROR(EINVAL);
2397 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2398 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2399 in_file_index, out_file_index, in_file_index);
2400 ret = AVERROR(EINVAL);
2404 out_file = output_files[out_file_index];
2405 in_file = input_files[in_file_index];
2409 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2410 av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2411 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2412 in_file->iformat->metadata_conv);
2415 /* copy chapters from the first input file that has them*/
2416 for (i = 0; i < nb_input_files; i++) {
2417 if (!input_files[i]->nb_chapters)
2420 for (j = 0; j < nb_output_files; j++)
2421 if ((ret = copy_chapters(i, j)) < 0)
2425 /* open files and write file headers */
2426 for(i=0;i<nb_output_files;i++) {
2427 os = output_files[i];
2428 if (av_write_header(os) < 0) {
2429 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2430 ret = AVERROR(EINVAL);
2433 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2439 /* dump the file output parameters - cannot be done before in case
2441 for(i=0;i<nb_output_files;i++) {
2442 dump_format(output_files[i], i, output_files[i]->filename, 1);
2445 /* dump the stream mapping */
2447 fprintf(stderr, "Stream mapping:\n");
2448 for(i=0;i<nb_ostreams;i++) {
2450 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2451 ist_table[ost->source_index]->file_index,
2452 ist_table[ost->source_index]->index,
2455 if (ost->sync_ist != ist_table[ost->source_index])
2456 fprintf(stderr, " [sync #%d.%d]",
2457 ost->sync_ist->file_index,
2458 ost->sync_ist->index);
2459 fprintf(stderr, "\n");
2464 fprintf(stderr, "%s\n", error);
2469 print_sdp(output_files, nb_output_files);
2472 if (!using_stdin && verbose >= 0) {
2473 fprintf(stderr, "Press [q] to stop encoding\n");
2474 url_set_interrupt_cb(decode_interrupt_cb);
2478 timer_start = av_gettime();
2480 for(; received_sigterm == 0;) {
2481 int file_index, ist_index;
2489 /* if 'q' pressed, exits */
2493 /* read_key() returns 0 on EOF */
2499 /* select the stream that we must read now by looking at the
2500 smallest output pts */
2502 for(i=0;i<nb_ostreams;i++) {
2505 os = output_files[ost->file_index];
2506 ist = ist_table[ost->source_index];
2507 if(ist->is_past_recording_time || no_packet[ist->file_index])
2509 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2510 ipts = (double)ist->pts;
2511 if (!file_table[ist->file_index].eof_reached){
2512 if(ipts < ipts_min) {
2514 if(input_sync ) file_index = ist->file_index;
2516 if(opts < opts_min) {
2518 if(!input_sync) file_index = ist->file_index;
2521 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2526 /* if none, if is finished */
2527 if (file_index < 0) {
2528 if(no_packet_count){
2530 memset(no_packet, 0, sizeof(no_packet));
2537 /* finish if limit size exhausted */
2538 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2541 /* read a frame from it and output it in the fifo */
2542 is = input_files[file_index];
2543 ret= av_read_frame(is, &pkt);
2544 if(ret == AVERROR(EAGAIN)){
2545 no_packet[file_index]=1;
2550 file_table[file_index].eof_reached = 1;
2558 memset(no_packet, 0, sizeof(no_packet));
2561 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2563 /* the following test is needed in case new streams appear
2564 dynamically in stream : we ignore them */
2565 if (pkt.stream_index >= file_table[file_index].nb_streams)
2566 goto discard_packet;
2567 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2568 ist = ist_table[ist_index];
2570 goto discard_packet;
2572 if (pkt.dts != AV_NOPTS_VALUE)
2573 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2574 if (pkt.pts != AV_NOPTS_VALUE)
2575 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2577 if(input_files_ts_scale[file_index][pkt.stream_index]){
2578 if(pkt.pts != AV_NOPTS_VALUE)
2579 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2580 if(pkt.dts != AV_NOPTS_VALUE)
2581 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2584 // 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);
2585 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2586 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2587 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2588 int64_t delta= pkt_dts - ist->next_pts;
2589 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2590 input_files_ts_offset[ist->file_index]-= delta;
2592 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2593 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2594 if(pkt.pts != AV_NOPTS_VALUE)
2595 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2599 /* finish if recording time exhausted */
2600 if (recording_time != INT64_MAX &&
2601 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2602 ist->is_past_recording_time = 1;
2603 goto discard_packet;
2606 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2607 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2610 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2611 ist->file_index, ist->index);
2614 av_free_packet(&pkt);
2619 av_free_packet(&pkt);
2621 /* dump report by using the output first video and audio streams */
2622 print_report(output_files, ost_table, nb_ostreams, 0);
2625 /* at the end of stream, we must flush the decoder buffers */
2626 for(i=0;i<nb_istreams;i++) {
2628 if (ist->decoding_needed) {
2629 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2635 /* write the trailer if needed and close file */
2636 for(i=0;i<nb_output_files;i++) {
2637 os = output_files[i];
2638 av_write_trailer(os);
2641 /* dump report by using the first video and audio streams */
2642 print_report(output_files, ost_table, nb_ostreams, 1);
2644 /* close each encoder */
2645 for(i=0;i<nb_ostreams;i++) {
2647 if (ost->encoding_needed) {
2648 av_freep(&ost->st->codec->stats_in);
2649 avcodec_close(ost->st->codec);
2653 /* close each decoder */
2654 for(i=0;i<nb_istreams;i++) {
2656 if (ist->decoding_needed) {
2657 avcodec_close(ist->st->codec);
2662 avfilter_graph_destroy(graph);
2671 av_freep(&bit_buffer);
2672 av_free(file_table);
2675 for(i=0;i<nb_istreams;i++) {
2682 for(i=0;i<nb_ostreams;i++) {
2686 fclose(ost->logfile);
2687 ost->logfile = NULL;
2689 av_fifo_free(ost->fifo); /* works even if fifo is not
2690 initialized but set to zero */
2691 av_free(ost->pict_tmp.data[0]);
2692 if (ost->video_resample)
2693 sws_freeContext(ost->img_resample_ctx);
2695 audio_resample_close(ost->resample);
2696 if (ost->reformat_ctx)
2697 av_audio_convert_free(ost->reformat_ctx);
2706 static void opt_format(const char *arg)
2708 /* compatibility stuff for pgmyuv */
2709 if (!strcmp(arg, "pgmyuv")) {
2710 pgmyuv_compatibility_hack=1;
2711 // opt_image_format(arg);
2713 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2716 last_asked_format = arg;
2719 static void opt_video_rc_override_string(const char *arg)
2721 video_rc_override_string = arg;
2724 static int opt_me_threshold(const char *opt, const char *arg)
2726 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2730 static int opt_verbose(const char *opt, const char *arg)
2732 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2736 static int opt_frame_rate(const char *opt, const char *arg)
2738 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2739 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2745 static int opt_bitrate(const char *opt, const char *arg)
2747 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2749 opt_default(opt, arg);
2751 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2752 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2757 static void opt_frame_crop_top(const char *arg)
2759 frame_topBand = atoi(arg);
2760 if (frame_topBand < 0) {
2761 fprintf(stderr, "Incorrect top crop size\n");
2764 if ((frame_topBand) >= frame_height){
2765 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2768 frame_height -= frame_topBand;
2771 static void opt_frame_crop_bottom(const char *arg)
2773 frame_bottomBand = atoi(arg);
2774 if (frame_bottomBand < 0) {
2775 fprintf(stderr, "Incorrect bottom crop size\n");
2778 if ((frame_bottomBand) >= frame_height){
2779 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2782 frame_height -= frame_bottomBand;
2785 static void opt_frame_crop_left(const char *arg)
2787 frame_leftBand = atoi(arg);
2788 if (frame_leftBand < 0) {
2789 fprintf(stderr, "Incorrect left crop size\n");
2792 if ((frame_leftBand) >= frame_width){
2793 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2796 frame_width -= frame_leftBand;
2799 static void opt_frame_crop_right(const char *arg)
2801 frame_rightBand = atoi(arg);
2802 if (frame_rightBand < 0) {
2803 fprintf(stderr, "Incorrect right crop size\n");
2806 if ((frame_rightBand) >= frame_width){
2807 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2810 frame_width -= frame_rightBand;
2813 static void opt_frame_size(const char *arg)
2815 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2816 fprintf(stderr, "Incorrect frame size\n");
2821 static void opt_pad(const char *arg) {
2822 fprintf(stderr, "Please use vf=pad\n");
2826 static void opt_frame_pix_fmt(const char *arg)
2828 if (strcmp(arg, "list")) {
2829 frame_pix_fmt = av_get_pix_fmt(arg);
2830 if (frame_pix_fmt == PIX_FMT_NONE) {
2831 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2840 static void opt_frame_aspect_ratio(const char *arg)
2847 p = strchr(arg, ':');
2849 x = strtol(arg, &end, 10);
2851 y = strtol(end+1, &end, 10);
2853 ar = (double)x / (double)y;
2855 ar = strtod(arg, NULL);
2858 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2861 frame_aspect_ratio = ar;
2864 static int opt_metadata(const char *opt, const char *arg)
2866 char *mid= strchr(arg, '=');
2869 fprintf(stderr, "Missing =\n");
2875 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2876 metadata[metadata_count-1].key = av_strdup(arg);
2877 metadata[metadata_count-1].value= av_strdup(mid);
2882 static void opt_qscale(const char *arg)
2884 video_qscale = atof(arg);
2885 if (video_qscale <= 0 ||
2886 video_qscale > 255) {
2887 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2892 static void opt_top_field_first(const char *arg)
2894 top_field_first= atoi(arg);
2897 static int opt_thread_count(const char *opt, const char *arg)
2899 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2902 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2907 static void opt_audio_sample_fmt(const char *arg)
2909 if (strcmp(arg, "list"))
2910 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2912 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2917 static int opt_audio_rate(const char *opt, const char *arg)
2919 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2923 static int opt_audio_channels(const char *opt, const char *arg)
2925 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2929 static void opt_video_channel(const char *arg)
2931 video_channel = strtol(arg, NULL, 0);
2934 static void opt_video_standard(const char *arg)
2936 video_standard = av_strdup(arg);
2939 static void opt_codec(int *pstream_copy, char **pcodec_name,
2940 int codec_type, const char *arg)
2942 av_freep(pcodec_name);
2943 if (!strcmp(arg, "copy")) {
2946 *pcodec_name = av_strdup(arg);
2950 static void opt_audio_codec(const char *arg)
2952 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2955 static void opt_audio_tag(const char *arg)
2958 audio_codec_tag= strtol(arg, &tail, 0);
2961 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2964 static void opt_video_tag(const char *arg)
2967 video_codec_tag= strtol(arg, &tail, 0);
2970 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2973 static void opt_video_codec(const char *arg)
2975 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2978 static void opt_subtitle_codec(const char *arg)
2980 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2983 static void opt_subtitle_tag(const char *arg)
2986 subtitle_codec_tag= strtol(arg, &tail, 0);
2989 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2992 static void opt_map(const char *arg)
2997 m = &stream_maps[nb_stream_maps++];
2999 m->file_index = strtol(arg, &p, 0);
3003 m->stream_index = strtol(p, &p, 0);
3006 m->sync_file_index = strtol(p, &p, 0);
3009 m->sync_stream_index = strtol(p, &p, 0);
3011 m->sync_file_index = m->file_index;
3012 m->sync_stream_index = m->stream_index;
3016 static void opt_map_meta_data(const char *arg)
3021 m = &meta_data_maps[nb_meta_data_maps++];
3023 m->out_file = strtol(arg, &p, 0);
3027 m->in_file = strtol(p, &p, 0);
3030 static void opt_input_ts_scale(const char *arg)
3032 unsigned int stream;
3036 stream = strtol(arg, &p, 0);
3039 scale= strtod(p, &p);
3041 if(stream >= MAX_STREAMS)
3044 input_files_ts_scale[nb_input_files][stream]= scale;
3047 static int opt_recording_time(const char *opt, const char *arg)
3049 recording_time = parse_time_or_die(opt, arg, 1);
3053 static int opt_start_time(const char *opt, const char *arg)
3055 start_time = parse_time_or_die(opt, arg, 1);
3059 static int opt_rec_timestamp(const char *opt, const char *arg)
3061 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3065 static int opt_input_ts_offset(const char *opt, const char *arg)
3067 input_ts_offset = parse_time_or_die(opt, arg, 1);
3071 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3073 const char *codec_string = encoder ? "encoder" : "decoder";
3077 return CODEC_ID_NONE;
3079 avcodec_find_encoder_by_name(name) :
3080 avcodec_find_decoder_by_name(name);
3082 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3085 if(codec->type != type) {
3086 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3089 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3090 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3091 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3092 "results.\nAdd '-strict experimental' if you want to use it.\n",
3093 codec_string, codec->name);
3099 static void opt_input_file(const char *filename)
3101 AVFormatContext *ic;
3102 AVFormatParameters params, *ap = ¶ms;
3103 AVInputFormat *file_iformat = NULL;
3104 int err, i, ret, rfps, rfps_base;
3107 if (last_asked_format) {
3108 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3109 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3112 last_asked_format = NULL;
3115 if (!strcmp(filename, "-"))
3118 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3119 !strcmp(filename, "/dev/stdin");
3121 /* get default parameters from command line */
3122 ic = avformat_alloc_context();
3124 print_error(filename, AVERROR(ENOMEM));
3128 memset(ap, 0, sizeof(*ap));
3129 ap->prealloced_context = 1;
3130 ap->sample_rate = audio_sample_rate;
3131 ap->channels = audio_channels;
3132 ap->time_base.den = frame_rate.num;
3133 ap->time_base.num = frame_rate.den;
3134 ap->width = frame_width;
3135 ap->height = frame_height;
3136 ap->pix_fmt = frame_pix_fmt;
3137 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3138 ap->channel = video_channel;
3139 ap->standard = video_standard;
3141 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3143 ic->video_codec_id =
3144 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3145 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3146 ic->audio_codec_id =
3147 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3148 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3149 ic->subtitle_codec_id=
3150 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3151 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3152 ic->flags |= AVFMT_FLAG_NONBLOCK;
3154 if(pgmyuv_compatibility_hack)
3155 ic->video_codec_id= CODEC_ID_PGMYUV;
3157 /* open the input file with generic libav function */
3158 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3160 print_error(filename, err);
3166 for(i=0; i<ic->nb_streams; i++){
3167 ic->streams[i]->discard= AVDISCARD_ALL;
3169 for(i=0; i<ic->nb_programs; i++){
3170 AVProgram *p= ic->programs[i];
3171 if(p->id != opt_programid){
3172 p->discard = AVDISCARD_ALL;
3175 for(j=0; j<p->nb_stream_indexes; j++){
3176 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3181 fprintf(stderr, "Specified program id not found\n");
3187 ic->loop_input = loop_input;
3189 /* If not enough info to get the stream parameters, we decode the
3190 first frames to get it. (used in mpeg case for example) */
3191 ret = av_find_stream_info(ic);
3192 if (ret < 0 && verbose >= 0) {
3193 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3197 timestamp = start_time;
3198 /* add the stream start time */
3199 if (ic->start_time != AV_NOPTS_VALUE)
3200 timestamp += ic->start_time;
3202 /* if seeking requested, we execute it */
3203 if (start_time != 0) {
3204 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3206 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3207 filename, (double)timestamp / AV_TIME_BASE);
3209 /* reset seek info */
3213 /* update the current parameters so that they match the one of the input stream */
3214 for(i=0;i<ic->nb_streams;i++) {
3215 AVStream *st = ic->streams[i];
3216 AVCodecContext *enc = st->codec;
3217 avcodec_thread_init(enc, thread_count);
3218 switch(enc->codec_type) {
3219 case AVMEDIA_TYPE_AUDIO:
3220 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3221 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3222 channel_layout = enc->channel_layout;
3223 audio_channels = enc->channels;
3224 audio_sample_rate = enc->sample_rate;
3225 audio_sample_fmt = enc->sample_fmt;
3226 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3228 st->discard= AVDISCARD_ALL;
3230 case AVMEDIA_TYPE_VIDEO:
3231 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3232 frame_height = enc->height;
3233 frame_width = enc->width;
3234 if(ic->streams[i]->sample_aspect_ratio.num)
3235 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3237 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
3238 frame_aspect_ratio *= (float) enc->width / enc->height;
3239 frame_pix_fmt = enc->pix_fmt;
3240 rfps = ic->streams[i]->r_frame_rate.num;
3241 rfps_base = ic->streams[i]->r_frame_rate.den;
3243 enc->flags |= CODEC_FLAG_EMU_EDGE;
3244 frame_height >>= enc->lowres;
3245 frame_width >>= enc->lowres;
3248 enc->debug |= FF_DEBUG_MV;
3250 if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {
3253 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3254 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3256 (float)rfps / rfps_base, rfps, rfps_base);
3258 /* update the current frame rate to match the stream frame rate */
3259 frame_rate.num = rfps;
3260 frame_rate.den = rfps_base;
3262 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3264 st->discard= AVDISCARD_ALL;
3265 else if(video_discard)
3266 st->discard= video_discard;
3268 case AVMEDIA_TYPE_DATA:
3270 case AVMEDIA_TYPE_SUBTITLE:
3271 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3272 if(subtitle_disable)
3273 st->discard = AVDISCARD_ALL;
3275 case AVMEDIA_TYPE_ATTACHMENT:
3276 case AVMEDIA_TYPE_UNKNOWN:
3284 input_files[nb_input_files] = ic;
3285 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3286 /* dump the file content */
3288 dump_format(ic, nb_input_files, filename, 0);
3294 av_freep(&video_codec_name);
3295 av_freep(&audio_codec_name);
3296 av_freep(&subtitle_codec_name);
3299 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3300 int *has_subtitle_ptr)
3302 int has_video, has_audio, has_subtitle, i, j;
3303 AVFormatContext *ic;
3308 for(j=0;j<nb_input_files;j++) {
3309 ic = input_files[j];
3310 for(i=0;i<ic->nb_streams;i++) {
3311 AVCodecContext *enc = ic->streams[i]->codec;
3312 switch(enc->codec_type) {
3313 case AVMEDIA_TYPE_AUDIO:
3316 case AVMEDIA_TYPE_VIDEO:
3319 case AVMEDIA_TYPE_SUBTITLE:
3322 case AVMEDIA_TYPE_DATA:
3323 case AVMEDIA_TYPE_ATTACHMENT:
3324 case AVMEDIA_TYPE_UNKNOWN:
3331 *has_video_ptr = has_video;
3332 *has_audio_ptr = has_audio;
3333 *has_subtitle_ptr = has_subtitle;
3336 static void new_video_stream(AVFormatContext *oc)
3339 AVCodecContext *video_enc;
3340 enum CodecID codec_id;
3342 st = av_new_stream(oc, oc->nb_streams);
3344 fprintf(stderr, "Could not alloc stream\n");
3347 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3348 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3349 video_bitstream_filters= NULL;
3351 avcodec_thread_init(st->codec, thread_count);
3353 video_enc = st->codec;
3356 video_enc->codec_tag= video_codec_tag;
3358 if( (video_global_header&1)
3359 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3360 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3361 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3363 if(video_global_header&2){
3364 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3365 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3368 if (video_stream_copy) {
3369 st->stream_copy = 1;
3370 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3371 video_enc->sample_aspect_ratio =
3372 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3377 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3379 if (video_codec_name) {
3380 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3381 video_enc->strict_std_compliance);
3382 codec = avcodec_find_encoder_by_name(video_codec_name);
3383 output_codecs[nb_ocodecs] = codec;
3385 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3386 codec = avcodec_find_encoder(codec_id);
3389 video_enc->codec_id = codec_id;
3391 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3393 if (codec && codec->supported_framerates && !force_fps)
3394 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3395 video_enc->time_base.den = fps.num;
3396 video_enc->time_base.num = fps.den;
3398 video_enc->width = frame_width;
3399 video_enc->height = frame_height;
3400 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3401 video_enc->pix_fmt = frame_pix_fmt;
3402 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3404 choose_pixel_fmt(st, codec);
3407 video_enc->gop_size = 0;
3408 if (video_qscale || same_quality) {
3409 video_enc->flags |= CODEC_FLAG_QSCALE;
3410 video_enc->global_quality=
3411 st->quality = FF_QP2LAMBDA * video_qscale;
3415 video_enc->intra_matrix = intra_matrix;
3417 video_enc->inter_matrix = inter_matrix;
3419 p= video_rc_override_string;
3422 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3424 fprintf(stderr, "error parsing rc_override\n");
3427 video_enc->rc_override=
3428 av_realloc(video_enc->rc_override,
3429 sizeof(RcOverride)*(i+1));
3430 video_enc->rc_override[i].start_frame= start;
3431 video_enc->rc_override[i].end_frame = end;
3433 video_enc->rc_override[i].qscale= q;
3434 video_enc->rc_override[i].quality_factor= 1.0;
3437 video_enc->rc_override[i].qscale= 0;
3438 video_enc->rc_override[i].quality_factor= -q/100.0;
3443 video_enc->rc_override_count=i;
3444 if (!video_enc->rc_initial_buffer_occupancy)
3445 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3446 video_enc->me_threshold= me_threshold;
3447 video_enc->intra_dc_precision= intra_dc_precision - 8;
3450 video_enc->flags|= CODEC_FLAG_PSNR;
3455 video_enc->flags |= CODEC_FLAG_PASS1;
3457 video_enc->flags |= CODEC_FLAG_PASS2;
3462 if (video_language) {
3463 av_metadata_set2(&st->metadata, "language", video_language, 0);
3464 av_freep(&video_language);
3467 /* reset some key parameters */
3469 av_freep(&video_codec_name);
3470 video_stream_copy = 0;
3471 frame_pix_fmt = PIX_FMT_NONE;
3474 static void new_audio_stream(AVFormatContext *oc)
3477 AVCodecContext *audio_enc;
3478 enum CodecID codec_id;
3480 st = av_new_stream(oc, oc->nb_streams);
3482 fprintf(stderr, "Could not alloc stream\n");
3485 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3487 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3488 audio_bitstream_filters= NULL;
3490 avcodec_thread_init(st->codec, thread_count);
3492 audio_enc = st->codec;
3493 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3496 audio_enc->codec_tag= audio_codec_tag;
3498 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3499 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3500 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3502 if (audio_stream_copy) {
3503 st->stream_copy = 1;
3504 audio_enc->channels = audio_channels;
3505 audio_enc->sample_rate = audio_sample_rate;
3509 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3511 if (audio_codec_name) {
3512 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3513 audio_enc->strict_std_compliance);
3514 codec = avcodec_find_encoder_by_name(audio_codec_name);
3515 output_codecs[nb_ocodecs] = codec;
3517 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3518 codec = avcodec_find_encoder(codec_id);
3520 audio_enc->codec_id = codec_id;
3522 if (audio_qscale > QSCALE_NONE) {
3523 audio_enc->flags |= CODEC_FLAG_QSCALE;
3524 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3526 audio_enc->channels = audio_channels;
3527 audio_enc->sample_fmt = audio_sample_fmt;
3528 audio_enc->sample_rate = audio_sample_rate;
3529 audio_enc->channel_layout = channel_layout;
3530 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3531 audio_enc->channel_layout = 0;
3532 choose_sample_fmt(st, codec);
3533 choose_sample_rate(st, codec);
3536 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3537 if (audio_language) {
3538 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3539 av_freep(&audio_language);
3542 /* reset some key parameters */
3544 av_freep(&audio_codec_name);
3545 audio_stream_copy = 0;
3548 static void new_subtitle_stream(AVFormatContext *oc)
3551 AVCodecContext *subtitle_enc;
3553 st = av_new_stream(oc, oc->nb_streams);
3555 fprintf(stderr, "Could not alloc stream\n");
3558 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3560 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3561 subtitle_bitstream_filters= NULL;
3563 subtitle_enc = st->codec;
3564 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3566 if(subtitle_codec_tag)
3567 subtitle_enc->codec_tag= subtitle_codec_tag;
3569 if (subtitle_stream_copy) {
3570 st->stream_copy = 1;
3572 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3573 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3574 subtitle_enc->strict_std_compliance);
3575 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3579 if (subtitle_language) {
3580 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3581 av_freep(&subtitle_language);
3584 subtitle_disable = 0;
3585 av_freep(&subtitle_codec_name);
3586 subtitle_stream_copy = 0;
3589 static void opt_new_audio_stream(void)
3591 AVFormatContext *oc;
3592 if (nb_output_files <= 0) {
3593 fprintf(stderr, "At least one output file must be specified\n");
3596 oc = output_files[nb_output_files - 1];
3597 new_audio_stream(oc);
3600 static void opt_new_video_stream(void)
3602 AVFormatContext *oc;
3603 if (nb_output_files <= 0) {
3604 fprintf(stderr, "At least one output file must be specified\n");
3607 oc = output_files[nb_output_files - 1];
3608 new_video_stream(oc);
3611 static void opt_new_subtitle_stream(void)
3613 AVFormatContext *oc;
3614 if (nb_output_files <= 0) {
3615 fprintf(stderr, "At least one output file must be specified\n");
3618 oc = output_files[nb_output_files - 1];
3619 new_subtitle_stream(oc);
3622 static void opt_output_file(const char *filename)
3624 AVFormatContext *oc;
3625 int err, use_video, use_audio, use_subtitle;
3626 int input_has_video, input_has_audio, input_has_subtitle;
3627 AVFormatParameters params, *ap = ¶ms;
3628 AVOutputFormat *file_oformat;
3630 if (!strcmp(filename, "-"))
3633 oc = avformat_alloc_context();
3635 print_error(filename, AVERROR(ENOMEM));
3639 if (last_asked_format) {
3640 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3641 if (!file_oformat) {
3642 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3645 last_asked_format = NULL;
3647 file_oformat = av_guess_format(NULL, filename, NULL);
3648 if (!file_oformat) {
3649 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3655 oc->oformat = file_oformat;
3656 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3658 if (!strcmp(file_oformat->name, "ffm") &&
3659 av_strstart(filename, "http:", NULL)) {
3660 /* special case for files sent to ffserver: we get the stream
3661 parameters from ffserver */
3662 int err = read_ffserver_streams(oc, filename);
3664 print_error(filename, err);
3668 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3669 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3670 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3672 /* disable if no corresponding type found and at least one
3674 if (nb_input_files > 0) {
3675 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3676 &input_has_subtitle);
3677 if (!input_has_video)
3679 if (!input_has_audio)
3681 if (!input_has_subtitle)
3685 /* manual disable */
3686 if (audio_disable) {
3689 if (video_disable) {
3692 if (subtitle_disable) {
3697 new_video_stream(oc);
3701 new_audio_stream(oc);
3705 new_subtitle_stream(oc);
3708 oc->timestamp = rec_timestamp;
3710 for(; metadata_count>0; metadata_count--){
3711 av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3712 metadata[metadata_count-1].value, 0);
3714 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3717 output_files[nb_output_files++] = oc;
3719 /* check filename in case of an image number is expected */
3720 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3721 if (!av_filename_number_test(oc->filename)) {
3722 print_error(oc->filename, AVERROR_NUMEXPECTED);
3727 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3728 /* test if it already exists to avoid loosing precious files */
3729 if (!file_overwrite &&
3730 (strchr(filename, ':') == NULL ||
3731 filename[1] == ':' ||
3732 av_strstart(filename, "file:", NULL))) {
3733 if (url_exist(filename)) {
3735 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3737 if (!read_yesno()) {
3738 fprintf(stderr, "Not overwriting - exiting\n");
3743 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3750 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3751 print_error(filename, err);
3756 memset(ap, 0, sizeof(*ap));
3757 if (av_set_parameters(oc, ap) < 0) {
3758 fprintf(stderr, "%s: Invalid encoding parameters\n",
3763 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3764 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3765 oc->loop_output = loop_output;
3766 oc->flags |= AVFMT_FLAG_NONBLOCK;
3768 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3771 /* same option as mencoder */
3772 static void opt_pass(const char *pass_str)
3775 pass = atoi(pass_str);
3776 if (pass != 1 && pass != 2) {
3777 fprintf(stderr, "pass number can be only 1 or 2\n");
3783 static int64_t getutime(void)
3786 struct rusage rusage;
3788 getrusage(RUSAGE_SELF, &rusage);
3789 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3790 #elif HAVE_GETPROCESSTIMES
3792 FILETIME c, e, k, u;
3793 proc = GetCurrentProcess();
3794 GetProcessTimes(proc, &c, &e, &k, &u);
3795 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3797 return av_gettime();
3801 static int64_t getmaxrss(void)
3803 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3804 struct rusage rusage;
3805 getrusage(RUSAGE_SELF, &rusage);
3806 return (int64_t)rusage.ru_maxrss * 1024;
3807 #elif HAVE_GETPROCESSMEMORYINFO
3809 PROCESS_MEMORY_COUNTERS memcounters;
3810 proc = GetCurrentProcess();
3811 memcounters.cb = sizeof(memcounters);
3812 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3813 return memcounters.PeakPagefileUsage;
3819 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3822 const char *p = str;
3829 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3836 static void opt_inter_matrix(const char *arg)
3838 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3839 parse_matrix_coeffs(inter_matrix, arg);
3842 static void opt_intra_matrix(const char *arg)
3844 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3845 parse_matrix_coeffs(intra_matrix, arg);
3849 * Trivial log callback.
3850 * Only suitable for show_help and similar since it lacks prefix handling.
3852 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3854 vfprintf(stdout, fmt, vl);
3857 static void show_usage(void)
3859 printf("Hyper fast Audio and Video encoder\n");
3860 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3864 static void show_help(void)
3866 av_log_set_callback(log_callback_help);
3868 show_help_options(options, "Main options:\n",
3869 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3870 show_help_options(options, "\nAdvanced options:\n",
3871 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3873 show_help_options(options, "\nVideo options:\n",
3874 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3876 show_help_options(options, "\nAdvanced Video options:\n",
3877 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3878 OPT_VIDEO | OPT_EXPERT);
3879 show_help_options(options, "\nAudio options:\n",
3880 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3882 show_help_options(options, "\nAdvanced Audio options:\n",
3883 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3884 OPT_AUDIO | OPT_EXPERT);
3885 show_help_options(options, "\nSubtitle options:\n",
3886 OPT_SUBTITLE | OPT_GRAB,
3888 show_help_options(options, "\nAudio/Video grab options:\n",
3892 av_opt_show(avcodec_opts[0], NULL);
3894 av_opt_show(avformat_opts, NULL);
3896 av_opt_show(sws_opts, NULL);
3899 static void opt_target(const char *arg)
3901 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3902 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3904 if(!strncmp(arg, "pal-", 4)) {
3907 } else if(!strncmp(arg, "ntsc-", 5)) {
3910 } else if(!strncmp(arg, "film-", 5)) {
3915 /* Calculate FR via float to avoid int overflow */
3916 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3919 } else if((fr == 29970) || (fr == 23976)) {
3922 /* Try to determine PAL/NTSC by peeking in the input files */
3923 if(nb_input_files) {
3925 for(j = 0; j < nb_input_files; j++) {
3926 for(i = 0; i < input_files[j]->nb_streams; i++) {
3927 AVCodecContext *c = input_files[j]->streams[i]->codec;
3928 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3930 fr = c->time_base.den * 1000 / c->time_base.num;
3934 } else if((fr == 29970) || (fr == 23976)) {
3944 if(verbose && norm != UNKNOWN)
3945 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3948 if(norm == UNKNOWN) {
3949 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3950 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3951 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3955 if(!strcmp(arg, "vcd")) {
3957 opt_video_codec("mpeg1video");
3958 opt_audio_codec("mp2");
3961 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3962 opt_frame_rate(NULL, frame_rates[norm]);
3963 opt_default("g", norm == PAL ? "15" : "18");
3965 opt_default("b", "1150000");
3966 opt_default("maxrate", "1150000");
3967 opt_default("minrate", "1150000");
3968 opt_default("bufsize", "327680"); // 40*1024*8;
3970 opt_default("ab", "224000");
3971 audio_sample_rate = 44100;
3974 opt_default("packetsize", "2324");
3975 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3977 /* We have to offset the PTS, so that it is consistent with the SCR.
3978 SCR starts at 36000, but the first two packs contain only padding
3979 and the first pack from the other stream, respectively, may also have
3980 been written before.
3981 So the real data starts at SCR 36000+3*1200. */
3982 mux_preload= (36000+3*1200) / 90000.0; //0.44
3983 } else if(!strcmp(arg, "svcd")) {
3985 opt_video_codec("mpeg2video");
3986 opt_audio_codec("mp2");
3989 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3990 opt_frame_rate(NULL, frame_rates[norm]);
3991 opt_default("g", norm == PAL ? "15" : "18");
3993 opt_default("b", "2040000");
3994 opt_default("maxrate", "2516000");
3995 opt_default("minrate", "0"); //1145000;
3996 opt_default("bufsize", "1835008"); //224*1024*8;
3997 opt_default("flags", "+scan_offset");
4000 opt_default("ab", "224000");
4001 audio_sample_rate = 44100;
4003 opt_default("packetsize", "2324");
4005 } else if(!strcmp(arg, "dvd")) {
4007 opt_video_codec("mpeg2video");
4008 opt_audio_codec("ac3");
4011 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4012 opt_frame_rate(NULL, frame_rates[norm]);
4013 opt_default("g", norm == PAL ? "15" : "18");
4015 opt_default("b", "6000000");
4016 opt_default("maxrate", "9000000");
4017 opt_default("minrate", "0"); //1500000;
4018 opt_default("bufsize", "1835008"); //224*1024*8;
4020 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4021 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4023 opt_default("ab", "448000");
4024 audio_sample_rate = 48000;
4026 } else if(!strncmp(arg, "dv", 2)) {
4030 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4031 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4032 (norm == PAL ? "yuv420p" : "yuv411p"));
4033 opt_frame_rate(NULL, frame_rates[norm]);
4035 audio_sample_rate = 48000;
4039 fprintf(stderr, "Unknown target: %s\n", arg);
4044 static void opt_vstats_file (const char *arg)
4046 av_free (vstats_filename);
4047 vstats_filename=av_strdup (arg);
4050 static void opt_vstats (void)
4053 time_t today2 = time(NULL);
4054 struct tm *today = localtime(&today2);
4056 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4058 opt_vstats_file(filename);
4061 static int opt_bsf(const char *opt, const char *arg)
4063 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4064 AVBitStreamFilterContext **bsfp;
4067 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4071 bsfp= *opt == 'v' ? &video_bitstream_filters :
4072 *opt == 'a' ? &audio_bitstream_filters :
4073 &subtitle_bitstream_filters;
4075 bsfp= &(*bsfp)->next;
4082 static int opt_preset(const char *opt, const char *arg)
4085 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4087 const char *base[3]= { getenv("FFMPEG_DATADIR"),
4093 for(i=0; i<3 && !f; i++){
4096 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4097 f= fopen(filename, "r");
4099 char *codec_name= *opt == 'v' ? video_codec_name :
4100 *opt == 'a' ? audio_codec_name :
4101 subtitle_codec_name;
4102 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4103 f= fopen(filename, "r");
4107 av_strlcpy(filename, arg, sizeof(filename));
4108 f= fopen(filename, "r");
4112 fprintf(stderr, "File for preset '%s' not found\n", arg);
4117 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4118 if(line[0] == '#' && !e)
4120 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4122 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4125 if(!strcmp(tmp, "acodec")){
4126 opt_audio_codec(tmp2);
4127 }else if(!strcmp(tmp, "vcodec")){
4128 opt_video_codec(tmp2);
4129 }else if(!strcmp(tmp, "scodec")){
4130 opt_subtitle_codec(tmp2);
4131 }else if(opt_default(tmp, tmp2) < 0){
4132 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4142 static const OptionDef options[] = {
4144 #include "cmdutils_common_opts.h"
4145 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4146 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4147 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4148 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4149 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4150 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4151 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4152 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4153 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4154 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4155 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
4156 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4157 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4158 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4159 "add timings for benchmarking" },
4160 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4161 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4162 "dump each input packet" },
4163 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4164 "when dumping packets, also dump the payload" },
4165 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4166 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4167 { "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)", "" },
4168 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4169 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4170 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4171 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4172 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4173 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4174 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4175 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4176 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4177 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4178 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4179 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4180 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4183 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4184 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4185 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4186 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4187 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4188 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4189 { "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" },
4190 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4191 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4192 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4193 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4194 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set top pad band size (in pixels)", "size" },
4195 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set bottom pad band size (in pixels)", "size" },
4196 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set left pad band size (in pixels)", "size" },
4197 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set right pad band size (in pixels)", "size" },
4198 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4199 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4200 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4201 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4202 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4203 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4204 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4205 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4206 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4207 "use same video quality as source (implies VBR)" },
4208 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4209 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4210 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4211 "deinterlace pictures" },
4212 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4213 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4214 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4216 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4218 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4219 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4220 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4221 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4222 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4223 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4224 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4225 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4226 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4229 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4230 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4231 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4232 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4233 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4234 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4235 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4236 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4237 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4238 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4239 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4240 { "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" },
4242 /* subtitle options */
4243 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4244 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4245 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4246 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4247 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4250 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4251 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4252 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4255 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4256 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4258 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4259 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4260 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4262 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4263 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4264 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4265 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4267 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4271 int main(int argc, char **argv)
4276 avcodec_register_all();
4278 avdevice_register_all();
4281 avfilter_register_all();
4286 if(isatty(STDIN_FILENO))
4287 url_set_interrupt_cb(decode_interrupt_cb);
4290 for(i=0; i<AVMEDIA_TYPE_NB; i++){
4291 avcodec_opts[i]= avcodec_alloc_context2(i);
4293 avformat_opts = avformat_alloc_context();
4294 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4299 parse_options(argc, argv, options, opt_output_file);
4301 if(nb_output_files <= 0 && nb_input_files == 0) {
4303 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4307 /* file converter / grab */
4308 if (nb_output_files <= 0) {
4309 fprintf(stderr, "At least one output file must be specified\n");
4313 if (nb_input_files == 0) {
4314 fprintf(stderr, "At least one input file must be specified\n");
4319 if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4320 stream_maps, nb_stream_maps) < 0)
4322 ti = getutime() - ti;
4324 int maxrss = getmaxrss() / 1024;
4325 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);