3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcore/parseutils.h"
40 #include "libavutil/colorspace.h"
41 #include "libavutil/fifo.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/libm.h"
45 #include "libavformat/os_support.h"
48 # include "libavfilter/avfilter.h"
49 # include "libavfilter/avfiltergraph.h"
50 # include "libavfilter/graphparser.h"
51 # include "libavfilter/vsrc_buffer.h"
54 #if HAVE_SYS_RESOURCE_H
55 #include <sys/types.h>
57 #include <sys/resource.h>
58 #elif HAVE_GETPROCESSTIMES
61 #if HAVE_GETPROCESSMEMORYINFO
67 #include <sys/select.h>
72 #include <sys/ioctl.h>
85 const char program_name[] = "FFmpeg";
86 const int program_birth_year = 2000;
88 /* select an input stream for an output stream */
89 typedef struct AVStreamMap {
93 int sync_stream_index;
96 /** select an input file for an output file */
97 typedef struct AVMetaDataMap {
102 static const OptionDef options[];
104 #define MAX_FILES 100
106 static const char *last_asked_format = NULL;
107 static AVFormatContext *input_files[MAX_FILES];
108 static int64_t input_files_ts_offset[MAX_FILES];
109 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
110 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
111 static int nb_input_files = 0;
112 static int nb_icodecs;
114 static AVFormatContext *output_files[MAX_FILES];
115 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
116 static int nb_output_files = 0;
117 static int nb_ocodecs;
119 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
120 static int nb_stream_maps;
122 static AVMetaDataMap meta_data_maps[MAX_FILES];
123 static int nb_meta_data_maps;
125 /* indexed by output file stream index */
126 static int streamid_map[MAX_STREAMS];
128 static int frame_width = 0;
129 static int frame_height = 0;
130 static float frame_aspect_ratio = 0;
131 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
132 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
133 static int frame_topBand = 0;
134 static int frame_bottomBand = 0;
135 static int frame_leftBand = 0;
136 static int frame_rightBand = 0;
137 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
138 static AVRational frame_rate;
139 static float video_qscale = 0;
140 static uint16_t *intra_matrix = NULL;
141 static uint16_t *inter_matrix = NULL;
142 static const char *video_rc_override_string=NULL;
143 static int video_disable = 0;
144 static int video_discard = 0;
145 static char *video_codec_name = NULL;
146 static unsigned int video_codec_tag = 0;
147 static char *video_language = NULL;
148 static int same_quality = 0;
149 static int do_deinterlace = 0;
150 static int top_field_first = -1;
151 static int me_threshold = 0;
152 static int intra_dc_precision = 8;
153 static int loop_input = 0;
154 static int loop_output = AVFMT_NOOUTPUTLOOP;
155 static int qp_hist = 0;
157 static char *vfilters = NULL;
158 AVFilterGraph *graph = NULL;
161 static int intra_only = 0;
162 static int audio_sample_rate = 44100;
163 static int64_t channel_layout = 0;
164 #define QSCALE_NONE -99999
165 static float audio_qscale = QSCALE_NONE;
166 static int audio_disable = 0;
167 static int audio_channels = 1;
168 static char *audio_codec_name = NULL;
169 static unsigned int audio_codec_tag = 0;
170 static char *audio_language = NULL;
172 static int subtitle_disable = 0;
173 static char *subtitle_codec_name = NULL;
174 static char *subtitle_language = NULL;
175 static unsigned int subtitle_codec_tag = 0;
177 static float mux_preload= 0.5;
178 static float mux_max_delay= 0.7;
180 static int64_t recording_time = INT64_MAX;
181 static int64_t start_time = 0;
182 static int64_t recording_timestamp = 0;
183 static int64_t input_ts_offset = 0;
184 static int file_overwrite = 0;
185 static int metadata_count;
186 static AVMetadataTag *metadata;
187 static int do_benchmark = 0;
188 static int do_hex_dump = 0;
189 static int do_pkt_dump = 0;
190 static int do_psnr = 0;
191 static int do_pass = 0;
192 static char *pass_logfilename_prefix = NULL;
193 static int audio_stream_copy = 0;
194 static int video_stream_copy = 0;
195 static int subtitle_stream_copy = 0;
196 static int video_sync_method= -1;
197 static int audio_sync_method= 0;
198 static float audio_drift_threshold= 0.1;
199 static int copy_ts= 0;
200 static int opt_shortest = 0;
201 static int video_global_header = 0;
202 static char *vstats_filename;
203 static FILE *vstats_file;
204 static int opt_programid = 0;
205 static int copy_initial_nonkeyframes = 0;
207 static int rate_emu = 0;
209 static int video_channel = 0;
210 static char *video_standard;
212 static int audio_volume = 256;
214 static int exit_on_error = 0;
215 static int using_stdin = 0;
216 static int verbose = 1;
217 static int thread_count= 1;
218 static int q_pressed = 0;
219 static int64_t video_size = 0;
220 static int64_t audio_size = 0;
221 static int64_t extra_size = 0;
222 static int nb_frames_dup = 0;
223 static int nb_frames_drop = 0;
224 static int input_sync;
225 static uint64_t limit_filesize = 0;
226 static int force_fps = 0;
228 static int pgmyuv_compatibility_hack=0;
229 static float dts_delta_threshold = 10;
231 static unsigned int sws_flags = SWS_BICUBIC;
233 static int64_t timer_start;
235 static uint8_t *audio_buf;
236 static uint8_t *audio_out;
237 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
239 static short *samples;
241 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
242 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
243 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
244 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
246 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
248 struct AVInputStream;
250 typedef struct AVOutputStream {
251 int file_index; /* file index */
252 int index; /* stream index in the output file */
253 int source_index; /* AVInputStream index */
254 AVStream *st; /* stream in the output file */
255 int encoding_needed; /* true if encoding needed for this stream */
257 /* input pts and corresponding output pts
259 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
260 struct AVInputStream *sync_ist; /* input stream to sync against */
261 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
264 AVFrame pict_tmp; /* temporary image for resampling */
265 struct SwsContext *img_resample_ctx; /* for image resampling */
268 int resample_pix_fmt;
270 /* full frame size of first frame */
274 /* cropping area sizes */
281 /* cropping area of first frame */
282 int original_topBand;
283 int original_bottomBand;
284 int original_leftBand;
285 int original_rightBand;
289 ReSampleContext *resample; /* for audio resampling */
291 AVAudioConvert *reformat_ctx;
292 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
296 typedef struct AVInputStream {
300 int discard; /* true if stream data should be discarded */
301 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
302 int64_t sample_index; /* current sample */
304 int64_t start; /* time when read started */
305 int64_t next_pts; /* synthetic pts for cases where pkt.pts
307 int64_t pts; /* current pts */
308 int is_start; /* is 1 at the start and after a discontinuity */
309 int showed_multi_packet_warning;
310 int is_past_recording_time;
312 AVFilterContext *out_video_filter;
313 AVFilterContext *input_video_filter;
314 AVFrame *filter_frame;
315 int has_filter_frame;
316 AVFilterBufferRef *picref;
320 typedef struct AVInputFile {
321 int eof_reached; /* true if eof reached */
322 int ist_index; /* index of first stream in ist_table */
323 int buffer_size; /* current total buffer size */
324 int nb_streams; /* nb streams we are aware of */
329 /* init terminal so that we can grab keys */
330 static struct termios oldtty;
339 static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
341 FilterOutPriv *priv = ctx->priv;
343 if(!opaque) return -1;
345 priv->pix_fmt = *((int *)opaque);
350 static void output_end_frame(AVFilterLink *link)
354 static int output_query_formats(AVFilterContext *ctx)
356 FilterOutPriv *priv = ctx->priv;
357 enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
359 avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
363 static int get_filtered_video_pic(AVFilterContext *ctx,
364 AVFilterBufferRef **picref, AVFrame *pic2,
367 AVFilterBufferRef *pic;
369 if(avfilter_request_frame(ctx->inputs[0]))
371 if(!(pic = ctx->inputs[0]->cur_buf))
374 ctx->inputs[0]->cur_buf = NULL;
378 memcpy(pic2->data, pic->data, sizeof(pic->data));
379 memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
380 pic2->interlaced_frame = pic->video->interlaced;
381 pic2->top_field_first = pic->video->top_field_first;
386 static AVFilter output_filter =
388 .name = "ffmpeg_output",
390 .priv_size = sizeof(FilterOutPriv),
393 .query_formats = output_query_formats,
395 .inputs = (AVFilterPad[]) {{ .name = "default",
396 .type = AVMEDIA_TYPE_VIDEO,
397 .end_frame = output_end_frame,
398 .min_perms = AV_PERM_READ, },
400 .outputs = (AVFilterPad[]) {{ .name = NULL }},
403 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
405 AVFilterContext *last_filter, *filter;
406 /** filter graph containing all filters including input & output */
407 AVCodecContext *codec = ost->st->codec;
408 AVCodecContext *icodec = ist->st->codec;
411 graph = av_mallocz(sizeof(AVFilterGraph));
413 if (avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src") < 0)
415 if (avfilter_open(&ist->out_video_filter, &output_filter, "out") < 0)
418 snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
419 ist->st->codec->height, ist->st->codec->pix_fmt);
420 if (avfilter_init_filter(ist->input_video_filter, args, NULL))
422 if (avfilter_init_filter(ist->out_video_filter, NULL, &codec->pix_fmt))
425 /* add input and output filters to the overall graph */
426 avfilter_graph_add_filter(graph, ist->input_video_filter);
427 avfilter_graph_add_filter(graph, ist->out_video_filter);
429 last_filter = ist->input_video_filter;
431 if (ost->video_crop) {
432 snprintf(args, 255, "%d:%d:%d:%d", ost->leftBand, ost->topBand,
435 avfilter_open(&filter, avfilter_get_by_name("crop"), NULL);
438 if (avfilter_init_filter(filter, args, NULL))
440 if (avfilter_link(last_filter, 0, filter, 0))
442 last_filter = filter;
443 avfilter_graph_add_filter(graph, last_filter);
447 icodec->width - (frame_leftBand + frame_rightBand)) ||
448 (codec->height != icodec->height - (frame_topBand + frame_bottomBand))) {
449 snprintf(args, 255, "%d:%d:flags=0x%X",
452 (int)av_get_int(sws_opts, "sws_flags", NULL));
453 avfilter_open(&filter, avfilter_get_by_name("scale"), NULL);
456 if (avfilter_init_filter(filter, args, NULL))
458 if (avfilter_link(last_filter, 0, filter, 0))
460 last_filter = filter;
461 avfilter_graph_add_filter(graph, last_filter);
464 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
465 graph->scale_sws_opts = av_strdup(args);
468 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
469 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
471 outputs->name = av_strdup("in");
472 outputs->filter = last_filter;
473 outputs->pad_idx = 0;
474 outputs->next = NULL;
476 inputs->name = av_strdup("out");
477 inputs->filter = ist->out_video_filter;
481 if (avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL) < 0)
485 if (avfilter_link(last_filter, 0, ist->out_video_filter, 0) < 0)
489 /* configure all the filter links */
490 if (avfilter_graph_check_validity(graph, NULL))
492 if (avfilter_graph_config_formats(graph, NULL))
494 if (avfilter_graph_config_links(graph, NULL))
497 codec->width = ist->out_video_filter->inputs[0]->w;
498 codec->height = ist->out_video_filter->inputs[0]->h;
502 #endif /* CONFIG_AVFILTER */
504 static void term_exit(void)
507 tcsetattr (0, TCSANOW, &oldtty);
511 static volatile int received_sigterm = 0;
514 sigterm_handler(int sig)
516 received_sigterm = sig;
520 static void term_init(void)
529 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
530 |INLCR|IGNCR|ICRNL|IXON);
531 tty.c_oflag |= OPOST;
532 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
533 tty.c_cflag &= ~(CSIZE|PARENB);
538 tcsetattr (0, TCSANOW, &tty);
539 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
542 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
543 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
545 signal(SIGXCPU, sigterm_handler);
549 /* read a key without blocking */
550 static int read_key(void)
562 n = select(1, &rfds, NULL, NULL, &tv);
577 static int decode_interrupt_cb(void)
579 return q_pressed || (q_pressed = read_key() == 'q');
582 static int ffmpeg_exit(int ret)
587 for(i=0;i<nb_output_files;i++) {
588 /* maybe av_close_output_file ??? */
589 AVFormatContext *s = output_files[i];
591 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
593 for(j=0;j<s->nb_streams;j++) {
594 av_metadata_free(&s->streams[j]->metadata);
595 av_free(s->streams[j]->codec);
596 av_free(s->streams[j]);
598 for(j=0;j<s->nb_programs;j++) {
599 av_metadata_free(&s->programs[j]->metadata);
601 for(j=0;j<s->nb_chapters;j++) {
602 av_metadata_free(&s->chapters[j]->metadata);
604 av_metadata_free(&s->metadata);
607 for(i=0;i<nb_input_files;i++)
608 av_close_input_file(input_files[i]);
610 av_free(intra_matrix);
611 av_free(inter_matrix);
615 av_free(vstats_filename);
619 av_free(video_codec_name);
620 av_free(audio_codec_name);
621 av_free(subtitle_codec_name);
623 av_free(video_standard);
625 for (i=0;i<AVMEDIA_TYPE_NB;i++)
626 av_free(avcodec_opts[i]);
627 av_free(avformat_opts);
631 allocated_audio_buf_size= allocated_audio_out_size= 0;
638 if (received_sigterm) {
640 "Received signal %d: terminating.\n",
641 (int) received_sigterm);
645 exit(ret); /* not all OS-es handle main() return value */
649 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
651 if(codec && codec->sample_fmts){
652 const enum SampleFormat *p= codec->sample_fmts;
654 if(*p == st->codec->sample_fmt)
658 st->codec->sample_fmt = codec->sample_fmts[0];
662 static void choose_sample_rate(AVStream *st, AVCodec *codec)
664 if(codec && codec->supported_samplerates){
665 const int *p= codec->supported_samplerates;
667 int best_dist=INT_MAX;
669 int dist= abs(st->codec->sample_rate - *p);
670 if(dist < best_dist){
676 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
678 st->codec->sample_rate= best;
682 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
684 if(codec && codec->pix_fmts){
685 const enum PixelFormat *p= codec->pix_fmts;
687 if(*p == st->codec->pix_fmt)
691 && !( st->codec->codec_id==CODEC_ID_MJPEG
692 && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
693 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
694 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
695 st->codec->pix_fmt = codec->pix_fmts[0];
699 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
705 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
708 /* copy stream format */
709 s->nb_streams = ic->nb_streams;
710 for(i=0;i<ic->nb_streams;i++) {
714 // FIXME: a more elegant solution is needed
715 st = av_mallocz(sizeof(AVStream));
716 memcpy(st, ic->streams[i], sizeof(AVStream));
717 st->codec = avcodec_alloc_context();
719 print_error(filename, AVERROR(ENOMEM));
722 avcodec_copy_context(st->codec, ic->streams[i]->codec);
725 codec = avcodec_find_encoder(st->codec->codec_id);
726 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
727 if (audio_stream_copy) {
730 choose_sample_fmt(st, codec);
731 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
732 if (video_stream_copy) {
735 choose_pixel_fmt(st, codec);
738 if(!st->codec->thread_count)
739 st->codec->thread_count = 1;
740 if(st->codec->thread_count>1)
741 avcodec_thread_init(st->codec, st->codec->thread_count);
743 if(st->codec->flags & CODEC_FLAG_BITEXACT)
748 s->timestamp = av_gettime();
750 av_close_input_file(ic);
755 get_sync_ipts(const AVOutputStream *ost)
757 const AVInputStream *ist = ost->sync_ist;
758 return (double)(ist->pts - start_time)/AV_TIME_BASE;
761 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
765 AVPacket new_pkt= *pkt;
766 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
767 &new_pkt.data, &new_pkt.size,
768 pkt->data, pkt->size,
769 pkt->flags & AV_PKT_FLAG_KEY);
772 new_pkt.destruct= av_destruct_packet;
774 fprintf(stderr, "%s failed for stream %d, codec %s",
775 bsfc->filter->name, pkt->stream_index,
776 avctx->codec ? avctx->codec->name : "copy");
786 ret= av_interleaved_write_frame(s, pkt);
788 print_error("av_interleaved_write_frame()", ret);
793 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
795 static void do_audio_out(AVFormatContext *s,
798 unsigned char *buf, int size)
801 int64_t audio_out_size, audio_buf_size;
802 int64_t allocated_for_size= size;
804 int size_out, frame_bytes, ret;
805 AVCodecContext *enc= ost->st->codec;
806 AVCodecContext *dec= ist->st->codec;
807 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
808 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
809 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
812 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
813 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
814 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
815 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
816 audio_buf_size*= osize*enc->channels;
818 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
819 if(coded_bps > 8*osize)
820 audio_out_size= audio_out_size * coded_bps / (8*osize);
821 audio_out_size += FF_MIN_BUFFER_SIZE;
823 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
824 fprintf(stderr, "Buffer sizes too large\n");
828 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
829 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
830 if (!audio_buf || !audio_out){
831 fprintf(stderr, "Out of memory in do_audio_out\n");
835 if (enc->channels != dec->channels)
836 ost->audio_resample = 1;
838 if (ost->audio_resample && !ost->resample) {
839 if (dec->sample_fmt != SAMPLE_FMT_S16)
840 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
841 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
842 enc->sample_rate, dec->sample_rate,
843 enc->sample_fmt, dec->sample_fmt,
845 if (!ost->resample) {
846 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
847 dec->channels, dec->sample_rate,
848 enc->channels, enc->sample_rate);
853 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
854 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
855 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
856 if (ost->reformat_ctx)
857 av_audio_convert_free(ost->reformat_ctx);
858 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
859 dec->sample_fmt, 1, NULL, 0);
860 if (!ost->reformat_ctx) {
861 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
862 avcodec_get_sample_fmt_name(dec->sample_fmt),
863 avcodec_get_sample_fmt_name(enc->sample_fmt));
866 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
869 if(audio_sync_method){
870 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
871 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
872 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
873 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
875 //FIXME resample delay
876 if(fabs(delta) > 50){
877 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
879 byte_delta= FFMAX(byte_delta, -size);
883 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
888 static uint8_t *input_tmp= NULL;
889 input_tmp= av_realloc(input_tmp, byte_delta + size);
891 if(byte_delta > allocated_for_size - size){
892 allocated_for_size= byte_delta + (int64_t)size;
897 memset(input_tmp, 0, byte_delta);
898 memcpy(input_tmp + byte_delta, buf, size);
902 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
904 }else if(audio_sync_method>1){
905 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
906 assert(ost->audio_resample);
908 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
909 // 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));
910 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
914 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
915 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
917 if (ost->audio_resample) {
919 size_out = audio_resample(ost->resample,
920 (short *)buftmp, (short *)buf,
921 size / (ist->st->codec->channels * isize));
922 size_out = size_out * enc->channels * osize;
928 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
929 const void *ibuf[6]= {buftmp};
930 void *obuf[6]= {audio_buf};
931 int istride[6]= {isize};
932 int ostride[6]= {osize};
933 int len= size_out/istride[0];
934 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
935 printf("av_audio_convert() failed\n");
941 size_out = len*osize;
944 /* now encode as many frames as possible */
945 if (enc->frame_size > 1) {
946 /* output resampled raw samples */
947 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
948 fprintf(stderr, "av_fifo_realloc2() failed\n");
951 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
953 frame_bytes = enc->frame_size * osize * enc->channels;
955 while (av_fifo_size(ost->fifo) >= frame_bytes) {
957 av_init_packet(&pkt);
959 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
961 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
963 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
966 fprintf(stderr, "Audio encoding failed\n");
970 pkt.stream_index= ost->index;
973 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
974 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
975 pkt.flags |= AV_PKT_FLAG_KEY;
976 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
978 ost->sync_opts += enc->frame_size;
982 av_init_packet(&pkt);
984 ost->sync_opts += size_out / (osize * enc->channels);
986 /* output a pcm frame */
987 /* determine the size of the coded buffer */
990 size_out = size_out*coded_bps/8;
992 if(size_out > audio_out_size){
993 fprintf(stderr, "Internal error, buffer size too small\n");
997 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
998 ret = avcodec_encode_audio(enc, audio_out, size_out,
1001 fprintf(stderr, "Audio encoding failed\n");
1005 pkt.stream_index= ost->index;
1006 pkt.data= audio_out;
1008 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1009 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1010 pkt.flags |= AV_PKT_FLAG_KEY;
1011 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1015 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1017 AVCodecContext *dec;
1018 AVPicture *picture2;
1019 AVPicture picture_tmp;
1022 dec = ist->st->codec;
1024 /* deinterlace : must be done before any resize */
1025 if (do_deinterlace) {
1028 /* create temporary picture */
1029 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1030 buf = av_malloc(size);
1034 picture2 = &picture_tmp;
1035 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1037 if(avpicture_deinterlace(picture2, picture,
1038 dec->pix_fmt, dec->width, dec->height) < 0) {
1039 /* if error, do not deinterlace */
1040 fprintf(stderr, "Deinterlacing failed\n");
1049 if (picture != picture2)
1050 *picture = *picture2;
1054 /* we begin to correct av delay at this threshold */
1055 #define AV_DELAY_MAX 0.100
1057 static void do_subtitle_out(AVFormatContext *s,
1058 AVOutputStream *ost,
1063 static uint8_t *subtitle_out = NULL;
1064 int subtitle_out_max_size = 1024 * 1024;
1065 int subtitle_out_size, nb, i;
1066 AVCodecContext *enc;
1069 if (pts == AV_NOPTS_VALUE) {
1070 fprintf(stderr, "Subtitle packets must have a pts\n");
1076 enc = ost->st->codec;
1078 if (!subtitle_out) {
1079 subtitle_out = av_malloc(subtitle_out_max_size);
1082 /* Note: DVB subtitle need one packet to draw them and one other
1083 packet to clear them */
1084 /* XXX: signal it in the codec context ? */
1085 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1090 for(i = 0; i < nb; i++) {
1091 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1092 // start_display_time is required to be 0
1093 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1094 sub->end_display_time -= sub->start_display_time;
1095 sub->start_display_time = 0;
1096 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1097 subtitle_out_max_size, sub);
1098 if (subtitle_out_size < 0) {
1099 fprintf(stderr, "Subtitle encoding failed\n");
1103 av_init_packet(&pkt);
1104 pkt.stream_index = ost->index;
1105 pkt.data = subtitle_out;
1106 pkt.size = subtitle_out_size;
1107 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1108 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1109 /* XXX: the pts correction is handled here. Maybe handling
1110 it in the codec would be better */
1112 pkt.pts += 90 * sub->start_display_time;
1114 pkt.pts += 90 * sub->end_display_time;
1116 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1120 static int bit_buffer_size= 1024*256;
1121 static uint8_t *bit_buffer= NULL;
1123 static void do_video_out(AVFormatContext *s,
1124 AVOutputStream *ost,
1126 AVFrame *in_picture,
1129 int nb_frames, i, ret;
1130 #if !CONFIG_AVFILTER
1131 int64_t topBand, bottomBand, leftBand, rightBand;
1133 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1134 AVFrame picture_crop_temp, picture_pad_temp;
1135 AVCodecContext *enc, *dec;
1138 avcodec_get_frame_defaults(&picture_crop_temp);
1139 avcodec_get_frame_defaults(&picture_pad_temp);
1141 enc = ost->st->codec;
1142 dec = ist->st->codec;
1144 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1146 /* by default, we output a single frame */
1151 if(video_sync_method){
1152 double vdelta = sync_ipts - ost->sync_opts;
1153 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1156 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1159 }else if(vdelta>0.6)
1160 ost->sync_opts= lrintf(sync_ipts);
1161 }else if (vdelta > 1.1)
1162 nb_frames = lrintf(vdelta);
1163 //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);
1164 if (nb_frames == 0){
1167 fprintf(stderr, "*** drop!\n");
1168 }else if (nb_frames > 1) {
1169 nb_frames_dup += nb_frames - 1;
1171 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1174 ost->sync_opts= lrintf(sync_ipts);
1176 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1181 formatted_picture = in_picture;
1183 if (ost->video_crop) {
1184 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1185 fprintf(stderr, "error cropping picture\n");
1190 formatted_picture = &picture_crop_temp;
1192 formatted_picture = in_picture;
1196 final_picture = formatted_picture;
1197 padding_src = formatted_picture;
1198 resampling_dst = &ost->pict_tmp;
1200 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1201 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1202 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1204 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));
1205 if(!ost->video_resample)
1209 #if !CONFIG_AVFILTER
1210 if (ost->video_resample) {
1212 final_picture = &ost->pict_tmp;
1213 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1214 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1215 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1217 /* keep bands proportional to the frame size */
1218 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
1219 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1220 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
1221 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
1223 /* sanity check to ensure no bad band sizes sneak in */
1224 assert(topBand <= INT_MAX && topBand >= 0);
1225 assert(bottomBand <= INT_MAX && bottomBand >= 0);
1226 assert(leftBand <= INT_MAX && leftBand >= 0);
1227 assert(rightBand <= INT_MAX && rightBand >= 0);
1229 ost->topBand = topBand;
1230 ost->bottomBand = bottomBand;
1231 ost->leftBand = leftBand;
1232 ost->rightBand = rightBand;
1234 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
1235 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
1236 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1238 /* initialize a new scaler context */
1239 sws_freeContext(ost->img_resample_ctx);
1240 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1241 ost->img_resample_ctx = sws_getContext(
1242 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1243 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1244 ist->st->codec->pix_fmt,
1245 ost->st->codec->width,
1246 ost->st->codec->height,
1247 ost->st->codec->pix_fmt,
1248 sws_flags, NULL, NULL, NULL);
1249 if (ost->img_resample_ctx == NULL) {
1250 fprintf(stderr, "Cannot get resampling context\n");
1254 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1255 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1259 /* duplicates frame if needed */
1260 for(i=0;i<nb_frames;i++) {
1262 av_init_packet(&pkt);
1263 pkt.stream_index= ost->index;
1265 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1266 /* raw pictures are written as AVPicture structure to
1267 avoid any copies. We support temorarily the older
1269 AVFrame* old_frame = enc->coded_frame;
1270 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1271 pkt.data= (uint8_t *)final_picture;
1272 pkt.size= sizeof(AVPicture);
1273 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1274 pkt.flags |= AV_PKT_FLAG_KEY;
1276 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1277 enc->coded_frame = old_frame;
1279 AVFrame big_picture;
1281 big_picture= *final_picture;
1282 /* better than nothing: use input picture interlaced
1284 big_picture.interlaced_frame = in_picture->interlaced_frame;
1285 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1286 if(top_field_first == -1)
1287 big_picture.top_field_first = in_picture->top_field_first;
1289 big_picture.top_field_first = top_field_first;
1292 /* handles sameq here. This is not correct because it may
1293 not be a global option */
1294 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1296 big_picture.pict_type = 0;
1297 // big_picture.pts = AV_NOPTS_VALUE;
1298 big_picture.pts= ost->sync_opts;
1299 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1300 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1301 ret = avcodec_encode_video(enc,
1302 bit_buffer, bit_buffer_size,
1305 fprintf(stderr, "Video encoding failed\n");
1310 pkt.data= bit_buffer;
1312 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1313 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1314 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1315 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1316 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1318 if(enc->coded_frame->key_frame)
1319 pkt.flags |= AV_PKT_FLAG_KEY;
1320 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1323 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1324 // enc->frame_number-1, ret, enc->pict_type);
1325 /* if two pass, output log */
1326 if (ost->logfile && enc->stats_out) {
1327 fprintf(ost->logfile, "%s", enc->stats_out);
1332 ost->frame_number++;
1336 static double psnr(double d){
1337 return -10.0*log(d)/log(10.0);
1340 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1343 AVCodecContext *enc;
1345 double ti1, bitrate, avg_bitrate;
1347 /* this is executed just the first time do_video_stats is called */
1349 vstats_file = fopen(vstats_filename, "w");
1356 enc = ost->st->codec;
1357 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1358 frame_number = ost->frame_number;
1359 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1360 if (enc->flags&CODEC_FLAG_PSNR)
1361 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1363 fprintf(vstats_file,"f_size= %6d ", frame_size);
1364 /* compute pts value */
1365 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1369 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1370 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1371 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1372 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1373 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1377 static void print_report(AVFormatContext **output_files,
1378 AVOutputStream **ost_table, int nb_ostreams,
1382 AVOutputStream *ost;
1383 AVFormatContext *oc;
1385 AVCodecContext *enc;
1386 int frame_number, vid, i;
1387 double bitrate, ti1, pts;
1388 static int64_t last_time = -1;
1389 static int qp_histogram[52];
1391 if (!is_last_report) {
1393 /* display the report every 0.5 seconds */
1394 cur_time = av_gettime();
1395 if (last_time == -1) {
1396 last_time = cur_time;
1399 if ((cur_time - last_time) < 500000)
1401 last_time = cur_time;
1405 oc = output_files[0];
1407 total_size = url_fsize(oc->pb);
1408 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1409 total_size= url_ftell(oc->pb);
1414 for(i=0;i<nb_ostreams;i++) {
1416 enc = ost->st->codec;
1417 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1419 !ost->st->stream_copy ?
1420 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1422 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1423 float t = (av_gettime()-timer_start) / 1000000.0;
1425 frame_number = ost->frame_number;
1426 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1427 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1428 !ost->st->stream_copy ?
1429 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1431 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1434 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1435 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1438 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1440 if (enc->flags&CODEC_FLAG_PSNR){
1442 double error, error_sum=0;
1443 double scale, scale_sum=0;
1444 char type[3]= {'Y','U','V'};
1445 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1448 error= enc->error[j];
1449 scale= enc->width*enc->height*255.0*255.0*frame_number;
1451 error= enc->coded_frame->error[j];
1452 scale= enc->width*enc->height*255.0*255.0;
1457 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1459 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1463 /* compute min output value */
1464 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1465 if ((pts < ti1) && (pts > 0))
1471 if (verbose || is_last_report) {
1472 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1474 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1475 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1476 (double)total_size / 1024, ti1, bitrate);
1478 if (nb_frames_dup || nb_frames_drop)
1479 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1480 nb_frames_dup, nb_frames_drop);
1483 fprintf(stderr, "%s \r", buf);
1488 if (is_last_report && verbose >= 0){
1489 int64_t raw= audio_size + video_size + extra_size;
1490 fprintf(stderr, "\n");
1491 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1495 100.0*(total_size - raw)/raw
1500 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1501 static int output_packet(AVInputStream *ist, int ist_index,
1502 AVOutputStream **ost_table, int nb_ostreams,
1503 const AVPacket *pkt)
1505 AVFormatContext *os;
1506 AVOutputStream *ost;
1510 void *buffer_to_free;
1511 static unsigned int samples_size= 0;
1512 AVSubtitle subtitle, *subtitle_to_free;
1514 int frame_available;
1518 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1520 if(ist->next_pts == AV_NOPTS_VALUE)
1521 ist->next_pts= ist->pts;
1525 av_init_packet(&avpkt);
1533 if(pkt->dts != AV_NOPTS_VALUE)
1534 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1536 //while we have more to decode or while the decoder did output something on EOF
1537 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1538 uint8_t *data_buf, *decoded_data_buf;
1539 int data_size, decoded_data_size;
1541 ist->pts= ist->next_pts;
1543 if(avpkt.size && avpkt.size != pkt->size &&
1544 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1545 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1546 ist->showed_multi_packet_warning=1;
1549 /* decode the packet if needed */
1550 decoded_data_buf = NULL; /* fail safe */
1551 decoded_data_size= 0;
1552 data_buf = avpkt.data;
1553 data_size = avpkt.size;
1554 subtitle_to_free = NULL;
1555 if (ist->decoding_needed) {
1556 switch(ist->st->codec->codec_type) {
1557 case AVMEDIA_TYPE_AUDIO:{
1558 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1559 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1561 samples= av_malloc(samples_size);
1563 decoded_data_size= samples_size;
1564 /* XXX: could avoid copy if PCM 16 bits with same
1565 endianness as CPU */
1566 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1573 /* Some bug in mpeg audio decoder gives */
1574 /* decoded_data_size < 0, it seems they are overflows */
1575 if (decoded_data_size <= 0) {
1576 /* no audio frame */
1579 decoded_data_buf = (uint8_t *)samples;
1580 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1581 (ist->st->codec->sample_rate * ist->st->codec->channels);
1583 case AVMEDIA_TYPE_VIDEO:
1584 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1585 /* XXX: allocate picture correctly */
1586 avcodec_get_frame_defaults(&picture);
1588 ret = avcodec_decode_video2(ist->st->codec,
1589 &picture, &got_picture, &avpkt);
1590 ist->st->quality= picture.quality;
1594 /* no picture yet */
1595 goto discard_packet;
1597 if (ist->st->codec->time_base.num != 0) {
1598 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1599 ist->next_pts += ((int64_t)AV_TIME_BASE *
1600 ist->st->codec->time_base.num * ticks) /
1601 ist->st->codec->time_base.den;
1605 case AVMEDIA_TYPE_SUBTITLE:
1606 ret = avcodec_decode_subtitle2(ist->st->codec,
1607 &subtitle, &got_picture, &avpkt);
1611 goto discard_packet;
1613 subtitle_to_free = &subtitle;
1620 switch(ist->st->codec->codec_type) {
1621 case AVMEDIA_TYPE_AUDIO:
1622 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1623 ist->st->codec->sample_rate;
1625 case AVMEDIA_TYPE_VIDEO:
1626 if (ist->st->codec->time_base.num != 0) {
1627 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1628 ist->next_pts += ((int64_t)AV_TIME_BASE *
1629 ist->st->codec->time_base.num * ticks) /
1630 ist->st->codec->time_base.den;
1638 buffer_to_free = NULL;
1639 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1640 pre_process_video_frame(ist, (AVPicture *)&picture,
1645 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1646 // add it to be filtered
1647 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1649 ist->st->codec->sample_aspect_ratio);
1653 // preprocess audio (volume)
1654 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1655 if (audio_volume != 256) {
1658 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1659 int v = ((*volp) * audio_volume + 128) >> 8;
1660 if (v < -32768) v = -32768;
1661 if (v > 32767) v = 32767;
1667 /* frame rate emulation */
1669 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1670 int64_t now = av_gettime() - ist->start;
1675 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1676 !ist->out_video_filter || avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1678 /* if output time reached then transcode raw format,
1679 encode packets and output them */
1680 if (start_time == 0 || ist->pts >= start_time)
1682 while (frame_available) {
1683 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->out_video_filter)
1684 get_filtered_video_pic(ist->out_video_filter, &ist->picref, &picture, &ist->pts);
1686 for(i=0;i<nb_ostreams;i++) {
1690 if (ost->source_index == ist_index) {
1691 os = output_files[ost->file_index];
1693 /* set the input output pts pairs */
1694 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1696 if (ost->encoding_needed) {
1697 assert(ist->decoding_needed);
1698 switch(ost->st->codec->codec_type) {
1699 case AVMEDIA_TYPE_AUDIO:
1700 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1702 case AVMEDIA_TYPE_VIDEO:
1704 if (ist->picref->video)
1705 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1707 do_video_out(os, ost, ist, &picture, &frame_size);
1708 if (vstats_filename && frame_size)
1709 do_video_stats(os, ost, frame_size);
1711 case AVMEDIA_TYPE_SUBTITLE:
1712 do_subtitle_out(os, ost, ist, &subtitle,
1719 AVFrame avframe; //FIXME/XXX remove this
1721 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1723 av_init_packet(&opkt);
1725 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1728 /* no reencoding needed : output the packet directly */
1729 /* force the input stream PTS */
1731 avcodec_get_frame_defaults(&avframe);
1732 ost->st->codec->coded_frame= &avframe;
1733 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1735 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1736 audio_size += data_size;
1737 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1738 video_size += data_size;
1742 opkt.stream_index= ost->index;
1743 if(pkt->pts != AV_NOPTS_VALUE)
1744 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1746 opkt.pts= AV_NOPTS_VALUE;
1748 if (pkt->dts == AV_NOPTS_VALUE)
1749 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1751 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1752 opkt.dts -= ost_tb_start_time;
1754 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1755 opkt.flags= pkt->flags;
1757 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1758 if( ost->st->codec->codec_id != CODEC_ID_H264
1759 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1760 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1762 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1763 opkt.destruct= av_destruct_packet;
1765 opkt.data = data_buf;
1766 opkt.size = data_size;
1769 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1770 ost->st->codec->frame_number++;
1771 ost->frame_number++;
1772 av_free_packet(&opkt);
1778 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1779 ist->out_video_filter && avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1781 avfilter_unref_buffer(ist->picref);
1784 av_free(buffer_to_free);
1785 /* XXX: allocate the subtitles in the codec ? */
1786 if (subtitle_to_free) {
1787 if (subtitle_to_free->rects != NULL) {
1788 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1789 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1790 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1791 av_freep(&subtitle_to_free->rects[i]);
1793 av_freep(&subtitle_to_free->rects);
1795 subtitle_to_free->num_rects = 0;
1796 subtitle_to_free = NULL;
1803 for(i=0;i<nb_ostreams;i++) {
1805 if (ost->source_index == ist_index) {
1806 AVCodecContext *enc= ost->st->codec;
1807 os = output_files[ost->file_index];
1809 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1811 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1814 if (ost->encoding_needed) {
1818 av_init_packet(&pkt);
1819 pkt.stream_index= ost->index;
1821 switch(ost->st->codec->codec_type) {
1822 case AVMEDIA_TYPE_AUDIO:
1823 fifo_bytes = av_fifo_size(ost->fifo);
1825 /* encode any samples remaining in fifo */
1826 if (fifo_bytes > 0) {
1827 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1828 int fs_tmp = enc->frame_size;
1830 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1831 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1832 enc->frame_size = fifo_bytes / (osize * enc->channels);
1834 int frame_bytes = enc->frame_size*osize*enc->channels;
1835 if (allocated_audio_buf_size < frame_bytes)
1837 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1840 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1841 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1842 ost->st->time_base.num, enc->sample_rate);
1843 enc->frame_size = fs_tmp;
1846 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1849 fprintf(stderr, "Audio encoding failed\n");
1853 pkt.flags |= AV_PKT_FLAG_KEY;
1855 case AVMEDIA_TYPE_VIDEO:
1856 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1858 fprintf(stderr, "Video encoding failed\n");
1862 if(enc->coded_frame && enc->coded_frame->key_frame)
1863 pkt.flags |= AV_PKT_FLAG_KEY;
1864 if (ost->logfile && enc->stats_out) {
1865 fprintf(ost->logfile, "%s", enc->stats_out);
1874 pkt.data= bit_buffer;
1876 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1877 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1878 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1890 static void print_sdp(AVFormatContext **avc, int n)
1894 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1895 printf("SDP:\n%s\n", sdp);
1899 static int copy_chapters(int infile, int outfile)
1901 AVFormatContext *is = input_files[infile];
1902 AVFormatContext *os = output_files[outfile];
1905 for (i = 0; i < is->nb_chapters; i++) {
1906 AVChapter *in_ch = is->chapters[i], *out_ch;
1907 AVMetadataTag *t = NULL;
1908 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1909 AV_TIME_BASE_Q, in_ch->time_base);
1910 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1911 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1914 if (in_ch->end < ts_off)
1916 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1919 out_ch = av_mallocz(sizeof(AVChapter));
1921 return AVERROR(ENOMEM);
1923 out_ch->id = in_ch->id;
1924 out_ch->time_base = in_ch->time_base;
1925 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1926 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1928 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1929 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1932 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1934 return AVERROR(ENOMEM);
1935 os->chapters[os->nb_chapters - 1] = out_ch;
1941 * The following code is the main loop of the file converter
1943 static int transcode(AVFormatContext **output_files,
1944 int nb_output_files,
1945 AVFormatContext **input_files,
1947 AVStreamMap *stream_maps, int nb_stream_maps)
1949 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1950 AVFormatContext *is, *os;
1951 AVCodecContext *codec, *icodec;
1952 AVOutputStream *ost, **ost_table = NULL;
1953 AVInputStream *ist, **ist_table = NULL;
1954 AVInputFile *file_table;
1958 uint8_t no_packet[MAX_FILES]={0};
1959 int no_packet_count=0;
1961 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1965 /* input stream init */
1967 for(i=0;i<nb_input_files;i++) {
1968 is = input_files[i];
1969 file_table[i].ist_index = j;
1970 file_table[i].nb_streams = is->nb_streams;
1971 j += is->nb_streams;
1975 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1979 for(i=0;i<nb_istreams;i++) {
1980 ist = av_mallocz(sizeof(AVInputStream));
1986 for(i=0;i<nb_input_files;i++) {
1987 is = input_files[i];
1988 for(k=0;k<is->nb_streams;k++) {
1989 ist = ist_table[j++];
1990 ist->st = is->streams[k];
1991 ist->file_index = i;
1993 ist->discard = 1; /* the stream is discarded by default
1997 ist->start = av_gettime();
2002 /* output stream init */
2004 for(i=0;i<nb_output_files;i++) {
2005 os = output_files[i];
2006 if (!os->nb_streams) {
2007 dump_format(output_files[i], i, output_files[i]->filename, 1);
2008 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2009 ret = AVERROR(EINVAL);
2012 nb_ostreams += os->nb_streams;
2014 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2015 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2016 ret = AVERROR(EINVAL);
2020 /* Sanity check the mapping args -- do the input files & streams exist? */
2021 for(i=0;i<nb_stream_maps;i++) {
2022 int fi = stream_maps[i].file_index;
2023 int si = stream_maps[i].stream_index;
2025 if (fi < 0 || fi > nb_input_files - 1 ||
2026 si < 0 || si > file_table[fi].nb_streams - 1) {
2027 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2028 ret = AVERROR(EINVAL);
2031 fi = stream_maps[i].sync_file_index;
2032 si = stream_maps[i].sync_stream_index;
2033 if (fi < 0 || fi > nb_input_files - 1 ||
2034 si < 0 || si > file_table[fi].nb_streams - 1) {
2035 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2036 ret = AVERROR(EINVAL);
2041 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2044 for(i=0;i<nb_ostreams;i++) {
2045 ost = av_mallocz(sizeof(AVOutputStream));
2052 for(k=0;k<nb_output_files;k++) {
2053 os = output_files[k];
2054 for(i=0;i<os->nb_streams;i++,n++) {
2057 ost->file_index = k;
2059 ost->st = os->streams[i];
2060 if (nb_stream_maps > 0) {
2061 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2062 stream_maps[n].stream_index;
2064 /* Sanity check that the stream types match */
2065 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2066 int i= ost->file_index;
2067 dump_format(output_files[i], i, output_files[i]->filename, 1);
2068 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2069 stream_maps[n].file_index, stream_maps[n].stream_index,
2070 ost->file_index, ost->index);
2075 int best_nb_frames=-1;
2076 /* get corresponding input stream index : we select the first one with the right type */
2078 for(j=0;j<nb_istreams;j++) {
2083 AVFormatContext *f= input_files[ ist->file_index ];
2085 for(pi=0; pi<f->nb_programs; pi++){
2086 AVProgram *p= f->programs[pi];
2087 if(p->id == opt_programid)
2088 for(si=0; si<p->nb_stream_indexes; si++){
2089 if(f->streams[ p->stream_index[si] ] == ist->st)
2094 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2095 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2096 if(best_nb_frames < ist->st->codec_info_nb_frames){
2097 best_nb_frames= ist->st->codec_info_nb_frames;
2098 ost->source_index = j;
2105 if(! opt_programid) {
2106 /* try again and reuse existing stream */
2107 for(j=0;j<nb_istreams;j++) {
2109 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2110 && ist->st->discard != AVDISCARD_ALL) {
2111 ost->source_index = j;
2117 int i= ost->file_index;
2118 dump_format(output_files[i], i, output_files[i]->filename, 1);
2119 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2120 ost->file_index, ost->index);
2125 ist = ist_table[ost->source_index];
2127 ost->sync_ist = (nb_stream_maps > 0) ?
2128 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2129 stream_maps[n].sync_stream_index] : ist;
2133 /* for each output stream, we compute the right encoding parameters */
2134 for(i=0;i<nb_ostreams;i++) {
2135 AVMetadataTag *t = NULL;
2137 os = output_files[ost->file_index];
2138 ist = ist_table[ost->source_index];
2140 codec = ost->st->codec;
2141 icodec = ist->st->codec;
2143 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2144 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2147 ost->st->disposition = ist->st->disposition;
2148 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2149 codec->chroma_sample_location = icodec->chroma_sample_location;
2151 if (ost->st->stream_copy) {
2152 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2154 if (extra_size > INT_MAX)
2157 /* if stream_copy is selected, no need to decode or encode */
2158 codec->codec_id = icodec->codec_id;
2159 codec->codec_type = icodec->codec_type;
2161 if(!codec->codec_tag){
2162 if( !os->oformat->codec_tag
2163 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2164 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2165 codec->codec_tag = icodec->codec_tag;
2168 codec->bit_rate = icodec->bit_rate;
2169 codec->extradata= av_mallocz(extra_size);
2170 if (!codec->extradata)
2172 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2173 codec->extradata_size= icodec->extradata_size;
2174 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){
2175 codec->time_base = icodec->time_base;
2176 codec->time_base.num *= icodec->ticks_per_frame;
2177 av_reduce(&codec->time_base.num, &codec->time_base.den,
2178 codec->time_base.num, codec->time_base.den, INT_MAX);
2180 codec->time_base = ist->st->time_base;
2181 switch(codec->codec_type) {
2182 case AVMEDIA_TYPE_AUDIO:
2183 if(audio_volume != 256) {
2184 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2187 codec->channel_layout = icodec->channel_layout;
2188 codec->sample_rate = icodec->sample_rate;
2189 codec->channels = icodec->channels;
2190 codec->frame_size = icodec->frame_size;
2191 codec->block_align= icodec->block_align;
2192 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2193 codec->block_align= 0;
2194 if(codec->codec_id == CODEC_ID_AC3)
2195 codec->block_align= 0;
2197 case AVMEDIA_TYPE_VIDEO:
2198 codec->pix_fmt = icodec->pix_fmt;
2199 codec->width = icodec->width;
2200 codec->height = icodec->height;
2201 codec->has_b_frames = icodec->has_b_frames;
2203 case AVMEDIA_TYPE_SUBTITLE:
2204 codec->width = icodec->width;
2205 codec->height = icodec->height;
2211 switch(codec->codec_type) {
2212 case AVMEDIA_TYPE_AUDIO:
2213 ost->fifo= av_fifo_alloc(1024);
2216 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2217 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2218 icodec->request_channels = codec->channels;
2219 ist->decoding_needed = 1;
2220 ost->encoding_needed = 1;
2222 case AVMEDIA_TYPE_VIDEO:
2223 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2224 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2227 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2228 ost->video_resample = ((codec->width != icodec->width -
2229 (frame_leftBand + frame_rightBand)) ||
2230 (codec->height != icodec->height -
2231 (frame_topBand + frame_bottomBand)) ||
2232 (codec->pix_fmt != icodec->pix_fmt));
2233 if (ost->video_crop) {
2234 ost->topBand = ost->original_topBand = frame_topBand;
2235 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2236 ost->leftBand = ost->original_leftBand = frame_leftBand;
2237 ost->rightBand = ost->original_rightBand = frame_rightBand;
2239 if (ost->video_resample) {
2240 avcodec_get_frame_defaults(&ost->pict_tmp);
2241 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2242 codec->width, codec->height)) {
2243 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2246 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2247 ost->img_resample_ctx = sws_getContext(
2248 icodec->width - (frame_leftBand + frame_rightBand),
2249 icodec->height - (frame_topBand + frame_bottomBand),
2254 sws_flags, NULL, NULL, NULL);
2255 if (ost->img_resample_ctx == NULL) {
2256 fprintf(stderr, "Cannot get resampling context\n");
2260 #if !CONFIG_AVFILTER
2261 ost->original_height = icodec->height;
2262 ost->original_width = icodec->width;
2264 codec->bits_per_raw_sample= 0;
2266 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
2267 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
2268 ost->resample_pix_fmt= icodec->pix_fmt;
2269 ost->encoding_needed = 1;
2270 ist->decoding_needed = 1;
2273 if (configure_filters(ist, ost)) {
2274 fprintf(stderr, "Error opening filters!\n");
2279 case AVMEDIA_TYPE_SUBTITLE:
2280 ost->encoding_needed = 1;
2281 ist->decoding_needed = 1;
2288 if (ost->encoding_needed &&
2289 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2290 char logfilename[1024];
2293 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2294 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2296 if (codec->flags & CODEC_FLAG_PASS1) {
2297 f = fopen(logfilename, "wb");
2299 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2305 size_t logbuffer_size;
2306 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2307 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2310 codec->stats_in = logbuffer;
2314 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2315 int size= codec->width * codec->height;
2316 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2321 bit_buffer = av_malloc(bit_buffer_size);
2323 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2325 ret = AVERROR(ENOMEM);
2329 /* open each encoder */
2330 for(i=0;i<nb_ostreams;i++) {
2332 if (ost->encoding_needed) {
2333 AVCodec *codec = output_codecs[i];
2335 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2337 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2338 ost->st->codec->codec_id, ost->file_index, ost->index);
2339 ret = AVERROR(EINVAL);
2342 if (avcodec_open(ost->st->codec, codec) < 0) {
2343 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2344 ost->file_index, ost->index);
2345 ret = AVERROR(EINVAL);
2348 extra_size += ost->st->codec->extradata_size;
2352 /* open each decoder */
2353 for(i=0;i<nb_istreams;i++) {
2355 if (ist->decoding_needed) {
2356 AVCodec *codec = input_codecs[i];
2358 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2360 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2361 ist->st->codec->codec_id, ist->file_index, ist->index);
2362 ret = AVERROR(EINVAL);
2365 if (avcodec_open(ist->st->codec, codec) < 0) {
2366 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2367 ist->file_index, ist->index);
2368 ret = AVERROR(EINVAL);
2371 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2372 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2377 for(i=0;i<nb_istreams;i++) {
2381 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2382 ist->next_pts = AV_NOPTS_VALUE;
2386 /* set meta data information from input file if required */
2387 for (i=0;i<nb_meta_data_maps;i++) {
2388 AVFormatContext *out_file;
2389 AVFormatContext *in_file;
2390 AVMetadataTag *mtag;
2392 int out_file_index = meta_data_maps[i].out_file;
2393 int in_file_index = meta_data_maps[i].in_file;
2394 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2395 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2396 out_file_index, out_file_index, in_file_index);
2397 ret = AVERROR(EINVAL);
2400 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2401 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2402 in_file_index, out_file_index, in_file_index);
2403 ret = AVERROR(EINVAL);
2407 out_file = output_files[out_file_index];
2408 in_file = input_files[in_file_index];
2412 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2413 av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2414 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2415 in_file->iformat->metadata_conv);
2418 /* copy chapters from the first input file that has them*/
2419 for (i = 0; i < nb_input_files; i++) {
2420 if (!input_files[i]->nb_chapters)
2423 for (j = 0; j < nb_output_files; j++)
2424 if ((ret = copy_chapters(i, j)) < 0)
2428 /* open files and write file headers */
2429 for(i=0;i<nb_output_files;i++) {
2430 os = output_files[i];
2431 if (av_write_header(os) < 0) {
2432 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2433 ret = AVERROR(EINVAL);
2436 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2442 /* dump the file output parameters - cannot be done before in case
2444 for(i=0;i<nb_output_files;i++) {
2445 dump_format(output_files[i], i, output_files[i]->filename, 1);
2448 /* dump the stream mapping */
2450 fprintf(stderr, "Stream mapping:\n");
2451 for(i=0;i<nb_ostreams;i++) {
2453 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2454 ist_table[ost->source_index]->file_index,
2455 ist_table[ost->source_index]->index,
2458 if (ost->sync_ist != ist_table[ost->source_index])
2459 fprintf(stderr, " [sync #%d.%d]",
2460 ost->sync_ist->file_index,
2461 ost->sync_ist->index);
2462 fprintf(stderr, "\n");
2467 fprintf(stderr, "%s\n", error);
2472 print_sdp(output_files, nb_output_files);
2475 if (!using_stdin && verbose >= 0) {
2476 fprintf(stderr, "Press [q] to stop encoding\n");
2477 url_set_interrupt_cb(decode_interrupt_cb);
2481 timer_start = av_gettime();
2483 for(; received_sigterm == 0;) {
2484 int file_index, ist_index;
2492 /* if 'q' pressed, exits */
2496 /* read_key() returns 0 on EOF */
2502 /* select the stream that we must read now by looking at the
2503 smallest output pts */
2505 for(i=0;i<nb_ostreams;i++) {
2508 os = output_files[ost->file_index];
2509 ist = ist_table[ost->source_index];
2510 if(ist->is_past_recording_time || no_packet[ist->file_index])
2512 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2513 ipts = (double)ist->pts;
2514 if (!file_table[ist->file_index].eof_reached){
2515 if(ipts < ipts_min) {
2517 if(input_sync ) file_index = ist->file_index;
2519 if(opts < opts_min) {
2521 if(!input_sync) file_index = ist->file_index;
2524 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2529 /* if none, if is finished */
2530 if (file_index < 0) {
2531 if(no_packet_count){
2533 memset(no_packet, 0, sizeof(no_packet));
2540 /* finish if limit size exhausted */
2541 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2544 /* read a frame from it and output it in the fifo */
2545 is = input_files[file_index];
2546 ret= av_read_frame(is, &pkt);
2547 if(ret == AVERROR(EAGAIN)){
2548 no_packet[file_index]=1;
2553 file_table[file_index].eof_reached = 1;
2561 memset(no_packet, 0, sizeof(no_packet));
2564 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2566 /* the following test is needed in case new streams appear
2567 dynamically in stream : we ignore them */
2568 if (pkt.stream_index >= file_table[file_index].nb_streams)
2569 goto discard_packet;
2570 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2571 ist = ist_table[ist_index];
2573 goto discard_packet;
2575 if (pkt.dts != AV_NOPTS_VALUE)
2576 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2577 if (pkt.pts != AV_NOPTS_VALUE)
2578 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2580 if(input_files_ts_scale[file_index][pkt.stream_index]){
2581 if(pkt.pts != AV_NOPTS_VALUE)
2582 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2583 if(pkt.dts != AV_NOPTS_VALUE)
2584 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2587 // 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);
2588 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2589 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2590 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2591 int64_t delta= pkt_dts - ist->next_pts;
2592 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2593 input_files_ts_offset[ist->file_index]-= delta;
2595 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2596 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2597 if(pkt.pts != AV_NOPTS_VALUE)
2598 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2602 /* finish if recording time exhausted */
2603 if (recording_time != INT64_MAX &&
2604 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2605 ist->is_past_recording_time = 1;
2606 goto discard_packet;
2609 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2610 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2613 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2614 ist->file_index, ist->index);
2617 av_free_packet(&pkt);
2622 av_free_packet(&pkt);
2624 /* dump report by using the output first video and audio streams */
2625 print_report(output_files, ost_table, nb_ostreams, 0);
2628 /* at the end of stream, we must flush the decoder buffers */
2629 for(i=0;i<nb_istreams;i++) {
2631 if (ist->decoding_needed) {
2632 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2638 /* write the trailer if needed and close file */
2639 for(i=0;i<nb_output_files;i++) {
2640 os = output_files[i];
2641 av_write_trailer(os);
2644 /* dump report by using the first video and audio streams */
2645 print_report(output_files, ost_table, nb_ostreams, 1);
2647 /* close each encoder */
2648 for(i=0;i<nb_ostreams;i++) {
2650 if (ost->encoding_needed) {
2651 av_freep(&ost->st->codec->stats_in);
2652 avcodec_close(ost->st->codec);
2656 /* close each decoder */
2657 for(i=0;i<nb_istreams;i++) {
2659 if (ist->decoding_needed) {
2660 avcodec_close(ist->st->codec);
2665 avfilter_graph_destroy(graph);
2674 av_freep(&bit_buffer);
2675 av_free(file_table);
2678 for(i=0;i<nb_istreams;i++) {
2685 for(i=0;i<nb_ostreams;i++) {
2688 if (ost->st->stream_copy)
2689 av_freep(&ost->st->codec->extradata);
2691 fclose(ost->logfile);
2692 ost->logfile = NULL;
2694 av_fifo_free(ost->fifo); /* works even if fifo is not
2695 initialized but set to zero */
2696 av_free(ost->pict_tmp.data[0]);
2697 if (ost->video_resample)
2698 sws_freeContext(ost->img_resample_ctx);
2700 audio_resample_close(ost->resample);
2701 if (ost->reformat_ctx)
2702 av_audio_convert_free(ost->reformat_ctx);
2711 static void opt_format(const char *arg)
2713 /* compatibility stuff for pgmyuv */
2714 if (!strcmp(arg, "pgmyuv")) {
2715 pgmyuv_compatibility_hack=1;
2716 // opt_image_format(arg);
2718 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2721 last_asked_format = arg;
2724 static void opt_video_rc_override_string(const char *arg)
2726 video_rc_override_string = arg;
2729 static int opt_me_threshold(const char *opt, const char *arg)
2731 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2735 static int opt_verbose(const char *opt, const char *arg)
2737 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2741 static int opt_frame_rate(const char *opt, const char *arg)
2743 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2744 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2750 static int opt_bitrate(const char *opt, const char *arg)
2752 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2754 opt_default(opt, arg);
2756 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2757 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2762 static void opt_frame_crop_top(const char *arg)
2764 frame_topBand = atoi(arg);
2765 if (frame_topBand < 0) {
2766 fprintf(stderr, "Incorrect top crop size\n");
2769 if ((frame_topBand) >= frame_height){
2770 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2773 fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2774 frame_height -= frame_topBand;
2777 static void opt_frame_crop_bottom(const char *arg)
2779 frame_bottomBand = atoi(arg);
2780 if (frame_bottomBand < 0) {
2781 fprintf(stderr, "Incorrect bottom crop size\n");
2784 if ((frame_bottomBand) >= frame_height){
2785 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2788 fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2789 frame_height -= frame_bottomBand;
2792 static void opt_frame_crop_left(const char *arg)
2794 frame_leftBand = atoi(arg);
2795 if (frame_leftBand < 0) {
2796 fprintf(stderr, "Incorrect left crop size\n");
2799 if ((frame_leftBand) >= frame_width){
2800 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2803 fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2804 frame_width -= frame_leftBand;
2807 static void opt_frame_crop_right(const char *arg)
2809 frame_rightBand = atoi(arg);
2810 if (frame_rightBand < 0) {
2811 fprintf(stderr, "Incorrect right crop size\n");
2814 if ((frame_rightBand) >= frame_width){
2815 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2818 fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2819 frame_width -= frame_rightBand;
2822 static void opt_frame_size(const char *arg)
2824 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2825 fprintf(stderr, "Incorrect frame size\n");
2830 static int opt_pad(const char *opt, const char *arg) {
2831 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2835 static void opt_frame_pix_fmt(const char *arg)
2837 if (strcmp(arg, "list")) {
2838 frame_pix_fmt = av_get_pix_fmt(arg);
2839 if (frame_pix_fmt == PIX_FMT_NONE) {
2840 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2849 static void opt_frame_aspect_ratio(const char *arg)
2856 p = strchr(arg, ':');
2858 x = strtol(arg, &end, 10);
2860 y = strtol(end+1, &end, 10);
2862 ar = (double)x / (double)y;
2864 ar = strtod(arg, NULL);
2867 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2870 frame_aspect_ratio = ar;
2873 static int opt_metadata(const char *opt, const char *arg)
2875 char *mid= strchr(arg, '=');
2878 fprintf(stderr, "Missing =\n");
2884 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2885 metadata[metadata_count-1].key = av_strdup(arg);
2886 metadata[metadata_count-1].value= av_strdup(mid);
2891 static void opt_qscale(const char *arg)
2893 video_qscale = atof(arg);
2894 if (video_qscale <= 0 ||
2895 video_qscale > 255) {
2896 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2901 static void opt_top_field_first(const char *arg)
2903 top_field_first= atoi(arg);
2906 static int opt_thread_count(const char *opt, const char *arg)
2908 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2911 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2916 static void opt_audio_sample_fmt(const char *arg)
2918 if (strcmp(arg, "list"))
2919 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2921 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2926 static int opt_audio_rate(const char *opt, const char *arg)
2928 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2932 static int opt_audio_channels(const char *opt, const char *arg)
2934 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2938 static void opt_video_channel(const char *arg)
2940 video_channel = strtol(arg, NULL, 0);
2943 static void opt_video_standard(const char *arg)
2945 video_standard = av_strdup(arg);
2948 static void opt_codec(int *pstream_copy, char **pcodec_name,
2949 int codec_type, const char *arg)
2951 av_freep(pcodec_name);
2952 if (!strcmp(arg, "copy")) {
2955 *pcodec_name = av_strdup(arg);
2959 static void opt_audio_codec(const char *arg)
2961 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2964 static void opt_audio_tag(const char *arg)
2967 audio_codec_tag= strtol(arg, &tail, 0);
2970 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2973 static void opt_video_tag(const char *arg)
2976 video_codec_tag= strtol(arg, &tail, 0);
2979 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2982 static void opt_video_codec(const char *arg)
2984 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2987 static void opt_subtitle_codec(const char *arg)
2989 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2992 static void opt_subtitle_tag(const char *arg)
2995 subtitle_codec_tag= strtol(arg, &tail, 0);
2998 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3001 static void opt_map(const char *arg)
3006 m = &stream_maps[nb_stream_maps++];
3008 m->file_index = strtol(arg, &p, 0);
3012 m->stream_index = strtol(p, &p, 0);
3015 m->sync_file_index = strtol(p, &p, 0);
3018 m->sync_stream_index = strtol(p, &p, 0);
3020 m->sync_file_index = m->file_index;
3021 m->sync_stream_index = m->stream_index;
3025 static void opt_map_meta_data(const char *arg)
3030 m = &meta_data_maps[nb_meta_data_maps++];
3032 m->out_file = strtol(arg, &p, 0);
3036 m->in_file = strtol(p, &p, 0);
3039 static void opt_input_ts_scale(const char *arg)
3041 unsigned int stream;
3045 stream = strtol(arg, &p, 0);
3048 scale= strtod(p, &p);
3050 if(stream >= MAX_STREAMS)
3053 input_files_ts_scale[nb_input_files][stream]= scale;
3056 static int opt_recording_time(const char *opt, const char *arg)
3058 recording_time = parse_time_or_die(opt, arg, 1);
3062 static int opt_start_time(const char *opt, const char *arg)
3064 start_time = parse_time_or_die(opt, arg, 1);
3068 static int opt_recording_timestamp(const char *opt, const char *arg)
3070 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3074 static int opt_input_ts_offset(const char *opt, const char *arg)
3076 input_ts_offset = parse_time_or_die(opt, arg, 1);
3080 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3082 const char *codec_string = encoder ? "encoder" : "decoder";
3086 return CODEC_ID_NONE;
3088 avcodec_find_encoder_by_name(name) :
3089 avcodec_find_decoder_by_name(name);
3091 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3094 if(codec->type != type) {
3095 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3098 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3099 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3100 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3101 "results.\nAdd '-strict experimental' if you want to use it.\n",
3102 codec_string, codec->name);
3104 avcodec_find_encoder(codec->id) :
3105 avcodec_find_decoder(codec->id);
3106 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3107 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3108 codec_string, codec->name);
3114 static void opt_input_file(const char *filename)
3116 AVFormatContext *ic;
3117 AVFormatParameters params, *ap = ¶ms;
3118 AVInputFormat *file_iformat = NULL;
3119 int err, i, ret, rfps, rfps_base;
3122 if (last_asked_format) {
3123 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3124 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3127 last_asked_format = NULL;
3130 if (!strcmp(filename, "-"))
3133 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3134 !strcmp(filename, "/dev/stdin");
3136 /* get default parameters from command line */
3137 ic = avformat_alloc_context();
3139 print_error(filename, AVERROR(ENOMEM));
3143 memset(ap, 0, sizeof(*ap));
3144 ap->prealloced_context = 1;
3145 ap->sample_rate = audio_sample_rate;
3146 ap->channels = audio_channels;
3147 ap->time_base.den = frame_rate.num;
3148 ap->time_base.num = frame_rate.den;
3149 ap->width = frame_width;
3150 ap->height = frame_height;
3151 ap->pix_fmt = frame_pix_fmt;
3152 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3153 ap->channel = video_channel;
3154 ap->standard = video_standard;
3156 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3158 ic->video_codec_id =
3159 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3160 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3161 ic->audio_codec_id =
3162 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3163 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3164 ic->subtitle_codec_id=
3165 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3166 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3167 ic->flags |= AVFMT_FLAG_NONBLOCK;
3169 if(pgmyuv_compatibility_hack)
3170 ic->video_codec_id= CODEC_ID_PGMYUV;
3172 /* open the input file with generic libav function */
3173 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3175 print_error(filename, err);
3181 for(i=0; i<ic->nb_streams; i++){
3182 ic->streams[i]->discard= AVDISCARD_ALL;
3184 for(i=0; i<ic->nb_programs; i++){
3185 AVProgram *p= ic->programs[i];
3186 if(p->id != opt_programid){
3187 p->discard = AVDISCARD_ALL;
3190 for(j=0; j<p->nb_stream_indexes; j++){
3191 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3196 fprintf(stderr, "Specified program id not found\n");
3202 ic->loop_input = loop_input;
3204 /* If not enough info to get the stream parameters, we decode the
3205 first frames to get it. (used in mpeg case for example) */
3206 ret = av_find_stream_info(ic);
3207 if (ret < 0 && verbose >= 0) {
3208 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3209 av_close_input_file(ic);
3213 timestamp = start_time;
3214 /* add the stream start time */
3215 if (ic->start_time != AV_NOPTS_VALUE)
3216 timestamp += ic->start_time;
3218 /* if seeking requested, we execute it */
3219 if (start_time != 0) {
3220 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3222 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3223 filename, (double)timestamp / AV_TIME_BASE);
3225 /* reset seek info */
3229 /* update the current parameters so that they match the one of the input stream */
3230 for(i=0;i<ic->nb_streams;i++) {
3231 AVStream *st = ic->streams[i];
3232 AVCodecContext *dec = st->codec;
3233 avcodec_thread_init(dec, thread_count);
3234 switch (dec->codec_type) {
3235 case AVMEDIA_TYPE_AUDIO:
3236 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3237 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3238 channel_layout = dec->channel_layout;
3239 audio_channels = dec->channels;
3240 audio_sample_rate = dec->sample_rate;
3241 audio_sample_fmt = dec->sample_fmt;
3242 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3244 st->discard= AVDISCARD_ALL;
3246 case AVMEDIA_TYPE_VIDEO:
3247 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3248 frame_height = dec->height;
3249 frame_width = dec->width;
3250 if(ic->streams[i]->sample_aspect_ratio.num)
3251 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3253 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3254 frame_aspect_ratio *= (float) dec->width / dec->height;
3255 frame_pix_fmt = dec->pix_fmt;
3256 rfps = ic->streams[i]->r_frame_rate.num;
3257 rfps_base = ic->streams[i]->r_frame_rate.den;
3259 dec->flags |= CODEC_FLAG_EMU_EDGE;
3260 frame_height >>= dec->lowres;
3261 frame_width >>= dec->lowres;
3264 dec->debug |= FF_DEBUG_MV;
3266 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3269 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3270 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3272 (float)rfps / rfps_base, rfps, rfps_base);
3274 /* update the current frame rate to match the stream frame rate */
3275 frame_rate.num = rfps;
3276 frame_rate.den = rfps_base;
3278 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3280 st->discard= AVDISCARD_ALL;
3281 else if(video_discard)
3282 st->discard= video_discard;
3284 case AVMEDIA_TYPE_DATA:
3286 case AVMEDIA_TYPE_SUBTITLE:
3287 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3288 if(subtitle_disable)
3289 st->discard = AVDISCARD_ALL;
3291 case AVMEDIA_TYPE_ATTACHMENT:
3292 case AVMEDIA_TYPE_UNKNOWN:
3300 input_files[nb_input_files] = ic;
3301 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3302 /* dump the file content */
3304 dump_format(ic, nb_input_files, filename, 0);
3310 av_freep(&video_codec_name);
3311 av_freep(&audio_codec_name);
3312 av_freep(&subtitle_codec_name);
3315 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3316 int *has_subtitle_ptr)
3318 int has_video, has_audio, has_subtitle, i, j;
3319 AVFormatContext *ic;
3324 for(j=0;j<nb_input_files;j++) {
3325 ic = input_files[j];
3326 for(i=0;i<ic->nb_streams;i++) {
3327 AVCodecContext *enc = ic->streams[i]->codec;
3328 switch(enc->codec_type) {
3329 case AVMEDIA_TYPE_AUDIO:
3332 case AVMEDIA_TYPE_VIDEO:
3335 case AVMEDIA_TYPE_SUBTITLE:
3338 case AVMEDIA_TYPE_DATA:
3339 case AVMEDIA_TYPE_ATTACHMENT:
3340 case AVMEDIA_TYPE_UNKNOWN:
3347 *has_video_ptr = has_video;
3348 *has_audio_ptr = has_audio;
3349 *has_subtitle_ptr = has_subtitle;
3352 static void new_video_stream(AVFormatContext *oc)
3355 AVCodecContext *video_enc;
3356 enum CodecID codec_id;
3358 st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3360 fprintf(stderr, "Could not alloc stream\n");
3363 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3364 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3365 video_bitstream_filters= NULL;
3367 avcodec_thread_init(st->codec, thread_count);
3369 video_enc = st->codec;
3372 video_enc->codec_tag= video_codec_tag;
3374 if( (video_global_header&1)
3375 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3376 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3377 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3379 if(video_global_header&2){
3380 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3381 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3384 if (video_stream_copy) {
3385 st->stream_copy = 1;
3386 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3387 video_enc->sample_aspect_ratio =
3388 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3393 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3395 if (video_codec_name) {
3396 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3397 video_enc->strict_std_compliance);
3398 codec = avcodec_find_encoder_by_name(video_codec_name);
3399 output_codecs[nb_ocodecs] = codec;
3401 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3402 codec = avcodec_find_encoder(codec_id);
3405 video_enc->codec_id = codec_id;
3407 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3409 if (codec && codec->supported_framerates && !force_fps)
3410 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3411 video_enc->time_base.den = fps.num;
3412 video_enc->time_base.num = fps.den;
3414 video_enc->width = frame_width;
3415 video_enc->height = frame_height;
3416 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3417 video_enc->pix_fmt = frame_pix_fmt;
3418 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3420 choose_pixel_fmt(st, codec);
3423 video_enc->gop_size = 0;
3424 if (video_qscale || same_quality) {
3425 video_enc->flags |= CODEC_FLAG_QSCALE;
3426 video_enc->global_quality=
3427 st->quality = FF_QP2LAMBDA * video_qscale;
3431 video_enc->intra_matrix = intra_matrix;
3433 video_enc->inter_matrix = inter_matrix;
3435 p= video_rc_override_string;
3438 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3440 fprintf(stderr, "error parsing rc_override\n");
3443 video_enc->rc_override=
3444 av_realloc(video_enc->rc_override,
3445 sizeof(RcOverride)*(i+1));
3446 video_enc->rc_override[i].start_frame= start;
3447 video_enc->rc_override[i].end_frame = end;
3449 video_enc->rc_override[i].qscale= q;
3450 video_enc->rc_override[i].quality_factor= 1.0;
3453 video_enc->rc_override[i].qscale= 0;
3454 video_enc->rc_override[i].quality_factor= -q/100.0;
3459 video_enc->rc_override_count=i;
3460 if (!video_enc->rc_initial_buffer_occupancy)
3461 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3462 video_enc->me_threshold= me_threshold;
3463 video_enc->intra_dc_precision= intra_dc_precision - 8;
3466 video_enc->flags|= CODEC_FLAG_PSNR;
3471 video_enc->flags |= CODEC_FLAG_PASS1;
3473 video_enc->flags |= CODEC_FLAG_PASS2;
3478 if (video_language) {
3479 av_metadata_set2(&st->metadata, "language", video_language, 0);
3480 av_freep(&video_language);
3483 /* reset some key parameters */
3485 av_freep(&video_codec_name);
3486 video_stream_copy = 0;
3487 frame_pix_fmt = PIX_FMT_NONE;
3490 static void new_audio_stream(AVFormatContext *oc)
3493 AVCodecContext *audio_enc;
3494 enum CodecID codec_id;
3496 st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3498 fprintf(stderr, "Could not alloc stream\n");
3501 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3503 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3504 audio_bitstream_filters= NULL;
3506 avcodec_thread_init(st->codec, thread_count);
3508 audio_enc = st->codec;
3509 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3512 audio_enc->codec_tag= audio_codec_tag;
3514 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3515 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3516 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3518 if (audio_stream_copy) {
3519 st->stream_copy = 1;
3520 audio_enc->channels = audio_channels;
3521 audio_enc->sample_rate = audio_sample_rate;
3525 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3527 if (audio_codec_name) {
3528 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3529 audio_enc->strict_std_compliance);
3530 codec = avcodec_find_encoder_by_name(audio_codec_name);
3531 output_codecs[nb_ocodecs] = codec;
3533 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3534 codec = avcodec_find_encoder(codec_id);
3536 audio_enc->codec_id = codec_id;
3538 if (audio_qscale > QSCALE_NONE) {
3539 audio_enc->flags |= CODEC_FLAG_QSCALE;
3540 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3542 audio_enc->channels = audio_channels;
3543 audio_enc->sample_fmt = audio_sample_fmt;
3544 audio_enc->sample_rate = audio_sample_rate;
3545 audio_enc->channel_layout = channel_layout;
3546 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3547 audio_enc->channel_layout = 0;
3548 choose_sample_fmt(st, codec);
3549 choose_sample_rate(st, codec);
3552 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3553 if (audio_language) {
3554 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3555 av_freep(&audio_language);
3558 /* reset some key parameters */
3560 av_freep(&audio_codec_name);
3561 audio_stream_copy = 0;
3564 static void new_subtitle_stream(AVFormatContext *oc)
3567 AVCodecContext *subtitle_enc;
3569 st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3571 fprintf(stderr, "Could not alloc stream\n");
3574 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3576 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3577 subtitle_bitstream_filters= NULL;
3579 subtitle_enc = st->codec;
3580 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3582 if(subtitle_codec_tag)
3583 subtitle_enc->codec_tag= subtitle_codec_tag;
3585 if (subtitle_stream_copy) {
3586 st->stream_copy = 1;
3588 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3589 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3590 subtitle_enc->strict_std_compliance);
3591 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3595 if (subtitle_language) {
3596 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3597 av_freep(&subtitle_language);
3600 subtitle_disable = 0;
3601 av_freep(&subtitle_codec_name);
3602 subtitle_stream_copy = 0;
3605 static void opt_new_audio_stream(void)
3607 AVFormatContext *oc;
3608 if (nb_output_files <= 0) {
3609 fprintf(stderr, "At least one output file must be specified\n");
3612 oc = output_files[nb_output_files - 1];
3613 new_audio_stream(oc);
3616 static void opt_new_video_stream(void)
3618 AVFormatContext *oc;
3619 if (nb_output_files <= 0) {
3620 fprintf(stderr, "At least one output file must be specified\n");
3623 oc = output_files[nb_output_files - 1];
3624 new_video_stream(oc);
3627 static void opt_new_subtitle_stream(void)
3629 AVFormatContext *oc;
3630 if (nb_output_files <= 0) {
3631 fprintf(stderr, "At least one output file must be specified\n");
3634 oc = output_files[nb_output_files - 1];
3635 new_subtitle_stream(oc);
3638 /* arg format is "output-stream-index:streamid-value". */
3639 static void opt_streamid(const char *opt, const char *arg)
3645 strncpy(idx_str, arg, sizeof(idx_str));
3646 idx_str[sizeof(idx_str)-1] = '\0';
3647 p = strchr(idx_str, ':');
3650 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3655 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3656 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3659 static void opt_output_file(const char *filename)
3661 AVFormatContext *oc;
3662 int err, use_video, use_audio, use_subtitle;
3663 int input_has_video, input_has_audio, input_has_subtitle;
3664 AVFormatParameters params, *ap = ¶ms;
3665 AVOutputFormat *file_oformat;
3667 if (!strcmp(filename, "-"))
3670 oc = avformat_alloc_context();
3672 print_error(filename, AVERROR(ENOMEM));
3676 if (last_asked_format) {
3677 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3678 if (!file_oformat) {
3679 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3682 last_asked_format = NULL;
3684 file_oformat = av_guess_format(NULL, filename, NULL);
3685 if (!file_oformat) {
3686 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3692 oc->oformat = file_oformat;
3693 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3695 if (!strcmp(file_oformat->name, "ffm") &&
3696 av_strstart(filename, "http:", NULL)) {
3697 /* special case for files sent to ffserver: we get the stream
3698 parameters from ffserver */
3699 int err = read_ffserver_streams(oc, filename);
3701 print_error(filename, err);
3705 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3706 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3707 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3709 /* disable if no corresponding type found and at least one
3711 if (nb_input_files > 0) {
3712 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3713 &input_has_subtitle);
3714 if (!input_has_video)
3716 if (!input_has_audio)
3718 if (!input_has_subtitle)
3722 /* manual disable */
3723 if (audio_disable) {
3726 if (video_disable) {
3729 if (subtitle_disable) {
3734 new_video_stream(oc);
3738 new_audio_stream(oc);
3742 new_subtitle_stream(oc);
3745 oc->timestamp = recording_timestamp;
3747 for(; metadata_count>0; metadata_count--){
3748 av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3749 metadata[metadata_count-1].value, 0);
3751 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3754 output_files[nb_output_files++] = oc;
3756 /* check filename in case of an image number is expected */
3757 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3758 if (!av_filename_number_test(oc->filename)) {
3759 print_error(oc->filename, AVERROR_NUMEXPECTED);
3764 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3765 /* test if it already exists to avoid loosing precious files */
3766 if (!file_overwrite &&
3767 (strchr(filename, ':') == NULL ||
3768 filename[1] == ':' ||
3769 av_strstart(filename, "file:", NULL))) {
3770 if (url_exist(filename)) {
3772 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3774 if (!read_yesno()) {
3775 fprintf(stderr, "Not overwriting - exiting\n");
3780 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3787 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3788 print_error(filename, err);
3793 memset(ap, 0, sizeof(*ap));
3794 if (av_set_parameters(oc, ap) < 0) {
3795 fprintf(stderr, "%s: Invalid encoding parameters\n",
3800 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3801 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3802 oc->loop_output = loop_output;
3803 oc->flags |= AVFMT_FLAG_NONBLOCK;
3805 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3807 memset(streamid_map, 0, sizeof(streamid_map));
3810 /* same option as mencoder */
3811 static void opt_pass(const char *pass_str)
3814 pass = atoi(pass_str);
3815 if (pass != 1 && pass != 2) {
3816 fprintf(stderr, "pass number can be only 1 or 2\n");
3822 static int64_t getutime(void)
3825 struct rusage rusage;
3827 getrusage(RUSAGE_SELF, &rusage);
3828 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3829 #elif HAVE_GETPROCESSTIMES
3831 FILETIME c, e, k, u;
3832 proc = GetCurrentProcess();
3833 GetProcessTimes(proc, &c, &e, &k, &u);
3834 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3836 return av_gettime();
3840 static int64_t getmaxrss(void)
3842 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3843 struct rusage rusage;
3844 getrusage(RUSAGE_SELF, &rusage);
3845 return (int64_t)rusage.ru_maxrss * 1024;
3846 #elif HAVE_GETPROCESSMEMORYINFO
3848 PROCESS_MEMORY_COUNTERS memcounters;
3849 proc = GetCurrentProcess();
3850 memcounters.cb = sizeof(memcounters);
3851 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3852 return memcounters.PeakPagefileUsage;
3858 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3861 const char *p = str;
3868 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3875 static void opt_inter_matrix(const char *arg)
3877 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3878 parse_matrix_coeffs(inter_matrix, arg);
3881 static void opt_intra_matrix(const char *arg)
3883 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3884 parse_matrix_coeffs(intra_matrix, arg);
3888 * Trivial log callback.
3889 * Only suitable for show_help and similar since it lacks prefix handling.
3891 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3893 vfprintf(stdout, fmt, vl);
3896 static void show_usage(void)
3898 printf("Hyper fast Audio and Video encoder\n");
3899 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3903 static void show_help(void)
3905 av_log_set_callback(log_callback_help);
3907 show_help_options(options, "Main options:\n",
3908 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3909 show_help_options(options, "\nAdvanced options:\n",
3910 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3912 show_help_options(options, "\nVideo options:\n",
3913 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3915 show_help_options(options, "\nAdvanced Video options:\n",
3916 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3917 OPT_VIDEO | OPT_EXPERT);
3918 show_help_options(options, "\nAudio options:\n",
3919 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3921 show_help_options(options, "\nAdvanced Audio options:\n",
3922 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3923 OPT_AUDIO | OPT_EXPERT);
3924 show_help_options(options, "\nSubtitle options:\n",
3925 OPT_SUBTITLE | OPT_GRAB,
3927 show_help_options(options, "\nAudio/Video grab options:\n",
3931 av_opt_show(avcodec_opts[0], NULL);
3933 av_opt_show(avformat_opts, NULL);
3935 av_opt_show(sws_opts, NULL);
3938 static void opt_target(const char *arg)
3940 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3941 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3943 if(!strncmp(arg, "pal-", 4)) {
3946 } else if(!strncmp(arg, "ntsc-", 5)) {
3949 } else if(!strncmp(arg, "film-", 5)) {
3954 /* Calculate FR via float to avoid int overflow */
3955 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3958 } else if((fr == 29970) || (fr == 23976)) {
3961 /* Try to determine PAL/NTSC by peeking in the input files */
3962 if(nb_input_files) {
3964 for(j = 0; j < nb_input_files; j++) {
3965 for(i = 0; i < input_files[j]->nb_streams; i++) {
3966 AVCodecContext *c = input_files[j]->streams[i]->codec;
3967 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3969 fr = c->time_base.den * 1000 / c->time_base.num;
3973 } else if((fr == 29970) || (fr == 23976)) {
3983 if(verbose && norm != UNKNOWN)
3984 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3987 if(norm == UNKNOWN) {
3988 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3989 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3990 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3994 if(!strcmp(arg, "vcd")) {
3996 opt_video_codec("mpeg1video");
3997 opt_audio_codec("mp2");
4000 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4001 opt_frame_rate(NULL, frame_rates[norm]);
4002 opt_default("g", norm == PAL ? "15" : "18");
4004 opt_default("b", "1150000");
4005 opt_default("maxrate", "1150000");
4006 opt_default("minrate", "1150000");
4007 opt_default("bufsize", "327680"); // 40*1024*8;
4009 opt_default("ab", "224000");
4010 audio_sample_rate = 44100;
4013 opt_default("packetsize", "2324");
4014 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4016 /* We have to offset the PTS, so that it is consistent with the SCR.
4017 SCR starts at 36000, but the first two packs contain only padding
4018 and the first pack from the other stream, respectively, may also have
4019 been written before.
4020 So the real data starts at SCR 36000+3*1200. */
4021 mux_preload= (36000+3*1200) / 90000.0; //0.44
4022 } else if(!strcmp(arg, "svcd")) {
4024 opt_video_codec("mpeg2video");
4025 opt_audio_codec("mp2");
4028 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4029 opt_frame_rate(NULL, frame_rates[norm]);
4030 opt_default("g", norm == PAL ? "15" : "18");
4032 opt_default("b", "2040000");
4033 opt_default("maxrate", "2516000");
4034 opt_default("minrate", "0"); //1145000;
4035 opt_default("bufsize", "1835008"); //224*1024*8;
4036 opt_default("flags", "+scan_offset");
4039 opt_default("ab", "224000");
4040 audio_sample_rate = 44100;
4042 opt_default("packetsize", "2324");
4044 } else if(!strcmp(arg, "dvd")) {
4046 opt_video_codec("mpeg2video");
4047 opt_audio_codec("ac3");
4050 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4051 opt_frame_rate(NULL, frame_rates[norm]);
4052 opt_default("g", norm == PAL ? "15" : "18");
4054 opt_default("b", "6000000");
4055 opt_default("maxrate", "9000000");
4056 opt_default("minrate", "0"); //1500000;
4057 opt_default("bufsize", "1835008"); //224*1024*8;
4059 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4060 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4062 opt_default("ab", "448000");
4063 audio_sample_rate = 48000;
4065 } else if(!strncmp(arg, "dv", 2)) {
4069 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4070 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4071 (norm == PAL ? "yuv420p" : "yuv411p"));
4072 opt_frame_rate(NULL, frame_rates[norm]);
4074 audio_sample_rate = 48000;
4078 fprintf(stderr, "Unknown target: %s\n", arg);
4083 static void opt_vstats_file (const char *arg)
4085 av_free (vstats_filename);
4086 vstats_filename=av_strdup (arg);
4089 static void opt_vstats (void)
4092 time_t today2 = time(NULL);
4093 struct tm *today = localtime(&today2);
4095 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4097 opt_vstats_file(filename);
4100 static int opt_bsf(const char *opt, const char *arg)
4102 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4103 AVBitStreamFilterContext **bsfp;
4106 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4110 bsfp= *opt == 'v' ? &video_bitstream_filters :
4111 *opt == 'a' ? &audio_bitstream_filters :
4112 &subtitle_bitstream_filters;
4114 bsfp= &(*bsfp)->next;
4121 static int opt_preset(const char *opt, const char *arg)
4124 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4126 const char *base[3]= { getenv("FFMPEG_DATADIR"),
4132 for(i=0; i<3 && !f; i++){
4135 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4136 f= fopen(filename, "r");
4138 char *codec_name= *opt == 'v' ? video_codec_name :
4139 *opt == 'a' ? audio_codec_name :
4140 subtitle_codec_name;
4141 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4142 f= fopen(filename, "r");
4146 av_strlcpy(filename, arg, sizeof(filename));
4147 f= fopen(filename, "r");
4151 fprintf(stderr, "File for preset '%s' not found\n", arg);
4156 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4157 if(line[0] == '#' && !e)
4159 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4161 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4164 if(!strcmp(tmp, "acodec")){
4165 opt_audio_codec(tmp2);
4166 }else if(!strcmp(tmp, "vcodec")){
4167 opt_video_codec(tmp2);
4168 }else if(!strcmp(tmp, "scodec")){
4169 opt_subtitle_codec(tmp2);
4170 }else if(opt_default(tmp, tmp2) < 0){
4171 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4181 static const OptionDef options[] = {
4183 #include "cmdutils_common_opts.h"
4184 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4185 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4186 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4187 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4188 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4189 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4190 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4191 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4192 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4193 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4194 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4195 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4196 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4197 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4198 "add timings for benchmarking" },
4199 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4200 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4201 "dump each input packet" },
4202 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4203 "when dumping packets, also dump the payload" },
4204 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4205 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4206 { "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)", "" },
4207 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4208 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4209 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4210 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4211 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4212 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4213 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4214 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4215 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4216 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4217 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4218 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4219 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4222 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4223 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4224 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4225 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4226 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4227 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4228 { "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" },
4229 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "Deprecated, please use the crop avfilter", "size" },
4230 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "Deprecated, please use the crop avfilter", "size" },
4231 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "Deprecated, please use the crop avfilter", "size" },
4232 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "Deprecated, please use the crop avfilter", "size" },
4233 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4234 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4235 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4236 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4237 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4238 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4239 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4240 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4241 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4242 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4243 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4244 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4245 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4246 "use same video quality as source (implies VBR)" },
4247 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4248 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4249 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4250 "deinterlace pictures" },
4251 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4252 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4253 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4255 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4257 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4258 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4259 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4260 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4261 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4262 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4263 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4264 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4265 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4266 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4269 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4270 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4271 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4272 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4273 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4274 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4275 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4276 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4277 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4278 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4279 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4280 { "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" },
4282 /* subtitle options */
4283 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4284 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4285 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4286 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4287 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4290 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4291 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4292 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4295 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4296 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4298 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4299 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4300 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4302 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4303 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4304 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4305 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4307 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4311 int main(int argc, char **argv)
4316 avcodec_register_all();
4318 avdevice_register_all();
4321 avfilter_register_all();
4326 if(isatty(STDIN_FILENO))
4327 url_set_interrupt_cb(decode_interrupt_cb);
4330 for(i=0; i<AVMEDIA_TYPE_NB; i++){
4331 avcodec_opts[i]= avcodec_alloc_context2(i);
4333 avformat_opts = avformat_alloc_context();
4334 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4339 parse_options(argc, argv, options, opt_output_file);
4341 if(nb_output_files <= 0 && nb_input_files == 0) {
4343 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4347 /* file converter / grab */
4348 if (nb_output_files <= 0) {
4349 fprintf(stderr, "At least one output file must be specified\n");
4353 if (nb_input_files == 0) {
4354 fprintf(stderr, "At least one input file must be specified\n");
4359 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4360 stream_maps, nb_stream_maps) < 0)
4362 ti = getutime() - ti;
4364 int maxrss = getmaxrss() / 1024;
4365 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4368 return ffmpeg_exit(0);