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)
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);
3092 static void opt_input_file(const char *filename)
3094 AVFormatContext *ic;
3095 AVFormatParameters params, *ap = ¶ms;
3096 AVInputFormat *file_iformat = NULL;
3097 int err, i, ret, rfps, rfps_base;
3100 if (last_asked_format) {
3101 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3102 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3105 last_asked_format = NULL;
3108 if (!strcmp(filename, "-"))
3111 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3112 !strcmp(filename, "/dev/stdin");
3114 /* get default parameters from command line */
3115 ic = avformat_alloc_context();
3117 print_error(filename, AVERROR(ENOMEM));
3121 memset(ap, 0, sizeof(*ap));
3122 ap->prealloced_context = 1;
3123 ap->sample_rate = audio_sample_rate;
3124 ap->channels = audio_channels;
3125 ap->time_base.den = frame_rate.num;
3126 ap->time_base.num = frame_rate.den;
3127 ap->width = frame_width;
3128 ap->height = frame_height;
3129 ap->pix_fmt = frame_pix_fmt;
3130 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3131 ap->channel = video_channel;
3132 ap->standard = video_standard;
3134 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3136 ic->video_codec_id = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3137 ic->audio_codec_id = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3138 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3139 ic->flags |= AVFMT_FLAG_NONBLOCK;
3141 if(pgmyuv_compatibility_hack)
3142 ic->video_codec_id= CODEC_ID_PGMYUV;
3144 /* open the input file with generic libav function */
3145 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3147 print_error(filename, err);
3153 for(i=0; i<ic->nb_streams; i++){
3154 ic->streams[i]->discard= AVDISCARD_ALL;
3156 for(i=0; i<ic->nb_programs; i++){
3157 AVProgram *p= ic->programs[i];
3158 if(p->id != opt_programid){
3159 p->discard = AVDISCARD_ALL;
3162 for(j=0; j<p->nb_stream_indexes; j++){
3163 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3168 fprintf(stderr, "Specified program id not found\n");
3174 ic->loop_input = loop_input;
3176 /* If not enough info to get the stream parameters, we decode the
3177 first frames to get it. (used in mpeg case for example) */
3178 ret = av_find_stream_info(ic);
3179 if (ret < 0 && verbose >= 0) {
3180 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3184 timestamp = start_time;
3185 /* add the stream start time */
3186 if (ic->start_time != AV_NOPTS_VALUE)
3187 timestamp += ic->start_time;
3189 /* if seeking requested, we execute it */
3190 if (start_time != 0) {
3191 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3193 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3194 filename, (double)timestamp / AV_TIME_BASE);
3196 /* reset seek info */
3200 /* update the current parameters so that they match the one of the input stream */
3201 for(i=0;i<ic->nb_streams;i++) {
3202 AVStream *st = ic->streams[i];
3203 AVCodecContext *enc = st->codec;
3204 avcodec_thread_init(enc, thread_count);
3205 switch(enc->codec_type) {
3206 case AVMEDIA_TYPE_AUDIO:
3207 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3208 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3209 channel_layout = enc->channel_layout;
3210 audio_channels = enc->channels;
3211 audio_sample_rate = enc->sample_rate;
3212 audio_sample_fmt = enc->sample_fmt;
3213 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3215 st->discard= AVDISCARD_ALL;
3217 case AVMEDIA_TYPE_VIDEO:
3218 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3219 frame_height = enc->height;
3220 frame_width = enc->width;
3221 if(ic->streams[i]->sample_aspect_ratio.num)
3222 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3224 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
3225 frame_aspect_ratio *= (float) enc->width / enc->height;
3226 frame_pix_fmt = enc->pix_fmt;
3227 rfps = ic->streams[i]->r_frame_rate.num;
3228 rfps_base = ic->streams[i]->r_frame_rate.den;
3230 enc->flags |= CODEC_FLAG_EMU_EDGE;
3231 frame_height >>= enc->lowres;
3232 frame_width >>= enc->lowres;
3235 enc->debug |= FF_DEBUG_MV;
3237 if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {
3240 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3241 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3243 (float)rfps / rfps_base, rfps, rfps_base);
3245 /* update the current frame rate to match the stream frame rate */
3246 frame_rate.num = rfps;
3247 frame_rate.den = rfps_base;
3249 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3251 st->discard= AVDISCARD_ALL;
3252 else if(video_discard)
3253 st->discard= video_discard;
3255 case AVMEDIA_TYPE_DATA:
3257 case AVMEDIA_TYPE_SUBTITLE:
3258 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3259 if(subtitle_disable)
3260 st->discard = AVDISCARD_ALL;
3262 case AVMEDIA_TYPE_ATTACHMENT:
3263 case AVMEDIA_TYPE_UNKNOWN:
3271 input_files[nb_input_files] = ic;
3272 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3273 /* dump the file content */
3275 dump_format(ic, nb_input_files, filename, 0);
3281 av_freep(&video_codec_name);
3282 av_freep(&audio_codec_name);
3283 av_freep(&subtitle_codec_name);
3286 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3287 int *has_subtitle_ptr)
3289 int has_video, has_audio, has_subtitle, i, j;
3290 AVFormatContext *ic;
3295 for(j=0;j<nb_input_files;j++) {
3296 ic = input_files[j];
3297 for(i=0;i<ic->nb_streams;i++) {
3298 AVCodecContext *enc = ic->streams[i]->codec;
3299 switch(enc->codec_type) {
3300 case AVMEDIA_TYPE_AUDIO:
3303 case AVMEDIA_TYPE_VIDEO:
3306 case AVMEDIA_TYPE_SUBTITLE:
3309 case AVMEDIA_TYPE_DATA:
3310 case AVMEDIA_TYPE_ATTACHMENT:
3311 case AVMEDIA_TYPE_UNKNOWN:
3318 *has_video_ptr = has_video;
3319 *has_audio_ptr = has_audio;
3320 *has_subtitle_ptr = has_subtitle;
3323 static void new_video_stream(AVFormatContext *oc)
3326 AVCodecContext *video_enc;
3327 enum CodecID codec_id;
3329 st = av_new_stream(oc, oc->nb_streams);
3331 fprintf(stderr, "Could not alloc stream\n");
3334 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3335 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3336 video_bitstream_filters= NULL;
3338 avcodec_thread_init(st->codec, thread_count);
3340 video_enc = st->codec;
3343 video_enc->codec_tag= video_codec_tag;
3345 if( (video_global_header&1)
3346 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3347 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3348 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3350 if(video_global_header&2){
3351 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3352 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3355 if (video_stream_copy) {
3356 st->stream_copy = 1;
3357 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3358 video_enc->sample_aspect_ratio =
3359 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3364 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3366 if (video_codec_name) {
3367 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3368 codec = avcodec_find_encoder_by_name(video_codec_name);
3369 output_codecs[nb_ocodecs] = codec;
3371 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3372 codec = avcodec_find_encoder(codec_id);
3375 video_enc->codec_id = codec_id;
3377 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3379 if (codec && codec->supported_framerates && !force_fps)
3380 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3381 video_enc->time_base.den = fps.num;
3382 video_enc->time_base.num = fps.den;
3384 video_enc->width = frame_width;
3385 video_enc->height = frame_height;
3386 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3387 video_enc->pix_fmt = frame_pix_fmt;
3388 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3390 choose_pixel_fmt(st, codec);
3393 video_enc->gop_size = 0;
3394 if (video_qscale || same_quality) {
3395 video_enc->flags |= CODEC_FLAG_QSCALE;
3396 video_enc->global_quality=
3397 st->quality = FF_QP2LAMBDA * video_qscale;
3401 video_enc->intra_matrix = intra_matrix;
3403 video_enc->inter_matrix = inter_matrix;
3405 p= video_rc_override_string;
3408 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3410 fprintf(stderr, "error parsing rc_override\n");
3413 video_enc->rc_override=
3414 av_realloc(video_enc->rc_override,
3415 sizeof(RcOverride)*(i+1));
3416 video_enc->rc_override[i].start_frame= start;
3417 video_enc->rc_override[i].end_frame = end;
3419 video_enc->rc_override[i].qscale= q;
3420 video_enc->rc_override[i].quality_factor= 1.0;
3423 video_enc->rc_override[i].qscale= 0;
3424 video_enc->rc_override[i].quality_factor= -q/100.0;
3429 video_enc->rc_override_count=i;
3430 if (!video_enc->rc_initial_buffer_occupancy)
3431 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3432 video_enc->me_threshold= me_threshold;
3433 video_enc->intra_dc_precision= intra_dc_precision - 8;
3436 video_enc->flags|= CODEC_FLAG_PSNR;
3441 video_enc->flags |= CODEC_FLAG_PASS1;
3443 video_enc->flags |= CODEC_FLAG_PASS2;
3448 if (video_language) {
3449 av_metadata_set2(&st->metadata, "language", video_language, 0);
3450 av_freep(&video_language);
3453 /* reset some key parameters */
3455 av_freep(&video_codec_name);
3456 video_stream_copy = 0;
3457 frame_pix_fmt = PIX_FMT_NONE;
3460 static void new_audio_stream(AVFormatContext *oc)
3463 AVCodecContext *audio_enc;
3464 enum CodecID codec_id;
3466 st = av_new_stream(oc, oc->nb_streams);
3468 fprintf(stderr, "Could not alloc stream\n");
3471 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3473 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3474 audio_bitstream_filters= NULL;
3476 avcodec_thread_init(st->codec, thread_count);
3478 audio_enc = st->codec;
3479 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3482 audio_enc->codec_tag= audio_codec_tag;
3484 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3485 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3486 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3488 if (audio_stream_copy) {
3489 st->stream_copy = 1;
3490 audio_enc->channels = audio_channels;
3491 audio_enc->sample_rate = audio_sample_rate;
3495 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3497 if (audio_codec_name) {
3498 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3499 codec = avcodec_find_encoder_by_name(audio_codec_name);
3500 output_codecs[nb_ocodecs] = codec;
3502 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3503 codec = avcodec_find_encoder(codec_id);
3505 audio_enc->codec_id = codec_id;
3507 if (audio_qscale > QSCALE_NONE) {
3508 audio_enc->flags |= CODEC_FLAG_QSCALE;
3509 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3511 audio_enc->channels = audio_channels;
3512 audio_enc->sample_fmt = audio_sample_fmt;
3513 audio_enc->sample_rate = audio_sample_rate;
3514 audio_enc->channel_layout = channel_layout;
3515 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3516 audio_enc->channel_layout = 0;
3517 choose_sample_fmt(st, codec);
3518 choose_sample_rate(st, codec);
3521 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3522 if (audio_language) {
3523 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3524 av_freep(&audio_language);
3527 /* reset some key parameters */
3529 av_freep(&audio_codec_name);
3530 audio_stream_copy = 0;
3533 static void new_subtitle_stream(AVFormatContext *oc)
3536 AVCodecContext *subtitle_enc;
3538 st = av_new_stream(oc, oc->nb_streams);
3540 fprintf(stderr, "Could not alloc stream\n");
3543 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3545 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3546 subtitle_bitstream_filters= NULL;
3548 subtitle_enc = st->codec;
3549 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3551 if(subtitle_codec_tag)
3552 subtitle_enc->codec_tag= subtitle_codec_tag;
3554 if (subtitle_stream_copy) {
3555 st->stream_copy = 1;
3557 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3558 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3559 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3563 if (subtitle_language) {
3564 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3565 av_freep(&subtitle_language);
3568 subtitle_disable = 0;
3569 av_freep(&subtitle_codec_name);
3570 subtitle_stream_copy = 0;
3573 static void opt_new_audio_stream(void)
3575 AVFormatContext *oc;
3576 if (nb_output_files <= 0) {
3577 fprintf(stderr, "At least one output file must be specified\n");
3580 oc = output_files[nb_output_files - 1];
3581 new_audio_stream(oc);
3584 static void opt_new_video_stream(void)
3586 AVFormatContext *oc;
3587 if (nb_output_files <= 0) {
3588 fprintf(stderr, "At least one output file must be specified\n");
3591 oc = output_files[nb_output_files - 1];
3592 new_video_stream(oc);
3595 static void opt_new_subtitle_stream(void)
3597 AVFormatContext *oc;
3598 if (nb_output_files <= 0) {
3599 fprintf(stderr, "At least one output file must be specified\n");
3602 oc = output_files[nb_output_files - 1];
3603 new_subtitle_stream(oc);
3606 static void opt_output_file(const char *filename)
3608 AVFormatContext *oc;
3609 int err, use_video, use_audio, use_subtitle;
3610 int input_has_video, input_has_audio, input_has_subtitle;
3611 AVFormatParameters params, *ap = ¶ms;
3612 AVOutputFormat *file_oformat;
3614 if (!strcmp(filename, "-"))
3617 oc = avformat_alloc_context();
3619 print_error(filename, AVERROR(ENOMEM));
3623 if (last_asked_format) {
3624 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3625 if (!file_oformat) {
3626 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3629 last_asked_format = NULL;
3631 file_oformat = av_guess_format(NULL, filename, NULL);
3632 if (!file_oformat) {
3633 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3639 oc->oformat = file_oformat;
3640 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3642 if (!strcmp(file_oformat->name, "ffm") &&
3643 av_strstart(filename, "http:", NULL)) {
3644 /* special case for files sent to ffserver: we get the stream
3645 parameters from ffserver */
3646 int err = read_ffserver_streams(oc, filename);
3648 print_error(filename, err);
3652 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3653 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3654 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3656 /* disable if no corresponding type found and at least one
3658 if (nb_input_files > 0) {
3659 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3660 &input_has_subtitle);
3661 if (!input_has_video)
3663 if (!input_has_audio)
3665 if (!input_has_subtitle)
3669 /* manual disable */
3670 if (audio_disable) {
3673 if (video_disable) {
3676 if (subtitle_disable) {
3681 new_video_stream(oc);
3685 new_audio_stream(oc);
3689 new_subtitle_stream(oc);
3692 oc->timestamp = rec_timestamp;
3694 for(; metadata_count>0; metadata_count--){
3695 av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3696 metadata[metadata_count-1].value, 0);
3698 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3701 output_files[nb_output_files++] = oc;
3703 /* check filename in case of an image number is expected */
3704 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3705 if (!av_filename_number_test(oc->filename)) {
3706 print_error(oc->filename, AVERROR_NUMEXPECTED);
3711 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3712 /* test if it already exists to avoid loosing precious files */
3713 if (!file_overwrite &&
3714 (strchr(filename, ':') == NULL ||
3715 filename[1] == ':' ||
3716 av_strstart(filename, "file:", NULL))) {
3717 if (url_exist(filename)) {
3719 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3721 if (!read_yesno()) {
3722 fprintf(stderr, "Not overwriting - exiting\n");
3727 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3734 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3735 print_error(filename, err);
3740 memset(ap, 0, sizeof(*ap));
3741 if (av_set_parameters(oc, ap) < 0) {
3742 fprintf(stderr, "%s: Invalid encoding parameters\n",
3747 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3748 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3749 oc->loop_output = loop_output;
3750 oc->flags |= AVFMT_FLAG_NONBLOCK;
3752 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3755 /* same option as mencoder */
3756 static void opt_pass(const char *pass_str)
3759 pass = atoi(pass_str);
3760 if (pass != 1 && pass != 2) {
3761 fprintf(stderr, "pass number can be only 1 or 2\n");
3767 static int64_t getutime(void)
3770 struct rusage rusage;
3772 getrusage(RUSAGE_SELF, &rusage);
3773 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3774 #elif HAVE_GETPROCESSTIMES
3776 FILETIME c, e, k, u;
3777 proc = GetCurrentProcess();
3778 GetProcessTimes(proc, &c, &e, &k, &u);
3779 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3781 return av_gettime();
3785 static int64_t getmaxrss(void)
3787 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3788 struct rusage rusage;
3789 getrusage(RUSAGE_SELF, &rusage);
3790 return (int64_t)rusage.ru_maxrss * 1024;
3791 #elif HAVE_GETPROCESSMEMORYINFO
3793 PROCESS_MEMORY_COUNTERS memcounters;
3794 proc = GetCurrentProcess();
3795 memcounters.cb = sizeof(memcounters);
3796 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3797 return memcounters.PeakPagefileUsage;
3803 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3806 const char *p = str;
3813 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3820 static void opt_inter_matrix(const char *arg)
3822 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3823 parse_matrix_coeffs(inter_matrix, arg);
3826 static void opt_intra_matrix(const char *arg)
3828 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3829 parse_matrix_coeffs(intra_matrix, arg);
3833 * Trivial log callback.
3834 * Only suitable for show_help and similar since it lacks prefix handling.
3836 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3838 vfprintf(stdout, fmt, vl);
3841 static void show_usage(void)
3843 printf("Hyper fast Audio and Video encoder\n");
3844 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3848 static void show_help(void)
3850 av_log_set_callback(log_callback_help);
3852 show_help_options(options, "Main options:\n",
3853 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3854 show_help_options(options, "\nAdvanced options:\n",
3855 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3857 show_help_options(options, "\nVideo options:\n",
3858 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3860 show_help_options(options, "\nAdvanced Video options:\n",
3861 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3862 OPT_VIDEO | OPT_EXPERT);
3863 show_help_options(options, "\nAudio options:\n",
3864 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3866 show_help_options(options, "\nAdvanced Audio options:\n",
3867 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3868 OPT_AUDIO | OPT_EXPERT);
3869 show_help_options(options, "\nSubtitle options:\n",
3870 OPT_SUBTITLE | OPT_GRAB,
3872 show_help_options(options, "\nAudio/Video grab options:\n",
3876 av_opt_show(avcodec_opts[0], NULL);
3878 av_opt_show(avformat_opts, NULL);
3880 av_opt_show(sws_opts, NULL);
3883 static void opt_target(const char *arg)
3885 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3886 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3888 if(!strncmp(arg, "pal-", 4)) {
3891 } else if(!strncmp(arg, "ntsc-", 5)) {
3894 } else if(!strncmp(arg, "film-", 5)) {
3899 /* Calculate FR via float to avoid int overflow */
3900 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3903 } else if((fr == 29970) || (fr == 23976)) {
3906 /* Try to determine PAL/NTSC by peeking in the input files */
3907 if(nb_input_files) {
3909 for(j = 0; j < nb_input_files; j++) {
3910 for(i = 0; i < input_files[j]->nb_streams; i++) {
3911 AVCodecContext *c = input_files[j]->streams[i]->codec;
3912 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3914 fr = c->time_base.den * 1000 / c->time_base.num;
3918 } else if((fr == 29970) || (fr == 23976)) {
3928 if(verbose && norm != UNKNOWN)
3929 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3932 if(norm == UNKNOWN) {
3933 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3934 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3935 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3939 if(!strcmp(arg, "vcd")) {
3941 opt_video_codec("mpeg1video");
3942 opt_audio_codec("mp2");
3945 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3946 opt_frame_rate(NULL, frame_rates[norm]);
3947 opt_default("g", norm == PAL ? "15" : "18");
3949 opt_default("b", "1150000");
3950 opt_default("maxrate", "1150000");
3951 opt_default("minrate", "1150000");
3952 opt_default("bufsize", "327680"); // 40*1024*8;
3954 opt_default("ab", "224000");
3955 audio_sample_rate = 44100;
3958 opt_default("packetsize", "2324");
3959 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3961 /* We have to offset the PTS, so that it is consistent with the SCR.
3962 SCR starts at 36000, but the first two packs contain only padding
3963 and the first pack from the other stream, respectively, may also have
3964 been written before.
3965 So the real data starts at SCR 36000+3*1200. */
3966 mux_preload= (36000+3*1200) / 90000.0; //0.44
3967 } else if(!strcmp(arg, "svcd")) {
3969 opt_video_codec("mpeg2video");
3970 opt_audio_codec("mp2");
3973 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3974 opt_frame_rate(NULL, frame_rates[norm]);
3975 opt_default("g", norm == PAL ? "15" : "18");
3977 opt_default("b", "2040000");
3978 opt_default("maxrate", "2516000");
3979 opt_default("minrate", "0"); //1145000;
3980 opt_default("bufsize", "1835008"); //224*1024*8;
3981 opt_default("flags", "+scan_offset");
3984 opt_default("ab", "224000");
3985 audio_sample_rate = 44100;
3987 opt_default("packetsize", "2324");
3989 } else if(!strcmp(arg, "dvd")) {
3991 opt_video_codec("mpeg2video");
3992 opt_audio_codec("ac3");
3995 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3996 opt_frame_rate(NULL, frame_rates[norm]);
3997 opt_default("g", norm == PAL ? "15" : "18");
3999 opt_default("b", "6000000");
4000 opt_default("maxrate", "9000000");
4001 opt_default("minrate", "0"); //1500000;
4002 opt_default("bufsize", "1835008"); //224*1024*8;
4004 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4005 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4007 opt_default("ab", "448000");
4008 audio_sample_rate = 48000;
4010 } else if(!strncmp(arg, "dv", 2)) {
4014 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4015 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4016 (norm == PAL ? "yuv420p" : "yuv411p"));
4017 opt_frame_rate(NULL, frame_rates[norm]);
4019 audio_sample_rate = 48000;
4023 fprintf(stderr, "Unknown target: %s\n", arg);
4028 static void opt_vstats_file (const char *arg)
4030 av_free (vstats_filename);
4031 vstats_filename=av_strdup (arg);
4034 static void opt_vstats (void)
4037 time_t today2 = time(NULL);
4038 struct tm *today = localtime(&today2);
4040 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4042 opt_vstats_file(filename);
4045 static int opt_bsf(const char *opt, const char *arg)
4047 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4048 AVBitStreamFilterContext **bsfp;
4051 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4055 bsfp= *opt == 'v' ? &video_bitstream_filters :
4056 *opt == 'a' ? &audio_bitstream_filters :
4057 &subtitle_bitstream_filters;
4059 bsfp= &(*bsfp)->next;
4066 static int opt_preset(const char *opt, const char *arg)
4069 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4071 const char *base[3]= { getenv("FFMPEG_DATADIR"),
4077 for(i=0; i<3 && !f; i++){
4080 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4081 f= fopen(filename, "r");
4083 char *codec_name= *opt == 'v' ? video_codec_name :
4084 *opt == 'a' ? audio_codec_name :
4085 subtitle_codec_name;
4086 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4087 f= fopen(filename, "r");
4091 av_strlcpy(filename, arg, sizeof(filename));
4092 f= fopen(filename, "r");
4096 fprintf(stderr, "File for preset '%s' not found\n", arg);
4101 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4102 if(line[0] == '#' && !e)
4104 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4106 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4109 if(!strcmp(tmp, "acodec")){
4110 opt_audio_codec(tmp2);
4111 }else if(!strcmp(tmp, "vcodec")){
4112 opt_video_codec(tmp2);
4113 }else if(!strcmp(tmp, "scodec")){
4114 opt_subtitle_codec(tmp2);
4115 }else if(opt_default(tmp, tmp2) < 0){
4116 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4126 static const OptionDef options[] = {
4128 #include "cmdutils_common_opts.h"
4129 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4130 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4131 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4132 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4133 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4134 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4135 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4136 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4137 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4138 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4139 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
4140 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4141 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4142 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4143 "add timings for benchmarking" },
4144 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4145 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4146 "dump each input packet" },
4147 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4148 "when dumping packets, also dump the payload" },
4149 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4150 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4151 { "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)", "" },
4152 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4153 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4154 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4155 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4156 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4157 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4158 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4159 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4160 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4161 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4162 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4163 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4164 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4167 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4168 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4169 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4170 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4171 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4172 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4173 { "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" },
4174 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4175 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4176 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4177 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4178 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set top pad band size (in pixels)", "size" },
4179 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set bottom pad band size (in pixels)", "size" },
4180 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set left pad band size (in pixels)", "size" },
4181 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set right pad band size (in pixels)", "size" },
4182 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4183 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4184 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4185 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4186 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4187 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4188 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4189 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4190 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4191 "use same video quality as source (implies VBR)" },
4192 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4193 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4194 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4195 "deinterlace pictures" },
4196 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4197 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4198 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4200 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4202 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4203 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4204 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4205 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4206 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4207 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4208 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4209 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4210 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4213 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4214 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4215 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4216 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4217 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4218 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4219 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4220 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4221 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4222 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4223 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4224 { "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" },
4226 /* subtitle options */
4227 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4228 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4229 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4230 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4231 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4234 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4235 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4236 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4239 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4240 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4242 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4243 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4244 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4246 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4247 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4248 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4249 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4251 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4255 int main(int argc, char **argv)
4260 avcodec_register_all();
4262 avdevice_register_all();
4265 avfilter_register_all();
4270 if(isatty(STDIN_FILENO))
4271 url_set_interrupt_cb(decode_interrupt_cb);
4274 for(i=0; i<AVMEDIA_TYPE_NB; i++){
4275 avcodec_opts[i]= avcodec_alloc_context2(i);
4277 avformat_opts = avformat_alloc_context();
4278 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4283 parse_options(argc, argv, options, opt_output_file);
4285 if(nb_output_files <= 0 && nb_input_files == 0) {
4287 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4291 /* file converter / grab */
4292 if (nb_output_files <= 0) {
4293 fprintf(stderr, "At least one output file must be specified\n");
4297 if (nb_input_files == 0) {
4298 fprintf(stderr, "At least one input file must be specified\n");
4303 if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4304 stream_maps, nb_stream_maps) < 0)
4306 ti = getutime() - ti;
4308 int maxrss = getmaxrss() / 1024;
4309 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);