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 "libavutil/audioconvert.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/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 static 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 static 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 AVFormatContext *s = output_files[i];
510 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
512 avformat_free_context(s);
513 av_free(output_streams_for_file[i]);
515 for(i=0;i<nb_input_files;i++) {
516 av_close_input_file(input_files[i]);
517 av_free(input_files_ts_scale[i]);
520 av_free(intra_matrix);
521 av_free(inter_matrix);
525 av_free(vstats_filename);
527 av_free(streamid_map);
528 av_free(input_codecs);
529 av_free(output_codecs);
530 av_free(stream_maps);
531 av_free(meta_data_maps);
533 av_free(video_codec_name);
534 av_free(audio_codec_name);
535 av_free(subtitle_codec_name);
537 av_free(video_standard);
542 allocated_audio_buf_size= allocated_audio_out_size= 0;
549 if (received_sigterm) {
551 "Received signal %d: terminating.\n",
552 (int) received_sigterm);
556 exit(ret); /* not all OS-es handle main() return value */
560 /* similar to ff_dynarray_add() and av_fast_realloc() */
561 static void *grow_array(void *array, int elem_size, int *size, int new_size)
563 if (new_size >= INT_MAX / elem_size) {
564 fprintf(stderr, "Array too big.\n");
567 if (*size < new_size) {
568 uint8_t *tmp = av_realloc(array, new_size*elem_size);
570 fprintf(stderr, "Could not alloc buffer.\n");
573 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
580 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
582 if(codec && codec->sample_fmts){
583 const enum AVSampleFormat *p= codec->sample_fmts;
585 if(*p == st->codec->sample_fmt)
589 av_log(NULL, AV_LOG_WARNING,
590 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
591 av_get_sample_fmt_name(st->codec->sample_fmt),
593 av_get_sample_fmt_name(codec->sample_fmts[0]));
594 st->codec->sample_fmt = codec->sample_fmts[0];
599 static void choose_sample_rate(AVStream *st, AVCodec *codec)
601 if(codec && codec->supported_samplerates){
602 const int *p= codec->supported_samplerates;
604 int best_dist=INT_MAX;
606 int dist= abs(st->codec->sample_rate - *p);
607 if(dist < best_dist){
613 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
615 st->codec->sample_rate= best;
619 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
621 if(codec && codec->pix_fmts){
622 const enum PixelFormat *p= codec->pix_fmts;
623 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
624 if(st->codec->codec_id==CODEC_ID_MJPEG){
625 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
626 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
627 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};
631 if(*p == st->codec->pix_fmt)
635 st->codec->pix_fmt = codec->pix_fmts[0];
639 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
641 int idx = oc->nb_streams - 1;
644 output_streams_for_file[file_idx] =
645 grow_array(output_streams_for_file[file_idx],
646 sizeof(*output_streams_for_file[file_idx]),
647 &nb_output_streams_for_file[file_idx],
649 ost = output_streams_for_file[file_idx][idx] =
650 av_mallocz(sizeof(AVOutputStream));
652 fprintf(stderr, "Could not alloc output stream\n");
655 ost->file_index = file_idx;
660 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
666 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
669 /* copy stream format */
671 for(i=0;i<ic->nb_streams;i++) {
677 // FIXME: a more elegant solution is needed
678 st = av_mallocz(sizeof(AVStream));
679 memcpy(st, ic->streams[i], sizeof(AVStream));
680 st->codec = avcodec_alloc_context();
682 print_error(filename, AVERROR(ENOMEM));
685 avcodec_copy_context(st->codec, ic->streams[i]->codec);
688 codec = avcodec_find_encoder(st->codec->codec_id);
689 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
690 if (audio_stream_copy) {
693 choose_sample_fmt(st, codec);
694 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
695 if (video_stream_copy) {
698 choose_pixel_fmt(st, codec);
701 if(st->codec->flags & CODEC_FLAG_BITEXACT)
704 new_output_stream(s, nb_output_files);
708 s->timestamp = av_gettime();
710 av_close_input_file(ic);
715 get_sync_ipts(const AVOutputStream *ost)
717 const AVInputStream *ist = ost->sync_ist;
718 return (double)(ist->pts - start_time)/AV_TIME_BASE;
721 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
725 AVPacket new_pkt= *pkt;
726 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
727 &new_pkt.data, &new_pkt.size,
728 pkt->data, pkt->size,
729 pkt->flags & AV_PKT_FLAG_KEY);
732 new_pkt.destruct= av_destruct_packet;
734 fprintf(stderr, "%s failed for stream %d, codec %s",
735 bsfc->filter->name, pkt->stream_index,
736 avctx->codec ? avctx->codec->name : "copy");
746 ret= av_interleaved_write_frame(s, pkt);
748 print_error("av_interleaved_write_frame()", ret);
753 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
755 static void do_audio_out(AVFormatContext *s,
758 unsigned char *buf, int size)
761 int64_t audio_out_size, audio_buf_size;
762 int64_t allocated_for_size= size;
764 int size_out, frame_bytes, ret, resample_changed;
765 AVCodecContext *enc= ost->st->codec;
766 AVCodecContext *dec= ist->st->codec;
767 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
768 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
769 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
772 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
773 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
774 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
775 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
776 audio_buf_size*= osize*enc->channels;
778 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
779 if(coded_bps > 8*osize)
780 audio_out_size= audio_out_size * coded_bps / (8*osize);
781 audio_out_size += FF_MIN_BUFFER_SIZE;
783 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
784 fprintf(stderr, "Buffer sizes too large\n");
788 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
789 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
790 if (!audio_buf || !audio_out){
791 fprintf(stderr, "Out of memory in do_audio_out\n");
795 if (enc->channels != dec->channels)
796 ost->audio_resample = 1;
798 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
799 ost->resample_channels != dec->channels ||
800 ost->resample_sample_rate != dec->sample_rate;
802 if ((ost->audio_resample && !ost->resample) || resample_changed) {
803 if (resample_changed) {
804 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",
805 ist->file_index, ist->index,
806 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
807 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
808 ost->resample_sample_fmt = dec->sample_fmt;
809 ost->resample_channels = dec->channels;
810 ost->resample_sample_rate = dec->sample_rate;
812 audio_resample_close(ost->resample);
814 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
815 if (audio_sync_method <= 1 &&
816 ost->resample_sample_fmt == enc->sample_fmt &&
817 ost->resample_channels == enc->channels &&
818 ost->resample_sample_rate == enc->sample_rate) {
819 ost->resample = NULL;
820 ost->audio_resample = 0;
822 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
823 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
824 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
825 enc->sample_rate, dec->sample_rate,
826 enc->sample_fmt, dec->sample_fmt,
828 if (!ost->resample) {
829 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
830 dec->channels, dec->sample_rate,
831 enc->channels, enc->sample_rate);
837 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
838 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
839 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
840 if (ost->reformat_ctx)
841 av_audio_convert_free(ost->reformat_ctx);
842 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
843 dec->sample_fmt, 1, NULL, 0);
844 if (!ost->reformat_ctx) {
845 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
846 av_get_sample_fmt_name(dec->sample_fmt),
847 av_get_sample_fmt_name(enc->sample_fmt));
850 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
853 if(audio_sync_method){
854 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
855 - av_fifo_size(ost->fifo)/(enc->channels * 2);
856 double idelta= delta*dec->sample_rate / enc->sample_rate;
857 int byte_delta= ((int)idelta)*2*dec->channels;
859 //FIXME resample delay
860 if(fabs(delta) > 50){
861 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
863 byte_delta= FFMAX(byte_delta, -size);
867 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
872 static uint8_t *input_tmp= NULL;
873 input_tmp= av_realloc(input_tmp, byte_delta + size);
875 if(byte_delta > allocated_for_size - size){
876 allocated_for_size= byte_delta + (int64_t)size;
881 memset(input_tmp, 0, byte_delta);
882 memcpy(input_tmp + byte_delta, buf, size);
886 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
888 }else if(audio_sync_method>1){
889 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
890 av_assert0(ost->audio_resample);
892 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
893 // 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));
894 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
898 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
899 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
901 if (ost->audio_resample) {
903 size_out = audio_resample(ost->resample,
904 (short *)buftmp, (short *)buf,
905 size / (dec->channels * isize));
906 size_out = size_out * enc->channels * osize;
912 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
913 const void *ibuf[6]= {buftmp};
914 void *obuf[6]= {audio_buf};
915 int istride[6]= {isize};
916 int ostride[6]= {osize};
917 int len= size_out/istride[0];
918 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
919 printf("av_audio_convert() failed\n");
925 size_out = len*osize;
928 /* now encode as many frames as possible */
929 if (enc->frame_size > 1) {
930 /* output resampled raw samples */
931 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
932 fprintf(stderr, "av_fifo_realloc2() failed\n");
935 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
937 frame_bytes = enc->frame_size * osize * enc->channels;
939 while (av_fifo_size(ost->fifo) >= frame_bytes) {
941 av_init_packet(&pkt);
943 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
945 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
947 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
950 fprintf(stderr, "Audio encoding failed\n");
954 pkt.stream_index= ost->index;
957 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
958 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
959 pkt.flags |= AV_PKT_FLAG_KEY;
960 write_frame(s, &pkt, enc, ost->bitstream_filters);
962 ost->sync_opts += enc->frame_size;
966 av_init_packet(&pkt);
968 ost->sync_opts += size_out / (osize * enc->channels);
970 /* output a pcm frame */
971 /* determine the size of the coded buffer */
974 size_out = size_out*coded_bps/8;
976 if(size_out > audio_out_size){
977 fprintf(stderr, "Internal error, buffer size too small\n");
981 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
982 ret = avcodec_encode_audio(enc, audio_out, size_out,
985 fprintf(stderr, "Audio encoding failed\n");
989 pkt.stream_index= ost->index;
992 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
993 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
994 pkt.flags |= AV_PKT_FLAG_KEY;
995 write_frame(s, &pkt, enc, ost->bitstream_filters);
999 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1001 AVCodecContext *dec;
1002 AVPicture *picture2;
1003 AVPicture picture_tmp;
1006 dec = ist->st->codec;
1008 /* deinterlace : must be done before any resize */
1009 if (do_deinterlace) {
1012 /* create temporary picture */
1013 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1014 buf = av_malloc(size);
1018 picture2 = &picture_tmp;
1019 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1021 if(avpicture_deinterlace(picture2, picture,
1022 dec->pix_fmt, dec->width, dec->height) < 0) {
1023 /* if error, do not deinterlace */
1024 fprintf(stderr, "Deinterlacing failed\n");
1033 if (picture != picture2)
1034 *picture = *picture2;
1038 /* we begin to correct av delay at this threshold */
1039 #define AV_DELAY_MAX 0.100
1041 static void do_subtitle_out(AVFormatContext *s,
1042 AVOutputStream *ost,
1047 static uint8_t *subtitle_out = NULL;
1048 int subtitle_out_max_size = 1024 * 1024;
1049 int subtitle_out_size, nb, i;
1050 AVCodecContext *enc;
1053 if (pts == AV_NOPTS_VALUE) {
1054 fprintf(stderr, "Subtitle packets must have a pts\n");
1060 enc = ost->st->codec;
1062 if (!subtitle_out) {
1063 subtitle_out = av_malloc(subtitle_out_max_size);
1066 /* Note: DVB subtitle need one packet to draw them and one other
1067 packet to clear them */
1068 /* XXX: signal it in the codec context ? */
1069 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1074 for(i = 0; i < nb; i++) {
1075 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1076 // start_display_time is required to be 0
1077 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1078 sub->end_display_time -= sub->start_display_time;
1079 sub->start_display_time = 0;
1080 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1081 subtitle_out_max_size, sub);
1082 if (subtitle_out_size < 0) {
1083 fprintf(stderr, "Subtitle encoding failed\n");
1087 av_init_packet(&pkt);
1088 pkt.stream_index = ost->index;
1089 pkt.data = subtitle_out;
1090 pkt.size = subtitle_out_size;
1091 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1092 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1093 /* XXX: the pts correction is handled here. Maybe handling
1094 it in the codec would be better */
1096 pkt.pts += 90 * sub->start_display_time;
1098 pkt.pts += 90 * sub->end_display_time;
1100 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1104 static int bit_buffer_size= 1024*256;
1105 static uint8_t *bit_buffer= NULL;
1107 static void do_video_out(AVFormatContext *s,
1108 AVOutputStream *ost,
1110 AVFrame *in_picture,
1113 int nb_frames, i, ret;
1114 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1115 AVCodecContext *enc, *dec;
1118 enc = ost->st->codec;
1119 dec = ist->st->codec;
1121 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1123 /* by default, we output a single frame */
1128 if(video_sync_method){
1129 double vdelta = sync_ipts - ost->sync_opts;
1130 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1133 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1136 }else if(vdelta>0.6)
1137 ost->sync_opts= lrintf(sync_ipts);
1138 }else if (vdelta > 1.1)
1139 nb_frames = lrintf(vdelta);
1140 //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);
1141 if (nb_frames == 0){
1144 fprintf(stderr, "*** drop!\n");
1145 }else if (nb_frames > 1) {
1146 nb_frames_dup += nb_frames - 1;
1148 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1151 ost->sync_opts= lrintf(sync_ipts);
1153 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1157 formatted_picture = in_picture;
1158 final_picture = formatted_picture;
1159 padding_src = formatted_picture;
1160 resampling_dst = &ost->pict_tmp;
1162 if ( ost->resample_height != ist->st->codec->height
1163 || ost->resample_width != ist->st->codec->width
1164 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1166 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));
1167 if(!ost->video_resample)
1171 #if !CONFIG_AVFILTER
1172 if (ost->video_resample) {
1174 final_picture = &ost->pict_tmp;
1175 if( ost->resample_height != ist->st->codec->height
1176 || ost->resample_width != ist->st->codec->width
1177 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1179 /* initialize a new scaler context */
1180 sws_freeContext(ost->img_resample_ctx);
1181 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1182 ost->img_resample_ctx = sws_getContext(
1183 ist->st->codec->width,
1184 ist->st->codec->height,
1185 ist->st->codec->pix_fmt,
1186 ost->st->codec->width,
1187 ost->st->codec->height,
1188 ost->st->codec->pix_fmt,
1189 sws_flags, NULL, NULL, NULL);
1190 if (ost->img_resample_ctx == NULL) {
1191 fprintf(stderr, "Cannot get resampling context\n");
1195 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1196 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1200 /* duplicates frame if needed */
1201 for(i=0;i<nb_frames;i++) {
1203 av_init_packet(&pkt);
1204 pkt.stream_index= ost->index;
1206 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1207 /* raw pictures are written as AVPicture structure to
1208 avoid any copies. We support temorarily the older
1210 AVFrame* old_frame = enc->coded_frame;
1211 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1212 pkt.data= (uint8_t *)final_picture;
1213 pkt.size= sizeof(AVPicture);
1214 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1215 pkt.flags |= AV_PKT_FLAG_KEY;
1217 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1218 enc->coded_frame = old_frame;
1220 AVFrame big_picture;
1222 big_picture= *final_picture;
1223 /* better than nothing: use input picture interlaced
1225 big_picture.interlaced_frame = in_picture->interlaced_frame;
1226 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1227 if(top_field_first == -1)
1228 big_picture.top_field_first = in_picture->top_field_first;
1230 big_picture.top_field_first = top_field_first;
1233 /* handles sameq here. This is not correct because it may
1234 not be a global option */
1235 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1237 big_picture.pict_type = 0;
1238 // big_picture.pts = AV_NOPTS_VALUE;
1239 big_picture.pts= ost->sync_opts;
1240 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1241 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1242 if (ost->forced_kf_index < ost->forced_kf_count &&
1243 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1244 big_picture.pict_type = FF_I_TYPE;
1245 ost->forced_kf_index++;
1247 ret = avcodec_encode_video(enc,
1248 bit_buffer, bit_buffer_size,
1251 fprintf(stderr, "Video encoding failed\n");
1256 pkt.data= bit_buffer;
1258 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1259 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1260 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1261 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1262 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1264 if(enc->coded_frame->key_frame)
1265 pkt.flags |= AV_PKT_FLAG_KEY;
1266 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1269 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1270 // enc->frame_number-1, ret, enc->pict_type);
1271 /* if two pass, output log */
1272 if (ost->logfile && enc->stats_out) {
1273 fprintf(ost->logfile, "%s", enc->stats_out);
1278 ost->frame_number++;
1282 static double psnr(double d){
1283 return -10.0*log(d)/log(10.0);
1286 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1289 AVCodecContext *enc;
1291 double ti1, bitrate, avg_bitrate;
1293 /* this is executed just the first time do_video_stats is called */
1295 vstats_file = fopen(vstats_filename, "w");
1302 enc = ost->st->codec;
1303 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1304 frame_number = ost->frame_number;
1305 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1306 if (enc->flags&CODEC_FLAG_PSNR)
1307 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1309 fprintf(vstats_file,"f_size= %6d ", frame_size);
1310 /* compute pts value */
1311 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1315 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1316 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1317 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1318 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1319 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1323 static void print_report(AVFormatContext **output_files,
1324 AVOutputStream **ost_table, int nb_ostreams,
1328 AVOutputStream *ost;
1329 AVFormatContext *oc;
1331 AVCodecContext *enc;
1332 int frame_number, vid, i;
1333 double bitrate, ti1, pts;
1334 static int64_t last_time = -1;
1335 static int qp_histogram[52];
1337 if (!is_last_report) {
1339 /* display the report every 0.5 seconds */
1340 cur_time = av_gettime();
1341 if (last_time == -1) {
1342 last_time = cur_time;
1345 if ((cur_time - last_time) < 500000)
1347 last_time = cur_time;
1351 oc = output_files[0];
1353 total_size = avio_size(oc->pb);
1354 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1355 total_size= avio_tell(oc->pb);
1360 for(i=0;i<nb_ostreams;i++) {
1362 enc = ost->st->codec;
1363 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1364 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1365 !ost->st->stream_copy ?
1366 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1368 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1369 float t = (av_gettime()-timer_start) / 1000000.0;
1371 frame_number = ost->frame_number;
1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1373 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1374 !ost->st->stream_copy ?
1375 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1377 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1380 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1381 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1384 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1386 if (enc->flags&CODEC_FLAG_PSNR){
1388 double error, error_sum=0;
1389 double scale, scale_sum=0;
1390 char type[3]= {'Y','U','V'};
1391 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1394 error= enc->error[j];
1395 scale= enc->width*enc->height*255.0*255.0*frame_number;
1397 error= enc->coded_frame->error[j];
1398 scale= enc->width*enc->height*255.0*255.0;
1403 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1405 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1409 /* compute min output value */
1410 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1411 if ((pts < ti1) && (pts > 0))
1417 if (verbose || is_last_report) {
1418 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1421 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1422 (double)total_size / 1024, ti1, bitrate);
1424 if (nb_frames_dup || nb_frames_drop)
1425 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1426 nb_frames_dup, nb_frames_drop);
1429 fprintf(stderr, "%s \r", buf);
1434 if (is_last_report && verbose >= 0){
1435 int64_t raw= audio_size + video_size + extra_size;
1436 fprintf(stderr, "\n");
1437 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1441 100.0*(total_size - raw)/raw
1446 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1447 static int output_packet(AVInputStream *ist, int ist_index,
1448 AVOutputStream **ost_table, int nb_ostreams,
1449 const AVPacket *pkt)
1451 AVFormatContext *os;
1452 AVOutputStream *ost;
1456 void *buffer_to_free;
1457 static unsigned int samples_size= 0;
1458 AVSubtitle subtitle, *subtitle_to_free;
1459 int64_t pkt_pts = AV_NOPTS_VALUE;
1461 int frame_available;
1465 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1467 if(ist->next_pts == AV_NOPTS_VALUE)
1468 ist->next_pts= ist->pts;
1472 av_init_packet(&avpkt);
1480 if(pkt->dts != AV_NOPTS_VALUE)
1481 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1482 if(pkt->pts != AV_NOPTS_VALUE)
1483 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1485 //while we have more to decode or while the decoder did output something on EOF
1486 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1487 uint8_t *data_buf, *decoded_data_buf;
1488 int data_size, decoded_data_size;
1490 ist->pts= ist->next_pts;
1492 if(avpkt.size && avpkt.size != pkt->size &&
1493 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1494 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1495 ist->showed_multi_packet_warning=1;
1498 /* decode the packet if needed */
1499 decoded_data_buf = NULL; /* fail safe */
1500 decoded_data_size= 0;
1501 data_buf = avpkt.data;
1502 data_size = avpkt.size;
1503 subtitle_to_free = NULL;
1504 if (ist->decoding_needed) {
1505 switch(ist->st->codec->codec_type) {
1506 case AVMEDIA_TYPE_AUDIO:{
1507 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1508 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1510 samples= av_malloc(samples_size);
1512 decoded_data_size= samples_size;
1513 /* XXX: could avoid copy if PCM 16 bits with same
1514 endianness as CPU */
1515 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1522 /* Some bug in mpeg audio decoder gives */
1523 /* decoded_data_size < 0, it seems they are overflows */
1524 if (decoded_data_size <= 0) {
1525 /* no audio frame */
1528 decoded_data_buf = (uint8_t *)samples;
1529 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1530 (ist->st->codec->sample_rate * ist->st->codec->channels);
1532 case AVMEDIA_TYPE_VIDEO:
1533 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1534 /* XXX: allocate picture correctly */
1535 avcodec_get_frame_defaults(&picture);
1536 avpkt.pts = pkt_pts;
1537 avpkt.dts = ist->pts;
1538 pkt_pts = AV_NOPTS_VALUE;
1540 ret = avcodec_decode_video2(ist->st->codec,
1541 &picture, &got_picture, &avpkt);
1542 ist->st->quality= picture.quality;
1546 /* no picture yet */
1547 goto discard_packet;
1549 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1550 if (ist->st->codec->time_base.num != 0) {
1551 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1552 ist->next_pts += ((int64_t)AV_TIME_BASE *
1553 ist->st->codec->time_base.num * ticks) /
1554 ist->st->codec->time_base.den;
1558 case AVMEDIA_TYPE_SUBTITLE:
1559 ret = avcodec_decode_subtitle2(ist->st->codec,
1560 &subtitle, &got_picture, &avpkt);
1564 goto discard_packet;
1566 subtitle_to_free = &subtitle;
1573 switch(ist->st->codec->codec_type) {
1574 case AVMEDIA_TYPE_AUDIO:
1575 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1576 ist->st->codec->sample_rate;
1578 case AVMEDIA_TYPE_VIDEO:
1579 if (ist->st->codec->time_base.num != 0) {
1580 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1581 ist->next_pts += ((int64_t)AV_TIME_BASE *
1582 ist->st->codec->time_base.num * ticks) /
1583 ist->st->codec->time_base.den;
1591 buffer_to_free = NULL;
1592 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1593 pre_process_video_frame(ist, (AVPicture *)&picture,
1598 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1600 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1601 else sar = ist->st->codec->sample_aspect_ratio;
1602 // add it to be filtered
1603 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1609 // preprocess audio (volume)
1610 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1611 if (audio_volume != 256) {
1614 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1615 int v = ((*volp) * audio_volume + 128) >> 8;
1616 if (v < -32768) v = -32768;
1617 if (v > 32767) v = 32767;
1623 /* frame rate emulation */
1625 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1626 int64_t now = av_gettime() - ist->start;
1631 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1632 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1634 /* if output time reached then transcode raw format,
1635 encode packets and output them */
1636 if (start_time == 0 || ist->pts >= start_time)
1638 while (frame_available) {
1639 AVRational ist_pts_tb;
1640 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1641 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1643 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1645 for(i=0;i<nb_ostreams;i++) {
1649 if (ost->source_index == ist_index) {
1650 os = output_files[ost->file_index];
1652 /* set the input output pts pairs */
1653 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1655 if (ost->encoding_needed) {
1656 av_assert0(ist->decoding_needed);
1657 switch(ost->st->codec->codec_type) {
1658 case AVMEDIA_TYPE_AUDIO:
1659 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1661 case AVMEDIA_TYPE_VIDEO:
1663 if (ist->picref->video)
1664 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1666 do_video_out(os, ost, ist, &picture, &frame_size);
1667 if (vstats_filename && frame_size)
1668 do_video_stats(os, ost, frame_size);
1670 case AVMEDIA_TYPE_SUBTITLE:
1671 do_subtitle_out(os, ost, ist, &subtitle,
1678 AVFrame avframe; //FIXME/XXX remove this
1680 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1682 av_init_packet(&opkt);
1684 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1687 /* no reencoding needed : output the packet directly */
1688 /* force the input stream PTS */
1690 avcodec_get_frame_defaults(&avframe);
1691 ost->st->codec->coded_frame= &avframe;
1692 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1694 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1695 audio_size += data_size;
1696 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1697 video_size += data_size;
1701 opkt.stream_index= ost->index;
1702 if(pkt->pts != AV_NOPTS_VALUE)
1703 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1705 opkt.pts= AV_NOPTS_VALUE;
1707 if (pkt->dts == AV_NOPTS_VALUE)
1708 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1710 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1711 opkt.dts -= ost_tb_start_time;
1713 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1714 opkt.flags= pkt->flags;
1716 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1717 if( ost->st->codec->codec_id != CODEC_ID_H264
1718 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1719 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1721 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1722 opkt.destruct= av_destruct_packet;
1724 opkt.data = data_buf;
1725 opkt.size = data_size;
1728 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1729 ost->st->codec->frame_number++;
1730 ost->frame_number++;
1731 av_free_packet(&opkt);
1737 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1738 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1740 avfilter_unref_buffer(ist->picref);
1743 av_free(buffer_to_free);
1744 /* XXX: allocate the subtitles in the codec ? */
1745 if (subtitle_to_free) {
1746 avsubtitle_free(subtitle_to_free);
1747 subtitle_to_free = NULL;
1754 for(i=0;i<nb_ostreams;i++) {
1756 if (ost->source_index == ist_index) {
1757 AVCodecContext *enc= ost->st->codec;
1758 os = output_files[ost->file_index];
1760 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1762 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1765 if (ost->encoding_needed) {
1769 av_init_packet(&pkt);
1770 pkt.stream_index= ost->index;
1772 switch(ost->st->codec->codec_type) {
1773 case AVMEDIA_TYPE_AUDIO:
1774 fifo_bytes = av_fifo_size(ost->fifo);
1776 /* encode any samples remaining in fifo */
1777 if (fifo_bytes > 0) {
1778 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1779 int fs_tmp = enc->frame_size;
1781 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1782 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1783 enc->frame_size = fifo_bytes / (osize * enc->channels);
1785 int frame_bytes = enc->frame_size*osize*enc->channels;
1786 if (allocated_audio_buf_size < frame_bytes)
1788 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1791 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1792 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1793 ost->st->time_base.num, enc->sample_rate);
1794 enc->frame_size = fs_tmp;
1797 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1800 fprintf(stderr, "Audio encoding failed\n");
1804 pkt.flags |= AV_PKT_FLAG_KEY;
1806 case AVMEDIA_TYPE_VIDEO:
1807 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1809 fprintf(stderr, "Video encoding failed\n");
1813 if(enc->coded_frame && enc->coded_frame->key_frame)
1814 pkt.flags |= AV_PKT_FLAG_KEY;
1815 if (ost->logfile && enc->stats_out) {
1816 fprintf(ost->logfile, "%s", enc->stats_out);
1825 pkt.data= bit_buffer;
1827 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1828 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1829 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1841 static void print_sdp(AVFormatContext **avc, int n)
1845 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1846 printf("SDP:\n%s\n", sdp);
1850 static int copy_chapters(int infile, int outfile)
1852 AVFormatContext *is = input_files[infile];
1853 AVFormatContext *os = output_files[outfile];
1856 for (i = 0; i < is->nb_chapters; i++) {
1857 AVChapter *in_ch = is->chapters[i], *out_ch;
1858 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1859 AV_TIME_BASE_Q, in_ch->time_base);
1860 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1861 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1864 if (in_ch->end < ts_off)
1866 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1869 out_ch = av_mallocz(sizeof(AVChapter));
1871 return AVERROR(ENOMEM);
1873 out_ch->id = in_ch->id;
1874 out_ch->time_base = in_ch->time_base;
1875 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1876 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1878 if (metadata_chapters_autocopy)
1879 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1882 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1884 return AVERROR(ENOMEM);
1885 os->chapters[os->nb_chapters - 1] = out_ch;
1890 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1891 AVCodecContext *avctx)
1897 for (p = kf; *p; p++)
1900 ost->forced_kf_count = n;
1901 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1902 if (!ost->forced_kf_pts) {
1903 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1906 for (i = 0; i < n; i++) {
1907 p = i ? strchr(p, ',') + 1 : kf;
1908 t = parse_time_or_die("force_key_frames", p, 1);
1909 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1914 * The following code is the main loop of the file converter
1916 static int transcode(AVFormatContext **output_files,
1917 int nb_output_files,
1918 AVFormatContext **input_files,
1920 AVStreamMap *stream_maps, int nb_stream_maps)
1922 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1923 AVFormatContext *is, *os;
1924 AVCodecContext *codec, *icodec;
1925 AVOutputStream *ost, **ost_table = NULL;
1926 AVInputStream *ist, **ist_table = NULL;
1927 AVInputFile *file_table;
1931 uint8_t no_packet[MAX_FILES]={0};
1932 int no_packet_count=0;
1934 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1938 /* input stream init */
1940 for(i=0;i<nb_input_files;i++) {
1941 is = input_files[i];
1942 file_table[i].ist_index = j;
1943 file_table[i].nb_streams = is->nb_streams;
1944 j += is->nb_streams;
1948 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1952 for(i=0;i<nb_istreams;i++) {
1953 ist = av_mallocz(sizeof(AVInputStream));
1959 for(i=0;i<nb_input_files;i++) {
1960 is = input_files[i];
1961 for(k=0;k<is->nb_streams;k++) {
1962 ist = ist_table[j++];
1963 ist->st = is->streams[k];
1964 ist->file_index = i;
1966 ist->discard = 1; /* the stream is discarded by default
1970 ist->start = av_gettime();
1975 /* output stream init */
1977 for(i=0;i<nb_output_files;i++) {
1978 os = output_files[i];
1979 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1980 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1981 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1982 ret = AVERROR(EINVAL);
1985 nb_ostreams += os->nb_streams;
1987 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1988 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1989 ret = AVERROR(EINVAL);
1993 /* Sanity check the mapping args -- do the input files & streams exist? */
1994 for(i=0;i<nb_stream_maps;i++) {
1995 int fi = stream_maps[i].file_index;
1996 int si = stream_maps[i].stream_index;
1998 if (fi < 0 || fi > nb_input_files - 1 ||
1999 si < 0 || si > file_table[fi].nb_streams - 1) {
2000 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2001 ret = AVERROR(EINVAL);
2004 fi = stream_maps[i].sync_file_index;
2005 si = stream_maps[i].sync_stream_index;
2006 if (fi < 0 || fi > nb_input_files - 1 ||
2007 si < 0 || si > file_table[fi].nb_streams - 1) {
2008 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2009 ret = AVERROR(EINVAL);
2014 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2018 for(k=0;k<nb_output_files;k++) {
2019 os = output_files[k];
2020 for(i=0;i<os->nb_streams;i++,n++) {
2022 ost = ost_table[n] = output_streams_for_file[k][i];
2023 ost->st = os->streams[i];
2024 if (nb_stream_maps > 0) {
2025 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2026 stream_maps[n].stream_index;
2028 /* Sanity check that the stream types match */
2029 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2030 int i= ost->file_index;
2031 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2032 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2033 stream_maps[n].file_index, stream_maps[n].stream_index,
2034 ost->file_index, ost->index);
2039 int best_nb_frames=-1;
2040 /* get corresponding input stream index : we select the first one with the right type */
2042 for(j=0;j<nb_istreams;j++) {
2047 AVFormatContext *f= input_files[ ist->file_index ];
2049 for(pi=0; pi<f->nb_programs; pi++){
2050 AVProgram *p= f->programs[pi];
2051 if(p->id == opt_programid)
2052 for(si=0; si<p->nb_stream_indexes; si++){
2053 if(f->streams[ p->stream_index[si] ] == ist->st)
2058 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2059 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2060 if(best_nb_frames < ist->st->codec_info_nb_frames){
2061 best_nb_frames= ist->st->codec_info_nb_frames;
2062 ost->source_index = j;
2069 if(! opt_programid) {
2070 /* try again and reuse existing stream */
2071 for(j=0;j<nb_istreams;j++) {
2073 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2074 && ist->st->discard != AVDISCARD_ALL) {
2075 ost->source_index = j;
2081 int i= ost->file_index;
2082 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2083 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2084 ost->file_index, ost->index);
2089 ist = ist_table[ost->source_index];
2091 ost->sync_ist = (nb_stream_maps > 0) ?
2092 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2093 stream_maps[n].sync_stream_index] : ist;
2097 /* for each output stream, we compute the right encoding parameters */
2098 for(i=0;i<nb_ostreams;i++) {
2100 os = output_files[ost->file_index];
2101 ist = ist_table[ost->source_index];
2103 codec = ost->st->codec;
2104 icodec = ist->st->codec;
2106 if (metadata_streams_autocopy)
2107 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2108 AV_METADATA_DONT_OVERWRITE);
2110 ost->st->disposition = ist->st->disposition;
2111 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2112 codec->chroma_sample_location = icodec->chroma_sample_location;
2114 if (ost->st->stream_copy) {
2115 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2117 if (extra_size > INT_MAX)
2120 /* if stream_copy is selected, no need to decode or encode */
2121 codec->codec_id = icodec->codec_id;
2122 codec->codec_type = icodec->codec_type;
2124 if(!codec->codec_tag){
2125 if( !os->oformat->codec_tag
2126 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2127 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2128 codec->codec_tag = icodec->codec_tag;
2131 codec->bit_rate = icodec->bit_rate;
2132 codec->rc_max_rate = icodec->rc_max_rate;
2133 codec->rc_buffer_size = icodec->rc_buffer_size;
2134 codec->extradata= av_mallocz(extra_size);
2135 if (!codec->extradata)
2137 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2138 codec->extradata_size= icodec->extradata_size;
2139 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){
2140 codec->time_base = icodec->time_base;
2141 codec->time_base.num *= icodec->ticks_per_frame;
2142 av_reduce(&codec->time_base.num, &codec->time_base.den,
2143 codec->time_base.num, codec->time_base.den, INT_MAX);
2145 codec->time_base = ist->st->time_base;
2146 switch(codec->codec_type) {
2147 case AVMEDIA_TYPE_AUDIO:
2148 if(audio_volume != 256) {
2149 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2152 codec->channel_layout = icodec->channel_layout;
2153 codec->sample_rate = icodec->sample_rate;
2154 codec->channels = icodec->channels;
2155 codec->frame_size = icodec->frame_size;
2156 codec->block_align= icodec->block_align;
2157 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2158 codec->block_align= 0;
2159 if(codec->codec_id == CODEC_ID_AC3)
2160 codec->block_align= 0;
2162 case AVMEDIA_TYPE_VIDEO:
2163 codec->pix_fmt = icodec->pix_fmt;
2164 codec->width = icodec->width;
2165 codec->height = icodec->height;
2166 codec->has_b_frames = icodec->has_b_frames;
2168 case AVMEDIA_TYPE_SUBTITLE:
2169 codec->width = icodec->width;
2170 codec->height = icodec->height;
2176 switch(codec->codec_type) {
2177 case AVMEDIA_TYPE_AUDIO:
2178 ost->fifo= av_fifo_alloc(1024);
2181 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2182 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2183 icodec->request_channels = codec->channels;
2184 ist->decoding_needed = 1;
2185 ost->encoding_needed = 1;
2186 ost->resample_sample_fmt = icodec->sample_fmt;
2187 ost->resample_sample_rate = icodec->sample_rate;
2188 ost->resample_channels = icodec->channels;
2190 case AVMEDIA_TYPE_VIDEO:
2191 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2192 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2195 ost->video_resample = (codec->width != icodec->width ||
2196 codec->height != icodec->height ||
2197 (codec->pix_fmt != icodec->pix_fmt));
2198 if (ost->video_resample) {
2199 #if !CONFIG_AVFILTER
2200 avcodec_get_frame_defaults(&ost->pict_tmp);
2201 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2202 codec->width, codec->height)) {
2203 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2206 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2207 ost->img_resample_ctx = sws_getContext(
2214 sws_flags, NULL, NULL, NULL);
2215 if (ost->img_resample_ctx == NULL) {
2216 fprintf(stderr, "Cannot get resampling context\n");
2220 ost->original_height = icodec->height;
2221 ost->original_width = icodec->width;
2223 codec->bits_per_raw_sample= 0;
2225 ost->resample_height = icodec->height;
2226 ost->resample_width = icodec->width;
2227 ost->resample_pix_fmt= icodec->pix_fmt;
2228 ost->encoding_needed = 1;
2229 ist->decoding_needed = 1;
2232 if (configure_filters(ist, ost)) {
2233 fprintf(stderr, "Error opening filters!\n");
2238 case AVMEDIA_TYPE_SUBTITLE:
2239 ost->encoding_needed = 1;
2240 ist->decoding_needed = 1;
2247 if (ost->encoding_needed &&
2248 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2249 char logfilename[1024];
2252 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2253 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2255 if (codec->flags & CODEC_FLAG_PASS1) {
2256 f = fopen(logfilename, "wb");
2258 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2264 size_t logbuffer_size;
2265 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2266 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2269 codec->stats_in = logbuffer;
2273 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2274 int size= codec->width * codec->height;
2275 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2280 bit_buffer = av_malloc(bit_buffer_size);
2282 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2284 ret = AVERROR(ENOMEM);
2288 /* open each encoder */
2289 for(i=0;i<nb_ostreams;i++) {
2291 if (ost->encoding_needed) {
2292 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2293 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2295 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2297 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2298 ost->st->codec->codec_id, ost->file_index, ost->index);
2299 ret = AVERROR(EINVAL);
2302 if (dec->subtitle_header) {
2303 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2304 if (!ost->st->codec->subtitle_header) {
2305 ret = AVERROR(ENOMEM);
2308 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2309 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2311 if (avcodec_open(ost->st->codec, codec) < 0) {
2312 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2313 ost->file_index, ost->index);
2314 ret = AVERROR(EINVAL);
2317 extra_size += ost->st->codec->extradata_size;
2321 /* open each decoder */
2322 for(i=0;i<nb_istreams;i++) {
2324 if (ist->decoding_needed) {
2325 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2327 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2329 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2330 ist->st->codec->codec_id, ist->file_index, ist->index);
2331 ret = AVERROR(EINVAL);
2334 if (avcodec_open(ist->st->codec, codec) < 0) {
2335 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2336 ist->file_index, ist->index);
2337 ret = AVERROR(EINVAL);
2340 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2341 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2346 for(i=0;i<nb_istreams;i++) {
2350 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2351 ist->next_pts = AV_NOPTS_VALUE;
2352 init_pts_correction(&ist->pts_ctx);
2356 /* set meta data information from input file if required */
2357 for (i=0;i<nb_meta_data_maps;i++) {
2358 AVFormatContext *files[2];
2359 AVMetadata **meta[2];
2362 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2363 if ((index) < 0 || (index) >= (nb_elems)) {\
2364 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2366 ret = AVERROR(EINVAL);\
2370 int out_file_index = meta_data_maps[i][0].file;
2371 int in_file_index = meta_data_maps[i][1].file;
2372 if (in_file_index < 0 || out_file_index < 0)
2374 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2375 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2377 files[0] = output_files[out_file_index];
2378 files[1] = input_files[in_file_index];
2380 for (j = 0; j < 2; j++) {
2381 AVMetaDataMap *map = &meta_data_maps[i][j];
2383 switch (map->type) {
2385 meta[j] = &files[j]->metadata;
2388 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2389 meta[j] = &files[j]->streams[map->index]->metadata;
2392 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2393 meta[j] = &files[j]->chapters[map->index]->metadata;
2396 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2397 meta[j] = &files[j]->programs[map->index]->metadata;
2402 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2405 /* copy global metadata by default */
2406 if (metadata_global_autocopy) {
2408 for (i = 0; i < nb_output_files; i++)
2409 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2410 AV_METADATA_DONT_OVERWRITE);
2413 /* copy chapters according to chapter maps */
2414 for (i = 0; i < nb_chapter_maps; i++) {
2415 int infile = chapter_maps[i].in_file;
2416 int outfile = chapter_maps[i].out_file;
2418 if (infile < 0 || outfile < 0)
2420 if (infile >= nb_input_files) {
2421 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2422 ret = AVERROR(EINVAL);
2425 if (outfile >= nb_output_files) {
2426 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2427 ret = AVERROR(EINVAL);
2430 copy_chapters(infile, outfile);
2433 /* copy chapters from the first input file that has them*/
2434 if (!nb_chapter_maps)
2435 for (i = 0; i < nb_input_files; i++) {
2436 if (!input_files[i]->nb_chapters)
2439 for (j = 0; j < nb_output_files; j++)
2440 if ((ret = copy_chapters(i, j)) < 0)
2445 /* open files and write file headers */
2446 for(i=0;i<nb_output_files;i++) {
2447 os = output_files[i];
2448 if (av_write_header(os) < 0) {
2449 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2450 ret = AVERROR(EINVAL);
2453 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2459 /* dump the file output parameters - cannot be done before in case
2461 for(i=0;i<nb_output_files;i++) {
2462 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2465 /* dump the stream mapping */
2467 fprintf(stderr, "Stream mapping:\n");
2468 for(i=0;i<nb_ostreams;i++) {
2470 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2471 ist_table[ost->source_index]->file_index,
2472 ist_table[ost->source_index]->index,
2475 if (ost->sync_ist != ist_table[ost->source_index])
2476 fprintf(stderr, " [sync #%d.%d]",
2477 ost->sync_ist->file_index,
2478 ost->sync_ist->index);
2479 fprintf(stderr, "\n");
2484 fprintf(stderr, "%s\n", error);
2489 print_sdp(output_files, nb_output_files);
2492 if (!using_stdin && verbose >= 0) {
2493 fprintf(stderr, "Press [q] to stop encoding\n");
2494 url_set_interrupt_cb(decode_interrupt_cb);
2498 timer_start = av_gettime();
2500 for(; received_sigterm == 0;) {
2501 int file_index, ist_index;
2509 /* if 'q' pressed, exits */
2513 /* read_key() returns 0 on EOF */
2519 /* select the stream that we must read now by looking at the
2520 smallest output pts */
2522 for(i=0;i<nb_ostreams;i++) {
2525 os = output_files[ost->file_index];
2526 ist = ist_table[ost->source_index];
2527 if(ist->is_past_recording_time || no_packet[ist->file_index])
2529 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2530 ipts = (double)ist->pts;
2531 if (!file_table[ist->file_index].eof_reached){
2532 if(ipts < ipts_min) {
2534 if(input_sync ) file_index = ist->file_index;
2536 if(opts < opts_min) {
2538 if(!input_sync) file_index = ist->file_index;
2541 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2546 /* if none, if is finished */
2547 if (file_index < 0) {
2548 if(no_packet_count){
2550 memset(no_packet, 0, sizeof(no_packet));
2557 /* finish if limit size exhausted */
2558 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2561 /* read a frame from it and output it in the fifo */
2562 is = input_files[file_index];
2563 ret= av_read_frame(is, &pkt);
2564 if(ret == AVERROR(EAGAIN)){
2565 no_packet[file_index]=1;
2570 file_table[file_index].eof_reached = 1;
2578 memset(no_packet, 0, sizeof(no_packet));
2581 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2582 is->streams[pkt.stream_index]);
2584 /* the following test is needed in case new streams appear
2585 dynamically in stream : we ignore them */
2586 if (pkt.stream_index >= file_table[file_index].nb_streams)
2587 goto discard_packet;
2588 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2589 ist = ist_table[ist_index];
2591 goto discard_packet;
2593 if (pkt.dts != AV_NOPTS_VALUE)
2594 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2595 if (pkt.pts != AV_NOPTS_VALUE)
2596 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2598 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2599 && input_files_ts_scale[file_index][pkt.stream_index]){
2600 if(pkt.pts != AV_NOPTS_VALUE)
2601 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2602 if(pkt.dts != AV_NOPTS_VALUE)
2603 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2606 // 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);
2607 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2608 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2609 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2610 int64_t delta= pkt_dts - ist->next_pts;
2611 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2612 input_files_ts_offset[ist->file_index]-= delta;
2614 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2615 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2616 if(pkt.pts != AV_NOPTS_VALUE)
2617 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2621 /* finish if recording time exhausted */
2622 if (recording_time != INT64_MAX &&
2623 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2624 ist->is_past_recording_time = 1;
2625 goto discard_packet;
2628 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2629 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2632 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2633 ist->file_index, ist->index);
2636 av_free_packet(&pkt);
2641 av_free_packet(&pkt);
2643 /* dump report by using the output first video and audio streams */
2644 print_report(output_files, ost_table, nb_ostreams, 0);
2647 /* at the end of stream, we must flush the decoder buffers */
2648 for(i=0;i<nb_istreams;i++) {
2650 if (ist->decoding_needed) {
2651 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2657 /* write the trailer if needed and close file */
2658 for(i=0;i<nb_output_files;i++) {
2659 os = output_files[i];
2660 av_write_trailer(os);
2663 /* dump report by using the first video and audio streams */
2664 print_report(output_files, ost_table, nb_ostreams, 1);
2666 /* close each encoder */
2667 for(i=0;i<nb_ostreams;i++) {
2669 if (ost->encoding_needed) {
2670 av_freep(&ost->st->codec->stats_in);
2671 avcodec_close(ost->st->codec);
2675 /* close each decoder */
2676 for(i=0;i<nb_istreams;i++) {
2678 if (ist->decoding_needed) {
2679 avcodec_close(ist->st->codec);
2683 avfilter_graph_free(&graph);
2690 av_freep(&bit_buffer);
2691 av_free(file_table);
2694 for(i=0;i<nb_istreams;i++) {
2701 for(i=0;i<nb_ostreams;i++) {
2704 if (ost->st->stream_copy)
2705 av_freep(&ost->st->codec->extradata);
2707 fclose(ost->logfile);
2708 ost->logfile = NULL;
2710 av_fifo_free(ost->fifo); /* works even if fifo is not
2711 initialized but set to zero */
2712 av_freep(&ost->st->codec->subtitle_header);
2713 av_free(ost->pict_tmp.data[0]);
2714 av_free(ost->forced_kf_pts);
2715 if (ost->video_resample)
2716 sws_freeContext(ost->img_resample_ctx);
2718 audio_resample_close(ost->resample);
2719 if (ost->reformat_ctx)
2720 av_audio_convert_free(ost->reformat_ctx);
2729 static void opt_format(const char *arg)
2731 last_asked_format = arg;
2734 static void opt_video_rc_override_string(const char *arg)
2736 video_rc_override_string = arg;
2739 static int opt_me_threshold(const char *opt, const char *arg)
2741 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2745 static int opt_verbose(const char *opt, const char *arg)
2747 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2751 static int opt_frame_rate(const char *opt, const char *arg)
2753 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2754 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2760 static int opt_bitrate(const char *opt, const char *arg)
2762 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2764 opt_default(opt, arg);
2766 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2767 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2772 static int opt_frame_crop(const char *opt, const char *arg)
2774 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2775 return AVERROR(EINVAL);
2778 static void opt_frame_size(const char *arg)
2780 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2781 fprintf(stderr, "Incorrect frame size\n");
2786 static int opt_pad(const char *opt, const char *arg) {
2787 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2791 static void opt_frame_pix_fmt(const char *arg)
2793 if (strcmp(arg, "list")) {
2794 frame_pix_fmt = av_get_pix_fmt(arg);
2795 if (frame_pix_fmt == PIX_FMT_NONE) {
2796 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2805 static void opt_frame_aspect_ratio(const char *arg)
2812 p = strchr(arg, ':');
2814 x = strtol(arg, &end, 10);
2816 y = strtol(end+1, &end, 10);
2818 ar = (double)x / (double)y;
2820 ar = strtod(arg, NULL);
2823 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2826 frame_aspect_ratio = ar;
2829 static int opt_metadata(const char *opt, const char *arg)
2831 char *mid= strchr(arg, '=');
2834 fprintf(stderr, "Missing =\n");
2839 av_metadata_set2(&metadata, arg, mid, 0);
2844 static void opt_qscale(const char *arg)
2846 video_qscale = atof(arg);
2847 if (video_qscale <= 0 ||
2848 video_qscale > 255) {
2849 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2854 static void opt_top_field_first(const char *arg)
2856 top_field_first= atoi(arg);
2859 static int opt_thread_count(const char *opt, const char *arg)
2861 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2864 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2869 static void opt_audio_sample_fmt(const char *arg)
2871 if (strcmp(arg, "list")) {
2872 audio_sample_fmt = av_get_sample_fmt(arg);
2873 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2874 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2878 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2883 static int opt_audio_rate(const char *opt, const char *arg)
2885 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2889 static int opt_audio_channels(const char *opt, const char *arg)
2891 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2895 static void opt_video_channel(const char *arg)
2897 video_channel = strtol(arg, NULL, 0);
2900 static void opt_video_standard(const char *arg)
2902 video_standard = av_strdup(arg);
2905 static void opt_codec(int *pstream_copy, char **pcodec_name,
2906 int codec_type, const char *arg)
2908 av_freep(pcodec_name);
2909 if (!strcmp(arg, "copy")) {
2912 *pcodec_name = av_strdup(arg);
2916 static void opt_audio_codec(const char *arg)
2918 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2921 static void opt_video_codec(const char *arg)
2923 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2926 static void opt_subtitle_codec(const char *arg)
2928 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2931 static int opt_codec_tag(const char *opt, const char *arg)
2934 uint32_t *codec_tag;
2936 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2937 !strcmp(opt, "vtag") ? &video_codec_tag :
2938 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2942 *codec_tag = strtol(arg, &tail, 0);
2944 *codec_tag = AV_RL32(arg);
2949 static void opt_map(const char *arg)
2954 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2955 m = &stream_maps[nb_stream_maps-1];
2957 m->file_index = strtol(arg, &p, 0);
2961 m->stream_index = strtol(p, &p, 0);
2964 m->sync_file_index = strtol(p, &p, 0);
2967 m->sync_stream_index = strtol(p, &p, 0);
2969 m->sync_file_index = m->file_index;
2970 m->sync_stream_index = m->stream_index;
2974 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2985 *index = strtol(++arg, endptr, 0);
2988 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2995 static void opt_map_metadata(const char *arg)
2997 AVMetaDataMap *m, *m1;
3000 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3001 &nb_meta_data_maps, nb_meta_data_maps + 1);
3003 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3004 m->file = strtol(arg, &p, 0);
3005 parse_meta_type(p, &m->type, &m->index, &p);
3009 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3010 m1->file = strtol(p, &p, 0);
3011 parse_meta_type(p, &m1->type, &m1->index, &p);
3013 if (m->type == 'g' || m1->type == 'g')
3014 metadata_global_autocopy = 0;
3015 if (m->type == 's' || m1->type == 's')
3016 metadata_streams_autocopy = 0;
3017 if (m->type == 'c' || m1->type == 'c')
3018 metadata_chapters_autocopy = 0;
3021 static void opt_map_meta_data(const char *arg)
3023 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3024 "Use -map_metadata instead.\n");
3025 opt_map_metadata(arg);
3028 static void opt_map_chapters(const char *arg)
3033 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3034 nb_chapter_maps + 1);
3035 c = &chapter_maps[nb_chapter_maps - 1];
3036 c->out_file = strtol(arg, &p, 0);
3040 c->in_file = strtol(p, &p, 0);
3043 static void opt_input_ts_scale(const char *arg)
3045 unsigned int stream;
3049 stream = strtol(arg, &p, 0);
3052 scale= strtod(p, &p);
3054 if(stream >= MAX_STREAMS)
3057 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);
3058 input_files_ts_scale[nb_input_files][stream]= scale;
3061 static int opt_recording_time(const char *opt, const char *arg)
3063 recording_time = parse_time_or_die(opt, arg, 1);
3067 static int opt_start_time(const char *opt, const char *arg)
3069 start_time = parse_time_or_die(opt, arg, 1);
3073 static int opt_recording_timestamp(const char *opt, const char *arg)
3075 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3079 static int opt_input_ts_offset(const char *opt, const char *arg)
3081 input_ts_offset = parse_time_or_die(opt, arg, 1);
3085 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3087 const char *codec_string = encoder ? "encoder" : "decoder";
3091 return CODEC_ID_NONE;
3093 avcodec_find_encoder_by_name(name) :
3094 avcodec_find_decoder_by_name(name);
3096 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3099 if(codec->type != type) {
3100 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3103 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3104 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3105 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3106 "results.\nAdd '-strict experimental' if you want to use it.\n",
3107 codec_string, codec->name);
3109 avcodec_find_encoder(codec->id) :
3110 avcodec_find_decoder(codec->id);
3111 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3112 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3113 codec_string, codec->name);
3119 static void opt_input_file(const char *filename)
3121 AVFormatContext *ic;
3122 AVFormatParameters params, *ap = ¶ms;
3123 AVInputFormat *file_iformat = NULL;
3124 int err, i, ret, rfps, rfps_base;
3127 if (last_asked_format) {
3128 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3129 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3132 last_asked_format = NULL;
3135 if (!strcmp(filename, "-"))
3138 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3139 !strcmp(filename, "/dev/stdin");
3141 /* get default parameters from command line */
3142 ic = avformat_alloc_context();
3144 print_error(filename, AVERROR(ENOMEM));
3148 memset(ap, 0, sizeof(*ap));
3149 ap->prealloced_context = 1;
3150 ap->sample_rate = audio_sample_rate;
3151 ap->channels = audio_channels;
3152 ap->time_base.den = frame_rate.num;
3153 ap->time_base.num = frame_rate.den;
3154 ap->width = frame_width;
3155 ap->height = frame_height;
3156 ap->pix_fmt = frame_pix_fmt;
3157 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3158 ap->channel = video_channel;
3159 ap->standard = video_standard;
3161 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3163 ic->video_codec_id =
3164 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3165 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3166 ic->audio_codec_id =
3167 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3168 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3169 ic->subtitle_codec_id=
3170 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3171 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3172 ic->flags |= AVFMT_FLAG_NONBLOCK;
3174 /* open the input file with generic libav function */
3175 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3177 print_error(filename, err);
3183 for(i=0; i<ic->nb_streams; i++){
3184 ic->streams[i]->discard= AVDISCARD_ALL;
3186 for(i=0; i<ic->nb_programs; i++){
3187 AVProgram *p= ic->programs[i];
3188 if(p->id != opt_programid){
3189 p->discard = AVDISCARD_ALL;
3192 for(j=0; j<p->nb_stream_indexes; j++){
3193 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3198 fprintf(stderr, "Specified program id not found\n");
3204 ic->loop_input = loop_input;
3206 /* If not enough info to get the stream parameters, we decode the
3207 first frames to get it. (used in mpeg case for example) */
3208 ret = av_find_stream_info(ic);
3209 if (ret < 0 && verbose >= 0) {
3210 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3211 av_close_input_file(ic);
3215 timestamp = start_time;
3216 /* add the stream start time */
3217 if (ic->start_time != AV_NOPTS_VALUE)
3218 timestamp += ic->start_time;
3220 /* if seeking requested, we execute it */
3221 if (start_time != 0) {
3222 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3224 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3225 filename, (double)timestamp / AV_TIME_BASE);
3227 /* reset seek info */
3231 /* update the current parameters so that they match the one of the input stream */
3232 for(i=0;i<ic->nb_streams;i++) {
3233 AVStream *st = ic->streams[i];
3234 AVCodecContext *dec = st->codec;
3235 dec->thread_count = thread_count;
3236 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3237 switch (dec->codec_type) {
3238 case AVMEDIA_TYPE_AUDIO:
3239 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3240 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]);
3241 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3242 channel_layout = dec->channel_layout;
3243 audio_channels = dec->channels;
3244 audio_sample_rate = dec->sample_rate;
3245 audio_sample_fmt = dec->sample_fmt;
3247 st->discard= AVDISCARD_ALL;
3248 /* Note that av_find_stream_info can add more streams, and we
3249 * currently have no chance of setting up lowres decoding
3250 * early enough for them. */
3252 audio_sample_rate >>= dec->lowres;
3254 case AVMEDIA_TYPE_VIDEO:
3255 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3256 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]);
3257 frame_height = dec->height;
3258 frame_width = dec->width;
3259 if(ic->streams[i]->sample_aspect_ratio.num)
3260 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3262 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3263 frame_aspect_ratio *= (float) dec->width / dec->height;
3264 frame_pix_fmt = dec->pix_fmt;
3265 rfps = ic->streams[i]->r_frame_rate.num;
3266 rfps_base = ic->streams[i]->r_frame_rate.den;
3268 dec->flags |= CODEC_FLAG_EMU_EDGE;
3269 frame_height >>= dec->lowres;
3270 frame_width >>= dec->lowres;
3271 dec->height = frame_height;
3272 dec->width = frame_width;
3275 dec->debug |= FF_DEBUG_MV;
3277 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3280 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3281 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3283 (float)rfps / rfps_base, rfps, rfps_base);
3285 /* update the current frame rate to match the stream frame rate */
3286 frame_rate.num = rfps;
3287 frame_rate.den = rfps_base;
3290 st->discard= AVDISCARD_ALL;
3291 else if(video_discard)
3292 st->discard= video_discard;
3294 case AVMEDIA_TYPE_DATA:
3296 case AVMEDIA_TYPE_SUBTITLE:
3297 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3298 if(subtitle_disable)
3299 st->discard = AVDISCARD_ALL;
3301 case AVMEDIA_TYPE_ATTACHMENT:
3302 case AVMEDIA_TYPE_UNKNOWN:
3309 input_files[nb_input_files] = ic;
3310 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3311 /* dump the file content */
3313 av_dump_format(ic, nb_input_files, filename, 0);
3319 av_freep(&video_codec_name);
3320 av_freep(&audio_codec_name);
3321 av_freep(&subtitle_codec_name);
3324 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3325 int *has_subtitle_ptr)
3327 int has_video, has_audio, has_subtitle, i, j;
3328 AVFormatContext *ic;
3333 for(j=0;j<nb_input_files;j++) {
3334 ic = input_files[j];
3335 for(i=0;i<ic->nb_streams;i++) {
3336 AVCodecContext *enc = ic->streams[i]->codec;
3337 switch(enc->codec_type) {
3338 case AVMEDIA_TYPE_AUDIO:
3341 case AVMEDIA_TYPE_VIDEO:
3344 case AVMEDIA_TYPE_SUBTITLE:
3347 case AVMEDIA_TYPE_DATA:
3348 case AVMEDIA_TYPE_ATTACHMENT:
3349 case AVMEDIA_TYPE_UNKNOWN:
3356 *has_video_ptr = has_video;
3357 *has_audio_ptr = has_audio;
3358 *has_subtitle_ptr = has_subtitle;
3361 static void new_video_stream(AVFormatContext *oc, int file_idx)
3364 AVOutputStream *ost;
3365 AVCodecContext *video_enc;
3366 enum CodecID codec_id = CODEC_ID_NONE;
3367 AVCodec *codec= NULL;
3369 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3371 fprintf(stderr, "Could not alloc stream\n");
3374 ost = new_output_stream(oc, file_idx);
3376 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3377 if(!video_stream_copy){
3378 if (video_codec_name) {
3379 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3380 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3381 codec = avcodec_find_encoder_by_name(video_codec_name);
3382 output_codecs[nb_output_codecs-1] = codec;
3384 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3385 codec = avcodec_find_encoder(codec_id);
3389 avcodec_get_context_defaults3(st->codec, codec);
3390 ost->bitstream_filters = video_bitstream_filters;
3391 video_bitstream_filters= NULL;
3393 st->codec->thread_count= thread_count;
3395 video_enc = st->codec;
3398 video_enc->codec_tag= video_codec_tag;
3400 if( (video_global_header&1)
3401 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3402 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3403 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3405 if(video_global_header&2){
3406 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3407 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3410 if (video_stream_copy) {
3411 st->stream_copy = 1;
3412 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3413 video_enc->sample_aspect_ratio =
3414 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3418 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3420 video_enc->codec_id = codec_id;
3421 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3423 if (codec && codec->supported_framerates && !force_fps)
3424 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3425 video_enc->time_base.den = fps.num;
3426 video_enc->time_base.num = fps.den;
3428 video_enc->width = frame_width;
3429 video_enc->height = frame_height;
3430 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3431 video_enc->pix_fmt = frame_pix_fmt;
3432 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3434 choose_pixel_fmt(st, codec);
3437 video_enc->gop_size = 0;
3438 if (video_qscale || same_quality) {
3439 video_enc->flags |= CODEC_FLAG_QSCALE;
3440 video_enc->global_quality=
3441 st->quality = FF_QP2LAMBDA * video_qscale;
3445 video_enc->intra_matrix = intra_matrix;
3447 video_enc->inter_matrix = inter_matrix;
3449 p= video_rc_override_string;
3452 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3454 fprintf(stderr, "error parsing rc_override\n");
3457 video_enc->rc_override=
3458 av_realloc(video_enc->rc_override,
3459 sizeof(RcOverride)*(i+1));
3460 video_enc->rc_override[i].start_frame= start;
3461 video_enc->rc_override[i].end_frame = end;
3463 video_enc->rc_override[i].qscale= q;
3464 video_enc->rc_override[i].quality_factor= 1.0;
3467 video_enc->rc_override[i].qscale= 0;
3468 video_enc->rc_override[i].quality_factor= -q/100.0;
3473 video_enc->rc_override_count=i;
3474 if (!video_enc->rc_initial_buffer_occupancy)
3475 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3476 video_enc->me_threshold= me_threshold;
3477 video_enc->intra_dc_precision= intra_dc_precision - 8;
3480 video_enc->flags|= CODEC_FLAG_PSNR;
3485 video_enc->flags |= CODEC_FLAG_PASS1;
3487 video_enc->flags |= CODEC_FLAG_PASS2;
3491 if (forced_key_frames)
3492 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3494 if (video_language) {
3495 av_metadata_set2(&st->metadata, "language", video_language, 0);
3496 av_freep(&video_language);
3499 /* reset some key parameters */
3501 av_freep(&video_codec_name);
3502 av_freep(&forced_key_frames);
3503 video_stream_copy = 0;
3504 frame_pix_fmt = PIX_FMT_NONE;
3507 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3510 AVOutputStream *ost;
3511 AVCodec *codec= NULL;
3512 AVCodecContext *audio_enc;
3513 enum CodecID codec_id = CODEC_ID_NONE;
3515 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3517 fprintf(stderr, "Could not alloc stream\n");
3520 ost = new_output_stream(oc, file_idx);
3522 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3523 if(!audio_stream_copy){
3524 if (audio_codec_name) {
3525 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3526 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3527 codec = avcodec_find_encoder_by_name(audio_codec_name);
3528 output_codecs[nb_output_codecs-1] = codec;
3530 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3531 codec = avcodec_find_encoder(codec_id);
3535 avcodec_get_context_defaults3(st->codec, codec);
3537 ost->bitstream_filters = audio_bitstream_filters;
3538 audio_bitstream_filters= NULL;
3540 st->codec->thread_count= thread_count;
3542 audio_enc = st->codec;
3543 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3546 audio_enc->codec_tag= audio_codec_tag;
3548 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3549 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3550 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3552 if (audio_stream_copy) {
3553 st->stream_copy = 1;
3554 audio_enc->channels = audio_channels;
3555 audio_enc->sample_rate = audio_sample_rate;
3557 audio_enc->codec_id = codec_id;
3558 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3560 if (audio_qscale > QSCALE_NONE) {
3561 audio_enc->flags |= CODEC_FLAG_QSCALE;
3562 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3564 audio_enc->channels = audio_channels;
3565 audio_enc->sample_fmt = audio_sample_fmt;
3566 audio_enc->sample_rate = audio_sample_rate;
3567 audio_enc->channel_layout = channel_layout;
3568 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3569 audio_enc->channel_layout = 0;
3570 choose_sample_fmt(st, codec);
3571 choose_sample_rate(st, codec);
3573 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3574 if (audio_language) {
3575 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3576 av_freep(&audio_language);
3579 /* reset some key parameters */
3581 av_freep(&audio_codec_name);
3582 audio_stream_copy = 0;
3585 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3588 AVOutputStream *ost;
3589 AVCodec *codec=NULL;
3590 AVCodecContext *subtitle_enc;
3591 enum CodecID codec_id = CODEC_ID_NONE;
3593 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3595 fprintf(stderr, "Could not alloc stream\n");
3598 ost = new_output_stream(oc, file_idx);
3599 subtitle_enc = st->codec;
3600 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3601 if(!subtitle_stream_copy){
3602 if (subtitle_codec_name) {
3603 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3604 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3605 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3607 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3608 codec = avcodec_find_encoder(codec_id);
3611 avcodec_get_context_defaults3(st->codec, codec);
3613 ost->bitstream_filters = subtitle_bitstream_filters;
3614 subtitle_bitstream_filters= NULL;
3616 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3618 if(subtitle_codec_tag)
3619 subtitle_enc->codec_tag= subtitle_codec_tag;
3621 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3622 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3623 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3625 if (subtitle_stream_copy) {
3626 st->stream_copy = 1;
3628 subtitle_enc->codec_id = codec_id;
3629 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3632 if (subtitle_language) {
3633 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3634 av_freep(&subtitle_language);
3637 subtitle_disable = 0;
3638 av_freep(&subtitle_codec_name);
3639 subtitle_stream_copy = 0;
3642 static int opt_new_stream(const char *opt, const char *arg)
3644 AVFormatContext *oc;
3645 int file_idx = nb_output_files - 1;
3646 if (nb_output_files <= 0) {
3647 fprintf(stderr, "At least one output file must be specified\n");
3650 oc = output_files[file_idx];
3652 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3653 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3654 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3659 /* arg format is "output-stream-index:streamid-value". */
3660 static int opt_streamid(const char *opt, const char *arg)
3666 strncpy(idx_str, arg, sizeof(idx_str));
3667 idx_str[sizeof(idx_str)-1] = '\0';
3668 p = strchr(idx_str, ':');
3671 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3676 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3677 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3678 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3682 static void opt_output_file(const char *filename)
3684 AVFormatContext *oc;
3685 int err, use_video, use_audio, use_subtitle;
3686 int input_has_video, input_has_audio, input_has_subtitle;
3687 AVFormatParameters params, *ap = ¶ms;
3688 AVOutputFormat *file_oformat;
3690 if (!strcmp(filename, "-"))
3693 oc = avformat_alloc_context();
3695 print_error(filename, AVERROR(ENOMEM));
3699 if (last_asked_format) {
3700 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3701 if (!file_oformat) {
3702 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3705 last_asked_format = NULL;
3707 file_oformat = av_guess_format(NULL, filename, NULL);
3708 if (!file_oformat) {
3709 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3715 oc->oformat = file_oformat;
3716 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3718 if (!strcmp(file_oformat->name, "ffm") &&
3719 av_strstart(filename, "http:", NULL)) {
3720 /* special case for files sent to ffserver: we get the stream
3721 parameters from ffserver */
3722 int err = read_ffserver_streams(oc, filename);
3724 print_error(filename, err);
3728 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3729 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3730 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3732 /* disable if no corresponding type found and at least one
3734 if (nb_input_files > 0) {
3735 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3736 &input_has_subtitle);
3737 if (!input_has_video)
3739 if (!input_has_audio)
3741 if (!input_has_subtitle)
3745 /* manual disable */
3746 if (audio_disable) use_audio = 0;
3747 if (video_disable) use_video = 0;
3748 if (subtitle_disable) use_subtitle = 0;
3750 if (use_video) new_video_stream(oc, nb_output_files);
3751 if (use_audio) new_audio_stream(oc, nb_output_files);
3752 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3754 oc->timestamp = recording_timestamp;
3756 av_metadata_copy(&oc->metadata, metadata, 0);
3757 av_metadata_free(&metadata);
3760 output_files[nb_output_files++] = oc;
3762 /* check filename in case of an image number is expected */
3763 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3764 if (!av_filename_number_test(oc->filename)) {
3765 print_error(oc->filename, AVERROR_NUMEXPECTED);
3770 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3771 /* test if it already exists to avoid loosing precious files */
3772 if (!file_overwrite &&
3773 (strchr(filename, ':') == NULL ||
3774 filename[1] == ':' ||
3775 av_strstart(filename, "file:", NULL))) {
3776 if (url_exist(filename)) {
3778 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3780 if (!read_yesno()) {
3781 fprintf(stderr, "Not overwriting - exiting\n");
3786 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3793 if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3794 print_error(filename, err);
3799 memset(ap, 0, sizeof(*ap));
3800 if (av_set_parameters(oc, ap) < 0) {
3801 fprintf(stderr, "%s: Invalid encoding parameters\n",
3806 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3807 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3808 oc->loop_output = loop_output;
3809 oc->flags |= AVFMT_FLAG_NONBLOCK;
3811 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3813 av_freep(&forced_key_frames);
3816 /* same option as mencoder */
3817 static void opt_pass(const char *pass_str)
3820 pass = atoi(pass_str);
3821 if (pass != 1 && pass != 2) {
3822 fprintf(stderr, "pass number can be only 1 or 2\n");
3828 static int64_t getutime(void)
3831 struct rusage rusage;
3833 getrusage(RUSAGE_SELF, &rusage);
3834 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3835 #elif HAVE_GETPROCESSTIMES
3837 FILETIME c, e, k, u;
3838 proc = GetCurrentProcess();
3839 GetProcessTimes(proc, &c, &e, &k, &u);
3840 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3842 return av_gettime();
3846 static int64_t getmaxrss(void)
3848 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3849 struct rusage rusage;
3850 getrusage(RUSAGE_SELF, &rusage);
3851 return (int64_t)rusage.ru_maxrss * 1024;
3852 #elif HAVE_GETPROCESSMEMORYINFO
3854 PROCESS_MEMORY_COUNTERS memcounters;
3855 proc = GetCurrentProcess();
3856 memcounters.cb = sizeof(memcounters);
3857 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3858 return memcounters.PeakPagefileUsage;
3864 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3867 const char *p = str;
3874 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3881 static void opt_inter_matrix(const char *arg)
3883 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3884 parse_matrix_coeffs(inter_matrix, arg);
3887 static void opt_intra_matrix(const char *arg)
3889 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3890 parse_matrix_coeffs(intra_matrix, arg);
3893 static void show_usage(void)
3895 printf("Hyper fast Audio and Video encoder\n");
3896 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3900 static void show_help(void)
3903 AVOutputFormat *oformat = NULL;
3905 av_log_set_callback(log_callback_help);
3907 show_help_options(options, "Main options:\n",
3908 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3909 show_help_options(options, "\nAdvanced options:\n",
3910 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3912 show_help_options(options, "\nVideo options:\n",
3913 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3915 show_help_options(options, "\nAdvanced Video options:\n",
3916 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3917 OPT_VIDEO | OPT_EXPERT);
3918 show_help_options(options, "\nAudio options:\n",
3919 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3921 show_help_options(options, "\nAdvanced Audio options:\n",
3922 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3923 OPT_AUDIO | OPT_EXPERT);
3924 show_help_options(options, "\nSubtitle options:\n",
3925 OPT_SUBTITLE | OPT_GRAB,
3927 show_help_options(options, "\nAudio/Video grab options:\n",
3931 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3934 /* individual codec options */
3936 while ((c = av_codec_next(c))) {
3937 if (c->priv_class) {
3938 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3943 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3946 /* individual muxer options */
3947 while ((oformat = av_oformat_next(oformat))) {
3948 if (oformat->priv_class) {
3949 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3954 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3957 static void opt_target(const char *arg)
3959 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3960 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3962 if(!strncmp(arg, "pal-", 4)) {
3965 } else if(!strncmp(arg, "ntsc-", 5)) {
3968 } else if(!strncmp(arg, "film-", 5)) {
3973 /* Calculate FR via float to avoid int overflow */
3974 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3977 } else if((fr == 29970) || (fr == 23976)) {
3980 /* Try to determine PAL/NTSC by peeking in the input files */
3981 if(nb_input_files) {
3983 for(j = 0; j < nb_input_files; j++) {
3984 for(i = 0; i < input_files[j]->nb_streams; i++) {
3985 AVCodecContext *c = input_files[j]->streams[i]->codec;
3986 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3988 fr = c->time_base.den * 1000 / c->time_base.num;
3992 } else if((fr == 29970) || (fr == 23976)) {
4002 if(verbose && norm != UNKNOWN)
4003 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4006 if(norm == UNKNOWN) {
4007 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4008 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4009 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4013 if(!strcmp(arg, "vcd")) {
4015 opt_video_codec("mpeg1video");
4016 opt_audio_codec("mp2");
4019 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4020 opt_frame_rate(NULL, frame_rates[norm]);
4021 opt_default("g", norm == PAL ? "15" : "18");
4023 opt_default("b", "1150000");
4024 opt_default("maxrate", "1150000");
4025 opt_default("minrate", "1150000");
4026 opt_default("bufsize", "327680"); // 40*1024*8;
4028 opt_default("ab", "224000");
4029 audio_sample_rate = 44100;
4032 opt_default("packetsize", "2324");
4033 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4035 /* We have to offset the PTS, so that it is consistent with the SCR.
4036 SCR starts at 36000, but the first two packs contain only padding
4037 and the first pack from the other stream, respectively, may also have
4038 been written before.
4039 So the real data starts at SCR 36000+3*1200. */
4040 mux_preload= (36000+3*1200) / 90000.0; //0.44
4041 } else if(!strcmp(arg, "svcd")) {
4043 opt_video_codec("mpeg2video");
4044 opt_audio_codec("mp2");
4047 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4048 opt_frame_rate(NULL, frame_rates[norm]);
4049 opt_default("g", norm == PAL ? "15" : "18");
4051 opt_default("b", "2040000");
4052 opt_default("maxrate", "2516000");
4053 opt_default("minrate", "0"); //1145000;
4054 opt_default("bufsize", "1835008"); //224*1024*8;
4055 opt_default("flags", "+scan_offset");
4058 opt_default("ab", "224000");
4059 audio_sample_rate = 44100;
4061 opt_default("packetsize", "2324");
4063 } else if(!strcmp(arg, "dvd")) {
4065 opt_video_codec("mpeg2video");
4066 opt_audio_codec("ac3");
4069 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4070 opt_frame_rate(NULL, frame_rates[norm]);
4071 opt_default("g", norm == PAL ? "15" : "18");
4073 opt_default("b", "6000000");
4074 opt_default("maxrate", "9000000");
4075 opt_default("minrate", "0"); //1500000;
4076 opt_default("bufsize", "1835008"); //224*1024*8;
4078 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4079 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4081 opt_default("ab", "448000");
4082 audio_sample_rate = 48000;
4084 } else if(!strncmp(arg, "dv", 2)) {
4088 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4089 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4090 (norm == PAL ? "yuv420p" : "yuv411p"));
4091 opt_frame_rate(NULL, frame_rates[norm]);
4093 audio_sample_rate = 48000;
4097 fprintf(stderr, "Unknown target: %s\n", arg);
4102 static void opt_vstats_file (const char *arg)
4104 av_free (vstats_filename);
4105 vstats_filename=av_strdup (arg);
4108 static void opt_vstats (void)
4111 time_t today2 = time(NULL);
4112 struct tm *today = localtime(&today2);
4114 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4116 opt_vstats_file(filename);
4119 static int opt_bsf(const char *opt, const char *arg)
4121 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4122 AVBitStreamFilterContext **bsfp;
4125 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4129 bsfp= *opt == 'v' ? &video_bitstream_filters :
4130 *opt == 'a' ? &audio_bitstream_filters :
4131 &subtitle_bitstream_filters;
4133 bsfp= &(*bsfp)->next;
4140 static int opt_preset(const char *opt, const char *arg)
4143 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4144 char *codec_name = *opt == 'v' ? video_codec_name :
4145 *opt == 'a' ? audio_codec_name :
4146 subtitle_codec_name;
4148 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4149 fprintf(stderr, "File for preset '%s' not found\n", arg);
4154 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4155 if(line[0] == '#' && !e)
4157 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4159 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4162 if(!strcmp(tmp, "acodec")){
4163 opt_audio_codec(tmp2);
4164 }else if(!strcmp(tmp, "vcodec")){
4165 opt_video_codec(tmp2);
4166 }else if(!strcmp(tmp, "scodec")){
4167 opt_subtitle_codec(tmp2);
4168 }else if(opt_default(tmp, tmp2) < 0){
4169 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4179 static const OptionDef options[] = {
4181 #include "cmdutils_common_opts.h"
4182 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4183 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4184 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4185 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4186 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4187 "outfile[,metadata]:infile[,metadata]" },
4188 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4189 "outfile[,metadata]:infile[,metadata]" },
4190 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4191 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4192 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4193 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4194 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4195 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4196 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4197 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4198 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4199 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4200 "add timings for benchmarking" },
4201 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4202 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4203 "dump each input packet" },
4204 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4205 "when dumping packets, also dump the payload" },
4206 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4207 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4208 { "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)", "" },
4209 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4210 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4211 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4212 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4213 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4214 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4215 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4216 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4217 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4218 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4219 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4220 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4221 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4222 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4225 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4226 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4227 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4228 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4229 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4230 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4231 { "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" },
4232 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4233 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4234 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4235 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4236 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4237 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4238 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4239 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4240 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4241 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4242 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4243 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4244 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4245 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4246 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4247 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4248 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4249 "use same video quality as source (implies VBR)" },
4250 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4251 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4252 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4253 "deinterlace pictures" },
4254 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4255 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4256 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4258 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4260 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4261 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4262 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4263 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4264 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4265 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4266 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4267 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4268 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4269 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4270 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4273 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4274 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4275 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4276 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4277 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4278 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4279 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4280 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4281 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4282 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4283 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4284 { "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" },
4286 /* subtitle options */
4287 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4288 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4289 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4290 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4291 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4294 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4295 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4296 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4299 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4300 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4302 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4303 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4304 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4306 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4307 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4308 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4309 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4311 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4315 int main(int argc, char **argv)
4319 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4321 avcodec_register_all();
4323 avdevice_register_all();
4326 avfilter_register_all();
4331 if(isatty(STDIN_FILENO))
4332 url_set_interrupt_cb(decode_interrupt_cb);
4340 parse_options(argc, argv, options, opt_output_file);
4342 if(nb_output_files <= 0 && nb_input_files == 0) {
4344 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4348 /* file converter / grab */
4349 if (nb_output_files <= 0) {
4350 fprintf(stderr, "At least one output file must be specified\n");
4354 if (nb_input_files == 0) {
4355 fprintf(stderr, "At least one input file must be specified\n");
4360 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4361 stream_maps, nb_stream_maps) < 0)
4363 ti = getutime() - ti;
4365 int maxrss = getmaxrss() / 1024;
4366 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4369 return ffmpeg_exit(0);