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/audioconvert.h"
40 #include "libavcore/parseutils.h"
41 #include "libavcore/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/libm.h"
48 #include "libavformat/os_support.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
74 #include <sys/ioctl.h>
84 #include "libavutil/avassert.h"
86 const char program_name[] = "FFmpeg";
87 const int program_birth_year = 2000;
89 /* select an input stream for an output stream */
90 typedef struct AVStreamMap {
94 int sync_stream_index;
98 * select an input file for an output file
100 typedef struct AVMetaDataMap {
101 int file; //< file index
102 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103 int index; //< stream/chapter/program number
106 typedef struct AVChapterMap {
111 static const OptionDef options[];
113 #define MAX_FILES 100
114 #if !FF_API_MAX_STREAMS
115 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static AVFormatContext *input_files[MAX_FILES];
120 static int64_t input_files_ts_offset[MAX_FILES];
121 static double *input_files_ts_scale[MAX_FILES] = {NULL};
122 static AVCodec **input_codecs = NULL;
123 static int nb_input_files = 0;
124 static int nb_input_codecs = 0;
125 static int nb_input_files_ts_scale[MAX_FILES] = {0};
127 static AVFormatContext *output_files[MAX_FILES];
128 static AVCodec **output_codecs = NULL;
129 static int nb_output_files = 0;
130 static int nb_output_codecs = 0;
132 static AVStreamMap *stream_maps = NULL;
133 static int nb_stream_maps;
135 /* first item specifies output metadata, second is input */
136 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137 static int nb_meta_data_maps;
138 static int metadata_global_autocopy = 1;
139 static int metadata_streams_autocopy = 1;
140 static int metadata_chapters_autocopy = 1;
142 static AVChapterMap *chapter_maps = NULL;
143 static int nb_chapter_maps;
145 /* indexed by output file stream index */
146 static int *streamid_map = NULL;
147 static int nb_streamid_map = 0;
149 static int frame_width = 0;
150 static int frame_height = 0;
151 static float frame_aspect_ratio = 0;
152 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155 static AVRational frame_rate;
156 static float video_qscale = 0;
157 static uint16_t *intra_matrix = NULL;
158 static uint16_t *inter_matrix = NULL;
159 static const char *video_rc_override_string=NULL;
160 static int video_disable = 0;
161 static int video_discard = 0;
162 static char *video_codec_name = NULL;
163 static unsigned int video_codec_tag = 0;
164 static char *video_language = NULL;
165 static int same_quality = 0;
166 static int do_deinterlace = 0;
167 static int top_field_first = -1;
168 static int me_threshold = 0;
169 static int intra_dc_precision = 8;
170 static int loop_input = 0;
171 static int loop_output = AVFMT_NOOUTPUTLOOP;
172 static int qp_hist = 0;
174 static char *vfilters = NULL;
175 AVFilterGraph *graph = NULL;
178 static int intra_only = 0;
179 static int audio_sample_rate = 44100;
180 static int64_t channel_layout = 0;
181 #define QSCALE_NONE -99999
182 static float audio_qscale = QSCALE_NONE;
183 static int audio_disable = 0;
184 static int audio_channels = 1;
185 static char *audio_codec_name = NULL;
186 static unsigned int audio_codec_tag = 0;
187 static char *audio_language = NULL;
189 static int subtitle_disable = 0;
190 static char *subtitle_codec_name = NULL;
191 static char *subtitle_language = NULL;
192 static unsigned int subtitle_codec_tag = 0;
194 static float mux_preload= 0.5;
195 static float mux_max_delay= 0.7;
197 static int64_t recording_time = INT64_MAX;
198 static int64_t start_time = 0;
199 static int64_t recording_timestamp = 0;
200 static int64_t input_ts_offset = 0;
201 static int file_overwrite = 0;
202 static AVMetadata *metadata;
203 static int do_benchmark = 0;
204 static int do_hex_dump = 0;
205 static int do_pkt_dump = 0;
206 static int do_psnr = 0;
207 static int do_pass = 0;
208 static char *pass_logfilename_prefix = NULL;
209 static int audio_stream_copy = 0;
210 static int video_stream_copy = 0;
211 static int subtitle_stream_copy = 0;
212 static int video_sync_method= -1;
213 static int audio_sync_method= 0;
214 static float audio_drift_threshold= 0.1;
215 static int copy_ts= 0;
217 static int opt_shortest = 0;
218 static int video_global_header = 0;
219 static char *vstats_filename;
220 static FILE *vstats_file;
221 static int opt_programid = 0;
222 static int copy_initial_nonkeyframes = 0;
224 static int rate_emu = 0;
226 static int video_channel = 0;
227 static char *video_standard;
229 static int audio_volume = 256;
231 static int exit_on_error = 0;
232 static int using_stdin = 0;
233 static int verbose = 1;
234 static int thread_count= 1;
235 static int q_pressed = 0;
236 static int64_t video_size = 0;
237 static int64_t audio_size = 0;
238 static int64_t extra_size = 0;
239 static int nb_frames_dup = 0;
240 static int nb_frames_drop = 0;
241 static int input_sync;
242 static uint64_t limit_filesize = 0;
243 static int force_fps = 0;
244 static char *forced_key_frames = NULL;
246 static float dts_delta_threshold = 10;
248 static unsigned int sws_flags = SWS_BICUBIC;
250 static int64_t timer_start;
252 static uint8_t *audio_buf;
253 static uint8_t *audio_out;
254 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
256 static short *samples;
258 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
260 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
262 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
264 struct AVInputStream;
266 typedef struct AVOutputStream {
267 int file_index; /* file index */
268 int index; /* stream index in the output file */
269 int source_index; /* AVInputStream index */
270 AVStream *st; /* stream in the output file */
271 int encoding_needed; /* true if encoding needed for this stream */
273 /* input pts and corresponding output pts
275 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
276 struct AVInputStream *sync_ist; /* input stream to sync against */
277 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
278 AVBitStreamFilterContext *bitstream_filters;
281 AVFrame pict_tmp; /* temporary image for resampling */
282 struct SwsContext *img_resample_ctx; /* for image resampling */
285 int resample_pix_fmt;
287 /* full frame size of first frame */
291 /* forced key frames */
292 int64_t *forced_kf_pts;
298 ReSampleContext *resample; /* for audio resampling */
299 int resample_sample_fmt;
300 int resample_channels;
301 int resample_sample_rate;
303 AVAudioConvert *reformat_ctx;
304 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
308 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
311 typedef struct AVInputStream {
315 int discard; /* true if stream data should be discarded */
316 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
317 int64_t sample_index; /* current sample */
319 int64_t start; /* time when read started */
320 int64_t next_pts; /* synthetic pts for cases where pkt.pts
322 int64_t pts; /* current pts */
323 PtsCorrectionContext pts_ctx;
324 int is_start; /* is 1 at the start and after a discontinuity */
325 int showed_multi_packet_warning;
326 int is_past_recording_time;
328 AVFilterContext *output_video_filter;
329 AVFilterContext *input_video_filter;
330 AVFrame *filter_frame;
331 int has_filter_frame;
332 AVFilterBufferRef *picref;
336 typedef struct AVInputFile {
337 int eof_reached; /* true if eof reached */
338 int ist_index; /* index of first stream in ist_table */
339 int buffer_size; /* current total buffer size */
340 int nb_streams; /* nb streams we are aware of */
345 /* init terminal so that we can grab keys */
346 static struct termios oldtty;
351 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
353 AVFilterContext *last_filter, *filter;
354 /** filter graph containing all filters including input & output */
355 AVCodecContext *codec = ost->st->codec;
356 AVCodecContext *icodec = ist->st->codec;
357 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
361 graph = avfilter_graph_alloc();
363 snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
364 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
365 ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
366 "src", args, NULL, graph);
369 ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
370 "out", NULL, &ffsink_ctx, graph);
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_graph_create_filter(&filter, avfilter_get_by_name("scale"),
381 NULL, args, NULL, graph)) < 0)
383 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
385 last_filter = filter;
388 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
389 graph->scale_sws_opts = av_strdup(args);
392 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
395 outputs->name = av_strdup("in");
396 outputs->filter_ctx = last_filter;
397 outputs->pad_idx = 0;
398 outputs->next = NULL;
400 inputs->name = av_strdup("out");
401 inputs->filter_ctx = ist->output_video_filter;
405 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
409 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
413 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
416 codec->width = ist->output_video_filter->inputs[0]->w;
417 codec->height = ist->output_video_filter->inputs[0]->h;
421 #endif /* CONFIG_AVFILTER */
423 static void term_exit(void)
425 av_log(NULL, AV_LOG_QUIET, "");
427 tcsetattr (0, TCSANOW, &oldtty);
431 static volatile int received_sigterm = 0;
434 sigterm_handler(int sig)
436 received_sigterm = sig;
440 static void term_init(void)
449 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
450 |INLCR|IGNCR|ICRNL|IXON);
451 tty.c_oflag |= OPOST;
452 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
453 tty.c_cflag &= ~(CSIZE|PARENB);
458 tcsetattr (0, TCSANOW, &tty);
459 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
462 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
463 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
465 signal(SIGXCPU, sigterm_handler);
469 /* read a key without blocking */
470 static int read_key(void)
482 n = select(1, &rfds, NULL, NULL, &tv);
497 static int decode_interrupt_cb(void)
499 return q_pressed || (q_pressed = read_key() == 'q');
502 static int ffmpeg_exit(int ret)
507 for(i=0;i<nb_output_files;i++) {
508 /* maybe av_close_output_file ??? */
509 AVFormatContext *s = output_files[i];
511 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
513 for(j=0;j<s->nb_streams;j++) {
514 av_metadata_free(&s->streams[j]->metadata);
515 av_free(s->streams[j]->codec);
516 av_free(s->streams[j]->info);
517 av_free(s->streams[j]);
519 for(j=0;j<s->nb_programs;j++) {
520 av_metadata_free(&s->programs[j]->metadata);
522 for(j=0;j<s->nb_chapters;j++) {
523 av_metadata_free(&s->chapters[j]->metadata);
525 av_metadata_free(&s->metadata);
527 av_free(output_streams_for_file[i]);
529 for(i=0;i<nb_input_files;i++) {
530 av_close_input_file(input_files[i]);
531 av_free(input_files_ts_scale[i]);
534 av_free(intra_matrix);
535 av_free(inter_matrix);
539 av_free(vstats_filename);
542 av_free(streamid_map);
543 av_free(input_codecs);
544 av_free(output_codecs);
545 av_free(stream_maps);
546 av_free(meta_data_maps);
548 av_free(video_codec_name);
549 av_free(audio_codec_name);
550 av_free(subtitle_codec_name);
552 av_free(video_standard);
557 allocated_audio_buf_size= allocated_audio_out_size= 0;
564 if (received_sigterm) {
566 "Received signal %d: terminating.\n",
567 (int) received_sigterm);
571 exit(ret); /* not all OS-es handle main() return value */
575 /* similar to ff_dynarray_add() and av_fast_realloc() */
576 static void *grow_array(void *array, int elem_size, int *size, int new_size)
578 if (new_size >= INT_MAX / elem_size) {
579 fprintf(stderr, "Array too big.\n");
582 if (*size < new_size) {
583 uint8_t *tmp = av_realloc(array, new_size*elem_size);
585 fprintf(stderr, "Could not alloc buffer.\n");
588 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
595 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
597 if(codec && codec->sample_fmts){
598 const enum AVSampleFormat *p= codec->sample_fmts;
600 if(*p == st->codec->sample_fmt)
604 st->codec->sample_fmt = codec->sample_fmts[0];
608 static void choose_sample_rate(AVStream *st, AVCodec *codec)
610 if(codec && codec->supported_samplerates){
611 const int *p= codec->supported_samplerates;
613 int best_dist=INT_MAX;
615 int dist= abs(st->codec->sample_rate - *p);
616 if(dist < best_dist){
622 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
624 st->codec->sample_rate= best;
628 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
630 if(codec && codec->pix_fmts){
631 const enum PixelFormat *p= codec->pix_fmts;
632 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
633 if(st->codec->codec_id==CODEC_ID_MJPEG){
634 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
635 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
636 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
640 if(*p == st->codec->pix_fmt)
644 st->codec->pix_fmt = codec->pix_fmts[0];
648 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
650 int idx = oc->nb_streams - 1;
653 output_streams_for_file[file_idx] =
654 grow_array(output_streams_for_file[file_idx],
655 sizeof(*output_streams_for_file[file_idx]),
656 &nb_output_streams_for_file[file_idx],
658 ost = output_streams_for_file[file_idx][idx] =
659 av_mallocz(sizeof(AVOutputStream));
661 fprintf(stderr, "Could not alloc output stream\n");
664 ost->file_index = file_idx;
669 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
675 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
678 /* copy stream format */
680 for(i=0;i<ic->nb_streams;i++) {
686 // FIXME: a more elegant solution is needed
687 st = av_mallocz(sizeof(AVStream));
688 memcpy(st, ic->streams[i], sizeof(AVStream));
689 st->codec = avcodec_alloc_context();
691 print_error(filename, AVERROR(ENOMEM));
694 avcodec_copy_context(st->codec, ic->streams[i]->codec);
697 codec = avcodec_find_encoder(st->codec->codec_id);
698 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
699 if (audio_stream_copy) {
702 choose_sample_fmt(st, codec);
703 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
704 if (video_stream_copy) {
707 choose_pixel_fmt(st, codec);
710 if(!st->codec->thread_count)
711 st->codec->thread_count = 1;
712 if(st->codec->thread_count>1)
713 avcodec_thread_init(st->codec, st->codec->thread_count);
715 if(st->codec->flags & CODEC_FLAG_BITEXACT)
718 new_output_stream(s, nb_output_files);
722 s->timestamp = av_gettime();
724 av_close_input_file(ic);
729 get_sync_ipts(const AVOutputStream *ost)
731 const AVInputStream *ist = ost->sync_ist;
732 return (double)(ist->pts - start_time)/AV_TIME_BASE;
735 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
739 AVPacket new_pkt= *pkt;
740 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
741 &new_pkt.data, &new_pkt.size,
742 pkt->data, pkt->size,
743 pkt->flags & AV_PKT_FLAG_KEY);
746 new_pkt.destruct= av_destruct_packet;
748 fprintf(stderr, "%s failed for stream %d, codec %s",
749 bsfc->filter->name, pkt->stream_index,
750 avctx->codec ? avctx->codec->name : "copy");
760 ret= av_interleaved_write_frame(s, pkt);
762 print_error("av_interleaved_write_frame()", ret);
767 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
769 static void do_audio_out(AVFormatContext *s,
772 unsigned char *buf, int size)
775 int64_t audio_out_size, audio_buf_size;
776 int64_t allocated_for_size= size;
778 int size_out, frame_bytes, ret, resample_changed;
779 AVCodecContext *enc= ost->st->codec;
780 AVCodecContext *dec= ist->st->codec;
781 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
782 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
783 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
786 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
787 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
788 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
789 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
790 audio_buf_size*= osize*enc->channels;
792 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
793 if(coded_bps > 8*osize)
794 audio_out_size= audio_out_size * coded_bps / (8*osize);
795 audio_out_size += FF_MIN_BUFFER_SIZE;
797 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
798 fprintf(stderr, "Buffer sizes too large\n");
802 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
803 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
804 if (!audio_buf || !audio_out){
805 fprintf(stderr, "Out of memory in do_audio_out\n");
809 if (enc->channels != dec->channels)
810 ost->audio_resample = 1;
812 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
813 ost->resample_channels != dec->channels ||
814 ost->resample_sample_rate != dec->sample_rate;
816 if ((ost->audio_resample && !ost->resample) || resample_changed) {
817 if (resample_changed) {
818 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
819 ist->file_index, ist->index,
820 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
821 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
822 ost->resample_sample_fmt = dec->sample_fmt;
823 ost->resample_channels = dec->channels;
824 ost->resample_sample_rate = dec->sample_rate;
826 audio_resample_close(ost->resample);
828 if (ost->resample_sample_fmt == enc->sample_fmt &&
829 ost->resample_channels == enc->channels &&
830 ost->resample_sample_rate == enc->sample_rate) {
831 ost->resample = NULL;
832 ost->audio_resample = 0;
834 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
835 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
836 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
837 enc->sample_rate, dec->sample_rate,
838 enc->sample_fmt, dec->sample_fmt,
840 if (!ost->resample) {
841 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
842 dec->channels, dec->sample_rate,
843 enc->channels, enc->sample_rate);
849 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
850 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
851 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
852 if (ost->reformat_ctx)
853 av_audio_convert_free(ost->reformat_ctx);
854 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
855 dec->sample_fmt, 1, NULL, 0);
856 if (!ost->reformat_ctx) {
857 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
858 av_get_sample_fmt_name(dec->sample_fmt),
859 av_get_sample_fmt_name(enc->sample_fmt));
862 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
865 if(audio_sync_method){
866 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
867 - av_fifo_size(ost->fifo)/(enc->channels * 2);
868 double idelta= delta*dec->sample_rate / enc->sample_rate;
869 int byte_delta= ((int)idelta)*2*dec->channels;
871 //FIXME resample delay
872 if(fabs(delta) > 50){
873 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
875 byte_delta= FFMAX(byte_delta, -size);
879 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
884 static uint8_t *input_tmp= NULL;
885 input_tmp= av_realloc(input_tmp, byte_delta + size);
887 if(byte_delta > allocated_for_size - size){
888 allocated_for_size= byte_delta + (int64_t)size;
893 memset(input_tmp, 0, byte_delta);
894 memcpy(input_tmp + byte_delta, buf, size);
898 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
900 }else if(audio_sync_method>1){
901 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
902 av_assert0(ost->audio_resample);
904 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
905 // 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));
906 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
910 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
911 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
913 if (ost->audio_resample) {
915 size_out = audio_resample(ost->resample,
916 (short *)buftmp, (short *)buf,
917 size / (dec->channels * isize));
918 size_out = size_out * enc->channels * osize;
924 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
925 const void *ibuf[6]= {buftmp};
926 void *obuf[6]= {audio_buf};
927 int istride[6]= {isize};
928 int ostride[6]= {osize};
929 int len= size_out/istride[0];
930 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
931 printf("av_audio_convert() failed\n");
937 size_out = len*osize;
940 /* now encode as many frames as possible */
941 if (enc->frame_size > 1) {
942 /* output resampled raw samples */
943 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
944 fprintf(stderr, "av_fifo_realloc2() failed\n");
947 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
949 frame_bytes = enc->frame_size * osize * enc->channels;
951 while (av_fifo_size(ost->fifo) >= frame_bytes) {
953 av_init_packet(&pkt);
955 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
957 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
959 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
962 fprintf(stderr, "Audio encoding failed\n");
966 pkt.stream_index= ost->index;
969 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
970 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
971 pkt.flags |= AV_PKT_FLAG_KEY;
972 write_frame(s, &pkt, enc, ost->bitstream_filters);
974 ost->sync_opts += enc->frame_size;
978 av_init_packet(&pkt);
980 ost->sync_opts += size_out / (osize * enc->channels);
982 /* output a pcm frame */
983 /* determine the size of the coded buffer */
986 size_out = size_out*coded_bps/8;
988 if(size_out > audio_out_size){
989 fprintf(stderr, "Internal error, buffer size too small\n");
993 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
994 ret = avcodec_encode_audio(enc, audio_out, size_out,
997 fprintf(stderr, "Audio encoding failed\n");
1001 pkt.stream_index= ost->index;
1002 pkt.data= audio_out;
1004 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1005 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1006 pkt.flags |= AV_PKT_FLAG_KEY;
1007 write_frame(s, &pkt, enc, ost->bitstream_filters);
1011 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1013 AVCodecContext *dec;
1014 AVPicture *picture2;
1015 AVPicture picture_tmp;
1018 dec = ist->st->codec;
1020 /* deinterlace : must be done before any resize */
1021 if (do_deinterlace) {
1024 /* create temporary picture */
1025 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1026 buf = av_malloc(size);
1030 picture2 = &picture_tmp;
1031 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1033 if(avpicture_deinterlace(picture2, picture,
1034 dec->pix_fmt, dec->width, dec->height) < 0) {
1035 /* if error, do not deinterlace */
1036 fprintf(stderr, "Deinterlacing failed\n");
1045 if (picture != picture2)
1046 *picture = *picture2;
1050 /* we begin to correct av delay at this threshold */
1051 #define AV_DELAY_MAX 0.100
1053 static void do_subtitle_out(AVFormatContext *s,
1054 AVOutputStream *ost,
1059 static uint8_t *subtitle_out = NULL;
1060 int subtitle_out_max_size = 1024 * 1024;
1061 int subtitle_out_size, nb, i;
1062 AVCodecContext *enc;
1065 if (pts == AV_NOPTS_VALUE) {
1066 fprintf(stderr, "Subtitle packets must have a pts\n");
1072 enc = ost->st->codec;
1074 if (!subtitle_out) {
1075 subtitle_out = av_malloc(subtitle_out_max_size);
1078 /* Note: DVB subtitle need one packet to draw them and one other
1079 packet to clear them */
1080 /* XXX: signal it in the codec context ? */
1081 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1086 for(i = 0; i < nb; i++) {
1087 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1088 // start_display_time is required to be 0
1089 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1090 sub->end_display_time -= sub->start_display_time;
1091 sub->start_display_time = 0;
1092 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1093 subtitle_out_max_size, sub);
1094 if (subtitle_out_size < 0) {
1095 fprintf(stderr, "Subtitle encoding failed\n");
1099 av_init_packet(&pkt);
1100 pkt.stream_index = ost->index;
1101 pkt.data = subtitle_out;
1102 pkt.size = subtitle_out_size;
1103 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1104 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1105 /* XXX: the pts correction is handled here. Maybe handling
1106 it in the codec would be better */
1108 pkt.pts += 90 * sub->start_display_time;
1110 pkt.pts += 90 * sub->end_display_time;
1112 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1116 static int bit_buffer_size= 1024*256;
1117 static uint8_t *bit_buffer= NULL;
1119 static void do_video_out(AVFormatContext *s,
1120 AVOutputStream *ost,
1122 AVFrame *in_picture,
1125 int nb_frames, i, ret;
1126 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1127 AVCodecContext *enc, *dec;
1130 enc = ost->st->codec;
1131 dec = ist->st->codec;
1133 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1135 /* by default, we output a single frame */
1140 if(video_sync_method){
1141 double vdelta = sync_ipts - ost->sync_opts;
1142 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1145 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1148 }else if(vdelta>0.6)
1149 ost->sync_opts= lrintf(sync_ipts);
1150 }else if (vdelta > 1.1)
1151 nb_frames = lrintf(vdelta);
1152 //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);
1153 if (nb_frames == 0){
1156 fprintf(stderr, "*** drop!\n");
1157 }else if (nb_frames > 1) {
1158 nb_frames_dup += nb_frames - 1;
1160 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1163 ost->sync_opts= lrintf(sync_ipts);
1165 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1169 formatted_picture = in_picture;
1170 final_picture = formatted_picture;
1171 padding_src = formatted_picture;
1172 resampling_dst = &ost->pict_tmp;
1174 if ( ost->resample_height != ist->st->codec->height
1175 || ost->resample_width != ist->st->codec->width
1176 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1178 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));
1179 if(!ost->video_resample)
1183 #if !CONFIG_AVFILTER
1184 if (ost->video_resample) {
1186 final_picture = &ost->pict_tmp;
1187 if( ost->resample_height != ist->st->codec->height
1188 || ost->resample_width != ist->st->codec->width
1189 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1191 /* initialize a new scaler context */
1192 sws_freeContext(ost->img_resample_ctx);
1193 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1194 ost->img_resample_ctx = sws_getContext(
1195 ist->st->codec->width,
1196 ist->st->codec->height,
1197 ist->st->codec->pix_fmt,
1198 ost->st->codec->width,
1199 ost->st->codec->height,
1200 ost->st->codec->pix_fmt,
1201 sws_flags, NULL, NULL, NULL);
1202 if (ost->img_resample_ctx == NULL) {
1203 fprintf(stderr, "Cannot get resampling context\n");
1207 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1208 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1212 /* duplicates frame if needed */
1213 for(i=0;i<nb_frames;i++) {
1215 av_init_packet(&pkt);
1216 pkt.stream_index= ost->index;
1218 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1219 /* raw pictures are written as AVPicture structure to
1220 avoid any copies. We support temorarily the older
1222 AVFrame* old_frame = enc->coded_frame;
1223 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1224 pkt.data= (uint8_t *)final_picture;
1225 pkt.size= sizeof(AVPicture);
1226 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1227 pkt.flags |= AV_PKT_FLAG_KEY;
1229 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1230 enc->coded_frame = old_frame;
1232 AVFrame big_picture;
1234 big_picture= *final_picture;
1235 /* better than nothing: use input picture interlaced
1237 big_picture.interlaced_frame = in_picture->interlaced_frame;
1238 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1239 if(top_field_first == -1)
1240 big_picture.top_field_first = in_picture->top_field_first;
1242 big_picture.top_field_first = top_field_first;
1245 /* handles sameq here. This is not correct because it may
1246 not be a global option */
1247 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1249 big_picture.pict_type = 0;
1250 // big_picture.pts = AV_NOPTS_VALUE;
1251 big_picture.pts= ost->sync_opts;
1252 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1253 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1254 if (ost->forced_kf_index < ost->forced_kf_count &&
1255 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1256 big_picture.pict_type = FF_I_TYPE;
1257 ost->forced_kf_index++;
1259 ret = avcodec_encode_video(enc,
1260 bit_buffer, bit_buffer_size,
1263 fprintf(stderr, "Video encoding failed\n");
1268 pkt.data= bit_buffer;
1270 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1271 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1272 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1273 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1274 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1276 if(enc->coded_frame->key_frame)
1277 pkt.flags |= AV_PKT_FLAG_KEY;
1278 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1281 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1282 // enc->frame_number-1, ret, enc->pict_type);
1283 /* if two pass, output log */
1284 if (ost->logfile && enc->stats_out) {
1285 fprintf(ost->logfile, "%s", enc->stats_out);
1290 ost->frame_number++;
1294 static double psnr(double d){
1295 return -10.0*log(d)/log(10.0);
1298 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1301 AVCodecContext *enc;
1303 double ti1, bitrate, avg_bitrate;
1305 /* this is executed just the first time do_video_stats is called */
1307 vstats_file = fopen(vstats_filename, "w");
1314 enc = ost->st->codec;
1315 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1316 frame_number = ost->frame_number;
1317 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1318 if (enc->flags&CODEC_FLAG_PSNR)
1319 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1321 fprintf(vstats_file,"f_size= %6d ", frame_size);
1322 /* compute pts value */
1323 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1327 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1328 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1329 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1330 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1331 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1335 static void print_report(AVFormatContext **output_files,
1336 AVOutputStream **ost_table, int nb_ostreams,
1340 AVOutputStream *ost;
1341 AVFormatContext *oc;
1343 AVCodecContext *enc;
1344 int frame_number, vid, i;
1345 double bitrate, ti1, pts;
1346 static int64_t last_time = -1;
1347 static int qp_histogram[52];
1349 if (!is_last_report) {
1351 /* display the report every 0.5 seconds */
1352 cur_time = av_gettime();
1353 if (last_time == -1) {
1354 last_time = cur_time;
1357 if ((cur_time - last_time) < 500000)
1359 last_time = cur_time;
1363 oc = output_files[0];
1365 total_size = url_fsize(oc->pb);
1366 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1367 total_size= url_ftell(oc->pb);
1372 for(i=0;i<nb_ostreams;i++) {
1374 enc = ost->st->codec;
1375 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1376 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1377 !ost->st->stream_copy ?
1378 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1380 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1381 float t = (av_gettime()-timer_start) / 1000000.0;
1383 frame_number = ost->frame_number;
1384 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1385 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1386 !ost->st->stream_copy ?
1387 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1392 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1393 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1396 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1398 if (enc->flags&CODEC_FLAG_PSNR){
1400 double error, error_sum=0;
1401 double scale, scale_sum=0;
1402 char type[3]= {'Y','U','V'};
1403 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1406 error= enc->error[j];
1407 scale= enc->width*enc->height*255.0*255.0*frame_number;
1409 error= enc->coded_frame->error[j];
1410 scale= enc->width*enc->height*255.0*255.0;
1415 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1417 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1421 /* compute min output value */
1422 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1423 if ((pts < ti1) && (pts > 0))
1429 if (verbose || is_last_report) {
1430 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1432 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1433 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1434 (double)total_size / 1024, ti1, bitrate);
1436 if (nb_frames_dup || nb_frames_drop)
1437 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1438 nb_frames_dup, nb_frames_drop);
1441 fprintf(stderr, "%s \r", buf);
1446 if (is_last_report && verbose >= 0){
1447 int64_t raw= audio_size + video_size + extra_size;
1448 fprintf(stderr, "\n");
1449 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1453 100.0*(total_size - raw)/raw
1458 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1459 static int output_packet(AVInputStream *ist, int ist_index,
1460 AVOutputStream **ost_table, int nb_ostreams,
1461 const AVPacket *pkt)
1463 AVFormatContext *os;
1464 AVOutputStream *ost;
1468 void *buffer_to_free;
1469 static unsigned int samples_size= 0;
1470 AVSubtitle subtitle, *subtitle_to_free;
1471 int64_t pkt_pts = AV_NOPTS_VALUE;
1473 int frame_available;
1477 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1479 if(ist->next_pts == AV_NOPTS_VALUE)
1480 ist->next_pts= ist->pts;
1484 av_init_packet(&avpkt);
1492 if(pkt->dts != AV_NOPTS_VALUE)
1493 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1494 if(pkt->pts != AV_NOPTS_VALUE)
1495 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1497 //while we have more to decode or while the decoder did output something on EOF
1498 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1499 uint8_t *data_buf, *decoded_data_buf;
1500 int data_size, decoded_data_size;
1502 ist->pts= ist->next_pts;
1504 if(avpkt.size && avpkt.size != pkt->size &&
1505 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1506 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1507 ist->showed_multi_packet_warning=1;
1510 /* decode the packet if needed */
1511 decoded_data_buf = NULL; /* fail safe */
1512 decoded_data_size= 0;
1513 data_buf = avpkt.data;
1514 data_size = avpkt.size;
1515 subtitle_to_free = NULL;
1516 if (ist->decoding_needed) {
1517 switch(ist->st->codec->codec_type) {
1518 case AVMEDIA_TYPE_AUDIO:{
1519 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1520 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1522 samples= av_malloc(samples_size);
1524 decoded_data_size= samples_size;
1525 /* XXX: could avoid copy if PCM 16 bits with same
1526 endianness as CPU */
1527 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1534 /* Some bug in mpeg audio decoder gives */
1535 /* decoded_data_size < 0, it seems they are overflows */
1536 if (decoded_data_size <= 0) {
1537 /* no audio frame */
1540 decoded_data_buf = (uint8_t *)samples;
1541 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1542 (ist->st->codec->sample_rate * ist->st->codec->channels);
1544 case AVMEDIA_TYPE_VIDEO:
1545 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1546 /* XXX: allocate picture correctly */
1547 avcodec_get_frame_defaults(&picture);
1548 ist->st->codec->reordered_opaque = pkt_pts;
1549 pkt_pts = AV_NOPTS_VALUE;
1551 ret = avcodec_decode_video2(ist->st->codec,
1552 &picture, &got_picture, &avpkt);
1553 ist->st->quality= picture.quality;
1557 /* no picture yet */
1558 goto discard_packet;
1560 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1561 if (ist->st->codec->time_base.num != 0) {
1562 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1563 ist->next_pts += ((int64_t)AV_TIME_BASE *
1564 ist->st->codec->time_base.num * ticks) /
1565 ist->st->codec->time_base.den;
1569 case AVMEDIA_TYPE_SUBTITLE:
1570 ret = avcodec_decode_subtitle2(ist->st->codec,
1571 &subtitle, &got_picture, &avpkt);
1575 goto discard_packet;
1577 subtitle_to_free = &subtitle;
1584 switch(ist->st->codec->codec_type) {
1585 case AVMEDIA_TYPE_AUDIO:
1586 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1587 ist->st->codec->sample_rate;
1589 case AVMEDIA_TYPE_VIDEO:
1590 if (ist->st->codec->time_base.num != 0) {
1591 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1592 ist->next_pts += ((int64_t)AV_TIME_BASE *
1593 ist->st->codec->time_base.num * ticks) /
1594 ist->st->codec->time_base.den;
1602 buffer_to_free = NULL;
1603 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1604 pre_process_video_frame(ist, (AVPicture *)&picture,
1609 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1611 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1612 else sar = ist->st->codec->sample_aspect_ratio;
1613 // add it to be filtered
1614 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1620 // preprocess audio (volume)
1621 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1622 if (audio_volume != 256) {
1625 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1626 int v = ((*volp) * audio_volume + 128) >> 8;
1627 if (v < -32768) v = -32768;
1628 if (v > 32767) v = 32767;
1634 /* frame rate emulation */
1636 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1637 int64_t now = av_gettime() - ist->start;
1642 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1643 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1645 /* if output time reached then transcode raw format,
1646 encode packets and output them */
1647 if (start_time == 0 || ist->pts >= start_time)
1649 while (frame_available) {
1650 AVRational ist_pts_tb;
1651 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1652 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1654 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1656 for(i=0;i<nb_ostreams;i++) {
1660 if (ost->source_index == ist_index) {
1661 os = output_files[ost->file_index];
1663 /* set the input output pts pairs */
1664 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1666 if (ost->encoding_needed) {
1667 av_assert0(ist->decoding_needed);
1668 switch(ost->st->codec->codec_type) {
1669 case AVMEDIA_TYPE_AUDIO:
1670 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1672 case AVMEDIA_TYPE_VIDEO:
1674 if (ist->picref->video)
1675 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1677 do_video_out(os, ost, ist, &picture, &frame_size);
1678 if (vstats_filename && frame_size)
1679 do_video_stats(os, ost, frame_size);
1681 case AVMEDIA_TYPE_SUBTITLE:
1682 do_subtitle_out(os, ost, ist, &subtitle,
1689 AVFrame avframe; //FIXME/XXX remove this
1691 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1693 av_init_packet(&opkt);
1695 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1698 /* no reencoding needed : output the packet directly */
1699 /* force the input stream PTS */
1701 avcodec_get_frame_defaults(&avframe);
1702 ost->st->codec->coded_frame= &avframe;
1703 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1705 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1706 audio_size += data_size;
1707 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1708 video_size += data_size;
1712 opkt.stream_index= ost->index;
1713 if(pkt->pts != AV_NOPTS_VALUE)
1714 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1716 opkt.pts= AV_NOPTS_VALUE;
1718 if (pkt->dts == AV_NOPTS_VALUE)
1719 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1721 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1722 opkt.dts -= ost_tb_start_time;
1724 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1725 opkt.flags= pkt->flags;
1727 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1728 if( ost->st->codec->codec_id != CODEC_ID_H264
1729 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1730 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1732 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1733 opkt.destruct= av_destruct_packet;
1735 opkt.data = data_buf;
1736 opkt.size = data_size;
1739 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1740 ost->st->codec->frame_number++;
1741 ost->frame_number++;
1742 av_free_packet(&opkt);
1748 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1749 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1751 avfilter_unref_buffer(ist->picref);
1754 av_free(buffer_to_free);
1755 /* XXX: allocate the subtitles in the codec ? */
1756 if (subtitle_to_free) {
1757 avsubtitle_free(subtitle_to_free);
1758 subtitle_to_free = NULL;
1765 for(i=0;i<nb_ostreams;i++) {
1767 if (ost->source_index == ist_index) {
1768 AVCodecContext *enc= ost->st->codec;
1769 os = output_files[ost->file_index];
1771 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1773 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1776 if (ost->encoding_needed) {
1780 av_init_packet(&pkt);
1781 pkt.stream_index= ost->index;
1783 switch(ost->st->codec->codec_type) {
1784 case AVMEDIA_TYPE_AUDIO:
1785 fifo_bytes = av_fifo_size(ost->fifo);
1787 /* encode any samples remaining in fifo */
1788 if (fifo_bytes > 0) {
1789 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1790 int fs_tmp = enc->frame_size;
1792 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1793 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1794 enc->frame_size = fifo_bytes / (osize * enc->channels);
1796 int frame_bytes = enc->frame_size*osize*enc->channels;
1797 if (allocated_audio_buf_size < frame_bytes)
1799 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1802 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1803 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1804 ost->st->time_base.num, enc->sample_rate);
1805 enc->frame_size = fs_tmp;
1808 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1811 fprintf(stderr, "Audio encoding failed\n");
1815 pkt.flags |= AV_PKT_FLAG_KEY;
1817 case AVMEDIA_TYPE_VIDEO:
1818 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1820 fprintf(stderr, "Video encoding failed\n");
1824 if(enc->coded_frame && enc->coded_frame->key_frame)
1825 pkt.flags |= AV_PKT_FLAG_KEY;
1826 if (ost->logfile && enc->stats_out) {
1827 fprintf(ost->logfile, "%s", enc->stats_out);
1836 pkt.data= bit_buffer;
1838 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1839 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1840 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1852 static void print_sdp(AVFormatContext **avc, int n)
1856 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1857 printf("SDP:\n%s\n", sdp);
1861 static int copy_chapters(int infile, int outfile)
1863 AVFormatContext *is = input_files[infile];
1864 AVFormatContext *os = output_files[outfile];
1867 for (i = 0; i < is->nb_chapters; i++) {
1868 AVChapter *in_ch = is->chapters[i], *out_ch;
1869 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1870 AV_TIME_BASE_Q, in_ch->time_base);
1871 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1872 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1875 if (in_ch->end < ts_off)
1877 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1880 out_ch = av_mallocz(sizeof(AVChapter));
1882 return AVERROR(ENOMEM);
1884 out_ch->id = in_ch->id;
1885 out_ch->time_base = in_ch->time_base;
1886 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1887 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1889 if (metadata_chapters_autocopy)
1890 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1893 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1895 return AVERROR(ENOMEM);
1896 os->chapters[os->nb_chapters - 1] = out_ch;
1901 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1902 AVCodecContext *avctx)
1908 for (p = kf; *p; p++)
1911 ost->forced_kf_count = n;
1912 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1913 if (!ost->forced_kf_pts) {
1914 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1917 for (i = 0; i < n; i++) {
1918 p = i ? strchr(p, ',') + 1 : kf;
1919 t = parse_time_or_die("force_key_frames", p, 1);
1920 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1925 * The following code is the main loop of the file converter
1927 static int transcode(AVFormatContext **output_files,
1928 int nb_output_files,
1929 AVFormatContext **input_files,
1931 AVStreamMap *stream_maps, int nb_stream_maps)
1933 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1934 AVFormatContext *is, *os;
1935 AVCodecContext *codec, *icodec;
1936 AVOutputStream *ost, **ost_table = NULL;
1937 AVInputStream *ist, **ist_table = NULL;
1938 AVInputFile *file_table;
1942 uint8_t no_packet[MAX_FILES]={0};
1943 int no_packet_count=0;
1945 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1949 /* input stream init */
1951 for(i=0;i<nb_input_files;i++) {
1952 is = input_files[i];
1953 file_table[i].ist_index = j;
1954 file_table[i].nb_streams = is->nb_streams;
1955 j += is->nb_streams;
1959 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1963 for(i=0;i<nb_istreams;i++) {
1964 ist = av_mallocz(sizeof(AVInputStream));
1970 for(i=0;i<nb_input_files;i++) {
1971 is = input_files[i];
1972 for(k=0;k<is->nb_streams;k++) {
1973 ist = ist_table[j++];
1974 ist->st = is->streams[k];
1975 ist->file_index = i;
1977 ist->discard = 1; /* the stream is discarded by default
1981 ist->start = av_gettime();
1986 /* output stream init */
1988 for(i=0;i<nb_output_files;i++) {
1989 os = output_files[i];
1990 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1991 dump_format(output_files[i], i, output_files[i]->filename, 1);
1992 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1993 ret = AVERROR(EINVAL);
1996 nb_ostreams += os->nb_streams;
1998 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1999 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2000 ret = AVERROR(EINVAL);
2004 /* Sanity check the mapping args -- do the input files & streams exist? */
2005 for(i=0;i<nb_stream_maps;i++) {
2006 int fi = stream_maps[i].file_index;
2007 int si = stream_maps[i].stream_index;
2009 if (fi < 0 || fi > nb_input_files - 1 ||
2010 si < 0 || si > file_table[fi].nb_streams - 1) {
2011 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2012 ret = AVERROR(EINVAL);
2015 fi = stream_maps[i].sync_file_index;
2016 si = stream_maps[i].sync_stream_index;
2017 if (fi < 0 || fi > nb_input_files - 1 ||
2018 si < 0 || si > file_table[fi].nb_streams - 1) {
2019 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2020 ret = AVERROR(EINVAL);
2025 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2029 for(k=0;k<nb_output_files;k++) {
2030 os = output_files[k];
2031 for(i=0;i<os->nb_streams;i++,n++) {
2033 ost = ost_table[n] = output_streams_for_file[k][i];
2034 ost->st = os->streams[i];
2035 if (nb_stream_maps > 0) {
2036 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2037 stream_maps[n].stream_index;
2039 /* Sanity check that the stream types match */
2040 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2041 int i= ost->file_index;
2042 dump_format(output_files[i], i, output_files[i]->filename, 1);
2043 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2044 stream_maps[n].file_index, stream_maps[n].stream_index,
2045 ost->file_index, ost->index);
2050 int best_nb_frames=-1;
2051 /* get corresponding input stream index : we select the first one with the right type */
2053 for(j=0;j<nb_istreams;j++) {
2058 AVFormatContext *f= input_files[ ist->file_index ];
2060 for(pi=0; pi<f->nb_programs; pi++){
2061 AVProgram *p= f->programs[pi];
2062 if(p->id == opt_programid)
2063 for(si=0; si<p->nb_stream_indexes; si++){
2064 if(f->streams[ p->stream_index[si] ] == ist->st)
2069 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2070 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2071 if(best_nb_frames < ist->st->codec_info_nb_frames){
2072 best_nb_frames= ist->st->codec_info_nb_frames;
2073 ost->source_index = j;
2080 if(! opt_programid) {
2081 /* try again and reuse existing stream */
2082 for(j=0;j<nb_istreams;j++) {
2084 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2085 && ist->st->discard != AVDISCARD_ALL) {
2086 ost->source_index = j;
2092 int i= ost->file_index;
2093 dump_format(output_files[i], i, output_files[i]->filename, 1);
2094 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2095 ost->file_index, ost->index);
2100 ist = ist_table[ost->source_index];
2102 ost->sync_ist = (nb_stream_maps > 0) ?
2103 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2104 stream_maps[n].sync_stream_index] : ist;
2108 /* for each output stream, we compute the right encoding parameters */
2109 for(i=0;i<nb_ostreams;i++) {
2111 os = output_files[ost->file_index];
2112 ist = ist_table[ost->source_index];
2114 codec = ost->st->codec;
2115 icodec = ist->st->codec;
2117 if (metadata_streams_autocopy)
2118 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2119 AV_METADATA_DONT_OVERWRITE);
2121 ost->st->disposition = ist->st->disposition;
2122 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2123 codec->chroma_sample_location = icodec->chroma_sample_location;
2125 if (ost->st->stream_copy) {
2126 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2128 if (extra_size > INT_MAX)
2131 /* if stream_copy is selected, no need to decode or encode */
2132 codec->codec_id = icodec->codec_id;
2133 codec->codec_type = icodec->codec_type;
2135 if(!codec->codec_tag){
2136 if( !os->oformat->codec_tag
2137 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2138 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2139 codec->codec_tag = icodec->codec_tag;
2142 codec->bit_rate = icodec->bit_rate;
2143 codec->rc_max_rate = icodec->rc_max_rate;
2144 codec->rc_buffer_size = icodec->rc_buffer_size;
2145 codec->extradata= av_mallocz(extra_size);
2146 if (!codec->extradata)
2148 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2149 codec->extradata_size= icodec->extradata_size;
2150 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2151 codec->time_base = icodec->time_base;
2152 codec->time_base.num *= icodec->ticks_per_frame;
2153 av_reduce(&codec->time_base.num, &codec->time_base.den,
2154 codec->time_base.num, codec->time_base.den, INT_MAX);
2156 codec->time_base = ist->st->time_base;
2157 switch(codec->codec_type) {
2158 case AVMEDIA_TYPE_AUDIO:
2159 if(audio_volume != 256) {
2160 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2163 codec->channel_layout = icodec->channel_layout;
2164 codec->sample_rate = icodec->sample_rate;
2165 codec->channels = icodec->channels;
2166 codec->frame_size = icodec->frame_size;
2167 codec->block_align= icodec->block_align;
2168 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2169 codec->block_align= 0;
2170 if(codec->codec_id == CODEC_ID_AC3)
2171 codec->block_align= 0;
2173 case AVMEDIA_TYPE_VIDEO:
2174 codec->pix_fmt = icodec->pix_fmt;
2175 codec->width = icodec->width;
2176 codec->height = icodec->height;
2177 codec->has_b_frames = icodec->has_b_frames;
2179 case AVMEDIA_TYPE_SUBTITLE:
2180 codec->width = icodec->width;
2181 codec->height = icodec->height;
2187 switch(codec->codec_type) {
2188 case AVMEDIA_TYPE_AUDIO:
2189 ost->fifo= av_fifo_alloc(1024);
2192 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2193 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2194 icodec->request_channels = codec->channels;
2195 ist->decoding_needed = 1;
2196 ost->encoding_needed = 1;
2197 ost->resample_sample_fmt = icodec->sample_fmt;
2198 ost->resample_sample_rate = icodec->sample_rate;
2199 ost->resample_channels = icodec->channels;
2201 case AVMEDIA_TYPE_VIDEO:
2202 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2203 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2206 ost->video_resample = (codec->width != icodec->width ||
2207 codec->height != icodec->height ||
2208 (codec->pix_fmt != icodec->pix_fmt));
2209 if (ost->video_resample) {
2210 #if !CONFIG_AVFILTER
2211 avcodec_get_frame_defaults(&ost->pict_tmp);
2212 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2213 codec->width, codec->height)) {
2214 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2217 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2218 ost->img_resample_ctx = sws_getContext(
2225 sws_flags, NULL, NULL, NULL);
2226 if (ost->img_resample_ctx == NULL) {
2227 fprintf(stderr, "Cannot get resampling context\n");
2231 ost->original_height = icodec->height;
2232 ost->original_width = icodec->width;
2234 codec->bits_per_raw_sample= 0;
2236 ost->resample_height = icodec->height;
2237 ost->resample_width = icodec->width;
2238 ost->resample_pix_fmt= icodec->pix_fmt;
2239 ost->encoding_needed = 1;
2240 ist->decoding_needed = 1;
2243 if (configure_filters(ist, ost)) {
2244 fprintf(stderr, "Error opening filters!\n");
2249 case AVMEDIA_TYPE_SUBTITLE:
2250 ost->encoding_needed = 1;
2251 ist->decoding_needed = 1;
2258 if (ost->encoding_needed &&
2259 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2260 char logfilename[1024];
2263 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2264 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2266 if (codec->flags & CODEC_FLAG_PASS1) {
2267 f = fopen(logfilename, "wb");
2269 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2275 size_t logbuffer_size;
2276 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2277 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2280 codec->stats_in = logbuffer;
2284 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2285 int size= codec->width * codec->height;
2286 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2291 bit_buffer = av_malloc(bit_buffer_size);
2293 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2295 ret = AVERROR(ENOMEM);
2299 /* open each encoder */
2300 for(i=0;i<nb_ostreams;i++) {
2302 if (ost->encoding_needed) {
2303 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2304 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2306 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2308 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2309 ost->st->codec->codec_id, ost->file_index, ost->index);
2310 ret = AVERROR(EINVAL);
2313 if (dec->subtitle_header) {
2314 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2315 if (!ost->st->codec->subtitle_header) {
2316 ret = AVERROR(ENOMEM);
2319 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2320 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2322 if (avcodec_open(ost->st->codec, codec) < 0) {
2323 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2324 ost->file_index, ost->index);
2325 ret = AVERROR(EINVAL);
2328 extra_size += ost->st->codec->extradata_size;
2332 /* open each decoder */
2333 for(i=0;i<nb_istreams;i++) {
2335 if (ist->decoding_needed) {
2336 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2338 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2340 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2341 ist->st->codec->codec_id, ist->file_index, ist->index);
2342 ret = AVERROR(EINVAL);
2345 if (avcodec_open(ist->st->codec, codec) < 0) {
2346 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2347 ist->file_index, ist->index);
2348 ret = AVERROR(EINVAL);
2351 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2352 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2357 for(i=0;i<nb_istreams;i++) {
2361 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2362 ist->next_pts = AV_NOPTS_VALUE;
2363 init_pts_correction(&ist->pts_ctx);
2367 /* set meta data information from input file if required */
2368 for (i=0;i<nb_meta_data_maps;i++) {
2369 AVFormatContext *files[2];
2370 AVMetadata **meta[2];
2373 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2374 if ((index) < 0 || (index) >= (nb_elems)) {\
2375 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2377 ret = AVERROR(EINVAL);\
2381 int out_file_index = meta_data_maps[i][0].file;
2382 int in_file_index = meta_data_maps[i][1].file;
2383 if (in_file_index < 0 || out_file_index < 0)
2385 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2386 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2388 files[0] = output_files[out_file_index];
2389 files[1] = input_files[in_file_index];
2391 for (j = 0; j < 2; j++) {
2392 AVMetaDataMap *map = &meta_data_maps[i][j];
2394 switch (map->type) {
2396 meta[j] = &files[j]->metadata;
2399 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2400 meta[j] = &files[j]->streams[map->index]->metadata;
2403 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2404 meta[j] = &files[j]->chapters[map->index]->metadata;
2407 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2408 meta[j] = &files[j]->programs[map->index]->metadata;
2413 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2416 /* copy global metadata by default */
2417 if (metadata_global_autocopy) {
2419 for (i = 0; i < nb_output_files; i++)
2420 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2421 AV_METADATA_DONT_OVERWRITE);
2424 /* copy chapters according to chapter maps */
2425 for (i = 0; i < nb_chapter_maps; i++) {
2426 int infile = chapter_maps[i].in_file;
2427 int outfile = chapter_maps[i].out_file;
2429 if (infile < 0 || outfile < 0)
2431 if (infile >= nb_input_files) {
2432 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2433 ret = AVERROR(EINVAL);
2436 if (outfile >= nb_output_files) {
2437 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2438 ret = AVERROR(EINVAL);
2441 copy_chapters(infile, outfile);
2444 /* copy chapters from the first input file that has them*/
2445 if (!nb_chapter_maps)
2446 for (i = 0; i < nb_input_files; i++) {
2447 if (!input_files[i]->nb_chapters)
2450 for (j = 0; j < nb_output_files; j++)
2451 if ((ret = copy_chapters(i, j)) < 0)
2456 /* open files and write file headers */
2457 for(i=0;i<nb_output_files;i++) {
2458 os = output_files[i];
2459 if (av_write_header(os) < 0) {
2460 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2461 ret = AVERROR(EINVAL);
2464 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2470 /* dump the file output parameters - cannot be done before in case
2472 for(i=0;i<nb_output_files;i++) {
2473 dump_format(output_files[i], i, output_files[i]->filename, 1);
2476 /* dump the stream mapping */
2478 fprintf(stderr, "Stream mapping:\n");
2479 for(i=0;i<nb_ostreams;i++) {
2481 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2482 ist_table[ost->source_index]->file_index,
2483 ist_table[ost->source_index]->index,
2486 if (ost->sync_ist != ist_table[ost->source_index])
2487 fprintf(stderr, " [sync #%d.%d]",
2488 ost->sync_ist->file_index,
2489 ost->sync_ist->index);
2490 fprintf(stderr, "\n");
2495 fprintf(stderr, "%s\n", error);
2500 print_sdp(output_files, nb_output_files);
2503 if (!using_stdin && verbose >= 0) {
2504 fprintf(stderr, "Press [q] to stop encoding\n");
2505 url_set_interrupt_cb(decode_interrupt_cb);
2509 timer_start = av_gettime();
2511 for(; received_sigterm == 0;) {
2512 int file_index, ist_index;
2520 /* if 'q' pressed, exits */
2524 /* read_key() returns 0 on EOF */
2530 /* select the stream that we must read now by looking at the
2531 smallest output pts */
2533 for(i=0;i<nb_ostreams;i++) {
2536 os = output_files[ost->file_index];
2537 ist = ist_table[ost->source_index];
2538 if(ist->is_past_recording_time || no_packet[ist->file_index])
2540 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2541 ipts = (double)ist->pts;
2542 if (!file_table[ist->file_index].eof_reached){
2543 if(ipts < ipts_min) {
2545 if(input_sync ) file_index = ist->file_index;
2547 if(opts < opts_min) {
2549 if(!input_sync) file_index = ist->file_index;
2552 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2557 /* if none, if is finished */
2558 if (file_index < 0) {
2559 if(no_packet_count){
2561 memset(no_packet, 0, sizeof(no_packet));
2568 /* finish if limit size exhausted */
2569 if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2572 /* read a frame from it and output it in the fifo */
2573 is = input_files[file_index];
2574 ret= av_read_frame(is, &pkt);
2575 if(ret == AVERROR(EAGAIN)){
2576 no_packet[file_index]=1;
2581 file_table[file_index].eof_reached = 1;
2589 memset(no_packet, 0, sizeof(no_packet));
2592 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2594 /* the following test is needed in case new streams appear
2595 dynamically in stream : we ignore them */
2596 if (pkt.stream_index >= file_table[file_index].nb_streams)
2597 goto discard_packet;
2598 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2599 ist = ist_table[ist_index];
2601 goto discard_packet;
2603 if (pkt.dts != AV_NOPTS_VALUE)
2604 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2605 if (pkt.pts != AV_NOPTS_VALUE)
2606 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2608 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2609 && input_files_ts_scale[file_index][pkt.stream_index]){
2610 if(pkt.pts != AV_NOPTS_VALUE)
2611 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2612 if(pkt.dts != AV_NOPTS_VALUE)
2613 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2616 // 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);
2617 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2618 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2619 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2620 int64_t delta= pkt_dts - ist->next_pts;
2621 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2622 input_files_ts_offset[ist->file_index]-= delta;
2624 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2625 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2626 if(pkt.pts != AV_NOPTS_VALUE)
2627 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2631 /* finish if recording time exhausted */
2632 if (recording_time != INT64_MAX &&
2633 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2634 ist->is_past_recording_time = 1;
2635 goto discard_packet;
2638 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2639 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2642 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2643 ist->file_index, ist->index);
2646 av_free_packet(&pkt);
2651 av_free_packet(&pkt);
2653 /* dump report by using the output first video and audio streams */
2654 print_report(output_files, ost_table, nb_ostreams, 0);
2657 /* at the end of stream, we must flush the decoder buffers */
2658 for(i=0;i<nb_istreams;i++) {
2660 if (ist->decoding_needed) {
2661 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2667 /* write the trailer if needed and close file */
2668 for(i=0;i<nb_output_files;i++) {
2669 os = output_files[i];
2670 av_write_trailer(os);
2673 /* dump report by using the first video and audio streams */
2674 print_report(output_files, ost_table, nb_ostreams, 1);
2676 /* close each encoder */
2677 for(i=0;i<nb_ostreams;i++) {
2679 if (ost->encoding_needed) {
2680 av_freep(&ost->st->codec->stats_in);
2681 avcodec_close(ost->st->codec);
2685 /* close each decoder */
2686 for(i=0;i<nb_istreams;i++) {
2688 if (ist->decoding_needed) {
2689 avcodec_close(ist->st->codec);
2694 avfilter_graph_free(graph);
2703 av_freep(&bit_buffer);
2704 av_free(file_table);
2707 for(i=0;i<nb_istreams;i++) {
2714 for(i=0;i<nb_ostreams;i++) {
2717 if (ost->st->stream_copy)
2718 av_freep(&ost->st->codec->extradata);
2720 fclose(ost->logfile);
2721 ost->logfile = NULL;
2723 av_fifo_free(ost->fifo); /* works even if fifo is not
2724 initialized but set to zero */
2725 av_freep(&ost->st->codec->subtitle_header);
2726 av_free(ost->pict_tmp.data[0]);
2727 av_free(ost->forced_kf_pts);
2728 if (ost->video_resample)
2729 sws_freeContext(ost->img_resample_ctx);
2731 audio_resample_close(ost->resample);
2732 if (ost->reformat_ctx)
2733 av_audio_convert_free(ost->reformat_ctx);
2742 static void opt_format(const char *arg)
2744 last_asked_format = arg;
2747 static void opt_video_rc_override_string(const char *arg)
2749 video_rc_override_string = arg;
2752 static int opt_me_threshold(const char *opt, const char *arg)
2754 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2758 static int opt_verbose(const char *opt, const char *arg)
2760 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2764 static int opt_frame_rate(const char *opt, const char *arg)
2766 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2767 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2773 static int opt_bitrate(const char *opt, const char *arg)
2775 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2777 opt_default(opt, arg);
2779 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2780 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2785 static int opt_frame_crop(const char *opt, const char *arg)
2787 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2788 return AVERROR(EINVAL);
2791 static void opt_frame_size(const char *arg)
2793 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2794 fprintf(stderr, "Incorrect frame size\n");
2799 static int opt_pad(const char *opt, const char *arg) {
2800 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2804 static void opt_frame_pix_fmt(const char *arg)
2806 if (strcmp(arg, "list")) {
2807 frame_pix_fmt = av_get_pix_fmt(arg);
2808 if (frame_pix_fmt == PIX_FMT_NONE) {
2809 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2818 static void opt_frame_aspect_ratio(const char *arg)
2825 p = strchr(arg, ':');
2827 x = strtol(arg, &end, 10);
2829 y = strtol(end+1, &end, 10);
2831 ar = (double)x / (double)y;
2833 ar = strtod(arg, NULL);
2836 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2839 frame_aspect_ratio = ar;
2842 static int opt_metadata(const char *opt, const char *arg)
2844 char *mid= strchr(arg, '=');
2847 fprintf(stderr, "Missing =\n");
2852 av_metadata_set2(&metadata, arg, mid, 0);
2857 static void opt_qscale(const char *arg)
2859 video_qscale = atof(arg);
2860 if (video_qscale <= 0 ||
2861 video_qscale > 255) {
2862 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2867 static void opt_top_field_first(const char *arg)
2869 top_field_first= atoi(arg);
2872 static int opt_thread_count(const char *opt, const char *arg)
2874 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2877 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2882 static void opt_audio_sample_fmt(const char *arg)
2884 if (strcmp(arg, "list")) {
2885 audio_sample_fmt = av_get_sample_fmt(arg);
2886 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2887 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2891 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2896 static int opt_audio_rate(const char *opt, const char *arg)
2898 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2902 static int opt_audio_channels(const char *opt, const char *arg)
2904 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2908 static void opt_video_channel(const char *arg)
2910 video_channel = strtol(arg, NULL, 0);
2913 static void opt_video_standard(const char *arg)
2915 video_standard = av_strdup(arg);
2918 static void opt_codec(int *pstream_copy, char **pcodec_name,
2919 int codec_type, const char *arg)
2921 av_freep(pcodec_name);
2922 if (!strcmp(arg, "copy")) {
2925 *pcodec_name = av_strdup(arg);
2929 static void opt_audio_codec(const char *arg)
2931 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2934 static void opt_video_codec(const char *arg)
2936 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2939 static void opt_subtitle_codec(const char *arg)
2941 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2944 static int opt_codec_tag(const char *opt, const char *arg)
2947 uint32_t *codec_tag;
2949 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2950 !strcmp(opt, "vtag") ? &video_codec_tag :
2951 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2955 *codec_tag = strtol(arg, &tail, 0);
2957 *codec_tag = AV_RL32(arg);
2962 static void opt_map(const char *arg)
2967 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2968 m = &stream_maps[nb_stream_maps-1];
2970 m->file_index = strtol(arg, &p, 0);
2974 m->stream_index = strtol(p, &p, 0);
2977 m->sync_file_index = strtol(p, &p, 0);
2980 m->sync_stream_index = strtol(p, &p, 0);
2982 m->sync_file_index = m->file_index;
2983 m->sync_stream_index = m->stream_index;
2987 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2998 *index = strtol(++arg, endptr, 0);
3001 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3008 static void opt_map_meta_data(const char *arg)
3010 AVMetaDataMap *m, *m1;
3013 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3014 &nb_meta_data_maps, nb_meta_data_maps + 1);
3016 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3017 m->file = strtol(arg, &p, 0);
3018 parse_meta_type(p, &m->type, &m->index, &p);
3022 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3023 m1->file = strtol(p, &p, 0);
3024 parse_meta_type(p, &m1->type, &m1->index, &p);
3026 if (m->type == 'g' || m1->type == 'g')
3027 metadata_global_autocopy = 0;
3028 if (m->type == 's' || m1->type == 's')
3029 metadata_streams_autocopy = 0;
3030 if (m->type == 'c' || m1->type == 'c')
3031 metadata_chapters_autocopy = 0;
3034 static void opt_map_chapters(const char *arg)
3039 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3040 nb_chapter_maps + 1);
3041 c = &chapter_maps[nb_chapter_maps - 1];
3042 c->out_file = strtol(arg, &p, 0);
3046 c->in_file = strtol(p, &p, 0);
3049 static void opt_input_ts_scale(const char *arg)
3051 unsigned int stream;
3055 stream = strtol(arg, &p, 0);
3058 scale= strtod(p, &p);
3060 if(stream >= MAX_STREAMS)
3063 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);
3064 input_files_ts_scale[nb_input_files][stream]= scale;
3067 static int opt_recording_time(const char *opt, const char *arg)
3069 recording_time = parse_time_or_die(opt, arg, 1);
3073 static int opt_start_time(const char *opt, const char *arg)
3075 start_time = parse_time_or_die(opt, arg, 1);
3079 static int opt_recording_timestamp(const char *opt, const char *arg)
3081 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3085 static int opt_input_ts_offset(const char *opt, const char *arg)
3087 input_ts_offset = parse_time_or_die(opt, arg, 1);
3091 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3093 const char *codec_string = encoder ? "encoder" : "decoder";
3097 return CODEC_ID_NONE;
3099 avcodec_find_encoder_by_name(name) :
3100 avcodec_find_decoder_by_name(name);
3102 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3105 if(codec->type != type) {
3106 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3109 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3110 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3111 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3112 "results.\nAdd '-strict experimental' if you want to use it.\n",
3113 codec_string, codec->name);
3115 avcodec_find_encoder(codec->id) :
3116 avcodec_find_decoder(codec->id);
3117 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3118 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3119 codec_string, codec->name);
3125 static void opt_input_file(const char *filename)
3127 AVFormatContext *ic;
3128 AVFormatParameters params, *ap = ¶ms;
3129 AVInputFormat *file_iformat = NULL;
3130 int err, i, ret, rfps, rfps_base;
3133 if (last_asked_format) {
3134 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3135 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3138 last_asked_format = NULL;
3141 if (!strcmp(filename, "-"))
3144 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3145 !strcmp(filename, "/dev/stdin");
3147 /* get default parameters from command line */
3148 ic = avformat_alloc_context();
3150 print_error(filename, AVERROR(ENOMEM));
3154 memset(ap, 0, sizeof(*ap));
3155 ap->prealloced_context = 1;
3156 ap->sample_rate = audio_sample_rate;
3157 ap->channels = audio_channels;
3158 ap->time_base.den = frame_rate.num;
3159 ap->time_base.num = frame_rate.den;
3160 ap->width = frame_width;
3161 ap->height = frame_height;
3162 ap->pix_fmt = frame_pix_fmt;
3163 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3164 ap->channel = video_channel;
3165 ap->standard = video_standard;
3167 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3169 ic->video_codec_id =
3170 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3171 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3172 ic->audio_codec_id =
3173 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3174 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3175 ic->subtitle_codec_id=
3176 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3177 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3178 ic->flags |= AVFMT_FLAG_NONBLOCK;
3180 /* open the input file with generic libav function */
3181 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3183 print_error(filename, err);
3189 for(i=0; i<ic->nb_streams; i++){
3190 ic->streams[i]->discard= AVDISCARD_ALL;
3192 for(i=0; i<ic->nb_programs; i++){
3193 AVProgram *p= ic->programs[i];
3194 if(p->id != opt_programid){
3195 p->discard = AVDISCARD_ALL;
3198 for(j=0; j<p->nb_stream_indexes; j++){
3199 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3204 fprintf(stderr, "Specified program id not found\n");
3210 ic->loop_input = loop_input;
3212 /* If not enough info to get the stream parameters, we decode the
3213 first frames to get it. (used in mpeg case for example) */
3214 ret = av_find_stream_info(ic);
3215 if (ret < 0 && verbose >= 0) {
3216 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3217 av_close_input_file(ic);
3221 timestamp = start_time;
3222 /* add the stream start time */
3223 if (ic->start_time != AV_NOPTS_VALUE)
3224 timestamp += ic->start_time;
3226 /* if seeking requested, we execute it */
3227 if (start_time != 0) {
3228 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3230 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3231 filename, (double)timestamp / AV_TIME_BASE);
3233 /* reset seek info */
3237 /* update the current parameters so that they match the one of the input stream */
3238 for(i=0;i<ic->nb_streams;i++) {
3239 AVStream *st = ic->streams[i];
3240 AVCodecContext *dec = st->codec;
3241 avcodec_thread_init(dec, thread_count);
3242 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3243 switch (dec->codec_type) {
3244 case AVMEDIA_TYPE_AUDIO:
3245 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3246 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]);
3247 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3248 channel_layout = dec->channel_layout;
3249 audio_channels = dec->channels;
3250 audio_sample_rate = dec->sample_rate;
3251 audio_sample_fmt = dec->sample_fmt;
3253 st->discard= AVDISCARD_ALL;
3254 /* Note that av_find_stream_info can add more streams, and we
3255 * currently have no chance of setting up lowres decoding
3256 * early enough for them. */
3258 audio_sample_rate >>= dec->lowres;
3260 case AVMEDIA_TYPE_VIDEO:
3261 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3262 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]);
3263 frame_height = dec->height;
3264 frame_width = dec->width;
3265 if(ic->streams[i]->sample_aspect_ratio.num)
3266 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3268 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3269 frame_aspect_ratio *= (float) dec->width / dec->height;
3270 frame_pix_fmt = dec->pix_fmt;
3271 rfps = ic->streams[i]->r_frame_rate.num;
3272 rfps_base = ic->streams[i]->r_frame_rate.den;
3274 dec->flags |= CODEC_FLAG_EMU_EDGE;
3275 frame_height >>= dec->lowres;
3276 frame_width >>= dec->lowres;
3277 dec->height = frame_height;
3278 dec->width = frame_width;
3281 dec->debug |= FF_DEBUG_MV;
3283 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3286 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3287 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3289 (float)rfps / rfps_base, rfps, rfps_base);
3291 /* update the current frame rate to match the stream frame rate */
3292 frame_rate.num = rfps;
3293 frame_rate.den = rfps_base;
3296 st->discard= AVDISCARD_ALL;
3297 else if(video_discard)
3298 st->discard= video_discard;
3300 case AVMEDIA_TYPE_DATA:
3302 case AVMEDIA_TYPE_SUBTITLE:
3303 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3304 if(subtitle_disable)
3305 st->discard = AVDISCARD_ALL;
3307 case AVMEDIA_TYPE_ATTACHMENT:
3308 case AVMEDIA_TYPE_UNKNOWN:
3315 input_files[nb_input_files] = ic;
3316 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3317 /* dump the file content */
3319 dump_format(ic, nb_input_files, filename, 0);
3325 av_freep(&video_codec_name);
3326 av_freep(&audio_codec_name);
3327 av_freep(&subtitle_codec_name);
3330 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3331 int *has_subtitle_ptr)
3333 int has_video, has_audio, has_subtitle, i, j;
3334 AVFormatContext *ic;
3339 for(j=0;j<nb_input_files;j++) {
3340 ic = input_files[j];
3341 for(i=0;i<ic->nb_streams;i++) {
3342 AVCodecContext *enc = ic->streams[i]->codec;
3343 switch(enc->codec_type) {
3344 case AVMEDIA_TYPE_AUDIO:
3347 case AVMEDIA_TYPE_VIDEO:
3350 case AVMEDIA_TYPE_SUBTITLE:
3353 case AVMEDIA_TYPE_DATA:
3354 case AVMEDIA_TYPE_ATTACHMENT:
3355 case AVMEDIA_TYPE_UNKNOWN:
3362 *has_video_ptr = has_video;
3363 *has_audio_ptr = has_audio;
3364 *has_subtitle_ptr = has_subtitle;
3367 static void new_video_stream(AVFormatContext *oc, int file_idx)
3370 AVOutputStream *ost;
3371 AVCodecContext *video_enc;
3372 enum CodecID codec_id = CODEC_ID_NONE;
3373 AVCodec *codec= NULL;
3375 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3377 fprintf(stderr, "Could not alloc stream\n");
3380 ost = new_output_stream(oc, file_idx);
3382 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3383 if(!video_stream_copy){
3384 if (video_codec_name) {
3385 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3386 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3387 codec = avcodec_find_encoder_by_name(video_codec_name);
3388 output_codecs[nb_output_codecs-1] = codec;
3390 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3391 codec = avcodec_find_encoder(codec_id);
3395 avcodec_get_context_defaults3(st->codec, codec);
3396 ost->bitstream_filters = video_bitstream_filters;
3397 video_bitstream_filters= NULL;
3399 avcodec_thread_init(st->codec, thread_count);
3401 video_enc = st->codec;
3404 video_enc->codec_tag= video_codec_tag;
3406 if( (video_global_header&1)
3407 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3408 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3409 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3411 if(video_global_header&2){
3412 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3413 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3416 if (video_stream_copy) {
3417 st->stream_copy = 1;
3418 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3419 video_enc->sample_aspect_ratio =
3420 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3424 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3426 video_enc->codec_id = codec_id;
3427 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3429 if (codec && codec->supported_framerates && !force_fps)
3430 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3431 video_enc->time_base.den = fps.num;
3432 video_enc->time_base.num = fps.den;
3434 video_enc->width = frame_width;
3435 video_enc->height = frame_height;
3436 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3437 video_enc->pix_fmt = frame_pix_fmt;
3438 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3440 choose_pixel_fmt(st, codec);
3443 video_enc->gop_size = 0;
3444 if (video_qscale || same_quality) {
3445 video_enc->flags |= CODEC_FLAG_QSCALE;
3446 video_enc->global_quality=
3447 st->quality = FF_QP2LAMBDA * video_qscale;
3451 video_enc->intra_matrix = intra_matrix;
3453 video_enc->inter_matrix = inter_matrix;
3455 p= video_rc_override_string;
3458 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3460 fprintf(stderr, "error parsing rc_override\n");
3463 video_enc->rc_override=
3464 av_realloc(video_enc->rc_override,
3465 sizeof(RcOverride)*(i+1));
3466 video_enc->rc_override[i].start_frame= start;
3467 video_enc->rc_override[i].end_frame = end;
3469 video_enc->rc_override[i].qscale= q;
3470 video_enc->rc_override[i].quality_factor= 1.0;
3473 video_enc->rc_override[i].qscale= 0;
3474 video_enc->rc_override[i].quality_factor= -q/100.0;
3479 video_enc->rc_override_count=i;
3480 if (!video_enc->rc_initial_buffer_occupancy)
3481 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3482 video_enc->me_threshold= me_threshold;
3483 video_enc->intra_dc_precision= intra_dc_precision - 8;
3486 video_enc->flags|= CODEC_FLAG_PSNR;
3491 video_enc->flags |= CODEC_FLAG_PASS1;
3493 video_enc->flags |= CODEC_FLAG_PASS2;
3497 if (forced_key_frames)
3498 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3500 if (video_language) {
3501 av_metadata_set2(&st->metadata, "language", video_language, 0);
3502 av_freep(&video_language);
3505 /* reset some key parameters */
3507 av_freep(&video_codec_name);
3508 av_freep(&forced_key_frames);
3509 video_stream_copy = 0;
3510 frame_pix_fmt = PIX_FMT_NONE;
3513 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3516 AVOutputStream *ost;
3517 AVCodec *codec= NULL;
3518 AVCodecContext *audio_enc;
3519 enum CodecID codec_id = CODEC_ID_NONE;
3521 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3523 fprintf(stderr, "Could not alloc stream\n");
3526 ost = new_output_stream(oc, file_idx);
3528 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3529 if(!audio_stream_copy){
3530 if (audio_codec_name) {
3531 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3532 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3533 codec = avcodec_find_encoder_by_name(audio_codec_name);
3534 output_codecs[nb_output_codecs-1] = codec;
3536 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3537 codec = avcodec_find_encoder(codec_id);
3541 avcodec_get_context_defaults3(st->codec, codec);
3543 ost->bitstream_filters = audio_bitstream_filters;
3544 audio_bitstream_filters= NULL;
3546 avcodec_thread_init(st->codec, thread_count);
3548 audio_enc = st->codec;
3549 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3552 audio_enc->codec_tag= audio_codec_tag;
3554 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3555 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3556 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3558 if (audio_stream_copy) {
3559 st->stream_copy = 1;
3560 audio_enc->channels = audio_channels;
3561 audio_enc->sample_rate = audio_sample_rate;
3563 audio_enc->codec_id = codec_id;
3564 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3566 if (audio_qscale > QSCALE_NONE) {
3567 audio_enc->flags |= CODEC_FLAG_QSCALE;
3568 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3570 audio_enc->channels = audio_channels;
3571 audio_enc->sample_fmt = audio_sample_fmt;
3572 audio_enc->sample_rate = audio_sample_rate;
3573 audio_enc->channel_layout = channel_layout;
3574 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3575 audio_enc->channel_layout = 0;
3576 choose_sample_fmt(st, codec);
3577 choose_sample_rate(st, codec);
3579 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3580 if (audio_language) {
3581 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3582 av_freep(&audio_language);
3585 /* reset some key parameters */
3587 av_freep(&audio_codec_name);
3588 audio_stream_copy = 0;
3591 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3594 AVOutputStream *ost;
3595 AVCodec *codec=NULL;
3596 AVCodecContext *subtitle_enc;
3597 enum CodecID codec_id = CODEC_ID_NONE;
3599 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3601 fprintf(stderr, "Could not alloc stream\n");
3604 ost = new_output_stream(oc, file_idx);
3605 subtitle_enc = st->codec;
3606 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3607 if(!subtitle_stream_copy){
3608 if (subtitle_codec_name) {
3609 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3610 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3611 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3613 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3614 codec = avcodec_find_encoder(codec_id);
3617 avcodec_get_context_defaults3(st->codec, codec);
3619 ost->bitstream_filters = subtitle_bitstream_filters;
3620 subtitle_bitstream_filters= NULL;
3622 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3624 if(subtitle_codec_tag)
3625 subtitle_enc->codec_tag= subtitle_codec_tag;
3627 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3628 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3629 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3631 if (subtitle_stream_copy) {
3632 st->stream_copy = 1;
3634 subtitle_enc->codec_id = codec_id;
3635 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3638 if (subtitle_language) {
3639 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3640 av_freep(&subtitle_language);
3643 subtitle_disable = 0;
3644 av_freep(&subtitle_codec_name);
3645 subtitle_stream_copy = 0;
3648 static int opt_new_stream(const char *opt, const char *arg)
3650 AVFormatContext *oc;
3651 int file_idx = nb_output_files - 1;
3652 if (nb_output_files <= 0) {
3653 fprintf(stderr, "At least one output file must be specified\n");
3656 oc = output_files[file_idx];
3658 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3659 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3660 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3665 /* arg format is "output-stream-index:streamid-value". */
3666 static int opt_streamid(const char *opt, const char *arg)
3672 strncpy(idx_str, arg, sizeof(idx_str));
3673 idx_str[sizeof(idx_str)-1] = '\0';
3674 p = strchr(idx_str, ':');
3677 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3682 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3683 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3684 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3688 static void opt_output_file(const char *filename)
3690 AVFormatContext *oc;
3691 int err, use_video, use_audio, use_subtitle;
3692 int input_has_video, input_has_audio, input_has_subtitle;
3693 AVFormatParameters params, *ap = ¶ms;
3694 AVOutputFormat *file_oformat;
3696 if (!strcmp(filename, "-"))
3699 oc = avformat_alloc_context();
3701 print_error(filename, AVERROR(ENOMEM));
3705 if (last_asked_format) {
3706 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3707 if (!file_oformat) {
3708 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3711 last_asked_format = NULL;
3713 file_oformat = av_guess_format(NULL, filename, NULL);
3714 if (!file_oformat) {
3715 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3721 oc->oformat = file_oformat;
3722 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3724 if (!strcmp(file_oformat->name, "ffm") &&
3725 av_strstart(filename, "http:", NULL)) {
3726 /* special case for files sent to ffserver: we get the stream
3727 parameters from ffserver */
3728 int err = read_ffserver_streams(oc, filename);
3730 print_error(filename, err);
3734 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3735 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3736 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3738 /* disable if no corresponding type found and at least one
3740 if (nb_input_files > 0) {
3741 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3742 &input_has_subtitle);
3743 if (!input_has_video)
3745 if (!input_has_audio)
3747 if (!input_has_subtitle)
3751 /* manual disable */
3752 if (audio_disable) use_audio = 0;
3753 if (video_disable) use_video = 0;
3754 if (subtitle_disable) use_subtitle = 0;
3756 if (use_video) new_video_stream(oc, nb_output_files);
3757 if (use_audio) new_audio_stream(oc, nb_output_files);
3758 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3760 oc->timestamp = recording_timestamp;
3762 av_metadata_copy(&oc->metadata, metadata, 0);
3763 av_metadata_free(&metadata);
3766 output_files[nb_output_files++] = oc;
3768 /* check filename in case of an image number is expected */
3769 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3770 if (!av_filename_number_test(oc->filename)) {
3771 print_error(oc->filename, AVERROR_NUMEXPECTED);
3776 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3777 /* test if it already exists to avoid loosing precious files */
3778 if (!file_overwrite &&
3779 (strchr(filename, ':') == NULL ||
3780 filename[1] == ':' ||
3781 av_strstart(filename, "file:", NULL))) {
3782 if (url_exist(filename)) {
3784 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3786 if (!read_yesno()) {
3787 fprintf(stderr, "Not overwriting - exiting\n");
3792 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3799 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3800 print_error(filename, err);
3805 memset(ap, 0, sizeof(*ap));
3806 if (av_set_parameters(oc, ap) < 0) {
3807 fprintf(stderr, "%s: Invalid encoding parameters\n",
3812 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3813 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3814 oc->loop_output = loop_output;
3815 oc->flags |= AVFMT_FLAG_NONBLOCK;
3817 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3819 nb_streamid_map = 0;
3820 av_freep(&forced_key_frames);
3823 /* same option as mencoder */
3824 static void opt_pass(const char *pass_str)
3827 pass = atoi(pass_str);
3828 if (pass != 1 && pass != 2) {
3829 fprintf(stderr, "pass number can be only 1 or 2\n");
3835 static int64_t getutime(void)
3838 struct rusage rusage;
3840 getrusage(RUSAGE_SELF, &rusage);
3841 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3842 #elif HAVE_GETPROCESSTIMES
3844 FILETIME c, e, k, u;
3845 proc = GetCurrentProcess();
3846 GetProcessTimes(proc, &c, &e, &k, &u);
3847 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3849 return av_gettime();
3853 static int64_t getmaxrss(void)
3855 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3856 struct rusage rusage;
3857 getrusage(RUSAGE_SELF, &rusage);
3858 return (int64_t)rusage.ru_maxrss * 1024;
3859 #elif HAVE_GETPROCESSMEMORYINFO
3861 PROCESS_MEMORY_COUNTERS memcounters;
3862 proc = GetCurrentProcess();
3863 memcounters.cb = sizeof(memcounters);
3864 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3865 return memcounters.PeakPagefileUsage;
3871 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3874 const char *p = str;
3881 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3888 static void opt_inter_matrix(const char *arg)
3890 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3891 parse_matrix_coeffs(inter_matrix, arg);
3894 static void opt_intra_matrix(const char *arg)
3896 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3897 parse_matrix_coeffs(intra_matrix, arg);
3900 static void show_usage(void)
3902 printf("Hyper fast Audio and Video encoder\n");
3903 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3907 static void show_help(void)
3910 AVOutputFormat *oformat = NULL;
3912 av_log_set_callback(log_callback_help);
3914 show_help_options(options, "Main options:\n",
3915 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3916 show_help_options(options, "\nAdvanced options:\n",
3917 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3919 show_help_options(options, "\nVideo options:\n",
3920 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3922 show_help_options(options, "\nAdvanced Video options:\n",
3923 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3924 OPT_VIDEO | OPT_EXPERT);
3925 show_help_options(options, "\nAudio options:\n",
3926 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3928 show_help_options(options, "\nAdvanced Audio options:\n",
3929 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3930 OPT_AUDIO | OPT_EXPERT);
3931 show_help_options(options, "\nSubtitle options:\n",
3932 OPT_SUBTITLE | OPT_GRAB,
3934 show_help_options(options, "\nAudio/Video grab options:\n",
3938 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3941 /* individual codec options */
3943 while ((c = av_codec_next(c))) {
3944 if (c->priv_class) {
3945 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3950 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3953 /* individual muxer options */
3954 while ((oformat = av_oformat_next(oformat))) {
3955 if (oformat->priv_class) {
3956 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3961 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3964 static void opt_target(const char *arg)
3966 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3967 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3969 if(!strncmp(arg, "pal-", 4)) {
3972 } else if(!strncmp(arg, "ntsc-", 5)) {
3975 } else if(!strncmp(arg, "film-", 5)) {
3980 /* Calculate FR via float to avoid int overflow */
3981 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3984 } else if((fr == 29970) || (fr == 23976)) {
3987 /* Try to determine PAL/NTSC by peeking in the input files */
3988 if(nb_input_files) {
3990 for(j = 0; j < nb_input_files; j++) {
3991 for(i = 0; i < input_files[j]->nb_streams; i++) {
3992 AVCodecContext *c = input_files[j]->streams[i]->codec;
3993 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3995 fr = c->time_base.den * 1000 / c->time_base.num;
3999 } else if((fr == 29970) || (fr == 23976)) {
4009 if(verbose && norm != UNKNOWN)
4010 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4013 if(norm == UNKNOWN) {
4014 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4015 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4016 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4020 if(!strcmp(arg, "vcd")) {
4022 opt_video_codec("mpeg1video");
4023 opt_audio_codec("mp2");
4026 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4027 opt_frame_rate(NULL, frame_rates[norm]);
4028 opt_default("g", norm == PAL ? "15" : "18");
4030 opt_default("b", "1150000");
4031 opt_default("maxrate", "1150000");
4032 opt_default("minrate", "1150000");
4033 opt_default("bufsize", "327680"); // 40*1024*8;
4035 opt_default("ab", "224000");
4036 audio_sample_rate = 44100;
4039 opt_default("packetsize", "2324");
4040 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4042 /* We have to offset the PTS, so that it is consistent with the SCR.
4043 SCR starts at 36000, but the first two packs contain only padding
4044 and the first pack from the other stream, respectively, may also have
4045 been written before.
4046 So the real data starts at SCR 36000+3*1200. */
4047 mux_preload= (36000+3*1200) / 90000.0; //0.44
4048 } else if(!strcmp(arg, "svcd")) {
4050 opt_video_codec("mpeg2video");
4051 opt_audio_codec("mp2");
4054 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4055 opt_frame_rate(NULL, frame_rates[norm]);
4056 opt_default("g", norm == PAL ? "15" : "18");
4058 opt_default("b", "2040000");
4059 opt_default("maxrate", "2516000");
4060 opt_default("minrate", "0"); //1145000;
4061 opt_default("bufsize", "1835008"); //224*1024*8;
4062 opt_default("flags", "+scan_offset");
4065 opt_default("ab", "224000");
4066 audio_sample_rate = 44100;
4068 opt_default("packetsize", "2324");
4070 } else if(!strcmp(arg, "dvd")) {
4072 opt_video_codec("mpeg2video");
4073 opt_audio_codec("ac3");
4076 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4077 opt_frame_rate(NULL, frame_rates[norm]);
4078 opt_default("g", norm == PAL ? "15" : "18");
4080 opt_default("b", "6000000");
4081 opt_default("maxrate", "9000000");
4082 opt_default("minrate", "0"); //1500000;
4083 opt_default("bufsize", "1835008"); //224*1024*8;
4085 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4086 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4088 opt_default("ab", "448000");
4089 audio_sample_rate = 48000;
4091 } else if(!strncmp(arg, "dv", 2)) {
4095 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4096 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4097 (norm == PAL ? "yuv420p" : "yuv411p"));
4098 opt_frame_rate(NULL, frame_rates[norm]);
4100 audio_sample_rate = 48000;
4104 fprintf(stderr, "Unknown target: %s\n", arg);
4109 static void opt_vstats_file (const char *arg)
4111 av_free (vstats_filename);
4112 vstats_filename=av_strdup (arg);
4115 static void opt_vstats (void)
4118 time_t today2 = time(NULL);
4119 struct tm *today = localtime(&today2);
4121 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4123 opt_vstats_file(filename);
4126 static int opt_bsf(const char *opt, const char *arg)
4128 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4129 AVBitStreamFilterContext **bsfp;
4132 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4136 bsfp= *opt == 'v' ? &video_bitstream_filters :
4137 *opt == 'a' ? &audio_bitstream_filters :
4138 &subtitle_bitstream_filters;
4140 bsfp= &(*bsfp)->next;
4147 static int opt_preset(const char *opt, const char *arg)
4150 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4151 char *codec_name = *opt == 'v' ? video_codec_name :
4152 *opt == 'a' ? audio_codec_name :
4153 subtitle_codec_name;
4155 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4156 fprintf(stderr, "File for preset '%s' not found\n", arg);
4161 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4162 if(line[0] == '#' && !e)
4164 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4166 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4169 if(!strcmp(tmp, "acodec")){
4170 opt_audio_codec(tmp2);
4171 }else if(!strcmp(tmp, "vcodec")){
4172 opt_video_codec(tmp2);
4173 }else if(!strcmp(tmp, "scodec")){
4174 opt_subtitle_codec(tmp2);
4175 }else if(opt_default(tmp, tmp2) < 0){
4176 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4186 static const OptionDef options[] = {
4188 #include "cmdutils_common_opts.h"
4189 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4190 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4191 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4192 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4193 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4194 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4195 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4196 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4197 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4198 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4199 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4200 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4201 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4202 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4203 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4204 "add timings for benchmarking" },
4205 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4206 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4207 "dump each input packet" },
4208 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4209 "when dumping packets, also dump the payload" },
4210 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4211 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4212 { "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)", "" },
4213 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4214 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4215 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4216 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4217 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4218 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4219 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4220 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4221 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4222 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4223 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4224 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4225 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4226 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4229 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4230 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4231 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4232 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4233 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4234 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4235 { "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" },
4236 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4237 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4238 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4239 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4240 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4241 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4242 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4243 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4244 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4245 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4246 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4247 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4248 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4249 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4250 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4251 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4252 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4253 "use same video quality as source (implies VBR)" },
4254 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4255 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4256 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4257 "deinterlace pictures" },
4258 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4259 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4260 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4262 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4264 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4265 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4266 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4267 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4268 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4269 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4270 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4271 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4272 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4273 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4274 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4277 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4278 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4279 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4280 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4281 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4282 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4283 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4284 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4285 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4286 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4287 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4288 { "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" },
4290 /* subtitle options */
4291 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4292 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4293 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4294 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4295 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4298 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4299 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4300 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4303 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4304 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4306 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4307 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4308 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4310 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4311 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4312 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4313 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4315 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4319 int main(int argc, char **argv)
4323 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4325 avcodec_register_all();
4327 avdevice_register_all();
4330 avfilter_register_all();
4335 if(isatty(STDIN_FILENO))
4336 url_set_interrupt_cb(decode_interrupt_cb);
4344 parse_options(argc, argv, options, opt_output_file);
4346 if(nb_output_files <= 0 && nb_input_files == 0) {
4348 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4352 /* file converter / grab */
4353 if (nb_output_files <= 0) {
4354 fprintf(stderr, "At least one output file must be specified\n");
4358 if (nb_input_files == 0) {
4359 fprintf(stderr, "At least one input file must be specified\n");
4364 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4365 stream_maps, nb_stream_maps) < 0)
4367 ti = getutime() - ti;
4369 int maxrss = getmaxrss() / 1024;
4370 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4373 return ffmpeg_exit(0);