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 audio_sync_method is >1 the resampler is needed for audio drift compensation */
829 if (audio_sync_method <= 1 &&
830 ost->resample_sample_fmt == enc->sample_fmt &&
831 ost->resample_channels == enc->channels &&
832 ost->resample_sample_rate == enc->sample_rate) {
833 ost->resample = NULL;
834 ost->audio_resample = 0;
836 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
837 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
838 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
839 enc->sample_rate, dec->sample_rate,
840 enc->sample_fmt, dec->sample_fmt,
842 if (!ost->resample) {
843 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
844 dec->channels, dec->sample_rate,
845 enc->channels, enc->sample_rate);
851 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
852 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
853 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
854 if (ost->reformat_ctx)
855 av_audio_convert_free(ost->reformat_ctx);
856 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
857 dec->sample_fmt, 1, NULL, 0);
858 if (!ost->reformat_ctx) {
859 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
860 av_get_sample_fmt_name(dec->sample_fmt),
861 av_get_sample_fmt_name(enc->sample_fmt));
864 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
867 if(audio_sync_method){
868 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
869 - av_fifo_size(ost->fifo)/(enc->channels * 2);
870 double idelta= delta*dec->sample_rate / enc->sample_rate;
871 int byte_delta= ((int)idelta)*2*dec->channels;
873 //FIXME resample delay
874 if(fabs(delta) > 50){
875 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
877 byte_delta= FFMAX(byte_delta, -size);
881 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
886 static uint8_t *input_tmp= NULL;
887 input_tmp= av_realloc(input_tmp, byte_delta + size);
889 if(byte_delta > allocated_for_size - size){
890 allocated_for_size= byte_delta + (int64_t)size;
895 memset(input_tmp, 0, byte_delta);
896 memcpy(input_tmp + byte_delta, buf, size);
900 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
902 }else if(audio_sync_method>1){
903 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
904 av_assert0(ost->audio_resample);
906 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
907 // 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));
908 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
912 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
913 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
915 if (ost->audio_resample) {
917 size_out = audio_resample(ost->resample,
918 (short *)buftmp, (short *)buf,
919 size / (dec->channels * isize));
920 size_out = size_out * enc->channels * osize;
926 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
927 const void *ibuf[6]= {buftmp};
928 void *obuf[6]= {audio_buf};
929 int istride[6]= {isize};
930 int ostride[6]= {osize};
931 int len= size_out/istride[0];
932 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
933 printf("av_audio_convert() failed\n");
939 size_out = len*osize;
942 /* now encode as many frames as possible */
943 if (enc->frame_size > 1) {
944 /* output resampled raw samples */
945 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
946 fprintf(stderr, "av_fifo_realloc2() failed\n");
949 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
951 frame_bytes = enc->frame_size * osize * enc->channels;
953 while (av_fifo_size(ost->fifo) >= frame_bytes) {
955 av_init_packet(&pkt);
957 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
959 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
961 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
964 fprintf(stderr, "Audio encoding failed\n");
968 pkt.stream_index= ost->index;
971 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
972 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
973 pkt.flags |= AV_PKT_FLAG_KEY;
974 write_frame(s, &pkt, enc, ost->bitstream_filters);
976 ost->sync_opts += enc->frame_size;
980 av_init_packet(&pkt);
982 ost->sync_opts += size_out / (osize * enc->channels);
984 /* output a pcm frame */
985 /* determine the size of the coded buffer */
988 size_out = size_out*coded_bps/8;
990 if(size_out > audio_out_size){
991 fprintf(stderr, "Internal error, buffer size too small\n");
995 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
996 ret = avcodec_encode_audio(enc, audio_out, size_out,
999 fprintf(stderr, "Audio encoding failed\n");
1003 pkt.stream_index= ost->index;
1004 pkt.data= audio_out;
1006 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1007 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1008 pkt.flags |= AV_PKT_FLAG_KEY;
1009 write_frame(s, &pkt, enc, ost->bitstream_filters);
1013 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1015 AVCodecContext *dec;
1016 AVPicture *picture2;
1017 AVPicture picture_tmp;
1020 dec = ist->st->codec;
1022 /* deinterlace : must be done before any resize */
1023 if (do_deinterlace) {
1026 /* create temporary picture */
1027 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1028 buf = av_malloc(size);
1032 picture2 = &picture_tmp;
1033 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1035 if(avpicture_deinterlace(picture2, picture,
1036 dec->pix_fmt, dec->width, dec->height) < 0) {
1037 /* if error, do not deinterlace */
1038 fprintf(stderr, "Deinterlacing failed\n");
1047 if (picture != picture2)
1048 *picture = *picture2;
1052 /* we begin to correct av delay at this threshold */
1053 #define AV_DELAY_MAX 0.100
1055 static void do_subtitle_out(AVFormatContext *s,
1056 AVOutputStream *ost,
1061 static uint8_t *subtitle_out = NULL;
1062 int subtitle_out_max_size = 1024 * 1024;
1063 int subtitle_out_size, nb, i;
1064 AVCodecContext *enc;
1067 if (pts == AV_NOPTS_VALUE) {
1068 fprintf(stderr, "Subtitle packets must have a pts\n");
1074 enc = ost->st->codec;
1076 if (!subtitle_out) {
1077 subtitle_out = av_malloc(subtitle_out_max_size);
1080 /* Note: DVB subtitle need one packet to draw them and one other
1081 packet to clear them */
1082 /* XXX: signal it in the codec context ? */
1083 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1088 for(i = 0; i < nb; i++) {
1089 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1090 // start_display_time is required to be 0
1091 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1092 sub->end_display_time -= sub->start_display_time;
1093 sub->start_display_time = 0;
1094 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1095 subtitle_out_max_size, sub);
1096 if (subtitle_out_size < 0) {
1097 fprintf(stderr, "Subtitle encoding failed\n");
1101 av_init_packet(&pkt);
1102 pkt.stream_index = ost->index;
1103 pkt.data = subtitle_out;
1104 pkt.size = subtitle_out_size;
1105 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1106 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1107 /* XXX: the pts correction is handled here. Maybe handling
1108 it in the codec would be better */
1110 pkt.pts += 90 * sub->start_display_time;
1112 pkt.pts += 90 * sub->end_display_time;
1114 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1118 static int bit_buffer_size= 1024*256;
1119 static uint8_t *bit_buffer= NULL;
1121 static void do_video_out(AVFormatContext *s,
1122 AVOutputStream *ost,
1124 AVFrame *in_picture,
1127 int nb_frames, i, ret;
1128 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1129 AVCodecContext *enc, *dec;
1132 enc = ost->st->codec;
1133 dec = ist->st->codec;
1135 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1137 /* by default, we output a single frame */
1142 if(video_sync_method){
1143 double vdelta = sync_ipts - ost->sync_opts;
1144 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1147 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1150 }else if(vdelta>0.6)
1151 ost->sync_opts= lrintf(sync_ipts);
1152 }else if (vdelta > 1.1)
1153 nb_frames = lrintf(vdelta);
1154 //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);
1155 if (nb_frames == 0){
1158 fprintf(stderr, "*** drop!\n");
1159 }else if (nb_frames > 1) {
1160 nb_frames_dup += nb_frames - 1;
1162 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1165 ost->sync_opts= lrintf(sync_ipts);
1167 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1171 formatted_picture = in_picture;
1172 final_picture = formatted_picture;
1173 padding_src = formatted_picture;
1174 resampling_dst = &ost->pict_tmp;
1176 if ( ost->resample_height != ist->st->codec->height
1177 || ost->resample_width != ist->st->codec->width
1178 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1180 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));
1181 if(!ost->video_resample)
1185 #if !CONFIG_AVFILTER
1186 if (ost->video_resample) {
1188 final_picture = &ost->pict_tmp;
1189 if( ost->resample_height != ist->st->codec->height
1190 || ost->resample_width != ist->st->codec->width
1191 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1193 /* initialize a new scaler context */
1194 sws_freeContext(ost->img_resample_ctx);
1195 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1196 ost->img_resample_ctx = sws_getContext(
1197 ist->st->codec->width,
1198 ist->st->codec->height,
1199 ist->st->codec->pix_fmt,
1200 ost->st->codec->width,
1201 ost->st->codec->height,
1202 ost->st->codec->pix_fmt,
1203 sws_flags, NULL, NULL, NULL);
1204 if (ost->img_resample_ctx == NULL) {
1205 fprintf(stderr, "Cannot get resampling context\n");
1209 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1210 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1214 /* duplicates frame if needed */
1215 for(i=0;i<nb_frames;i++) {
1217 av_init_packet(&pkt);
1218 pkt.stream_index= ost->index;
1220 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1221 /* raw pictures are written as AVPicture structure to
1222 avoid any copies. We support temorarily the older
1224 AVFrame* old_frame = enc->coded_frame;
1225 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1226 pkt.data= (uint8_t *)final_picture;
1227 pkt.size= sizeof(AVPicture);
1228 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1229 pkt.flags |= AV_PKT_FLAG_KEY;
1231 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1232 enc->coded_frame = old_frame;
1234 AVFrame big_picture;
1236 big_picture= *final_picture;
1237 /* better than nothing: use input picture interlaced
1239 big_picture.interlaced_frame = in_picture->interlaced_frame;
1240 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1241 if(top_field_first == -1)
1242 big_picture.top_field_first = in_picture->top_field_first;
1244 big_picture.top_field_first = top_field_first;
1247 /* handles sameq here. This is not correct because it may
1248 not be a global option */
1249 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1251 big_picture.pict_type = 0;
1252 // big_picture.pts = AV_NOPTS_VALUE;
1253 big_picture.pts= ost->sync_opts;
1254 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1255 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1256 if (ost->forced_kf_index < ost->forced_kf_count &&
1257 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1258 big_picture.pict_type = FF_I_TYPE;
1259 ost->forced_kf_index++;
1261 ret = avcodec_encode_video(enc,
1262 bit_buffer, bit_buffer_size,
1265 fprintf(stderr, "Video encoding failed\n");
1270 pkt.data= bit_buffer;
1272 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1273 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1274 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1275 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1276 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1278 if(enc->coded_frame->key_frame)
1279 pkt.flags |= AV_PKT_FLAG_KEY;
1280 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1283 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1284 // enc->frame_number-1, ret, enc->pict_type);
1285 /* if two pass, output log */
1286 if (ost->logfile && enc->stats_out) {
1287 fprintf(ost->logfile, "%s", enc->stats_out);
1292 ost->frame_number++;
1296 static double psnr(double d){
1297 return -10.0*log(d)/log(10.0);
1300 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1303 AVCodecContext *enc;
1305 double ti1, bitrate, avg_bitrate;
1307 /* this is executed just the first time do_video_stats is called */
1309 vstats_file = fopen(vstats_filename, "w");
1316 enc = ost->st->codec;
1317 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1318 frame_number = ost->frame_number;
1319 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1320 if (enc->flags&CODEC_FLAG_PSNR)
1321 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1323 fprintf(vstats_file,"f_size= %6d ", frame_size);
1324 /* compute pts value */
1325 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1329 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1330 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1331 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1332 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1333 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1337 static void print_report(AVFormatContext **output_files,
1338 AVOutputStream **ost_table, int nb_ostreams,
1342 AVOutputStream *ost;
1343 AVFormatContext *oc;
1345 AVCodecContext *enc;
1346 int frame_number, vid, i;
1347 double bitrate, ti1, pts;
1348 static int64_t last_time = -1;
1349 static int qp_histogram[52];
1351 if (!is_last_report) {
1353 /* display the report every 0.5 seconds */
1354 cur_time = av_gettime();
1355 if (last_time == -1) {
1356 last_time = cur_time;
1359 if ((cur_time - last_time) < 500000)
1361 last_time = cur_time;
1365 oc = output_files[0];
1367 total_size = url_fsize(oc->pb);
1368 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1369 total_size= url_ftell(oc->pb);
1374 for(i=0;i<nb_ostreams;i++) {
1376 enc = ost->st->codec;
1377 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1378 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1379 !ost->st->stream_copy ?
1380 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1382 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1383 float t = (av_gettime()-timer_start) / 1000000.0;
1385 frame_number = ost->frame_number;
1386 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1387 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1388 !ost->st->stream_copy ?
1389 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1391 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1394 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1395 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1398 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1400 if (enc->flags&CODEC_FLAG_PSNR){
1402 double error, error_sum=0;
1403 double scale, scale_sum=0;
1404 char type[3]= {'Y','U','V'};
1405 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1408 error= enc->error[j];
1409 scale= enc->width*enc->height*255.0*255.0*frame_number;
1411 error= enc->coded_frame->error[j];
1412 scale= enc->width*enc->height*255.0*255.0;
1417 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1423 /* compute min output value */
1424 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1425 if ((pts < ti1) && (pts > 0))
1431 if (verbose || is_last_report) {
1432 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1434 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1435 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1436 (double)total_size / 1024, ti1, bitrate);
1438 if (nb_frames_dup || nb_frames_drop)
1439 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1440 nb_frames_dup, nb_frames_drop);
1443 fprintf(stderr, "%s \r", buf);
1448 if (is_last_report && verbose >= 0){
1449 int64_t raw= audio_size + video_size + extra_size;
1450 fprintf(stderr, "\n");
1451 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1455 100.0*(total_size - raw)/raw
1460 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1461 static int output_packet(AVInputStream *ist, int ist_index,
1462 AVOutputStream **ost_table, int nb_ostreams,
1463 const AVPacket *pkt)
1465 AVFormatContext *os;
1466 AVOutputStream *ost;
1470 void *buffer_to_free;
1471 static unsigned int samples_size= 0;
1472 AVSubtitle subtitle, *subtitle_to_free;
1473 int64_t pkt_pts = AV_NOPTS_VALUE;
1475 int frame_available;
1479 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1481 if(ist->next_pts == AV_NOPTS_VALUE)
1482 ist->next_pts= ist->pts;
1486 av_init_packet(&avpkt);
1494 if(pkt->dts != AV_NOPTS_VALUE)
1495 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1496 if(pkt->pts != AV_NOPTS_VALUE)
1497 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1499 //while we have more to decode or while the decoder did output something on EOF
1500 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1501 uint8_t *data_buf, *decoded_data_buf;
1502 int data_size, decoded_data_size;
1504 ist->pts= ist->next_pts;
1506 if(avpkt.size && avpkt.size != pkt->size &&
1507 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1508 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1509 ist->showed_multi_packet_warning=1;
1512 /* decode the packet if needed */
1513 decoded_data_buf = NULL; /* fail safe */
1514 decoded_data_size= 0;
1515 data_buf = avpkt.data;
1516 data_size = avpkt.size;
1517 subtitle_to_free = NULL;
1518 if (ist->decoding_needed) {
1519 switch(ist->st->codec->codec_type) {
1520 case AVMEDIA_TYPE_AUDIO:{
1521 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1522 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1524 samples= av_malloc(samples_size);
1526 decoded_data_size= samples_size;
1527 /* XXX: could avoid copy if PCM 16 bits with same
1528 endianness as CPU */
1529 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1536 /* Some bug in mpeg audio decoder gives */
1537 /* decoded_data_size < 0, it seems they are overflows */
1538 if (decoded_data_size <= 0) {
1539 /* no audio frame */
1542 decoded_data_buf = (uint8_t *)samples;
1543 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1544 (ist->st->codec->sample_rate * ist->st->codec->channels);
1546 case AVMEDIA_TYPE_VIDEO:
1547 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1548 /* XXX: allocate picture correctly */
1549 avcodec_get_frame_defaults(&picture);
1550 ist->st->codec->reordered_opaque = pkt_pts;
1551 pkt_pts = AV_NOPTS_VALUE;
1553 ret = avcodec_decode_video2(ist->st->codec,
1554 &picture, &got_picture, &avpkt);
1555 ist->st->quality= picture.quality;
1559 /* no picture yet */
1560 goto discard_packet;
1562 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1563 if (ist->st->codec->time_base.num != 0) {
1564 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1565 ist->next_pts += ((int64_t)AV_TIME_BASE *
1566 ist->st->codec->time_base.num * ticks) /
1567 ist->st->codec->time_base.den;
1571 case AVMEDIA_TYPE_SUBTITLE:
1572 ret = avcodec_decode_subtitle2(ist->st->codec,
1573 &subtitle, &got_picture, &avpkt);
1577 goto discard_packet;
1579 subtitle_to_free = &subtitle;
1586 switch(ist->st->codec->codec_type) {
1587 case AVMEDIA_TYPE_AUDIO:
1588 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1589 ist->st->codec->sample_rate;
1591 case AVMEDIA_TYPE_VIDEO:
1592 if (ist->st->codec->time_base.num != 0) {
1593 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1594 ist->next_pts += ((int64_t)AV_TIME_BASE *
1595 ist->st->codec->time_base.num * ticks) /
1596 ist->st->codec->time_base.den;
1604 buffer_to_free = NULL;
1605 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1606 pre_process_video_frame(ist, (AVPicture *)&picture,
1611 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1613 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1614 else sar = ist->st->codec->sample_aspect_ratio;
1615 // add it to be filtered
1616 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1622 // preprocess audio (volume)
1623 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1624 if (audio_volume != 256) {
1627 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1628 int v = ((*volp) * audio_volume + 128) >> 8;
1629 if (v < -32768) v = -32768;
1630 if (v > 32767) v = 32767;
1636 /* frame rate emulation */
1638 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1639 int64_t now = av_gettime() - ist->start;
1644 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1645 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1647 /* if output time reached then transcode raw format,
1648 encode packets and output them */
1649 if (start_time == 0 || ist->pts >= start_time)
1651 while (frame_available) {
1652 AVRational ist_pts_tb;
1653 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1654 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1656 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1658 for(i=0;i<nb_ostreams;i++) {
1662 if (ost->source_index == ist_index) {
1663 os = output_files[ost->file_index];
1665 /* set the input output pts pairs */
1666 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1668 if (ost->encoding_needed) {
1669 av_assert0(ist->decoding_needed);
1670 switch(ost->st->codec->codec_type) {
1671 case AVMEDIA_TYPE_AUDIO:
1672 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1674 case AVMEDIA_TYPE_VIDEO:
1676 if (ist->picref->video)
1677 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1679 do_video_out(os, ost, ist, &picture, &frame_size);
1680 if (vstats_filename && frame_size)
1681 do_video_stats(os, ost, frame_size);
1683 case AVMEDIA_TYPE_SUBTITLE:
1684 do_subtitle_out(os, ost, ist, &subtitle,
1691 AVFrame avframe; //FIXME/XXX remove this
1693 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1695 av_init_packet(&opkt);
1697 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1700 /* no reencoding needed : output the packet directly */
1701 /* force the input stream PTS */
1703 avcodec_get_frame_defaults(&avframe);
1704 ost->st->codec->coded_frame= &avframe;
1705 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1707 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1708 audio_size += data_size;
1709 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1710 video_size += data_size;
1714 opkt.stream_index= ost->index;
1715 if(pkt->pts != AV_NOPTS_VALUE)
1716 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1718 opkt.pts= AV_NOPTS_VALUE;
1720 if (pkt->dts == AV_NOPTS_VALUE)
1721 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1723 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1724 opkt.dts -= ost_tb_start_time;
1726 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1727 opkt.flags= pkt->flags;
1729 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1730 if( ost->st->codec->codec_id != CODEC_ID_H264
1731 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1732 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1734 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1735 opkt.destruct= av_destruct_packet;
1737 opkt.data = data_buf;
1738 opkt.size = data_size;
1741 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1742 ost->st->codec->frame_number++;
1743 ost->frame_number++;
1744 av_free_packet(&opkt);
1750 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1751 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1753 avfilter_unref_buffer(ist->picref);
1756 av_free(buffer_to_free);
1757 /* XXX: allocate the subtitles in the codec ? */
1758 if (subtitle_to_free) {
1759 avsubtitle_free(subtitle_to_free);
1760 subtitle_to_free = NULL;
1767 for(i=0;i<nb_ostreams;i++) {
1769 if (ost->source_index == ist_index) {
1770 AVCodecContext *enc= ost->st->codec;
1771 os = output_files[ost->file_index];
1773 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1775 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1778 if (ost->encoding_needed) {
1782 av_init_packet(&pkt);
1783 pkt.stream_index= ost->index;
1785 switch(ost->st->codec->codec_type) {
1786 case AVMEDIA_TYPE_AUDIO:
1787 fifo_bytes = av_fifo_size(ost->fifo);
1789 /* encode any samples remaining in fifo */
1790 if (fifo_bytes > 0) {
1791 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1792 int fs_tmp = enc->frame_size;
1794 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1795 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1796 enc->frame_size = fifo_bytes / (osize * enc->channels);
1798 int frame_bytes = enc->frame_size*osize*enc->channels;
1799 if (allocated_audio_buf_size < frame_bytes)
1801 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1804 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1805 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1806 ost->st->time_base.num, enc->sample_rate);
1807 enc->frame_size = fs_tmp;
1810 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1813 fprintf(stderr, "Audio encoding failed\n");
1817 pkt.flags |= AV_PKT_FLAG_KEY;
1819 case AVMEDIA_TYPE_VIDEO:
1820 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1822 fprintf(stderr, "Video encoding failed\n");
1826 if(enc->coded_frame && enc->coded_frame->key_frame)
1827 pkt.flags |= AV_PKT_FLAG_KEY;
1828 if (ost->logfile && enc->stats_out) {
1829 fprintf(ost->logfile, "%s", enc->stats_out);
1838 pkt.data= bit_buffer;
1840 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1841 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1842 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1854 static void print_sdp(AVFormatContext **avc, int n)
1858 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1859 printf("SDP:\n%s\n", sdp);
1863 static int copy_chapters(int infile, int outfile)
1865 AVFormatContext *is = input_files[infile];
1866 AVFormatContext *os = output_files[outfile];
1869 for (i = 0; i < is->nb_chapters; i++) {
1870 AVChapter *in_ch = is->chapters[i], *out_ch;
1871 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1872 AV_TIME_BASE_Q, in_ch->time_base);
1873 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1874 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1877 if (in_ch->end < ts_off)
1879 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1882 out_ch = av_mallocz(sizeof(AVChapter));
1884 return AVERROR(ENOMEM);
1886 out_ch->id = in_ch->id;
1887 out_ch->time_base = in_ch->time_base;
1888 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1889 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1891 if (metadata_chapters_autocopy)
1892 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1895 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1897 return AVERROR(ENOMEM);
1898 os->chapters[os->nb_chapters - 1] = out_ch;
1903 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1904 AVCodecContext *avctx)
1910 for (p = kf; *p; p++)
1913 ost->forced_kf_count = n;
1914 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1915 if (!ost->forced_kf_pts) {
1916 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1919 for (i = 0; i < n; i++) {
1920 p = i ? strchr(p, ',') + 1 : kf;
1921 t = parse_time_or_die("force_key_frames", p, 1);
1922 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1927 * The following code is the main loop of the file converter
1929 static int transcode(AVFormatContext **output_files,
1930 int nb_output_files,
1931 AVFormatContext **input_files,
1933 AVStreamMap *stream_maps, int nb_stream_maps)
1935 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1936 AVFormatContext *is, *os;
1937 AVCodecContext *codec, *icodec;
1938 AVOutputStream *ost, **ost_table = NULL;
1939 AVInputStream *ist, **ist_table = NULL;
1940 AVInputFile *file_table;
1944 uint8_t no_packet[MAX_FILES]={0};
1945 int no_packet_count=0;
1947 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1951 /* input stream init */
1953 for(i=0;i<nb_input_files;i++) {
1954 is = input_files[i];
1955 file_table[i].ist_index = j;
1956 file_table[i].nb_streams = is->nb_streams;
1957 j += is->nb_streams;
1961 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1965 for(i=0;i<nb_istreams;i++) {
1966 ist = av_mallocz(sizeof(AVInputStream));
1972 for(i=0;i<nb_input_files;i++) {
1973 is = input_files[i];
1974 for(k=0;k<is->nb_streams;k++) {
1975 ist = ist_table[j++];
1976 ist->st = is->streams[k];
1977 ist->file_index = i;
1979 ist->discard = 1; /* the stream is discarded by default
1983 ist->start = av_gettime();
1988 /* output stream init */
1990 for(i=0;i<nb_output_files;i++) {
1991 os = output_files[i];
1992 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1993 dump_format(output_files[i], i, output_files[i]->filename, 1);
1994 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1995 ret = AVERROR(EINVAL);
1998 nb_ostreams += os->nb_streams;
2000 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2001 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2002 ret = AVERROR(EINVAL);
2006 /* Sanity check the mapping args -- do the input files & streams exist? */
2007 for(i=0;i<nb_stream_maps;i++) {
2008 int fi = stream_maps[i].file_index;
2009 int si = stream_maps[i].stream_index;
2011 if (fi < 0 || fi > nb_input_files - 1 ||
2012 si < 0 || si > file_table[fi].nb_streams - 1) {
2013 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2014 ret = AVERROR(EINVAL);
2017 fi = stream_maps[i].sync_file_index;
2018 si = stream_maps[i].sync_stream_index;
2019 if (fi < 0 || fi > nb_input_files - 1 ||
2020 si < 0 || si > file_table[fi].nb_streams - 1) {
2021 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2022 ret = AVERROR(EINVAL);
2027 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2031 for(k=0;k<nb_output_files;k++) {
2032 os = output_files[k];
2033 for(i=0;i<os->nb_streams;i++,n++) {
2035 ost = ost_table[n] = output_streams_for_file[k][i];
2036 ost->st = os->streams[i];
2037 if (nb_stream_maps > 0) {
2038 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2039 stream_maps[n].stream_index;
2041 /* Sanity check that the stream types match */
2042 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2043 int i= ost->file_index;
2044 dump_format(output_files[i], i, output_files[i]->filename, 1);
2045 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2046 stream_maps[n].file_index, stream_maps[n].stream_index,
2047 ost->file_index, ost->index);
2052 int best_nb_frames=-1;
2053 /* get corresponding input stream index : we select the first one with the right type */
2055 for(j=0;j<nb_istreams;j++) {
2060 AVFormatContext *f= input_files[ ist->file_index ];
2062 for(pi=0; pi<f->nb_programs; pi++){
2063 AVProgram *p= f->programs[pi];
2064 if(p->id == opt_programid)
2065 for(si=0; si<p->nb_stream_indexes; si++){
2066 if(f->streams[ p->stream_index[si] ] == ist->st)
2071 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2072 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2073 if(best_nb_frames < ist->st->codec_info_nb_frames){
2074 best_nb_frames= ist->st->codec_info_nb_frames;
2075 ost->source_index = j;
2082 if(! opt_programid) {
2083 /* try again and reuse existing stream */
2084 for(j=0;j<nb_istreams;j++) {
2086 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2087 && ist->st->discard != AVDISCARD_ALL) {
2088 ost->source_index = j;
2094 int i= ost->file_index;
2095 dump_format(output_files[i], i, output_files[i]->filename, 1);
2096 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2097 ost->file_index, ost->index);
2102 ist = ist_table[ost->source_index];
2104 ost->sync_ist = (nb_stream_maps > 0) ?
2105 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2106 stream_maps[n].sync_stream_index] : ist;
2110 /* for each output stream, we compute the right encoding parameters */
2111 for(i=0;i<nb_ostreams;i++) {
2113 os = output_files[ost->file_index];
2114 ist = ist_table[ost->source_index];
2116 codec = ost->st->codec;
2117 icodec = ist->st->codec;
2119 if (metadata_streams_autocopy)
2120 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2121 AV_METADATA_DONT_OVERWRITE);
2123 ost->st->disposition = ist->st->disposition;
2124 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2125 codec->chroma_sample_location = icodec->chroma_sample_location;
2127 if (ost->st->stream_copy) {
2128 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2130 if (extra_size > INT_MAX)
2133 /* if stream_copy is selected, no need to decode or encode */
2134 codec->codec_id = icodec->codec_id;
2135 codec->codec_type = icodec->codec_type;
2137 if(!codec->codec_tag){
2138 if( !os->oformat->codec_tag
2139 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2140 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2141 codec->codec_tag = icodec->codec_tag;
2144 codec->bit_rate = icodec->bit_rate;
2145 codec->rc_max_rate = icodec->rc_max_rate;
2146 codec->rc_buffer_size = icodec->rc_buffer_size;
2147 codec->extradata= av_mallocz(extra_size);
2148 if (!codec->extradata)
2150 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2151 codec->extradata_size= icodec->extradata_size;
2152 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){
2153 codec->time_base = icodec->time_base;
2154 codec->time_base.num *= icodec->ticks_per_frame;
2155 av_reduce(&codec->time_base.num, &codec->time_base.den,
2156 codec->time_base.num, codec->time_base.den, INT_MAX);
2158 codec->time_base = ist->st->time_base;
2159 switch(codec->codec_type) {
2160 case AVMEDIA_TYPE_AUDIO:
2161 if(audio_volume != 256) {
2162 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2165 codec->channel_layout = icodec->channel_layout;
2166 codec->sample_rate = icodec->sample_rate;
2167 codec->channels = icodec->channels;
2168 codec->frame_size = icodec->frame_size;
2169 codec->block_align= icodec->block_align;
2170 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2171 codec->block_align= 0;
2172 if(codec->codec_id == CODEC_ID_AC3)
2173 codec->block_align= 0;
2175 case AVMEDIA_TYPE_VIDEO:
2176 codec->pix_fmt = icodec->pix_fmt;
2177 codec->width = icodec->width;
2178 codec->height = icodec->height;
2179 codec->has_b_frames = icodec->has_b_frames;
2181 case AVMEDIA_TYPE_SUBTITLE:
2182 codec->width = icodec->width;
2183 codec->height = icodec->height;
2189 switch(codec->codec_type) {
2190 case AVMEDIA_TYPE_AUDIO:
2191 ost->fifo= av_fifo_alloc(1024);
2194 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2195 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2196 icodec->request_channels = codec->channels;
2197 ist->decoding_needed = 1;
2198 ost->encoding_needed = 1;
2199 ost->resample_sample_fmt = icodec->sample_fmt;
2200 ost->resample_sample_rate = icodec->sample_rate;
2201 ost->resample_channels = icodec->channels;
2203 case AVMEDIA_TYPE_VIDEO:
2204 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2205 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2208 ost->video_resample = (codec->width != icodec->width ||
2209 codec->height != icodec->height ||
2210 (codec->pix_fmt != icodec->pix_fmt));
2211 if (ost->video_resample) {
2212 #if !CONFIG_AVFILTER
2213 avcodec_get_frame_defaults(&ost->pict_tmp);
2214 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2215 codec->width, codec->height)) {
2216 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2219 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2220 ost->img_resample_ctx = sws_getContext(
2227 sws_flags, NULL, NULL, NULL);
2228 if (ost->img_resample_ctx == NULL) {
2229 fprintf(stderr, "Cannot get resampling context\n");
2233 ost->original_height = icodec->height;
2234 ost->original_width = icodec->width;
2236 codec->bits_per_raw_sample= 0;
2238 ost->resample_height = icodec->height;
2239 ost->resample_width = icodec->width;
2240 ost->resample_pix_fmt= icodec->pix_fmt;
2241 ost->encoding_needed = 1;
2242 ist->decoding_needed = 1;
2245 if (configure_filters(ist, ost)) {
2246 fprintf(stderr, "Error opening filters!\n");
2251 case AVMEDIA_TYPE_SUBTITLE:
2252 ost->encoding_needed = 1;
2253 ist->decoding_needed = 1;
2260 if (ost->encoding_needed &&
2261 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2262 char logfilename[1024];
2265 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2266 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2268 if (codec->flags & CODEC_FLAG_PASS1) {
2269 f = fopen(logfilename, "wb");
2271 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2277 size_t logbuffer_size;
2278 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2279 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2282 codec->stats_in = logbuffer;
2286 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2287 int size= codec->width * codec->height;
2288 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2293 bit_buffer = av_malloc(bit_buffer_size);
2295 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2297 ret = AVERROR(ENOMEM);
2301 /* open each encoder */
2302 for(i=0;i<nb_ostreams;i++) {
2304 if (ost->encoding_needed) {
2305 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2306 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2308 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2310 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2311 ost->st->codec->codec_id, ost->file_index, ost->index);
2312 ret = AVERROR(EINVAL);
2315 if (dec->subtitle_header) {
2316 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2317 if (!ost->st->codec->subtitle_header) {
2318 ret = AVERROR(ENOMEM);
2321 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2322 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2324 if (avcodec_open(ost->st->codec, codec) < 0) {
2325 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2326 ost->file_index, ost->index);
2327 ret = AVERROR(EINVAL);
2330 extra_size += ost->st->codec->extradata_size;
2334 /* open each decoder */
2335 for(i=0;i<nb_istreams;i++) {
2337 if (ist->decoding_needed) {
2338 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2340 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2342 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2343 ist->st->codec->codec_id, ist->file_index, ist->index);
2344 ret = AVERROR(EINVAL);
2347 if (avcodec_open(ist->st->codec, codec) < 0) {
2348 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2349 ist->file_index, ist->index);
2350 ret = AVERROR(EINVAL);
2353 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2354 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2359 for(i=0;i<nb_istreams;i++) {
2363 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2364 ist->next_pts = AV_NOPTS_VALUE;
2365 init_pts_correction(&ist->pts_ctx);
2369 /* set meta data information from input file if required */
2370 for (i=0;i<nb_meta_data_maps;i++) {
2371 AVFormatContext *files[2];
2372 AVMetadata **meta[2];
2375 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2376 if ((index) < 0 || (index) >= (nb_elems)) {\
2377 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2379 ret = AVERROR(EINVAL);\
2383 int out_file_index = meta_data_maps[i][0].file;
2384 int in_file_index = meta_data_maps[i][1].file;
2385 if (in_file_index < 0 || out_file_index < 0)
2387 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2388 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2390 files[0] = output_files[out_file_index];
2391 files[1] = input_files[in_file_index];
2393 for (j = 0; j < 2; j++) {
2394 AVMetaDataMap *map = &meta_data_maps[i][j];
2396 switch (map->type) {
2398 meta[j] = &files[j]->metadata;
2401 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2402 meta[j] = &files[j]->streams[map->index]->metadata;
2405 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2406 meta[j] = &files[j]->chapters[map->index]->metadata;
2409 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2410 meta[j] = &files[j]->programs[map->index]->metadata;
2415 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2418 /* copy global metadata by default */
2419 if (metadata_global_autocopy) {
2421 for (i = 0; i < nb_output_files; i++)
2422 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2423 AV_METADATA_DONT_OVERWRITE);
2426 /* copy chapters according to chapter maps */
2427 for (i = 0; i < nb_chapter_maps; i++) {
2428 int infile = chapter_maps[i].in_file;
2429 int outfile = chapter_maps[i].out_file;
2431 if (infile < 0 || outfile < 0)
2433 if (infile >= nb_input_files) {
2434 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2435 ret = AVERROR(EINVAL);
2438 if (outfile >= nb_output_files) {
2439 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2440 ret = AVERROR(EINVAL);
2443 copy_chapters(infile, outfile);
2446 /* copy chapters from the first input file that has them*/
2447 if (!nb_chapter_maps)
2448 for (i = 0; i < nb_input_files; i++) {
2449 if (!input_files[i]->nb_chapters)
2452 for (j = 0; j < nb_output_files; j++)
2453 if ((ret = copy_chapters(i, j)) < 0)
2458 /* open files and write file headers */
2459 for(i=0;i<nb_output_files;i++) {
2460 os = output_files[i];
2461 if (av_write_header(os) < 0) {
2462 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2463 ret = AVERROR(EINVAL);
2466 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2472 /* dump the file output parameters - cannot be done before in case
2474 for(i=0;i<nb_output_files;i++) {
2475 dump_format(output_files[i], i, output_files[i]->filename, 1);
2478 /* dump the stream mapping */
2480 fprintf(stderr, "Stream mapping:\n");
2481 for(i=0;i<nb_ostreams;i++) {
2483 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2484 ist_table[ost->source_index]->file_index,
2485 ist_table[ost->source_index]->index,
2488 if (ost->sync_ist != ist_table[ost->source_index])
2489 fprintf(stderr, " [sync #%d.%d]",
2490 ost->sync_ist->file_index,
2491 ost->sync_ist->index);
2492 fprintf(stderr, "\n");
2497 fprintf(stderr, "%s\n", error);
2502 print_sdp(output_files, nb_output_files);
2505 if (!using_stdin && verbose >= 0) {
2506 fprintf(stderr, "Press [q] to stop encoding\n");
2507 url_set_interrupt_cb(decode_interrupt_cb);
2511 timer_start = av_gettime();
2513 for(; received_sigterm == 0;) {
2514 int file_index, ist_index;
2522 /* if 'q' pressed, exits */
2526 /* read_key() returns 0 on EOF */
2532 /* select the stream that we must read now by looking at the
2533 smallest output pts */
2535 for(i=0;i<nb_ostreams;i++) {
2538 os = output_files[ost->file_index];
2539 ist = ist_table[ost->source_index];
2540 if(ist->is_past_recording_time || no_packet[ist->file_index])
2542 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2543 ipts = (double)ist->pts;
2544 if (!file_table[ist->file_index].eof_reached){
2545 if(ipts < ipts_min) {
2547 if(input_sync ) file_index = ist->file_index;
2549 if(opts < opts_min) {
2551 if(!input_sync) file_index = ist->file_index;
2554 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2559 /* if none, if is finished */
2560 if (file_index < 0) {
2561 if(no_packet_count){
2563 memset(no_packet, 0, sizeof(no_packet));
2570 /* finish if limit size exhausted */
2571 if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2574 /* read a frame from it and output it in the fifo */
2575 is = input_files[file_index];
2576 ret= av_read_frame(is, &pkt);
2577 if(ret == AVERROR(EAGAIN)){
2578 no_packet[file_index]=1;
2583 file_table[file_index].eof_reached = 1;
2591 memset(no_packet, 0, sizeof(no_packet));
2594 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2596 /* the following test is needed in case new streams appear
2597 dynamically in stream : we ignore them */
2598 if (pkt.stream_index >= file_table[file_index].nb_streams)
2599 goto discard_packet;
2600 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2601 ist = ist_table[ist_index];
2603 goto discard_packet;
2605 if (pkt.dts != AV_NOPTS_VALUE)
2606 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2607 if (pkt.pts != AV_NOPTS_VALUE)
2608 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2610 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2611 && input_files_ts_scale[file_index][pkt.stream_index]){
2612 if(pkt.pts != AV_NOPTS_VALUE)
2613 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2614 if(pkt.dts != AV_NOPTS_VALUE)
2615 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2618 // 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);
2619 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2620 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2621 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2622 int64_t delta= pkt_dts - ist->next_pts;
2623 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2624 input_files_ts_offset[ist->file_index]-= delta;
2626 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2627 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2628 if(pkt.pts != AV_NOPTS_VALUE)
2629 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2633 /* finish if recording time exhausted */
2634 if (recording_time != INT64_MAX &&
2635 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2636 ist->is_past_recording_time = 1;
2637 goto discard_packet;
2640 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2641 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2644 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2645 ist->file_index, ist->index);
2648 av_free_packet(&pkt);
2653 av_free_packet(&pkt);
2655 /* dump report by using the output first video and audio streams */
2656 print_report(output_files, ost_table, nb_ostreams, 0);
2659 /* at the end of stream, we must flush the decoder buffers */
2660 for(i=0;i<nb_istreams;i++) {
2662 if (ist->decoding_needed) {
2663 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2669 /* write the trailer if needed and close file */
2670 for(i=0;i<nb_output_files;i++) {
2671 os = output_files[i];
2672 av_write_trailer(os);
2675 /* dump report by using the first video and audio streams */
2676 print_report(output_files, ost_table, nb_ostreams, 1);
2678 /* close each encoder */
2679 for(i=0;i<nb_ostreams;i++) {
2681 if (ost->encoding_needed) {
2682 av_freep(&ost->st->codec->stats_in);
2683 avcodec_close(ost->st->codec);
2687 /* close each decoder */
2688 for(i=0;i<nb_istreams;i++) {
2690 if (ist->decoding_needed) {
2691 avcodec_close(ist->st->codec);
2696 avfilter_graph_free(graph);
2705 av_freep(&bit_buffer);
2706 av_free(file_table);
2709 for(i=0;i<nb_istreams;i++) {
2716 for(i=0;i<nb_ostreams;i++) {
2719 if (ost->st->stream_copy)
2720 av_freep(&ost->st->codec->extradata);
2722 fclose(ost->logfile);
2723 ost->logfile = NULL;
2725 av_fifo_free(ost->fifo); /* works even if fifo is not
2726 initialized but set to zero */
2727 av_freep(&ost->st->codec->subtitle_header);
2728 av_free(ost->pict_tmp.data[0]);
2729 av_free(ost->forced_kf_pts);
2730 if (ost->video_resample)
2731 sws_freeContext(ost->img_resample_ctx);
2733 audio_resample_close(ost->resample);
2734 if (ost->reformat_ctx)
2735 av_audio_convert_free(ost->reformat_ctx);
2744 static void opt_format(const char *arg)
2746 last_asked_format = arg;
2749 static void opt_video_rc_override_string(const char *arg)
2751 video_rc_override_string = arg;
2754 static int opt_me_threshold(const char *opt, const char *arg)
2756 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2760 static int opt_verbose(const char *opt, const char *arg)
2762 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2766 static int opt_frame_rate(const char *opt, const char *arg)
2768 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2769 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2775 static int opt_bitrate(const char *opt, const char *arg)
2777 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2779 opt_default(opt, arg);
2781 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2782 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2787 static int opt_frame_crop(const char *opt, const char *arg)
2789 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2790 return AVERROR(EINVAL);
2793 static void opt_frame_size(const char *arg)
2795 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2796 fprintf(stderr, "Incorrect frame size\n");
2801 static int opt_pad(const char *opt, const char *arg) {
2802 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2806 static void opt_frame_pix_fmt(const char *arg)
2808 if (strcmp(arg, "list")) {
2809 frame_pix_fmt = av_get_pix_fmt(arg);
2810 if (frame_pix_fmt == PIX_FMT_NONE) {
2811 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2820 static void opt_frame_aspect_ratio(const char *arg)
2827 p = strchr(arg, ':');
2829 x = strtol(arg, &end, 10);
2831 y = strtol(end+1, &end, 10);
2833 ar = (double)x / (double)y;
2835 ar = strtod(arg, NULL);
2838 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2841 frame_aspect_ratio = ar;
2844 static int opt_metadata(const char *opt, const char *arg)
2846 char *mid= strchr(arg, '=');
2849 fprintf(stderr, "Missing =\n");
2854 av_metadata_set2(&metadata, arg, mid, 0);
2859 static void opt_qscale(const char *arg)
2861 video_qscale = atof(arg);
2862 if (video_qscale <= 0 ||
2863 video_qscale > 255) {
2864 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2869 static void opt_top_field_first(const char *arg)
2871 top_field_first= atoi(arg);
2874 static int opt_thread_count(const char *opt, const char *arg)
2876 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2879 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2884 static void opt_audio_sample_fmt(const char *arg)
2886 if (strcmp(arg, "list")) {
2887 audio_sample_fmt = av_get_sample_fmt(arg);
2888 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2889 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2893 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2898 static int opt_audio_rate(const char *opt, const char *arg)
2900 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2904 static int opt_audio_channels(const char *opt, const char *arg)
2906 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2910 static void opt_video_channel(const char *arg)
2912 video_channel = strtol(arg, NULL, 0);
2915 static void opt_video_standard(const char *arg)
2917 video_standard = av_strdup(arg);
2920 static void opt_codec(int *pstream_copy, char **pcodec_name,
2921 int codec_type, const char *arg)
2923 av_freep(pcodec_name);
2924 if (!strcmp(arg, "copy")) {
2927 *pcodec_name = av_strdup(arg);
2931 static void opt_audio_codec(const char *arg)
2933 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2936 static void opt_video_codec(const char *arg)
2938 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2941 static void opt_subtitle_codec(const char *arg)
2943 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2946 static int opt_codec_tag(const char *opt, const char *arg)
2949 uint32_t *codec_tag;
2951 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2952 !strcmp(opt, "vtag") ? &video_codec_tag :
2953 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2957 *codec_tag = strtol(arg, &tail, 0);
2959 *codec_tag = AV_RL32(arg);
2964 static void opt_map(const char *arg)
2969 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2970 m = &stream_maps[nb_stream_maps-1];
2972 m->file_index = strtol(arg, &p, 0);
2976 m->stream_index = strtol(p, &p, 0);
2979 m->sync_file_index = strtol(p, &p, 0);
2982 m->sync_stream_index = strtol(p, &p, 0);
2984 m->sync_file_index = m->file_index;
2985 m->sync_stream_index = m->stream_index;
2989 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3000 *index = strtol(++arg, endptr, 0);
3003 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3010 static void opt_map_meta_data(const char *arg)
3012 AVMetaDataMap *m, *m1;
3015 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3016 &nb_meta_data_maps, nb_meta_data_maps + 1);
3018 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3019 m->file = strtol(arg, &p, 0);
3020 parse_meta_type(p, &m->type, &m->index, &p);
3024 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3025 m1->file = strtol(p, &p, 0);
3026 parse_meta_type(p, &m1->type, &m1->index, &p);
3028 if (m->type == 'g' || m1->type == 'g')
3029 metadata_global_autocopy = 0;
3030 if (m->type == 's' || m1->type == 's')
3031 metadata_streams_autocopy = 0;
3032 if (m->type == 'c' || m1->type == 'c')
3033 metadata_chapters_autocopy = 0;
3036 static void opt_map_chapters(const char *arg)
3041 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3042 nb_chapter_maps + 1);
3043 c = &chapter_maps[nb_chapter_maps - 1];
3044 c->out_file = strtol(arg, &p, 0);
3048 c->in_file = strtol(p, &p, 0);
3051 static void opt_input_ts_scale(const char *arg)
3053 unsigned int stream;
3057 stream = strtol(arg, &p, 0);
3060 scale= strtod(p, &p);
3062 if(stream >= MAX_STREAMS)
3065 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);
3066 input_files_ts_scale[nb_input_files][stream]= scale;
3069 static int opt_recording_time(const char *opt, const char *arg)
3071 recording_time = parse_time_or_die(opt, arg, 1);
3075 static int opt_start_time(const char *opt, const char *arg)
3077 start_time = parse_time_or_die(opt, arg, 1);
3081 static int opt_recording_timestamp(const char *opt, const char *arg)
3083 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3087 static int opt_input_ts_offset(const char *opt, const char *arg)
3089 input_ts_offset = parse_time_or_die(opt, arg, 1);
3093 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3095 const char *codec_string = encoder ? "encoder" : "decoder";
3099 return CODEC_ID_NONE;
3101 avcodec_find_encoder_by_name(name) :
3102 avcodec_find_decoder_by_name(name);
3104 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3107 if(codec->type != type) {
3108 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3111 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3112 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3113 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3114 "results.\nAdd '-strict experimental' if you want to use it.\n",
3115 codec_string, codec->name);
3117 avcodec_find_encoder(codec->id) :
3118 avcodec_find_decoder(codec->id);
3119 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3120 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3121 codec_string, codec->name);
3127 static void opt_input_file(const char *filename)
3129 AVFormatContext *ic;
3130 AVFormatParameters params, *ap = ¶ms;
3131 AVInputFormat *file_iformat = NULL;
3132 int err, i, ret, rfps, rfps_base;
3135 if (last_asked_format) {
3136 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3137 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3140 last_asked_format = NULL;
3143 if (!strcmp(filename, "-"))
3146 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3147 !strcmp(filename, "/dev/stdin");
3149 /* get default parameters from command line */
3150 ic = avformat_alloc_context();
3152 print_error(filename, AVERROR(ENOMEM));
3156 memset(ap, 0, sizeof(*ap));
3157 ap->prealloced_context = 1;
3158 ap->sample_rate = audio_sample_rate;
3159 ap->channels = audio_channels;
3160 ap->time_base.den = frame_rate.num;
3161 ap->time_base.num = frame_rate.den;
3162 ap->width = frame_width;
3163 ap->height = frame_height;
3164 ap->pix_fmt = frame_pix_fmt;
3165 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3166 ap->channel = video_channel;
3167 ap->standard = video_standard;
3169 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3171 ic->video_codec_id =
3172 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3173 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3174 ic->audio_codec_id =
3175 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3176 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3177 ic->subtitle_codec_id=
3178 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3179 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3180 ic->flags |= AVFMT_FLAG_NONBLOCK;
3182 /* open the input file with generic libav function */
3183 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3185 print_error(filename, err);
3191 for(i=0; i<ic->nb_streams; i++){
3192 ic->streams[i]->discard= AVDISCARD_ALL;
3194 for(i=0; i<ic->nb_programs; i++){
3195 AVProgram *p= ic->programs[i];
3196 if(p->id != opt_programid){
3197 p->discard = AVDISCARD_ALL;
3200 for(j=0; j<p->nb_stream_indexes; j++){
3201 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3206 fprintf(stderr, "Specified program id not found\n");
3212 ic->loop_input = loop_input;
3214 /* If not enough info to get the stream parameters, we decode the
3215 first frames to get it. (used in mpeg case for example) */
3216 ret = av_find_stream_info(ic);
3217 if (ret < 0 && verbose >= 0) {
3218 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3219 av_close_input_file(ic);
3223 timestamp = start_time;
3224 /* add the stream start time */
3225 if (ic->start_time != AV_NOPTS_VALUE)
3226 timestamp += ic->start_time;
3228 /* if seeking requested, we execute it */
3229 if (start_time != 0) {
3230 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3232 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3233 filename, (double)timestamp / AV_TIME_BASE);
3235 /* reset seek info */
3239 /* update the current parameters so that they match the one of the input stream */
3240 for(i=0;i<ic->nb_streams;i++) {
3241 AVStream *st = ic->streams[i];
3242 AVCodecContext *dec = st->codec;
3243 avcodec_thread_init(dec, thread_count);
3244 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3245 switch (dec->codec_type) {
3246 case AVMEDIA_TYPE_AUDIO:
3247 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3248 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]);
3249 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3250 channel_layout = dec->channel_layout;
3251 audio_channels = dec->channels;
3252 audio_sample_rate = dec->sample_rate;
3253 audio_sample_fmt = dec->sample_fmt;
3255 st->discard= AVDISCARD_ALL;
3256 /* Note that av_find_stream_info can add more streams, and we
3257 * currently have no chance of setting up lowres decoding
3258 * early enough for them. */
3260 audio_sample_rate >>= dec->lowres;
3262 case AVMEDIA_TYPE_VIDEO:
3263 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3264 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]);
3265 frame_height = dec->height;
3266 frame_width = dec->width;
3267 if(ic->streams[i]->sample_aspect_ratio.num)
3268 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3270 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3271 frame_aspect_ratio *= (float) dec->width / dec->height;
3272 frame_pix_fmt = dec->pix_fmt;
3273 rfps = ic->streams[i]->r_frame_rate.num;
3274 rfps_base = ic->streams[i]->r_frame_rate.den;
3276 dec->flags |= CODEC_FLAG_EMU_EDGE;
3277 frame_height >>= dec->lowres;
3278 frame_width >>= dec->lowres;
3279 dec->height = frame_height;
3280 dec->width = frame_width;
3283 dec->debug |= FF_DEBUG_MV;
3285 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3288 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3289 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3291 (float)rfps / rfps_base, rfps, rfps_base);
3293 /* update the current frame rate to match the stream frame rate */
3294 frame_rate.num = rfps;
3295 frame_rate.den = rfps_base;
3298 st->discard= AVDISCARD_ALL;
3299 else if(video_discard)
3300 st->discard= video_discard;
3302 case AVMEDIA_TYPE_DATA:
3304 case AVMEDIA_TYPE_SUBTITLE:
3305 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3306 if(subtitle_disable)
3307 st->discard = AVDISCARD_ALL;
3309 case AVMEDIA_TYPE_ATTACHMENT:
3310 case AVMEDIA_TYPE_UNKNOWN:
3317 input_files[nb_input_files] = ic;
3318 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3319 /* dump the file content */
3321 dump_format(ic, nb_input_files, filename, 0);
3327 av_freep(&video_codec_name);
3328 av_freep(&audio_codec_name);
3329 av_freep(&subtitle_codec_name);
3332 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3333 int *has_subtitle_ptr)
3335 int has_video, has_audio, has_subtitle, i, j;
3336 AVFormatContext *ic;
3341 for(j=0;j<nb_input_files;j++) {
3342 ic = input_files[j];
3343 for(i=0;i<ic->nb_streams;i++) {
3344 AVCodecContext *enc = ic->streams[i]->codec;
3345 switch(enc->codec_type) {
3346 case AVMEDIA_TYPE_AUDIO:
3349 case AVMEDIA_TYPE_VIDEO:
3352 case AVMEDIA_TYPE_SUBTITLE:
3355 case AVMEDIA_TYPE_DATA:
3356 case AVMEDIA_TYPE_ATTACHMENT:
3357 case AVMEDIA_TYPE_UNKNOWN:
3364 *has_video_ptr = has_video;
3365 *has_audio_ptr = has_audio;
3366 *has_subtitle_ptr = has_subtitle;
3369 static void new_video_stream(AVFormatContext *oc, int file_idx)
3372 AVOutputStream *ost;
3373 AVCodecContext *video_enc;
3374 enum CodecID codec_id = CODEC_ID_NONE;
3375 AVCodec *codec= NULL;
3377 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3379 fprintf(stderr, "Could not alloc stream\n");
3382 ost = new_output_stream(oc, file_idx);
3384 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3385 if(!video_stream_copy){
3386 if (video_codec_name) {
3387 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3388 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3389 codec = avcodec_find_encoder_by_name(video_codec_name);
3390 output_codecs[nb_output_codecs-1] = codec;
3392 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3393 codec = avcodec_find_encoder(codec_id);
3397 avcodec_get_context_defaults3(st->codec, codec);
3398 ost->bitstream_filters = video_bitstream_filters;
3399 video_bitstream_filters= NULL;
3401 avcodec_thread_init(st->codec, thread_count);
3403 video_enc = st->codec;
3406 video_enc->codec_tag= video_codec_tag;
3408 if( (video_global_header&1)
3409 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3410 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3411 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3413 if(video_global_header&2){
3414 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3415 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3418 if (video_stream_copy) {
3419 st->stream_copy = 1;
3420 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3421 video_enc->sample_aspect_ratio =
3422 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3426 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3428 video_enc->codec_id = codec_id;
3429 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3431 if (codec && codec->supported_framerates && !force_fps)
3432 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3433 video_enc->time_base.den = fps.num;
3434 video_enc->time_base.num = fps.den;
3436 video_enc->width = frame_width;
3437 video_enc->height = frame_height;
3438 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3439 video_enc->pix_fmt = frame_pix_fmt;
3440 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3442 choose_pixel_fmt(st, codec);
3445 video_enc->gop_size = 0;
3446 if (video_qscale || same_quality) {
3447 video_enc->flags |= CODEC_FLAG_QSCALE;
3448 video_enc->global_quality=
3449 st->quality = FF_QP2LAMBDA * video_qscale;
3453 video_enc->intra_matrix = intra_matrix;
3455 video_enc->inter_matrix = inter_matrix;
3457 p= video_rc_override_string;
3460 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3462 fprintf(stderr, "error parsing rc_override\n");
3465 video_enc->rc_override=
3466 av_realloc(video_enc->rc_override,
3467 sizeof(RcOverride)*(i+1));
3468 video_enc->rc_override[i].start_frame= start;
3469 video_enc->rc_override[i].end_frame = end;
3471 video_enc->rc_override[i].qscale= q;
3472 video_enc->rc_override[i].quality_factor= 1.0;
3475 video_enc->rc_override[i].qscale= 0;
3476 video_enc->rc_override[i].quality_factor= -q/100.0;
3481 video_enc->rc_override_count=i;
3482 if (!video_enc->rc_initial_buffer_occupancy)
3483 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3484 video_enc->me_threshold= me_threshold;
3485 video_enc->intra_dc_precision= intra_dc_precision - 8;
3488 video_enc->flags|= CODEC_FLAG_PSNR;
3493 video_enc->flags |= CODEC_FLAG_PASS1;
3495 video_enc->flags |= CODEC_FLAG_PASS2;
3499 if (forced_key_frames)
3500 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3502 if (video_language) {
3503 av_metadata_set2(&st->metadata, "language", video_language, 0);
3504 av_freep(&video_language);
3507 /* reset some key parameters */
3509 av_freep(&video_codec_name);
3510 av_freep(&forced_key_frames);
3511 video_stream_copy = 0;
3512 frame_pix_fmt = PIX_FMT_NONE;
3515 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3518 AVOutputStream *ost;
3519 AVCodec *codec= NULL;
3520 AVCodecContext *audio_enc;
3521 enum CodecID codec_id = CODEC_ID_NONE;
3523 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3525 fprintf(stderr, "Could not alloc stream\n");
3528 ost = new_output_stream(oc, file_idx);
3530 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3531 if(!audio_stream_copy){
3532 if (audio_codec_name) {
3533 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3534 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3535 codec = avcodec_find_encoder_by_name(audio_codec_name);
3536 output_codecs[nb_output_codecs-1] = codec;
3538 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3539 codec = avcodec_find_encoder(codec_id);
3543 avcodec_get_context_defaults3(st->codec, codec);
3545 ost->bitstream_filters = audio_bitstream_filters;
3546 audio_bitstream_filters= NULL;
3548 avcodec_thread_init(st->codec, thread_count);
3550 audio_enc = st->codec;
3551 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3554 audio_enc->codec_tag= audio_codec_tag;
3556 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3557 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3558 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3560 if (audio_stream_copy) {
3561 st->stream_copy = 1;
3562 audio_enc->channels = audio_channels;
3563 audio_enc->sample_rate = audio_sample_rate;
3565 audio_enc->codec_id = codec_id;
3566 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3568 if (audio_qscale > QSCALE_NONE) {
3569 audio_enc->flags |= CODEC_FLAG_QSCALE;
3570 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3572 audio_enc->channels = audio_channels;
3573 audio_enc->sample_fmt = audio_sample_fmt;
3574 audio_enc->sample_rate = audio_sample_rate;
3575 audio_enc->channel_layout = channel_layout;
3576 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3577 audio_enc->channel_layout = 0;
3578 choose_sample_fmt(st, codec);
3579 choose_sample_rate(st, codec);
3581 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3582 if (audio_language) {
3583 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3584 av_freep(&audio_language);
3587 /* reset some key parameters */
3589 av_freep(&audio_codec_name);
3590 audio_stream_copy = 0;
3593 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3596 AVOutputStream *ost;
3597 AVCodec *codec=NULL;
3598 AVCodecContext *subtitle_enc;
3599 enum CodecID codec_id = CODEC_ID_NONE;
3601 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3603 fprintf(stderr, "Could not alloc stream\n");
3606 ost = new_output_stream(oc, file_idx);
3607 subtitle_enc = st->codec;
3608 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3609 if(!subtitle_stream_copy){
3610 if (subtitle_codec_name) {
3611 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3612 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3613 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3615 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3616 codec = avcodec_find_encoder(codec_id);
3619 avcodec_get_context_defaults3(st->codec, codec);
3621 ost->bitstream_filters = subtitle_bitstream_filters;
3622 subtitle_bitstream_filters= NULL;
3624 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3626 if(subtitle_codec_tag)
3627 subtitle_enc->codec_tag= subtitle_codec_tag;
3629 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3630 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3631 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3633 if (subtitle_stream_copy) {
3634 st->stream_copy = 1;
3636 subtitle_enc->codec_id = codec_id;
3637 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3640 if (subtitle_language) {
3641 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3642 av_freep(&subtitle_language);
3645 subtitle_disable = 0;
3646 av_freep(&subtitle_codec_name);
3647 subtitle_stream_copy = 0;
3650 static int opt_new_stream(const char *opt, const char *arg)
3652 AVFormatContext *oc;
3653 int file_idx = nb_output_files - 1;
3654 if (nb_output_files <= 0) {
3655 fprintf(stderr, "At least one output file must be specified\n");
3658 oc = output_files[file_idx];
3660 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3661 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3662 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3667 /* arg format is "output-stream-index:streamid-value". */
3668 static int opt_streamid(const char *opt, const char *arg)
3674 strncpy(idx_str, arg, sizeof(idx_str));
3675 idx_str[sizeof(idx_str)-1] = '\0';
3676 p = strchr(idx_str, ':');
3679 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3684 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3685 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3686 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3690 static void opt_output_file(const char *filename)
3692 AVFormatContext *oc;
3693 int err, use_video, use_audio, use_subtitle;
3694 int input_has_video, input_has_audio, input_has_subtitle;
3695 AVFormatParameters params, *ap = ¶ms;
3696 AVOutputFormat *file_oformat;
3698 if (!strcmp(filename, "-"))
3701 oc = avformat_alloc_context();
3703 print_error(filename, AVERROR(ENOMEM));
3707 if (last_asked_format) {
3708 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3709 if (!file_oformat) {
3710 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3713 last_asked_format = NULL;
3715 file_oformat = av_guess_format(NULL, filename, NULL);
3716 if (!file_oformat) {
3717 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3723 oc->oformat = file_oformat;
3724 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3726 if (!strcmp(file_oformat->name, "ffm") &&
3727 av_strstart(filename, "http:", NULL)) {
3728 /* special case for files sent to ffserver: we get the stream
3729 parameters from ffserver */
3730 int err = read_ffserver_streams(oc, filename);
3732 print_error(filename, err);
3736 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3737 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3738 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3740 /* disable if no corresponding type found and at least one
3742 if (nb_input_files > 0) {
3743 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3744 &input_has_subtitle);
3745 if (!input_has_video)
3747 if (!input_has_audio)
3749 if (!input_has_subtitle)
3753 /* manual disable */
3754 if (audio_disable) use_audio = 0;
3755 if (video_disable) use_video = 0;
3756 if (subtitle_disable) use_subtitle = 0;
3758 if (use_video) new_video_stream(oc, nb_output_files);
3759 if (use_audio) new_audio_stream(oc, nb_output_files);
3760 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3762 oc->timestamp = recording_timestamp;
3764 av_metadata_copy(&oc->metadata, metadata, 0);
3765 av_metadata_free(&metadata);
3768 output_files[nb_output_files++] = oc;
3770 /* check filename in case of an image number is expected */
3771 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3772 if (!av_filename_number_test(oc->filename)) {
3773 print_error(oc->filename, AVERROR_NUMEXPECTED);
3778 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3779 /* test if it already exists to avoid loosing precious files */
3780 if (!file_overwrite &&
3781 (strchr(filename, ':') == NULL ||
3782 filename[1] == ':' ||
3783 av_strstart(filename, "file:", NULL))) {
3784 if (url_exist(filename)) {
3786 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3788 if (!read_yesno()) {
3789 fprintf(stderr, "Not overwriting - exiting\n");
3794 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3801 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3802 print_error(filename, err);
3807 memset(ap, 0, sizeof(*ap));
3808 if (av_set_parameters(oc, ap) < 0) {
3809 fprintf(stderr, "%s: Invalid encoding parameters\n",
3814 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3815 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3816 oc->loop_output = loop_output;
3817 oc->flags |= AVFMT_FLAG_NONBLOCK;
3819 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3821 av_freep(&forced_key_frames);
3824 /* same option as mencoder */
3825 static void opt_pass(const char *pass_str)
3828 pass = atoi(pass_str);
3829 if (pass != 1 && pass != 2) {
3830 fprintf(stderr, "pass number can be only 1 or 2\n");
3836 static int64_t getutime(void)
3839 struct rusage rusage;
3841 getrusage(RUSAGE_SELF, &rusage);
3842 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3843 #elif HAVE_GETPROCESSTIMES
3845 FILETIME c, e, k, u;
3846 proc = GetCurrentProcess();
3847 GetProcessTimes(proc, &c, &e, &k, &u);
3848 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3850 return av_gettime();
3854 static int64_t getmaxrss(void)
3856 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3857 struct rusage rusage;
3858 getrusage(RUSAGE_SELF, &rusage);
3859 return (int64_t)rusage.ru_maxrss * 1024;
3860 #elif HAVE_GETPROCESSMEMORYINFO
3862 PROCESS_MEMORY_COUNTERS memcounters;
3863 proc = GetCurrentProcess();
3864 memcounters.cb = sizeof(memcounters);
3865 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3866 return memcounters.PeakPagefileUsage;
3872 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3875 const char *p = str;
3882 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3889 static void opt_inter_matrix(const char *arg)
3891 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3892 parse_matrix_coeffs(inter_matrix, arg);
3895 static void opt_intra_matrix(const char *arg)
3897 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3898 parse_matrix_coeffs(intra_matrix, arg);
3901 static void show_usage(void)
3903 printf("Hyper fast Audio and Video encoder\n");
3904 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3908 static void show_help(void)
3911 AVOutputFormat *oformat = NULL;
3913 av_log_set_callback(log_callback_help);
3915 show_help_options(options, "Main options:\n",
3916 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3917 show_help_options(options, "\nAdvanced options:\n",
3918 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3920 show_help_options(options, "\nVideo options:\n",
3921 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3923 show_help_options(options, "\nAdvanced Video options:\n",
3924 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3925 OPT_VIDEO | OPT_EXPERT);
3926 show_help_options(options, "\nAudio options:\n",
3927 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3929 show_help_options(options, "\nAdvanced Audio options:\n",
3930 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3931 OPT_AUDIO | OPT_EXPERT);
3932 show_help_options(options, "\nSubtitle options:\n",
3933 OPT_SUBTITLE | OPT_GRAB,
3935 show_help_options(options, "\nAudio/Video grab options:\n",
3939 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3942 /* individual codec options */
3944 while ((c = av_codec_next(c))) {
3945 if (c->priv_class) {
3946 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3951 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3954 /* individual muxer options */
3955 while ((oformat = av_oformat_next(oformat))) {
3956 if (oformat->priv_class) {
3957 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3962 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3965 static void opt_target(const char *arg)
3967 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3968 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3970 if(!strncmp(arg, "pal-", 4)) {
3973 } else if(!strncmp(arg, "ntsc-", 5)) {
3976 } else if(!strncmp(arg, "film-", 5)) {
3981 /* Calculate FR via float to avoid int overflow */
3982 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3985 } else if((fr == 29970) || (fr == 23976)) {
3988 /* Try to determine PAL/NTSC by peeking in the input files */
3989 if(nb_input_files) {
3991 for(j = 0; j < nb_input_files; j++) {
3992 for(i = 0; i < input_files[j]->nb_streams; i++) {
3993 AVCodecContext *c = input_files[j]->streams[i]->codec;
3994 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3996 fr = c->time_base.den * 1000 / c->time_base.num;
4000 } else if((fr == 29970) || (fr == 23976)) {
4010 if(verbose && norm != UNKNOWN)
4011 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4014 if(norm == UNKNOWN) {
4015 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4016 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4017 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4021 if(!strcmp(arg, "vcd")) {
4023 opt_video_codec("mpeg1video");
4024 opt_audio_codec("mp2");
4027 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4028 opt_frame_rate(NULL, frame_rates[norm]);
4029 opt_default("g", norm == PAL ? "15" : "18");
4031 opt_default("b", "1150000");
4032 opt_default("maxrate", "1150000");
4033 opt_default("minrate", "1150000");
4034 opt_default("bufsize", "327680"); // 40*1024*8;
4036 opt_default("ab", "224000");
4037 audio_sample_rate = 44100;
4040 opt_default("packetsize", "2324");
4041 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4043 /* We have to offset the PTS, so that it is consistent with the SCR.
4044 SCR starts at 36000, but the first two packs contain only padding
4045 and the first pack from the other stream, respectively, may also have
4046 been written before.
4047 So the real data starts at SCR 36000+3*1200. */
4048 mux_preload= (36000+3*1200) / 90000.0; //0.44
4049 } else if(!strcmp(arg, "svcd")) {
4051 opt_video_codec("mpeg2video");
4052 opt_audio_codec("mp2");
4055 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4056 opt_frame_rate(NULL, frame_rates[norm]);
4057 opt_default("g", norm == PAL ? "15" : "18");
4059 opt_default("b", "2040000");
4060 opt_default("maxrate", "2516000");
4061 opt_default("minrate", "0"); //1145000;
4062 opt_default("bufsize", "1835008"); //224*1024*8;
4063 opt_default("flags", "+scan_offset");
4066 opt_default("ab", "224000");
4067 audio_sample_rate = 44100;
4069 opt_default("packetsize", "2324");
4071 } else if(!strcmp(arg, "dvd")) {
4073 opt_video_codec("mpeg2video");
4074 opt_audio_codec("ac3");
4077 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4078 opt_frame_rate(NULL, frame_rates[norm]);
4079 opt_default("g", norm == PAL ? "15" : "18");
4081 opt_default("b", "6000000");
4082 opt_default("maxrate", "9000000");
4083 opt_default("minrate", "0"); //1500000;
4084 opt_default("bufsize", "1835008"); //224*1024*8;
4086 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4087 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4089 opt_default("ab", "448000");
4090 audio_sample_rate = 48000;
4092 } else if(!strncmp(arg, "dv", 2)) {
4096 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4097 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4098 (norm == PAL ? "yuv420p" : "yuv411p"));
4099 opt_frame_rate(NULL, frame_rates[norm]);
4101 audio_sample_rate = 48000;
4105 fprintf(stderr, "Unknown target: %s\n", arg);
4110 static void opt_vstats_file (const char *arg)
4112 av_free (vstats_filename);
4113 vstats_filename=av_strdup (arg);
4116 static void opt_vstats (void)
4119 time_t today2 = time(NULL);
4120 struct tm *today = localtime(&today2);
4122 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4124 opt_vstats_file(filename);
4127 static int opt_bsf(const char *opt, const char *arg)
4129 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4130 AVBitStreamFilterContext **bsfp;
4133 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4137 bsfp= *opt == 'v' ? &video_bitstream_filters :
4138 *opt == 'a' ? &audio_bitstream_filters :
4139 &subtitle_bitstream_filters;
4141 bsfp= &(*bsfp)->next;
4148 static int opt_preset(const char *opt, const char *arg)
4151 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4152 char *codec_name = *opt == 'v' ? video_codec_name :
4153 *opt == 'a' ? audio_codec_name :
4154 subtitle_codec_name;
4156 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4157 fprintf(stderr, "File for preset '%s' not found\n", arg);
4162 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4163 if(line[0] == '#' && !e)
4165 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4167 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4170 if(!strcmp(tmp, "acodec")){
4171 opt_audio_codec(tmp2);
4172 }else if(!strcmp(tmp, "vcodec")){
4173 opt_video_codec(tmp2);
4174 }else if(!strcmp(tmp, "scodec")){
4175 opt_subtitle_codec(tmp2);
4176 }else if(opt_default(tmp, tmp2) < 0){
4177 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4187 static const OptionDef options[] = {
4189 #include "cmdutils_common_opts.h"
4190 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4191 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4192 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4193 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4194 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4195 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4196 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4197 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4198 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4199 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4200 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4201 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4202 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4203 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4204 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4205 "add timings for benchmarking" },
4206 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4207 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4208 "dump each input packet" },
4209 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4210 "when dumping packets, also dump the payload" },
4211 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4212 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4213 { "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)", "" },
4214 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4215 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4216 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4217 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4218 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4219 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4220 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4221 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4222 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4223 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4224 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4225 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4226 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4227 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4230 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4231 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4232 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4233 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4234 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4235 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4236 { "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" },
4237 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4238 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4239 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4240 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4241 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4242 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4243 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4244 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4245 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4246 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4247 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4248 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4249 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4250 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4251 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4252 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4253 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4254 "use same video quality as source (implies VBR)" },
4255 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4256 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4257 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4258 "deinterlace pictures" },
4259 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4260 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4261 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4263 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4265 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4266 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4267 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4268 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4269 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4270 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4271 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4272 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4273 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4274 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4275 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4278 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4279 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4280 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4281 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4282 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4283 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4284 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4285 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4286 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4287 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4288 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4289 { "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" },
4291 /* subtitle options */
4292 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4293 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4294 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4295 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4296 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4299 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4300 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4301 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4304 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4305 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4307 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4308 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4309 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4311 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4312 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4313 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4314 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4316 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4320 int main(int argc, char **argv)
4324 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4326 avcodec_register_all();
4328 avdevice_register_all();
4331 avfilter_register_all();
4336 if(isatty(STDIN_FILENO))
4337 url_set_interrupt_cb(decode_interrupt_cb);
4345 parse_options(argc, argv, options, opt_output_file);
4347 if(nb_output_files <= 0 && nb_input_files == 0) {
4349 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4353 /* file converter / grab */
4354 if (nb_output_files <= 0) {
4355 fprintf(stderr, "At least one output file must be specified\n");
4359 if (nb_input_files == 0) {
4360 fprintf(stderr, "At least one input file must be specified\n");
4365 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4366 stream_maps, nb_stream_maps) < 0)
4368 ti = getutime() - ti;
4370 int maxrss = getmaxrss() / 1024;
4371 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4374 return ffmpeg_exit(0);