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 "libavcore/samplefmt.h"
41 #include "libavutil/colorspace.h"
42 #include "libavutil/fifo.h"
43 #include "libavutil/intreadwrite.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
73 #include <sys/ioctl.h>
83 #include "libavutil/avassert.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;
97 * select an input file for an output file
99 typedef struct AVMetaDataMap {
100 int file; //< file index
101 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
102 int index; //< stream/chapter/program number
105 typedef struct AVChapterMap {
110 static const OptionDef options[];
112 #define MAX_FILES 100
113 #if !FF_API_MAX_STREAMS
114 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
117 static const char *last_asked_format = NULL;
118 static AVFormatContext *input_files[MAX_FILES];
119 static int64_t input_files_ts_offset[MAX_FILES];
120 static double *input_files_ts_scale[MAX_FILES] = {NULL};
121 static AVCodec **input_codecs = NULL;
122 static int nb_input_files = 0;
123 static int nb_input_codecs = 0;
124 static int nb_input_files_ts_scale[MAX_FILES] = {0};
126 static AVFormatContext *output_files[MAX_FILES];
127 static AVCodec **output_codecs = NULL;
128 static int nb_output_files = 0;
129 static int nb_output_codecs = 0;
131 static AVStreamMap *stream_maps = NULL;
132 static int nb_stream_maps;
134 /* first item specifies output metadata, second is input */
135 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
136 static int nb_meta_data_maps;
137 static int metadata_streams_autocopy = 1;
138 static int metadata_chapters_autocopy = 1;
140 static AVChapterMap *chapter_maps = NULL;
141 static int nb_chapter_maps;
143 /* indexed by output file stream index */
144 static int *streamid_map = NULL;
145 static int nb_streamid_map = 0;
147 static int frame_width = 0;
148 static int frame_height = 0;
149 static float frame_aspect_ratio = 0;
150 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
151 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
152 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
153 static AVRational frame_rate;
154 static float video_qscale = 0;
155 static uint16_t *intra_matrix = NULL;
156 static uint16_t *inter_matrix = NULL;
157 static const char *video_rc_override_string=NULL;
158 static int video_disable = 0;
159 static int video_discard = 0;
160 static char *video_codec_name = NULL;
161 static unsigned int video_codec_tag = 0;
162 static char *video_language = NULL;
163 static int same_quality = 0;
164 static int do_deinterlace = 0;
165 static int top_field_first = -1;
166 static int me_threshold = 0;
167 static int intra_dc_precision = 8;
168 static int loop_input = 0;
169 static int loop_output = AVFMT_NOOUTPUTLOOP;
170 static int qp_hist = 0;
172 static char *vfilters = NULL;
173 AVFilterGraph *graph = NULL;
176 static int intra_only = 0;
177 static int audio_sample_rate = 44100;
178 static int64_t channel_layout = 0;
179 #define QSCALE_NONE -99999
180 static float audio_qscale = QSCALE_NONE;
181 static int audio_disable = 0;
182 static int audio_channels = 1;
183 static char *audio_codec_name = NULL;
184 static unsigned int audio_codec_tag = 0;
185 static char *audio_language = NULL;
187 static int subtitle_disable = 0;
188 static char *subtitle_codec_name = NULL;
189 static char *subtitle_language = NULL;
190 static unsigned int subtitle_codec_tag = 0;
192 static float mux_preload= 0.5;
193 static float mux_max_delay= 0.7;
195 static int64_t recording_time = INT64_MAX;
196 static int64_t start_time = 0;
197 static int64_t recording_timestamp = 0;
198 static int64_t input_ts_offset = 0;
199 static int file_overwrite = 0;
200 static AVMetadata *metadata;
201 static int do_benchmark = 0;
202 static int do_hex_dump = 0;
203 static int do_pkt_dump = 0;
204 static int do_psnr = 0;
205 static int do_pass = 0;
206 static char *pass_logfilename_prefix = NULL;
207 static int audio_stream_copy = 0;
208 static int video_stream_copy = 0;
209 static int subtitle_stream_copy = 0;
210 static int video_sync_method= -1;
211 static int audio_sync_method= 0;
212 static float audio_drift_threshold= 0.1;
213 static int copy_ts= 0;
214 static int opt_shortest = 0;
215 static int video_global_header = 0;
216 static char *vstats_filename;
217 static FILE *vstats_file;
218 static int opt_programid = 0;
219 static int copy_initial_nonkeyframes = 0;
221 static int rate_emu = 0;
223 static int video_channel = 0;
224 static char *video_standard;
226 static int audio_volume = 256;
228 static int exit_on_error = 0;
229 static int using_stdin = 0;
230 static int verbose = 1;
231 static int thread_count= 1;
232 static int q_pressed = 0;
233 static int64_t video_size = 0;
234 static int64_t audio_size = 0;
235 static int64_t extra_size = 0;
236 static int nb_frames_dup = 0;
237 static int nb_frames_drop = 0;
238 static int input_sync;
239 static uint64_t limit_filesize = 0;
240 static int force_fps = 0;
241 static char *forced_key_frames = NULL;
243 static float dts_delta_threshold = 10;
245 static unsigned int sws_flags = SWS_BICUBIC;
247 static int64_t timer_start;
249 static uint8_t *audio_buf;
250 static uint8_t *audio_out;
251 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
253 static short *samples;
255 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
256 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
257 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
259 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
261 struct AVInputStream;
263 typedef struct AVOutputStream {
264 int file_index; /* file index */
265 int index; /* stream index in the output file */
266 int source_index; /* AVInputStream index */
267 AVStream *st; /* stream in the output file */
268 int encoding_needed; /* true if encoding needed for this stream */
270 /* input pts and corresponding output pts
272 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
273 struct AVInputStream *sync_ist; /* input stream to sync against */
274 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
275 AVBitStreamFilterContext *bitstream_filters;
278 AVFrame pict_tmp; /* temporary image for resampling */
279 struct SwsContext *img_resample_ctx; /* for image resampling */
282 int resample_pix_fmt;
284 /* full frame size of first frame */
288 /* forced key frames */
289 int64_t *forced_kf_pts;
295 ReSampleContext *resample; /* for audio resampling */
297 AVAudioConvert *reformat_ctx;
298 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
302 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
303 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
305 typedef struct AVInputStream {
309 int discard; /* true if stream data should be discarded */
310 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
311 int64_t sample_index; /* current sample */
313 int64_t start; /* time when read started */
314 int64_t next_pts; /* synthetic pts for cases where pkt.pts
316 int64_t pts; /* current pts */
317 PtsCorrectionContext pts_ctx;
318 int is_start; /* is 1 at the start and after a discontinuity */
319 int showed_multi_packet_warning;
320 int is_past_recording_time;
322 AVFilterContext *output_video_filter;
323 AVFilterContext *input_video_filter;
324 AVFrame *filter_frame;
325 int has_filter_frame;
326 AVFilterBufferRef *picref;
330 typedef struct AVInputFile {
331 int eof_reached; /* true if eof reached */
332 int ist_index; /* index of first stream in ist_table */
333 int buffer_size; /* current total buffer size */
334 int nb_streams; /* nb streams we are aware of */
339 /* init terminal so that we can grab keys */
340 static struct termios oldtty;
345 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
347 AVFilterContext *last_filter, *filter;
348 /** filter graph containing all filters including input & output */
349 AVCodecContext *codec = ost->st->codec;
350 AVCodecContext *icodec = ist->st->codec;
351 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
355 graph = avfilter_graph_alloc();
357 if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
359 if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
362 snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
363 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
364 if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
366 if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
369 /* add input and output filters to the overall graph */
370 avfilter_graph_add_filter(graph, ist->input_video_filter);
371 avfilter_graph_add_filter(graph, ist->output_video_filter);
373 last_filter = ist->input_video_filter;
375 if (codec->width != icodec->width || codec->height != icodec->height) {
376 snprintf(args, 255, "%d:%d:flags=0x%X",
379 (int)av_get_int(sws_opts, "sws_flags", NULL));
380 if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
382 if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
384 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
386 last_filter = filter;
387 avfilter_graph_add_filter(graph, last_filter);
390 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
391 graph->scale_sws_opts = av_strdup(args);
394 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
395 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
397 outputs->name = av_strdup("in");
398 outputs->filter_ctx = last_filter;
399 outputs->pad_idx = 0;
400 outputs->next = NULL;
402 inputs->name = av_strdup("out");
403 inputs->filter_ctx = ist->output_video_filter;
407 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
411 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
415 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
418 codec->width = ist->output_video_filter->inputs[0]->w;
419 codec->height = ist->output_video_filter->inputs[0]->h;
423 #endif /* CONFIG_AVFILTER */
425 static void term_exit(void)
427 av_log(NULL, AV_LOG_QUIET, "");
429 tcsetattr (0, TCSANOW, &oldtty);
433 static volatile int received_sigterm = 0;
436 sigterm_handler(int sig)
438 received_sigterm = sig;
442 static void term_init(void)
451 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
452 |INLCR|IGNCR|ICRNL|IXON);
453 tty.c_oflag |= OPOST;
454 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
455 tty.c_cflag &= ~(CSIZE|PARENB);
460 tcsetattr (0, TCSANOW, &tty);
461 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
464 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
465 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
467 signal(SIGXCPU, sigterm_handler);
471 /* read a key without blocking */
472 static int read_key(void)
484 n = select(1, &rfds, NULL, NULL, &tv);
499 static int decode_interrupt_cb(void)
501 return q_pressed || (q_pressed = read_key() == 'q');
504 static int ffmpeg_exit(int ret)
509 for(i=0;i<nb_output_files;i++) {
510 /* maybe av_close_output_file ??? */
511 AVFormatContext *s = output_files[i];
513 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
515 for(j=0;j<s->nb_streams;j++) {
516 av_metadata_free(&s->streams[j]->metadata);
517 av_free(s->streams[j]->codec);
518 av_free(s->streams[j]->info);
519 av_free(s->streams[j]);
521 for(j=0;j<s->nb_programs;j++) {
522 av_metadata_free(&s->programs[j]->metadata);
524 for(j=0;j<s->nb_chapters;j++) {
525 av_metadata_free(&s->chapters[j]->metadata);
527 av_metadata_free(&s->metadata);
529 av_free(output_streams_for_file[i]);
531 for(i=0;i<nb_input_files;i++) {
532 av_close_input_file(input_files[i]);
533 av_free(input_files_ts_scale[i]);
536 av_free(intra_matrix);
537 av_free(inter_matrix);
541 av_free(vstats_filename);
544 av_free(streamid_map);
545 av_free(input_codecs);
546 av_free(output_codecs);
547 av_free(stream_maps);
548 av_free(meta_data_maps);
550 av_free(video_codec_name);
551 av_free(audio_codec_name);
552 av_free(subtitle_codec_name);
554 av_free(video_standard);
559 allocated_audio_buf_size= allocated_audio_out_size= 0;
566 if (received_sigterm) {
568 "Received signal %d: terminating.\n",
569 (int) received_sigterm);
573 exit(ret); /* not all OS-es handle main() return value */
577 /* similar to ff_dynarray_add() and av_fast_realloc() */
578 static void *grow_array(void *array, int elem_size, int *size, int new_size)
580 if (new_size >= INT_MAX / elem_size) {
581 fprintf(stderr, "Array too big.\n");
584 if (*size < new_size) {
585 uint8_t *tmp = av_realloc(array, new_size*elem_size);
587 fprintf(stderr, "Could not alloc buffer.\n");
590 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
597 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
599 if(codec && codec->sample_fmts){
600 const enum AVSampleFormat *p= codec->sample_fmts;
602 if(*p == st->codec->sample_fmt)
606 st->codec->sample_fmt = codec->sample_fmts[0];
610 static void choose_sample_rate(AVStream *st, AVCodec *codec)
612 if(codec && codec->supported_samplerates){
613 const int *p= codec->supported_samplerates;
615 int best_dist=INT_MAX;
617 int dist= abs(st->codec->sample_rate - *p);
618 if(dist < best_dist){
624 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
626 st->codec->sample_rate= best;
630 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
632 if(codec && codec->pix_fmts){
633 const enum PixelFormat *p= codec->pix_fmts;
635 if(*p == st->codec->pix_fmt)
639 && !( st->codec->codec_id==CODEC_ID_MJPEG
640 && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
641 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
642 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
643 st->codec->pix_fmt = codec->pix_fmts[0];
647 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
649 int idx = oc->nb_streams - 1;
652 output_streams_for_file[file_idx] =
653 grow_array(output_streams_for_file[file_idx],
654 sizeof(*output_streams_for_file[file_idx]),
655 &nb_output_streams_for_file[file_idx],
657 ost = output_streams_for_file[file_idx][idx] =
658 av_mallocz(sizeof(AVOutputStream));
660 fprintf(stderr, "Could not alloc output stream\n");
663 ost->file_index = file_idx;
668 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
674 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
677 /* copy stream format */
679 for(i=0;i<ic->nb_streams;i++) {
685 // FIXME: a more elegant solution is needed
686 st = av_mallocz(sizeof(AVStream));
687 memcpy(st, ic->streams[i], sizeof(AVStream));
688 st->codec = avcodec_alloc_context();
690 print_error(filename, AVERROR(ENOMEM));
693 avcodec_copy_context(st->codec, ic->streams[i]->codec);
696 codec = avcodec_find_encoder(st->codec->codec_id);
697 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
698 if (audio_stream_copy) {
701 choose_sample_fmt(st, codec);
702 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
703 if (video_stream_copy) {
706 choose_pixel_fmt(st, codec);
709 if(!st->codec->thread_count)
710 st->codec->thread_count = 1;
711 if(st->codec->thread_count>1)
712 avcodec_thread_init(st->codec, st->codec->thread_count);
714 if(st->codec->flags & CODEC_FLAG_BITEXACT)
717 new_output_stream(s, nb_output_files);
721 s->timestamp = av_gettime();
723 av_close_input_file(ic);
728 get_sync_ipts(const AVOutputStream *ost)
730 const AVInputStream *ist = ost->sync_ist;
731 return (double)(ist->pts - start_time)/AV_TIME_BASE;
734 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
738 AVPacket new_pkt= *pkt;
739 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
740 &new_pkt.data, &new_pkt.size,
741 pkt->data, pkt->size,
742 pkt->flags & AV_PKT_FLAG_KEY);
745 new_pkt.destruct= av_destruct_packet;
747 fprintf(stderr, "%s failed for stream %d, codec %s",
748 bsfc->filter->name, pkt->stream_index,
749 avctx->codec ? avctx->codec->name : "copy");
759 ret= av_interleaved_write_frame(s, pkt);
761 print_error("av_interleaved_write_frame()", ret);
766 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
768 static void do_audio_out(AVFormatContext *s,
771 unsigned char *buf, int size)
774 int64_t audio_out_size, audio_buf_size;
775 int64_t allocated_for_size= size;
777 int size_out, frame_bytes, ret;
778 AVCodecContext *enc= ost->st->codec;
779 AVCodecContext *dec= ist->st->codec;
780 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
781 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
782 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
785 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
786 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
787 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
788 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
789 audio_buf_size*= osize*enc->channels;
791 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
792 if(coded_bps > 8*osize)
793 audio_out_size= audio_out_size * coded_bps / (8*osize);
794 audio_out_size += FF_MIN_BUFFER_SIZE;
796 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
797 fprintf(stderr, "Buffer sizes too large\n");
801 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
802 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
803 if (!audio_buf || !audio_out){
804 fprintf(stderr, "Out of memory in do_audio_out\n");
808 if (enc->channels != dec->channels)
809 ost->audio_resample = 1;
811 if (ost->audio_resample && !ost->resample) {
812 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
813 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
814 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
815 enc->sample_rate, dec->sample_rate,
816 enc->sample_fmt, dec->sample_fmt,
818 if (!ost->resample) {
819 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
820 dec->channels, dec->sample_rate,
821 enc->channels, enc->sample_rate);
826 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
827 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
828 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
829 if (ost->reformat_ctx)
830 av_audio_convert_free(ost->reformat_ctx);
831 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
832 dec->sample_fmt, 1, NULL, 0);
833 if (!ost->reformat_ctx) {
834 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
835 av_get_sample_fmt_name(dec->sample_fmt),
836 av_get_sample_fmt_name(enc->sample_fmt));
839 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
842 if(audio_sync_method){
843 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
844 - av_fifo_size(ost->fifo)/(enc->channels * 2);
845 double idelta= delta*dec->sample_rate / enc->sample_rate;
846 int byte_delta= ((int)idelta)*2*dec->channels;
848 //FIXME resample delay
849 if(fabs(delta) > 50){
850 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
852 byte_delta= FFMAX(byte_delta, -size);
856 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
861 static uint8_t *input_tmp= NULL;
862 input_tmp= av_realloc(input_tmp, byte_delta + size);
864 if(byte_delta > allocated_for_size - size){
865 allocated_for_size= byte_delta + (int64_t)size;
870 memset(input_tmp, 0, byte_delta);
871 memcpy(input_tmp + byte_delta, buf, size);
875 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
877 }else if(audio_sync_method>1){
878 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
879 av_assert0(ost->audio_resample);
881 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
882 // 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));
883 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
887 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
888 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
890 if (ost->audio_resample) {
892 size_out = audio_resample(ost->resample,
893 (short *)buftmp, (short *)buf,
894 size / (dec->channels * isize));
895 size_out = size_out * enc->channels * osize;
901 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
902 const void *ibuf[6]= {buftmp};
903 void *obuf[6]= {audio_buf};
904 int istride[6]= {isize};
905 int ostride[6]= {osize};
906 int len= size_out/istride[0];
907 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
908 printf("av_audio_convert() failed\n");
914 size_out = len*osize;
917 /* now encode as many frames as possible */
918 if (enc->frame_size > 1) {
919 /* output resampled raw samples */
920 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
921 fprintf(stderr, "av_fifo_realloc2() failed\n");
924 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
926 frame_bytes = enc->frame_size * osize * enc->channels;
928 while (av_fifo_size(ost->fifo) >= frame_bytes) {
930 av_init_packet(&pkt);
932 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
934 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
936 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
939 fprintf(stderr, "Audio encoding failed\n");
943 pkt.stream_index= ost->index;
946 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
947 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
948 pkt.flags |= AV_PKT_FLAG_KEY;
949 write_frame(s, &pkt, enc, ost->bitstream_filters);
951 ost->sync_opts += enc->frame_size;
955 av_init_packet(&pkt);
957 ost->sync_opts += size_out / (osize * enc->channels);
959 /* output a pcm frame */
960 /* determine the size of the coded buffer */
963 size_out = size_out*coded_bps/8;
965 if(size_out > audio_out_size){
966 fprintf(stderr, "Internal error, buffer size too small\n");
970 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
971 ret = avcodec_encode_audio(enc, audio_out, size_out,
974 fprintf(stderr, "Audio encoding failed\n");
978 pkt.stream_index= ost->index;
981 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
982 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
983 pkt.flags |= AV_PKT_FLAG_KEY;
984 write_frame(s, &pkt, enc, ost->bitstream_filters);
988 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
992 AVPicture picture_tmp;
995 dec = ist->st->codec;
997 /* deinterlace : must be done before any resize */
998 if (do_deinterlace) {
1001 /* create temporary picture */
1002 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1003 buf = av_malloc(size);
1007 picture2 = &picture_tmp;
1008 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1010 if(avpicture_deinterlace(picture2, picture,
1011 dec->pix_fmt, dec->width, dec->height) < 0) {
1012 /* if error, do not deinterlace */
1013 fprintf(stderr, "Deinterlacing failed\n");
1022 if (picture != picture2)
1023 *picture = *picture2;
1027 /* we begin to correct av delay at this threshold */
1028 #define AV_DELAY_MAX 0.100
1030 static void do_subtitle_out(AVFormatContext *s,
1031 AVOutputStream *ost,
1036 static uint8_t *subtitle_out = NULL;
1037 int subtitle_out_max_size = 1024 * 1024;
1038 int subtitle_out_size, nb, i;
1039 AVCodecContext *enc;
1042 if (pts == AV_NOPTS_VALUE) {
1043 fprintf(stderr, "Subtitle packets must have a pts\n");
1049 enc = ost->st->codec;
1051 if (!subtitle_out) {
1052 subtitle_out = av_malloc(subtitle_out_max_size);
1055 /* Note: DVB subtitle need one packet to draw them and one other
1056 packet to clear them */
1057 /* XXX: signal it in the codec context ? */
1058 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1063 for(i = 0; i < nb; i++) {
1064 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1065 // start_display_time is required to be 0
1066 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1067 sub->end_display_time -= sub->start_display_time;
1068 sub->start_display_time = 0;
1069 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1070 subtitle_out_max_size, sub);
1071 if (subtitle_out_size < 0) {
1072 fprintf(stderr, "Subtitle encoding failed\n");
1076 av_init_packet(&pkt);
1077 pkt.stream_index = ost->index;
1078 pkt.data = subtitle_out;
1079 pkt.size = subtitle_out_size;
1080 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1081 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1082 /* XXX: the pts correction is handled here. Maybe handling
1083 it in the codec would be better */
1085 pkt.pts += 90 * sub->start_display_time;
1087 pkt.pts += 90 * sub->end_display_time;
1089 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1093 static int bit_buffer_size= 1024*256;
1094 static uint8_t *bit_buffer= NULL;
1096 static void do_video_out(AVFormatContext *s,
1097 AVOutputStream *ost,
1099 AVFrame *in_picture,
1102 int nb_frames, i, ret;
1103 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1104 AVCodecContext *enc, *dec;
1107 enc = ost->st->codec;
1108 dec = ist->st->codec;
1110 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1112 /* by default, we output a single frame */
1117 if(video_sync_method){
1118 double vdelta = sync_ipts - ost->sync_opts;
1119 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1122 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1125 }else if(vdelta>0.6)
1126 ost->sync_opts= lrintf(sync_ipts);
1127 }else if (vdelta > 1.1)
1128 nb_frames = lrintf(vdelta);
1129 //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);
1130 if (nb_frames == 0){
1133 fprintf(stderr, "*** drop!\n");
1134 }else if (nb_frames > 1) {
1135 nb_frames_dup += nb_frames - 1;
1137 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1140 ost->sync_opts= lrintf(sync_ipts);
1142 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1146 formatted_picture = in_picture;
1147 final_picture = formatted_picture;
1148 padding_src = formatted_picture;
1149 resampling_dst = &ost->pict_tmp;
1151 if ( ost->resample_height != ist->st->codec->height
1152 || ost->resample_width != ist->st->codec->width
1153 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1155 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));
1156 if(!ost->video_resample)
1160 #if !CONFIG_AVFILTER
1161 if (ost->video_resample) {
1163 final_picture = &ost->pict_tmp;
1164 if( ost->resample_height != ist->st->codec->height
1165 || ost->resample_width != ist->st->codec->width
1166 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1168 /* initialize a new scaler context */
1169 sws_freeContext(ost->img_resample_ctx);
1170 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1171 ost->img_resample_ctx = sws_getContext(
1172 ist->st->codec->width,
1173 ist->st->codec->height,
1174 ist->st->codec->pix_fmt,
1175 ost->st->codec->width,
1176 ost->st->codec->height,
1177 ost->st->codec->pix_fmt,
1178 sws_flags, NULL, NULL, NULL);
1179 if (ost->img_resample_ctx == NULL) {
1180 fprintf(stderr, "Cannot get resampling context\n");
1184 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1185 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1189 /* duplicates frame if needed */
1190 for(i=0;i<nb_frames;i++) {
1192 av_init_packet(&pkt);
1193 pkt.stream_index= ost->index;
1195 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1196 /* raw pictures are written as AVPicture structure to
1197 avoid any copies. We support temorarily the older
1199 AVFrame* old_frame = enc->coded_frame;
1200 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1201 pkt.data= (uint8_t *)final_picture;
1202 pkt.size= sizeof(AVPicture);
1203 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1204 pkt.flags |= AV_PKT_FLAG_KEY;
1206 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1207 enc->coded_frame = old_frame;
1209 AVFrame big_picture;
1211 big_picture= *final_picture;
1212 /* better than nothing: use input picture interlaced
1214 big_picture.interlaced_frame = in_picture->interlaced_frame;
1215 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1216 if(top_field_first == -1)
1217 big_picture.top_field_first = in_picture->top_field_first;
1219 big_picture.top_field_first = top_field_first;
1222 /* handles sameq here. This is not correct because it may
1223 not be a global option */
1224 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1226 big_picture.pict_type = 0;
1227 // big_picture.pts = AV_NOPTS_VALUE;
1228 big_picture.pts= ost->sync_opts;
1229 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1230 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1231 if (ost->forced_kf_index < ost->forced_kf_count &&
1232 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1233 big_picture.pict_type = FF_I_TYPE;
1234 ost->forced_kf_index++;
1236 ret = avcodec_encode_video(enc,
1237 bit_buffer, bit_buffer_size,
1240 fprintf(stderr, "Video encoding failed\n");
1245 pkt.data= bit_buffer;
1247 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1248 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1249 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1250 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1251 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1253 if(enc->coded_frame->key_frame)
1254 pkt.flags |= AV_PKT_FLAG_KEY;
1255 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1258 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1259 // enc->frame_number-1, ret, enc->pict_type);
1260 /* if two pass, output log */
1261 if (ost->logfile && enc->stats_out) {
1262 fprintf(ost->logfile, "%s", enc->stats_out);
1267 ost->frame_number++;
1271 static double psnr(double d){
1272 return -10.0*log(d)/log(10.0);
1275 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1278 AVCodecContext *enc;
1280 double ti1, bitrate, avg_bitrate;
1282 /* this is executed just the first time do_video_stats is called */
1284 vstats_file = fopen(vstats_filename, "w");
1291 enc = ost->st->codec;
1292 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1293 frame_number = ost->frame_number;
1294 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1295 if (enc->flags&CODEC_FLAG_PSNR)
1296 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1298 fprintf(vstats_file,"f_size= %6d ", frame_size);
1299 /* compute pts value */
1300 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1304 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1305 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1306 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1307 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1308 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1312 static void print_report(AVFormatContext **output_files,
1313 AVOutputStream **ost_table, int nb_ostreams,
1317 AVOutputStream *ost;
1318 AVFormatContext *oc;
1320 AVCodecContext *enc;
1321 int frame_number, vid, i;
1322 double bitrate, ti1, pts;
1323 static int64_t last_time = -1;
1324 static int qp_histogram[52];
1326 if (!is_last_report) {
1328 /* display the report every 0.5 seconds */
1329 cur_time = av_gettime();
1330 if (last_time == -1) {
1331 last_time = cur_time;
1334 if ((cur_time - last_time) < 500000)
1336 last_time = cur_time;
1340 oc = output_files[0];
1342 total_size = url_fsize(oc->pb);
1343 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1344 total_size= url_ftell(oc->pb);
1349 for(i=0;i<nb_ostreams;i++) {
1351 enc = ost->st->codec;
1352 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1354 !ost->st->stream_copy ?
1355 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1357 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1358 float t = (av_gettime()-timer_start) / 1000000.0;
1360 frame_number = ost->frame_number;
1361 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1362 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1363 !ost->st->stream_copy ?
1364 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1369 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1370 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1373 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1375 if (enc->flags&CODEC_FLAG_PSNR){
1377 double error, error_sum=0;
1378 double scale, scale_sum=0;
1379 char type[3]= {'Y','U','V'};
1380 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1383 error= enc->error[j];
1384 scale= enc->width*enc->height*255.0*255.0*frame_number;
1386 error= enc->coded_frame->error[j];
1387 scale= enc->width*enc->height*255.0*255.0;
1392 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1394 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1398 /* compute min output value */
1399 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1400 if ((pts < ti1) && (pts > 0))
1406 if (verbose || is_last_report) {
1407 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1409 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1410 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1411 (double)total_size / 1024, ti1, bitrate);
1413 if (nb_frames_dup || nb_frames_drop)
1414 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1415 nb_frames_dup, nb_frames_drop);
1418 fprintf(stderr, "%s \r", buf);
1423 if (is_last_report && verbose >= 0){
1424 int64_t raw= audio_size + video_size + extra_size;
1425 fprintf(stderr, "\n");
1426 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1430 100.0*(total_size - raw)/raw
1435 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1436 static int output_packet(AVInputStream *ist, int ist_index,
1437 AVOutputStream **ost_table, int nb_ostreams,
1438 const AVPacket *pkt)
1440 AVFormatContext *os;
1441 AVOutputStream *ost;
1445 void *buffer_to_free;
1446 static unsigned int samples_size= 0;
1447 AVSubtitle subtitle, *subtitle_to_free;
1448 int64_t pkt_pts = AV_NOPTS_VALUE;
1450 int frame_available;
1454 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1456 if(ist->next_pts == AV_NOPTS_VALUE)
1457 ist->next_pts= ist->pts;
1461 av_init_packet(&avpkt);
1469 if(pkt->dts != AV_NOPTS_VALUE)
1470 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1471 if(pkt->pts != AV_NOPTS_VALUE)
1472 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1474 //while we have more to decode or while the decoder did output something on EOF
1475 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1476 uint8_t *data_buf, *decoded_data_buf;
1477 int data_size, decoded_data_size;
1479 ist->pts= ist->next_pts;
1481 if(avpkt.size && avpkt.size != pkt->size &&
1482 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1483 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1484 ist->showed_multi_packet_warning=1;
1487 /* decode the packet if needed */
1488 decoded_data_buf = NULL; /* fail safe */
1489 decoded_data_size= 0;
1490 data_buf = avpkt.data;
1491 data_size = avpkt.size;
1492 subtitle_to_free = NULL;
1493 if (ist->decoding_needed) {
1494 switch(ist->st->codec->codec_type) {
1495 case AVMEDIA_TYPE_AUDIO:{
1496 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1497 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1499 samples= av_malloc(samples_size);
1501 decoded_data_size= samples_size;
1502 /* XXX: could avoid copy if PCM 16 bits with same
1503 endianness as CPU */
1504 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1511 /* Some bug in mpeg audio decoder gives */
1512 /* decoded_data_size < 0, it seems they are overflows */
1513 if (decoded_data_size <= 0) {
1514 /* no audio frame */
1517 decoded_data_buf = (uint8_t *)samples;
1518 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1519 (ist->st->codec->sample_rate * ist->st->codec->channels);
1521 case AVMEDIA_TYPE_VIDEO:
1522 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1523 /* XXX: allocate picture correctly */
1524 avcodec_get_frame_defaults(&picture);
1525 ist->st->codec->reordered_opaque = pkt_pts;
1526 pkt_pts = AV_NOPTS_VALUE;
1528 ret = avcodec_decode_video2(ist->st->codec,
1529 &picture, &got_picture, &avpkt);
1530 ist->st->quality= picture.quality;
1534 /* no picture yet */
1535 goto discard_packet;
1537 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1538 if (ist->st->codec->time_base.num != 0) {
1539 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1540 ist->next_pts += ((int64_t)AV_TIME_BASE *
1541 ist->st->codec->time_base.num * ticks) /
1542 ist->st->codec->time_base.den;
1546 case AVMEDIA_TYPE_SUBTITLE:
1547 ret = avcodec_decode_subtitle2(ist->st->codec,
1548 &subtitle, &got_picture, &avpkt);
1552 goto discard_packet;
1554 subtitle_to_free = &subtitle;
1561 switch(ist->st->codec->codec_type) {
1562 case AVMEDIA_TYPE_AUDIO:
1563 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1564 ist->st->codec->sample_rate;
1566 case AVMEDIA_TYPE_VIDEO:
1567 if (ist->st->codec->time_base.num != 0) {
1568 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1569 ist->next_pts += ((int64_t)AV_TIME_BASE *
1570 ist->st->codec->time_base.num * ticks) /
1571 ist->st->codec->time_base.den;
1579 buffer_to_free = NULL;
1580 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1581 pre_process_video_frame(ist, (AVPicture *)&picture,
1586 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1587 // add it to be filtered
1588 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1590 ist->st->codec->sample_aspect_ratio);
1594 // preprocess audio (volume)
1595 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1596 if (audio_volume != 256) {
1599 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1600 int v = ((*volp) * audio_volume + 128) >> 8;
1601 if (v < -32768) v = -32768;
1602 if (v > 32767) v = 32767;
1608 /* frame rate emulation */
1610 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1611 int64_t now = av_gettime() - ist->start;
1616 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1617 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1619 /* if output time reached then transcode raw format,
1620 encode packets and output them */
1621 if (start_time == 0 || ist->pts >= start_time)
1623 while (frame_available) {
1624 AVRational ist_pts_tb;
1625 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1626 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1628 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1630 for(i=0;i<nb_ostreams;i++) {
1634 if (ost->source_index == ist_index) {
1635 os = output_files[ost->file_index];
1637 /* set the input output pts pairs */
1638 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1640 if (ost->encoding_needed) {
1641 av_assert0(ist->decoding_needed);
1642 switch(ost->st->codec->codec_type) {
1643 case AVMEDIA_TYPE_AUDIO:
1644 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1646 case AVMEDIA_TYPE_VIDEO:
1648 if (ist->picref->video)
1649 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1651 do_video_out(os, ost, ist, &picture, &frame_size);
1652 if (vstats_filename && frame_size)
1653 do_video_stats(os, ost, frame_size);
1655 case AVMEDIA_TYPE_SUBTITLE:
1656 do_subtitle_out(os, ost, ist, &subtitle,
1663 AVFrame avframe; //FIXME/XXX remove this
1665 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1667 av_init_packet(&opkt);
1669 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1672 /* no reencoding needed : output the packet directly */
1673 /* force the input stream PTS */
1675 avcodec_get_frame_defaults(&avframe);
1676 ost->st->codec->coded_frame= &avframe;
1677 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1679 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1680 audio_size += data_size;
1681 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1682 video_size += data_size;
1686 opkt.stream_index= ost->index;
1687 if(pkt->pts != AV_NOPTS_VALUE)
1688 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1690 opkt.pts= AV_NOPTS_VALUE;
1692 if (pkt->dts == AV_NOPTS_VALUE)
1693 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1695 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1696 opkt.dts -= ost_tb_start_time;
1698 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1699 opkt.flags= pkt->flags;
1701 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1702 if( ost->st->codec->codec_id != CODEC_ID_H264
1703 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1704 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1706 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1707 opkt.destruct= av_destruct_packet;
1709 opkt.data = data_buf;
1710 opkt.size = data_size;
1713 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1714 ost->st->codec->frame_number++;
1715 ost->frame_number++;
1716 av_free_packet(&opkt);
1722 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1723 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1725 avfilter_unref_buffer(ist->picref);
1728 av_free(buffer_to_free);
1729 /* XXX: allocate the subtitles in the codec ? */
1730 if (subtitle_to_free) {
1731 if (subtitle_to_free->rects != NULL) {
1732 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1733 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1734 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1735 av_freep(&subtitle_to_free->rects[i]);
1737 av_freep(&subtitle_to_free->rects);
1739 subtitle_to_free->num_rects = 0;
1740 subtitle_to_free = NULL;
1747 for(i=0;i<nb_ostreams;i++) {
1749 if (ost->source_index == ist_index) {
1750 AVCodecContext *enc= ost->st->codec;
1751 os = output_files[ost->file_index];
1753 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1755 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1758 if (ost->encoding_needed) {
1762 av_init_packet(&pkt);
1763 pkt.stream_index= ost->index;
1765 switch(ost->st->codec->codec_type) {
1766 case AVMEDIA_TYPE_AUDIO:
1767 fifo_bytes = av_fifo_size(ost->fifo);
1769 /* encode any samples remaining in fifo */
1770 if (fifo_bytes > 0) {
1771 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1772 int fs_tmp = enc->frame_size;
1774 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1775 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1776 enc->frame_size = fifo_bytes / (osize * enc->channels);
1778 int frame_bytes = enc->frame_size*osize*enc->channels;
1779 if (allocated_audio_buf_size < frame_bytes)
1781 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1784 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1785 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1786 ost->st->time_base.num, enc->sample_rate);
1787 enc->frame_size = fs_tmp;
1790 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1793 fprintf(stderr, "Audio encoding failed\n");
1797 pkt.flags |= AV_PKT_FLAG_KEY;
1799 case AVMEDIA_TYPE_VIDEO:
1800 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1802 fprintf(stderr, "Video encoding failed\n");
1806 if(enc->coded_frame && enc->coded_frame->key_frame)
1807 pkt.flags |= AV_PKT_FLAG_KEY;
1808 if (ost->logfile && enc->stats_out) {
1809 fprintf(ost->logfile, "%s", enc->stats_out);
1818 pkt.data= bit_buffer;
1820 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1821 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1822 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1834 static void print_sdp(AVFormatContext **avc, int n)
1838 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1839 printf("SDP:\n%s\n", sdp);
1843 static int copy_chapters(int infile, int outfile)
1845 AVFormatContext *is = input_files[infile];
1846 AVFormatContext *os = output_files[outfile];
1849 for (i = 0; i < is->nb_chapters; i++) {
1850 AVChapter *in_ch = is->chapters[i], *out_ch;
1851 AVMetadataTag *t = NULL;
1852 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1853 AV_TIME_BASE_Q, in_ch->time_base);
1854 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1855 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1858 if (in_ch->end < ts_off)
1860 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1863 out_ch = av_mallocz(sizeof(AVChapter));
1865 return AVERROR(ENOMEM);
1867 out_ch->id = in_ch->id;
1868 out_ch->time_base = in_ch->time_base;
1869 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1870 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1872 if (metadata_chapters_autocopy)
1873 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1874 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1877 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1879 return AVERROR(ENOMEM);
1880 os->chapters[os->nb_chapters - 1] = out_ch;
1885 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1886 AVCodecContext *avctx)
1892 for (p = kf; *p; p++)
1895 ost->forced_kf_count = n;
1896 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1897 if (!ost->forced_kf_pts) {
1898 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1901 for (i = 0; i < n; i++) {
1902 p = i ? strchr(p, ',') + 1 : kf;
1903 t = parse_time_or_die("force_key_frames", p, 1);
1904 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1909 * The following code is the main loop of the file converter
1911 static int transcode(AVFormatContext **output_files,
1912 int nb_output_files,
1913 AVFormatContext **input_files,
1915 AVStreamMap *stream_maps, int nb_stream_maps)
1917 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1918 AVFormatContext *is, *os;
1919 AVCodecContext *codec, *icodec;
1920 AVOutputStream *ost, **ost_table = NULL;
1921 AVInputStream *ist, **ist_table = NULL;
1922 AVInputFile *file_table;
1926 uint8_t no_packet[MAX_FILES]={0};
1927 int no_packet_count=0;
1929 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1933 /* input stream init */
1935 for(i=0;i<nb_input_files;i++) {
1936 is = input_files[i];
1937 file_table[i].ist_index = j;
1938 file_table[i].nb_streams = is->nb_streams;
1939 j += is->nb_streams;
1943 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1947 for(i=0;i<nb_istreams;i++) {
1948 ist = av_mallocz(sizeof(AVInputStream));
1954 for(i=0;i<nb_input_files;i++) {
1955 is = input_files[i];
1956 for(k=0;k<is->nb_streams;k++) {
1957 ist = ist_table[j++];
1958 ist->st = is->streams[k];
1959 ist->file_index = i;
1961 ist->discard = 1; /* the stream is discarded by default
1965 ist->start = av_gettime();
1970 /* output stream init */
1972 for(i=0;i<nb_output_files;i++) {
1973 os = output_files[i];
1974 if (!os->nb_streams) {
1975 dump_format(output_files[i], i, output_files[i]->filename, 1);
1976 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1977 ret = AVERROR(EINVAL);
1980 nb_ostreams += os->nb_streams;
1982 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1983 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1984 ret = AVERROR(EINVAL);
1988 /* Sanity check the mapping args -- do the input files & streams exist? */
1989 for(i=0;i<nb_stream_maps;i++) {
1990 int fi = stream_maps[i].file_index;
1991 int si = stream_maps[i].stream_index;
1993 if (fi < 0 || fi > nb_input_files - 1 ||
1994 si < 0 || si > file_table[fi].nb_streams - 1) {
1995 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1996 ret = AVERROR(EINVAL);
1999 fi = stream_maps[i].sync_file_index;
2000 si = stream_maps[i].sync_stream_index;
2001 if (fi < 0 || fi > nb_input_files - 1 ||
2002 si < 0 || si > file_table[fi].nb_streams - 1) {
2003 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2004 ret = AVERROR(EINVAL);
2009 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2013 for(k=0;k<nb_output_files;k++) {
2014 os = output_files[k];
2015 for(i=0;i<os->nb_streams;i++,n++) {
2017 ost = ost_table[n] = output_streams_for_file[k][i];
2018 ost->st = os->streams[i];
2019 if (nb_stream_maps > 0) {
2020 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2021 stream_maps[n].stream_index;
2023 /* Sanity check that the stream types match */
2024 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2025 int i= ost->file_index;
2026 dump_format(output_files[i], i, output_files[i]->filename, 1);
2027 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2028 stream_maps[n].file_index, stream_maps[n].stream_index,
2029 ost->file_index, ost->index);
2034 int best_nb_frames=-1;
2035 /* get corresponding input stream index : we select the first one with the right type */
2037 for(j=0;j<nb_istreams;j++) {
2042 AVFormatContext *f= input_files[ ist->file_index ];
2044 for(pi=0; pi<f->nb_programs; pi++){
2045 AVProgram *p= f->programs[pi];
2046 if(p->id == opt_programid)
2047 for(si=0; si<p->nb_stream_indexes; si++){
2048 if(f->streams[ p->stream_index[si] ] == ist->st)
2053 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2054 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2055 if(best_nb_frames < ist->st->codec_info_nb_frames){
2056 best_nb_frames= ist->st->codec_info_nb_frames;
2057 ost->source_index = j;
2064 if(! opt_programid) {
2065 /* try again and reuse existing stream */
2066 for(j=0;j<nb_istreams;j++) {
2068 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2069 && ist->st->discard != AVDISCARD_ALL) {
2070 ost->source_index = j;
2076 int i= ost->file_index;
2077 dump_format(output_files[i], i, output_files[i]->filename, 1);
2078 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2079 ost->file_index, ost->index);
2084 ist = ist_table[ost->source_index];
2086 ost->sync_ist = (nb_stream_maps > 0) ?
2087 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2088 stream_maps[n].sync_stream_index] : ist;
2092 /* for each output stream, we compute the right encoding parameters */
2093 for(i=0;i<nb_ostreams;i++) {
2094 AVMetadataTag *t = NULL;
2096 os = output_files[ost->file_index];
2097 ist = ist_table[ost->source_index];
2099 codec = ost->st->codec;
2100 icodec = ist->st->codec;
2102 if (metadata_streams_autocopy)
2103 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2104 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2107 ost->st->disposition = ist->st->disposition;
2108 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2109 codec->chroma_sample_location = icodec->chroma_sample_location;
2111 if (ost->st->stream_copy) {
2112 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2114 if (extra_size > INT_MAX)
2117 /* if stream_copy is selected, no need to decode or encode */
2118 codec->codec_id = icodec->codec_id;
2119 codec->codec_type = icodec->codec_type;
2121 if(!codec->codec_tag){
2122 if( !os->oformat->codec_tag
2123 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2124 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2125 codec->codec_tag = icodec->codec_tag;
2128 codec->bit_rate = icodec->bit_rate;
2129 codec->rc_max_rate = icodec->rc_max_rate;
2130 codec->rc_buffer_size = icodec->rc_buffer_size;
2131 codec->extradata= av_mallocz(extra_size);
2132 if (!codec->extradata)
2134 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2135 codec->extradata_size= icodec->extradata_size;
2136 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){
2137 codec->time_base = icodec->time_base;
2138 codec->time_base.num *= icodec->ticks_per_frame;
2139 av_reduce(&codec->time_base.num, &codec->time_base.den,
2140 codec->time_base.num, codec->time_base.den, INT_MAX);
2142 codec->time_base = ist->st->time_base;
2143 switch(codec->codec_type) {
2144 case AVMEDIA_TYPE_AUDIO:
2145 if(audio_volume != 256) {
2146 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2149 codec->channel_layout = icodec->channel_layout;
2150 codec->sample_rate = icodec->sample_rate;
2151 codec->channels = icodec->channels;
2152 codec->frame_size = icodec->frame_size;
2153 codec->block_align= icodec->block_align;
2154 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2155 codec->block_align= 0;
2156 if(codec->codec_id == CODEC_ID_AC3)
2157 codec->block_align= 0;
2159 case AVMEDIA_TYPE_VIDEO:
2160 codec->pix_fmt = icodec->pix_fmt;
2161 codec->width = icodec->width;
2162 codec->height = icodec->height;
2163 codec->has_b_frames = icodec->has_b_frames;
2165 case AVMEDIA_TYPE_SUBTITLE:
2166 codec->width = icodec->width;
2167 codec->height = icodec->height;
2173 switch(codec->codec_type) {
2174 case AVMEDIA_TYPE_AUDIO:
2175 ost->fifo= av_fifo_alloc(1024);
2178 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2179 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2180 icodec->request_channels = codec->channels;
2181 ist->decoding_needed = 1;
2182 ost->encoding_needed = 1;
2184 case AVMEDIA_TYPE_VIDEO:
2185 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2186 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2189 ost->video_resample = (codec->width != icodec->width ||
2190 codec->height != icodec->height ||
2191 (codec->pix_fmt != icodec->pix_fmt));
2192 if (ost->video_resample) {
2193 avcodec_get_frame_defaults(&ost->pict_tmp);
2194 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2195 codec->width, codec->height)) {
2196 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2199 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2200 ost->img_resample_ctx = sws_getContext(
2207 sws_flags, NULL, NULL, NULL);
2208 if (ost->img_resample_ctx == NULL) {
2209 fprintf(stderr, "Cannot get resampling context\n");
2213 #if !CONFIG_AVFILTER
2214 ost->original_height = icodec->height;
2215 ost->original_width = icodec->width;
2217 codec->bits_per_raw_sample= 0;
2219 ost->resample_height = icodec->height;
2220 ost->resample_width = icodec->width;
2221 ost->resample_pix_fmt= icodec->pix_fmt;
2222 ost->encoding_needed = 1;
2223 ist->decoding_needed = 1;
2226 if (configure_filters(ist, ost)) {
2227 fprintf(stderr, "Error opening filters!\n");
2232 case AVMEDIA_TYPE_SUBTITLE:
2233 ost->encoding_needed = 1;
2234 ist->decoding_needed = 1;
2241 if (ost->encoding_needed &&
2242 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2243 char logfilename[1024];
2246 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2247 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2249 if (codec->flags & CODEC_FLAG_PASS1) {
2250 f = fopen(logfilename, "wb");
2252 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2258 size_t logbuffer_size;
2259 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2260 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2263 codec->stats_in = logbuffer;
2267 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2268 int size= codec->width * codec->height;
2269 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2274 bit_buffer = av_malloc(bit_buffer_size);
2276 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2278 ret = AVERROR(ENOMEM);
2282 /* open each encoder */
2283 for(i=0;i<nb_ostreams;i++) {
2285 if (ost->encoding_needed) {
2286 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2288 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2290 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2291 ost->st->codec->codec_id, ost->file_index, ost->index);
2292 ret = AVERROR(EINVAL);
2295 if (avcodec_open(ost->st->codec, codec) < 0) {
2296 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2297 ost->file_index, ost->index);
2298 ret = AVERROR(EINVAL);
2301 extra_size += ost->st->codec->extradata_size;
2305 /* open each decoder */
2306 for(i=0;i<nb_istreams;i++) {
2308 if (ist->decoding_needed) {
2309 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2311 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2313 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2314 ist->st->codec->codec_id, ist->file_index, ist->index);
2315 ret = AVERROR(EINVAL);
2318 if (avcodec_open(ist->st->codec, codec) < 0) {
2319 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2320 ist->file_index, ist->index);
2321 ret = AVERROR(EINVAL);
2324 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2325 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2330 for(i=0;i<nb_istreams;i++) {
2334 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2335 ist->next_pts = AV_NOPTS_VALUE;
2336 init_pts_correction(&ist->pts_ctx);
2340 /* set meta data information from input file if required */
2341 for (i=0;i<nb_meta_data_maps;i++) {
2342 AVFormatContext *files[2];
2343 AVMetadata **meta[2];
2344 AVMetadataTag *mtag;
2347 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2348 if ((index) < 0 || (index) >= (nb_elems)) {\
2349 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2351 ret = AVERROR(EINVAL);\
2355 int out_file_index = meta_data_maps[i][0].file;
2356 int in_file_index = meta_data_maps[i][1].file;
2357 if (in_file_index < 0 || out_file_index < 0)
2359 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2360 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2362 files[0] = output_files[out_file_index];
2363 files[1] = input_files[in_file_index];
2365 for (j = 0; j < 2; j++) {
2366 AVMetaDataMap *map = &meta_data_maps[i][j];
2368 switch (map->type) {
2370 meta[j] = &files[j]->metadata;
2373 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2374 meta[j] = &files[j]->streams[map->index]->metadata;
2377 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2378 meta[j] = &files[j]->chapters[map->index]->metadata;
2381 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2382 meta[j] = &files[j]->programs[map->index]->metadata;
2388 while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2389 av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2392 /* copy chapters according to chapter maps */
2393 for (i = 0; i < nb_chapter_maps; i++) {
2394 int infile = chapter_maps[i].in_file;
2395 int outfile = chapter_maps[i].out_file;
2397 if (infile < 0 || outfile < 0)
2399 if (infile >= nb_input_files) {
2400 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2401 ret = AVERROR(EINVAL);
2404 if (outfile >= nb_output_files) {
2405 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2406 ret = AVERROR(EINVAL);
2409 copy_chapters(infile, outfile);
2412 /* copy chapters from the first input file that has them*/
2413 if (!nb_chapter_maps)
2414 for (i = 0; i < nb_input_files; i++) {
2415 if (!input_files[i]->nb_chapters)
2418 for (j = 0; j < nb_output_files; j++)
2419 if ((ret = copy_chapters(i, j)) < 0)
2424 /* open files and write file headers */
2425 for(i=0;i<nb_output_files;i++) {
2426 os = output_files[i];
2427 if (av_write_header(os) < 0) {
2428 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2429 ret = AVERROR(EINVAL);
2432 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2438 /* dump the file output parameters - cannot be done before in case
2440 for(i=0;i<nb_output_files;i++) {
2441 dump_format(output_files[i], i, output_files[i]->filename, 1);
2444 /* dump the stream mapping */
2446 fprintf(stderr, "Stream mapping:\n");
2447 for(i=0;i<nb_ostreams;i++) {
2449 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2450 ist_table[ost->source_index]->file_index,
2451 ist_table[ost->source_index]->index,
2454 if (ost->sync_ist != ist_table[ost->source_index])
2455 fprintf(stderr, " [sync #%d.%d]",
2456 ost->sync_ist->file_index,
2457 ost->sync_ist->index);
2458 fprintf(stderr, "\n");
2463 fprintf(stderr, "%s\n", error);
2468 print_sdp(output_files, nb_output_files);
2471 if (!using_stdin && verbose >= 0) {
2472 fprintf(stderr, "Press [q] to stop encoding\n");
2473 url_set_interrupt_cb(decode_interrupt_cb);
2477 timer_start = av_gettime();
2479 for(; received_sigterm == 0;) {
2480 int file_index, ist_index;
2488 /* if 'q' pressed, exits */
2492 /* read_key() returns 0 on EOF */
2498 /* select the stream that we must read now by looking at the
2499 smallest output pts */
2501 for(i=0;i<nb_ostreams;i++) {
2504 os = output_files[ost->file_index];
2505 ist = ist_table[ost->source_index];
2506 if(ist->is_past_recording_time || no_packet[ist->file_index])
2508 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2509 ipts = (double)ist->pts;
2510 if (!file_table[ist->file_index].eof_reached){
2511 if(ipts < ipts_min) {
2513 if(input_sync ) file_index = ist->file_index;
2515 if(opts < opts_min) {
2517 if(!input_sync) file_index = ist->file_index;
2520 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2525 /* if none, if is finished */
2526 if (file_index < 0) {
2527 if(no_packet_count){
2529 memset(no_packet, 0, sizeof(no_packet));
2536 /* finish if limit size exhausted */
2537 if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2540 /* read a frame from it and output it in the fifo */
2541 is = input_files[file_index];
2542 ret= av_read_frame(is, &pkt);
2543 if(ret == AVERROR(EAGAIN)){
2544 no_packet[file_index]=1;
2549 file_table[file_index].eof_reached = 1;
2557 memset(no_packet, 0, sizeof(no_packet));
2560 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2562 /* the following test is needed in case new streams appear
2563 dynamically in stream : we ignore them */
2564 if (pkt.stream_index >= file_table[file_index].nb_streams)
2565 goto discard_packet;
2566 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2567 ist = ist_table[ist_index];
2569 goto discard_packet;
2571 if (pkt.dts != AV_NOPTS_VALUE)
2572 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2573 if (pkt.pts != AV_NOPTS_VALUE)
2574 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2576 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2577 && input_files_ts_scale[file_index][pkt.stream_index]){
2578 if(pkt.pts != AV_NOPTS_VALUE)
2579 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2580 if(pkt.dts != AV_NOPTS_VALUE)
2581 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2584 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2585 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2586 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2587 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2588 int64_t delta= pkt_dts - ist->next_pts;
2589 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2590 input_files_ts_offset[ist->file_index]-= delta;
2592 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2593 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2594 if(pkt.pts != AV_NOPTS_VALUE)
2595 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2599 /* finish if recording time exhausted */
2600 if (recording_time != INT64_MAX &&
2601 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2602 ist->is_past_recording_time = 1;
2603 goto discard_packet;
2606 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2607 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2610 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2611 ist->file_index, ist->index);
2614 av_free_packet(&pkt);
2619 av_free_packet(&pkt);
2621 /* dump report by using the output first video and audio streams */
2622 print_report(output_files, ost_table, nb_ostreams, 0);
2625 /* at the end of stream, we must flush the decoder buffers */
2626 for(i=0;i<nb_istreams;i++) {
2628 if (ist->decoding_needed) {
2629 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2635 /* write the trailer if needed and close file */
2636 for(i=0;i<nb_output_files;i++) {
2637 os = output_files[i];
2638 av_write_trailer(os);
2641 /* dump report by using the first video and audio streams */
2642 print_report(output_files, ost_table, nb_ostreams, 1);
2644 /* close each encoder */
2645 for(i=0;i<nb_ostreams;i++) {
2647 if (ost->encoding_needed) {
2648 av_freep(&ost->st->codec->stats_in);
2649 avcodec_close(ost->st->codec);
2653 /* close each decoder */
2654 for(i=0;i<nb_istreams;i++) {
2656 if (ist->decoding_needed) {
2657 avcodec_close(ist->st->codec);
2662 avfilter_graph_free(graph);
2671 av_freep(&bit_buffer);
2672 av_free(file_table);
2675 for(i=0;i<nb_istreams;i++) {
2682 for(i=0;i<nb_ostreams;i++) {
2685 if (ost->st->stream_copy)
2686 av_freep(&ost->st->codec->extradata);
2688 fclose(ost->logfile);
2689 ost->logfile = NULL;
2691 av_fifo_free(ost->fifo); /* works even if fifo is not
2692 initialized but set to zero */
2693 av_free(ost->pict_tmp.data[0]);
2694 av_free(ost->forced_kf_pts);
2695 if (ost->video_resample)
2696 sws_freeContext(ost->img_resample_ctx);
2698 audio_resample_close(ost->resample);
2699 if (ost->reformat_ctx)
2700 av_audio_convert_free(ost->reformat_ctx);
2709 static void opt_format(const char *arg)
2711 last_asked_format = arg;
2714 static void opt_video_rc_override_string(const char *arg)
2716 video_rc_override_string = arg;
2719 static int opt_me_threshold(const char *opt, const char *arg)
2721 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2725 static int opt_verbose(const char *opt, const char *arg)
2727 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2731 static int opt_frame_rate(const char *opt, const char *arg)
2733 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2734 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2740 static int opt_bitrate(const char *opt, const char *arg)
2742 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2744 opt_default(opt, arg);
2746 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2747 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2752 static int opt_frame_crop(const char *opt, const char *arg)
2754 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2755 return AVERROR(EINVAL);
2758 static void opt_frame_size(const char *arg)
2760 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2761 fprintf(stderr, "Incorrect frame size\n");
2766 static int opt_pad(const char *opt, const char *arg) {
2767 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2771 static void opt_frame_pix_fmt(const char *arg)
2773 if (strcmp(arg, "list")) {
2774 frame_pix_fmt = av_get_pix_fmt(arg);
2775 if (frame_pix_fmt == PIX_FMT_NONE) {
2776 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2785 static void opt_frame_aspect_ratio(const char *arg)
2792 p = strchr(arg, ':');
2794 x = strtol(arg, &end, 10);
2796 y = strtol(end+1, &end, 10);
2798 ar = (double)x / (double)y;
2800 ar = strtod(arg, NULL);
2803 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2806 frame_aspect_ratio = ar;
2809 static int opt_metadata(const char *opt, const char *arg)
2811 char *mid= strchr(arg, '=');
2814 fprintf(stderr, "Missing =\n");
2819 av_metadata_set2(&metadata, arg, mid, 0);
2824 static void opt_qscale(const char *arg)
2826 video_qscale = atof(arg);
2827 if (video_qscale <= 0 ||
2828 video_qscale > 255) {
2829 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2834 static void opt_top_field_first(const char *arg)
2836 top_field_first= atoi(arg);
2839 static int opt_thread_count(const char *opt, const char *arg)
2841 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2844 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2849 static void opt_audio_sample_fmt(const char *arg)
2851 if (strcmp(arg, "list"))
2852 audio_sample_fmt = av_get_sample_fmt(arg);
2854 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2859 static int opt_audio_rate(const char *opt, const char *arg)
2861 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2865 static int opt_audio_channels(const char *opt, const char *arg)
2867 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2871 static void opt_video_channel(const char *arg)
2873 video_channel = strtol(arg, NULL, 0);
2876 static void opt_video_standard(const char *arg)
2878 video_standard = av_strdup(arg);
2881 static void opt_codec(int *pstream_copy, char **pcodec_name,
2882 int codec_type, const char *arg)
2884 av_freep(pcodec_name);
2885 if (!strcmp(arg, "copy")) {
2888 *pcodec_name = av_strdup(arg);
2892 static void opt_audio_codec(const char *arg)
2894 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2897 static void opt_video_codec(const char *arg)
2899 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2902 static void opt_subtitle_codec(const char *arg)
2904 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2907 static int opt_codec_tag(const char *opt, const char *arg)
2910 uint32_t *codec_tag;
2912 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2913 !strcmp(opt, "vtag") ? &video_codec_tag :
2914 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2918 *codec_tag = strtol(arg, &tail, 0);
2920 *codec_tag = AV_RL32(arg);
2925 static void opt_map(const char *arg)
2930 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2931 m = &stream_maps[nb_stream_maps-1];
2933 m->file_index = strtol(arg, &p, 0);
2937 m->stream_index = strtol(p, &p, 0);
2940 m->sync_file_index = strtol(p, &p, 0);
2943 m->sync_stream_index = strtol(p, &p, 0);
2945 m->sync_file_index = m->file_index;
2946 m->sync_stream_index = m->stream_index;
2950 static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
2961 *index = strtol(++arg, endptr, 0);
2964 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2971 static void opt_map_meta_data(const char *arg)
2973 AVMetaDataMap *m, *m1;
2976 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2977 &nb_meta_data_maps, nb_meta_data_maps + 1);
2979 m = &meta_data_maps[nb_meta_data_maps - 1][0];
2980 m->file = strtol(arg, &p, 0);
2981 parse_meta_type(p, &m->type, &m->index, &p);
2985 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2986 m1->file = strtol(p, &p, 0);
2987 parse_meta_type(p, &m1->type, &m1->index, &p);
2989 if (m->type == 's' || m1->type == 's')
2990 metadata_streams_autocopy = 0;
2991 if (m->type == 'c' || m1->type == 'c')
2992 metadata_chapters_autocopy = 0;
2995 static void opt_map_chapters(const char *arg)
3000 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3001 nb_chapter_maps + 1);
3002 c = &chapter_maps[nb_chapter_maps - 1];
3003 c->out_file = strtol(arg, &p, 0);
3007 c->in_file = strtol(p, &p, 0);
3010 static void opt_input_ts_scale(const char *arg)
3012 unsigned int stream;
3016 stream = strtol(arg, &p, 0);
3019 scale= strtod(p, &p);
3021 if(stream >= MAX_STREAMS)
3024 input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3025 input_files_ts_scale[nb_input_files][stream]= scale;
3028 static int opt_recording_time(const char *opt, const char *arg)
3030 recording_time = parse_time_or_die(opt, arg, 1);
3034 static int opt_start_time(const char *opt, const char *arg)
3036 start_time = parse_time_or_die(opt, arg, 1);
3040 static int opt_recording_timestamp(const char *opt, const char *arg)
3042 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3046 static int opt_input_ts_offset(const char *opt, const char *arg)
3048 input_ts_offset = parse_time_or_die(opt, arg, 1);
3052 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3054 const char *codec_string = encoder ? "encoder" : "decoder";
3058 return CODEC_ID_NONE;
3060 avcodec_find_encoder_by_name(name) :
3061 avcodec_find_decoder_by_name(name);
3063 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3066 if(codec->type != type) {
3067 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3070 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3071 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3072 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3073 "results.\nAdd '-strict experimental' if you want to use it.\n",
3074 codec_string, codec->name);
3076 avcodec_find_encoder(codec->id) :
3077 avcodec_find_decoder(codec->id);
3078 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3079 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3080 codec_string, codec->name);
3086 static void opt_input_file(const char *filename)
3088 AVFormatContext *ic;
3089 AVFormatParameters params, *ap = ¶ms;
3090 AVInputFormat *file_iformat = NULL;
3091 int err, i, ret, rfps, rfps_base;
3094 if (last_asked_format) {
3095 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3096 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3099 last_asked_format = NULL;
3102 if (!strcmp(filename, "-"))
3105 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3106 !strcmp(filename, "/dev/stdin");
3108 /* get default parameters from command line */
3109 ic = avformat_alloc_context();
3111 print_error(filename, AVERROR(ENOMEM));
3115 memset(ap, 0, sizeof(*ap));
3116 ap->prealloced_context = 1;
3117 ap->sample_rate = audio_sample_rate;
3118 ap->channels = audio_channels;
3119 ap->time_base.den = frame_rate.num;
3120 ap->time_base.num = frame_rate.den;
3121 ap->width = frame_width;
3122 ap->height = frame_height;
3123 ap->pix_fmt = frame_pix_fmt;
3124 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3125 ap->channel = video_channel;
3126 ap->standard = video_standard;
3128 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3130 ic->video_codec_id =
3131 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3132 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3133 ic->audio_codec_id =
3134 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3135 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3136 ic->subtitle_codec_id=
3137 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3138 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3139 ic->flags |= AVFMT_FLAG_NONBLOCK;
3141 /* open the input file with generic libav function */
3142 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3144 print_error(filename, err);
3150 for(i=0; i<ic->nb_streams; i++){
3151 ic->streams[i]->discard= AVDISCARD_ALL;
3153 for(i=0; i<ic->nb_programs; i++){
3154 AVProgram *p= ic->programs[i];
3155 if(p->id != opt_programid){
3156 p->discard = AVDISCARD_ALL;
3159 for(j=0; j<p->nb_stream_indexes; j++){
3160 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3165 fprintf(stderr, "Specified program id not found\n");
3171 ic->loop_input = loop_input;
3173 /* If not enough info to get the stream parameters, we decode the
3174 first frames to get it. (used in mpeg case for example) */
3175 ret = av_find_stream_info(ic);
3176 if (ret < 0 && verbose >= 0) {
3177 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3178 av_close_input_file(ic);
3182 timestamp = start_time;
3183 /* add the stream start time */
3184 if (ic->start_time != AV_NOPTS_VALUE)
3185 timestamp += ic->start_time;
3187 /* if seeking requested, we execute it */
3188 if (start_time != 0) {
3189 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3191 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3192 filename, (double)timestamp / AV_TIME_BASE);
3194 /* reset seek info */
3198 /* update the current parameters so that they match the one of the input stream */
3199 for(i=0;i<ic->nb_streams;i++) {
3200 AVStream *st = ic->streams[i];
3201 AVCodecContext *dec = st->codec;
3202 avcodec_thread_init(dec, thread_count);
3203 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3204 switch (dec->codec_type) {
3205 case AVMEDIA_TYPE_AUDIO:
3206 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3207 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3208 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3209 channel_layout = dec->channel_layout;
3210 audio_channels = dec->channels;
3211 audio_sample_rate = dec->sample_rate;
3212 audio_sample_fmt = dec->sample_fmt;
3214 st->discard= AVDISCARD_ALL;
3215 /* Note that av_find_stream_info can add more streams, and we
3216 * currently have no chance of setting up lowres decoding
3217 * early enough for them. */
3219 audio_sample_rate >>= dec->lowres;
3221 case AVMEDIA_TYPE_VIDEO:
3222 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3223 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3224 frame_height = dec->height;
3225 frame_width = dec->width;
3226 if(ic->streams[i]->sample_aspect_ratio.num)
3227 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3229 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3230 frame_aspect_ratio *= (float) dec->width / dec->height;
3231 frame_pix_fmt = dec->pix_fmt;
3232 rfps = ic->streams[i]->r_frame_rate.num;
3233 rfps_base = ic->streams[i]->r_frame_rate.den;
3235 dec->flags |= CODEC_FLAG_EMU_EDGE;
3236 frame_height >>= dec->lowres;
3237 frame_width >>= dec->lowres;
3240 dec->debug |= FF_DEBUG_MV;
3242 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3245 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3246 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3248 (float)rfps / rfps_base, rfps, rfps_base);
3250 /* update the current frame rate to match the stream frame rate */
3251 frame_rate.num = rfps;
3252 frame_rate.den = rfps_base;
3255 st->discard= AVDISCARD_ALL;
3256 else if(video_discard)
3257 st->discard= video_discard;
3259 case AVMEDIA_TYPE_DATA:
3261 case AVMEDIA_TYPE_SUBTITLE:
3262 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3263 if(subtitle_disable)
3264 st->discard = AVDISCARD_ALL;
3266 case AVMEDIA_TYPE_ATTACHMENT:
3267 case AVMEDIA_TYPE_UNKNOWN:
3274 input_files[nb_input_files] = ic;
3275 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3276 /* dump the file content */
3278 dump_format(ic, nb_input_files, filename, 0);
3284 av_freep(&video_codec_name);
3285 av_freep(&audio_codec_name);
3286 av_freep(&subtitle_codec_name);
3289 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3290 int *has_subtitle_ptr)
3292 int has_video, has_audio, has_subtitle, i, j;
3293 AVFormatContext *ic;
3298 for(j=0;j<nb_input_files;j++) {
3299 ic = input_files[j];
3300 for(i=0;i<ic->nb_streams;i++) {
3301 AVCodecContext *enc = ic->streams[i]->codec;
3302 switch(enc->codec_type) {
3303 case AVMEDIA_TYPE_AUDIO:
3306 case AVMEDIA_TYPE_VIDEO:
3309 case AVMEDIA_TYPE_SUBTITLE:
3312 case AVMEDIA_TYPE_DATA:
3313 case AVMEDIA_TYPE_ATTACHMENT:
3314 case AVMEDIA_TYPE_UNKNOWN:
3321 *has_video_ptr = has_video;
3322 *has_audio_ptr = has_audio;
3323 *has_subtitle_ptr = has_subtitle;
3326 static void new_video_stream(AVFormatContext *oc, int file_idx)
3329 AVOutputStream *ost;
3330 AVCodecContext *video_enc;
3331 enum CodecID codec_id;
3332 AVCodec *codec= NULL;
3334 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3336 fprintf(stderr, "Could not alloc stream\n");
3339 ost = new_output_stream(oc, file_idx);
3341 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3342 if(!video_stream_copy){
3343 if (video_codec_name) {
3344 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3345 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3346 codec = avcodec_find_encoder_by_name(video_codec_name);
3347 output_codecs[nb_output_codecs-1] = codec;
3349 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3350 codec = avcodec_find_encoder(codec_id);
3354 avcodec_get_context_defaults3(st->codec, codec);
3355 ost->bitstream_filters = video_bitstream_filters;
3356 video_bitstream_filters= NULL;
3358 avcodec_thread_init(st->codec, thread_count);
3360 video_enc = st->codec;
3363 video_enc->codec_tag= video_codec_tag;
3365 if( (video_global_header&1)
3366 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3367 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3368 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3370 if(video_global_header&2){
3371 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3372 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3375 if (video_stream_copy) {
3376 st->stream_copy = 1;
3377 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3378 video_enc->sample_aspect_ratio =
3379 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3383 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3385 video_enc->codec_id = codec_id;
3386 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3388 if (codec && codec->supported_framerates && !force_fps)
3389 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3390 video_enc->time_base.den = fps.num;
3391 video_enc->time_base.num = fps.den;
3393 video_enc->width = frame_width;
3394 video_enc->height = frame_height;
3395 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3396 video_enc->pix_fmt = frame_pix_fmt;
3397 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3399 choose_pixel_fmt(st, codec);
3402 video_enc->gop_size = 0;
3403 if (video_qscale || same_quality) {
3404 video_enc->flags |= CODEC_FLAG_QSCALE;
3405 video_enc->global_quality=
3406 st->quality = FF_QP2LAMBDA * video_qscale;
3410 video_enc->intra_matrix = intra_matrix;
3412 video_enc->inter_matrix = inter_matrix;
3414 p= video_rc_override_string;
3417 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3419 fprintf(stderr, "error parsing rc_override\n");
3422 video_enc->rc_override=
3423 av_realloc(video_enc->rc_override,
3424 sizeof(RcOverride)*(i+1));
3425 video_enc->rc_override[i].start_frame= start;
3426 video_enc->rc_override[i].end_frame = end;
3428 video_enc->rc_override[i].qscale= q;
3429 video_enc->rc_override[i].quality_factor= 1.0;
3432 video_enc->rc_override[i].qscale= 0;
3433 video_enc->rc_override[i].quality_factor= -q/100.0;
3438 video_enc->rc_override_count=i;
3439 if (!video_enc->rc_initial_buffer_occupancy)
3440 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3441 video_enc->me_threshold= me_threshold;
3442 video_enc->intra_dc_precision= intra_dc_precision - 8;
3445 video_enc->flags|= CODEC_FLAG_PSNR;
3450 video_enc->flags |= CODEC_FLAG_PASS1;
3452 video_enc->flags |= CODEC_FLAG_PASS2;
3456 if (forced_key_frames)
3457 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3459 if (video_language) {
3460 av_metadata_set2(&st->metadata, "language", video_language, 0);
3461 av_freep(&video_language);
3464 /* reset some key parameters */
3466 av_freep(&video_codec_name);
3467 av_freep(&forced_key_frames);
3468 video_stream_copy = 0;
3469 frame_pix_fmt = PIX_FMT_NONE;
3472 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3475 AVOutputStream *ost;
3476 AVCodec *codec= NULL;
3477 AVCodecContext *audio_enc;
3478 enum CodecID codec_id;
3480 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3482 fprintf(stderr, "Could not alloc stream\n");
3485 ost = new_output_stream(oc, file_idx);
3487 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3488 if(!audio_stream_copy){
3489 if (audio_codec_name) {
3490 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3491 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3492 codec = avcodec_find_encoder_by_name(audio_codec_name);
3493 output_codecs[nb_output_codecs-1] = codec;
3495 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3496 codec = avcodec_find_encoder(codec_id);
3500 avcodec_get_context_defaults3(st->codec, codec);
3502 ost->bitstream_filters = audio_bitstream_filters;
3503 audio_bitstream_filters= NULL;
3505 avcodec_thread_init(st->codec, thread_count);
3507 audio_enc = st->codec;
3508 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3511 audio_enc->codec_tag= audio_codec_tag;
3513 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3514 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3515 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3517 if (audio_stream_copy) {
3518 st->stream_copy = 1;
3519 audio_enc->channels = audio_channels;
3520 audio_enc->sample_rate = audio_sample_rate;
3522 audio_enc->codec_id = codec_id;
3523 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3525 if (audio_qscale > QSCALE_NONE) {
3526 audio_enc->flags |= CODEC_FLAG_QSCALE;
3527 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3529 audio_enc->channels = audio_channels;
3530 audio_enc->sample_fmt = audio_sample_fmt;
3531 audio_enc->sample_rate = audio_sample_rate;
3532 audio_enc->channel_layout = channel_layout;
3533 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3534 audio_enc->channel_layout = 0;
3535 choose_sample_fmt(st, codec);
3536 choose_sample_rate(st, codec);
3538 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3539 if (audio_language) {
3540 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3541 av_freep(&audio_language);
3544 /* reset some key parameters */
3546 av_freep(&audio_codec_name);
3547 audio_stream_copy = 0;
3550 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3553 AVOutputStream *ost;
3554 AVCodec *codec=NULL;
3555 AVCodecContext *subtitle_enc;
3557 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3559 fprintf(stderr, "Could not alloc stream\n");
3562 ost = new_output_stream(oc, file_idx);
3563 subtitle_enc = st->codec;
3564 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3565 if(!subtitle_stream_copy){
3566 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3567 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3568 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3570 avcodec_get_context_defaults3(st->codec, codec);
3572 ost->bitstream_filters = subtitle_bitstream_filters;
3573 subtitle_bitstream_filters= NULL;
3575 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3577 if(subtitle_codec_tag)
3578 subtitle_enc->codec_tag= subtitle_codec_tag;
3580 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3581 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3582 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3584 if (subtitle_stream_copy) {
3585 st->stream_copy = 1;
3587 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3590 if (subtitle_language) {
3591 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3592 av_freep(&subtitle_language);
3595 subtitle_disable = 0;
3596 av_freep(&subtitle_codec_name);
3597 subtitle_stream_copy = 0;
3600 static int opt_new_stream(const char *opt, const char *arg)
3602 AVFormatContext *oc;
3603 int file_idx = nb_output_files - 1;
3604 if (nb_output_files <= 0) {
3605 fprintf(stderr, "At least one output file must be specified\n");
3608 oc = output_files[file_idx];
3610 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3611 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3612 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3617 /* arg format is "output-stream-index:streamid-value". */
3618 static int opt_streamid(const char *opt, const char *arg)
3624 strncpy(idx_str, arg, sizeof(idx_str));
3625 idx_str[sizeof(idx_str)-1] = '\0';
3626 p = strchr(idx_str, ':');
3629 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3634 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3635 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3636 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3640 static void opt_output_file(const char *filename)
3642 AVFormatContext *oc;
3643 int err, use_video, use_audio, use_subtitle;
3644 int input_has_video, input_has_audio, input_has_subtitle;
3645 AVFormatParameters params, *ap = ¶ms;
3646 AVOutputFormat *file_oformat;
3647 AVMetadataTag *tag = NULL;
3649 if (!strcmp(filename, "-"))
3652 oc = avformat_alloc_context();
3654 print_error(filename, AVERROR(ENOMEM));
3658 if (last_asked_format) {
3659 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3660 if (!file_oformat) {
3661 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3664 last_asked_format = NULL;
3666 file_oformat = av_guess_format(NULL, filename, NULL);
3667 if (!file_oformat) {
3668 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3674 oc->oformat = file_oformat;
3675 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3677 if (!strcmp(file_oformat->name, "ffm") &&
3678 av_strstart(filename, "http:", NULL)) {
3679 /* special case for files sent to ffserver: we get the stream
3680 parameters from ffserver */
3681 int err = read_ffserver_streams(oc, filename);
3683 print_error(filename, err);
3687 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3688 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3689 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3691 /* disable if no corresponding type found and at least one
3693 if (nb_input_files > 0) {
3694 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3695 &input_has_subtitle);
3696 if (!input_has_video)
3698 if (!input_has_audio)
3700 if (!input_has_subtitle)
3704 /* manual disable */
3705 if (audio_disable) use_audio = 0;
3706 if (video_disable) use_video = 0;
3707 if (subtitle_disable) use_subtitle = 0;
3709 if (use_video) new_video_stream(oc, nb_output_files);
3710 if (use_audio) new_audio_stream(oc, nb_output_files);
3711 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3713 oc->timestamp = recording_timestamp;
3715 while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3716 av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3717 av_metadata_free(&metadata);
3720 output_files[nb_output_files++] = oc;
3722 /* check filename in case of an image number is expected */
3723 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3724 if (!av_filename_number_test(oc->filename)) {
3725 print_error(oc->filename, AVERROR_NUMEXPECTED);
3730 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3731 /* test if it already exists to avoid loosing precious files */
3732 if (!file_overwrite &&
3733 (strchr(filename, ':') == NULL ||
3734 filename[1] == ':' ||
3735 av_strstart(filename, "file:", NULL))) {
3736 if (url_exist(filename)) {
3738 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3740 if (!read_yesno()) {
3741 fprintf(stderr, "Not overwriting - exiting\n");
3746 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3753 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3754 print_error(filename, err);
3759 memset(ap, 0, sizeof(*ap));
3760 if (av_set_parameters(oc, ap) < 0) {
3761 fprintf(stderr, "%s: Invalid encoding parameters\n",
3766 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3767 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3768 oc->loop_output = loop_output;
3769 oc->flags |= AVFMT_FLAG_NONBLOCK;
3771 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3773 nb_streamid_map = 0;
3774 av_freep(&forced_key_frames);
3777 /* same option as mencoder */
3778 static void opt_pass(const char *pass_str)
3781 pass = atoi(pass_str);
3782 if (pass != 1 && pass != 2) {
3783 fprintf(stderr, "pass number can be only 1 or 2\n");
3789 static int64_t getutime(void)
3792 struct rusage rusage;
3794 getrusage(RUSAGE_SELF, &rusage);
3795 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3796 #elif HAVE_GETPROCESSTIMES
3798 FILETIME c, e, k, u;
3799 proc = GetCurrentProcess();
3800 GetProcessTimes(proc, &c, &e, &k, &u);
3801 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3803 return av_gettime();
3807 static int64_t getmaxrss(void)
3809 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3810 struct rusage rusage;
3811 getrusage(RUSAGE_SELF, &rusage);
3812 return (int64_t)rusage.ru_maxrss * 1024;
3813 #elif HAVE_GETPROCESSMEMORYINFO
3815 PROCESS_MEMORY_COUNTERS memcounters;
3816 proc = GetCurrentProcess();
3817 memcounters.cb = sizeof(memcounters);
3818 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3819 return memcounters.PeakPagefileUsage;
3825 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3828 const char *p = str;
3835 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3842 static void opt_inter_matrix(const char *arg)
3844 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3845 parse_matrix_coeffs(inter_matrix, arg);
3848 static void opt_intra_matrix(const char *arg)
3850 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3851 parse_matrix_coeffs(intra_matrix, arg);
3854 static void show_usage(void)
3856 printf("Hyper fast Audio and Video encoder\n");
3857 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3861 static void show_help(void)
3863 av_log_set_callback(log_callback_help);
3865 show_help_options(options, "Main options:\n",
3866 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3867 show_help_options(options, "\nAdvanced options:\n",
3868 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3870 show_help_options(options, "\nVideo options:\n",
3871 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3873 show_help_options(options, "\nAdvanced Video options:\n",
3874 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3875 OPT_VIDEO | OPT_EXPERT);
3876 show_help_options(options, "\nAudio options:\n",
3877 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3879 show_help_options(options, "\nAdvanced Audio options:\n",
3880 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3881 OPT_AUDIO | OPT_EXPERT);
3882 show_help_options(options, "\nSubtitle options:\n",
3883 OPT_SUBTITLE | OPT_GRAB,
3885 show_help_options(options, "\nAudio/Video grab options:\n",
3889 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3891 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3893 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3896 static void opt_target(const char *arg)
3898 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3899 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3901 if(!strncmp(arg, "pal-", 4)) {
3904 } else if(!strncmp(arg, "ntsc-", 5)) {
3907 } else if(!strncmp(arg, "film-", 5)) {
3912 /* Calculate FR via float to avoid int overflow */
3913 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3916 } else if((fr == 29970) || (fr == 23976)) {
3919 /* Try to determine PAL/NTSC by peeking in the input files */
3920 if(nb_input_files) {
3922 for(j = 0; j < nb_input_files; j++) {
3923 for(i = 0; i < input_files[j]->nb_streams; i++) {
3924 AVCodecContext *c = input_files[j]->streams[i]->codec;
3925 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3927 fr = c->time_base.den * 1000 / c->time_base.num;
3931 } else if((fr == 29970) || (fr == 23976)) {
3941 if(verbose && norm != UNKNOWN)
3942 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3945 if(norm == UNKNOWN) {
3946 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3947 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3948 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3952 if(!strcmp(arg, "vcd")) {
3954 opt_video_codec("mpeg1video");
3955 opt_audio_codec("mp2");
3958 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3959 opt_frame_rate(NULL, frame_rates[norm]);
3960 opt_default("g", norm == PAL ? "15" : "18");
3962 opt_default("b", "1150000");
3963 opt_default("maxrate", "1150000");
3964 opt_default("minrate", "1150000");
3965 opt_default("bufsize", "327680"); // 40*1024*8;
3967 opt_default("ab", "224000");
3968 audio_sample_rate = 44100;
3971 opt_default("packetsize", "2324");
3972 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3974 /* We have to offset the PTS, so that it is consistent with the SCR.
3975 SCR starts at 36000, but the first two packs contain only padding
3976 and the first pack from the other stream, respectively, may also have
3977 been written before.
3978 So the real data starts at SCR 36000+3*1200. */
3979 mux_preload= (36000+3*1200) / 90000.0; //0.44
3980 } else if(!strcmp(arg, "svcd")) {
3982 opt_video_codec("mpeg2video");
3983 opt_audio_codec("mp2");
3986 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3987 opt_frame_rate(NULL, frame_rates[norm]);
3988 opt_default("g", norm == PAL ? "15" : "18");
3990 opt_default("b", "2040000");
3991 opt_default("maxrate", "2516000");
3992 opt_default("minrate", "0"); //1145000;
3993 opt_default("bufsize", "1835008"); //224*1024*8;
3994 opt_default("flags", "+scan_offset");
3997 opt_default("ab", "224000");
3998 audio_sample_rate = 44100;
4000 opt_default("packetsize", "2324");
4002 } else if(!strcmp(arg, "dvd")) {
4004 opt_video_codec("mpeg2video");
4005 opt_audio_codec("ac3");
4008 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4009 opt_frame_rate(NULL, frame_rates[norm]);
4010 opt_default("g", norm == PAL ? "15" : "18");
4012 opt_default("b", "6000000");
4013 opt_default("maxrate", "9000000");
4014 opt_default("minrate", "0"); //1500000;
4015 opt_default("bufsize", "1835008"); //224*1024*8;
4017 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4018 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4020 opt_default("ab", "448000");
4021 audio_sample_rate = 48000;
4023 } else if(!strncmp(arg, "dv", 2)) {
4027 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4028 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4029 (norm == PAL ? "yuv420p" : "yuv411p"));
4030 opt_frame_rate(NULL, frame_rates[norm]);
4032 audio_sample_rate = 48000;
4036 fprintf(stderr, "Unknown target: %s\n", arg);
4041 static void opt_vstats_file (const char *arg)
4043 av_free (vstats_filename);
4044 vstats_filename=av_strdup (arg);
4047 static void opt_vstats (void)
4050 time_t today2 = time(NULL);
4051 struct tm *today = localtime(&today2);
4053 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4055 opt_vstats_file(filename);
4058 static int opt_bsf(const char *opt, const char *arg)
4060 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4061 AVBitStreamFilterContext **bsfp;
4064 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4068 bsfp= *opt == 'v' ? &video_bitstream_filters :
4069 *opt == 'a' ? &audio_bitstream_filters :
4070 &subtitle_bitstream_filters;
4072 bsfp= &(*bsfp)->next;
4079 static int opt_preset(const char *opt, const char *arg)
4082 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4083 char *codec_name = *opt == 'v' ? video_codec_name :
4084 *opt == 'a' ? audio_codec_name :
4085 subtitle_codec_name;
4087 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4088 fprintf(stderr, "File for preset '%s' not found\n", arg);
4093 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4094 if(line[0] == '#' && !e)
4096 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4098 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4101 if(!strcmp(tmp, "acodec")){
4102 opt_audio_codec(tmp2);
4103 }else if(!strcmp(tmp, "vcodec")){
4104 opt_video_codec(tmp2);
4105 }else if(!strcmp(tmp, "scodec")){
4106 opt_subtitle_codec(tmp2);
4107 }else if(opt_default(tmp, tmp2) < 0){
4108 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4118 static const OptionDef options[] = {
4120 #include "cmdutils_common_opts.h"
4121 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4122 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4123 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4124 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4125 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4126 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4127 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4128 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4129 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4130 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4131 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4132 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4133 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4134 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4135 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4136 "add timings for benchmarking" },
4137 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4138 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4139 "dump each input packet" },
4140 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4141 "when dumping packets, also dump the payload" },
4142 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4143 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4144 { "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)", "" },
4145 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4146 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4147 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4148 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4149 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4150 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4151 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4152 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4153 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4154 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4155 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4156 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4157 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4160 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4161 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4162 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4163 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4164 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4165 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4166 { "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" },
4167 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4168 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4169 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4170 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4171 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4172 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4173 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4174 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4175 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4176 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4177 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4178 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4179 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4180 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4181 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4182 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4183 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4184 "use same video quality as source (implies VBR)" },
4185 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4186 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4187 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4188 "deinterlace pictures" },
4189 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4190 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4191 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4193 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4195 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4196 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4197 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4198 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4199 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4200 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4201 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4202 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4203 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4204 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4205 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4208 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4209 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4210 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4211 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4212 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4213 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4214 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4215 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4216 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4217 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4218 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4219 { "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" },
4221 /* subtitle options */
4222 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4223 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4224 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4225 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4226 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4229 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4230 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4231 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4234 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4235 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4237 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4238 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4239 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4241 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4242 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4243 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4244 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4246 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4250 int main(int argc, char **argv)
4254 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4256 avcodec_register_all();
4258 avdevice_register_all();
4261 avfilter_register_all();
4266 if(isatty(STDIN_FILENO))
4267 url_set_interrupt_cb(decode_interrupt_cb);
4275 parse_options(argc, argv, options, opt_output_file);
4277 if(nb_output_files <= 0 && nb_input_files == 0) {
4279 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4283 /* file converter / grab */
4284 if (nb_output_files <= 0) {
4285 fprintf(stderr, "At least one output file must be specified\n");
4289 if (nb_input_files == 0) {
4290 fprintf(stderr, "At least one input file must be specified\n");
4295 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4296 stream_maps, nb_stream_maps) < 0)
4298 ti = getutime() - ti;
4300 int maxrss = getmaxrss() / 1024;
4301 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4304 return ffmpeg_exit(0);