3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/libm.h"
45 #include "libavformat/os_support.h"
48 # include "libavfilter/avfilter.h"
49 # include "libavfilter/avfiltergraph.h"
50 # include "libavfilter/vsrc_buffer.h"
53 #if HAVE_SYS_RESOURCE_H
54 #include <sys/types.h>
56 #include <sys/resource.h>
57 #elif HAVE_GETPROCESSTIMES
60 #if HAVE_GETPROCESSMEMORYINFO
66 #include <sys/select.h>
73 #include "libavutil/avassert.h"
75 const char program_name[] = "ffmpeg";
76 const int program_birth_year = 2000;
78 /* select an input stream for an output stream */
79 typedef struct AVStreamMap {
83 int sync_stream_index;
87 * select an input file for an output file
89 typedef struct AVMetaDataMap {
90 int file; //< file index
91 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
92 int index; //< stream/chapter/program number
95 typedef struct AVChapterMap {
100 static const OptionDef options[];
102 #define MAX_FILES 100
103 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
105 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
107 static const char *last_asked_format = NULL;
108 static int64_t input_files_ts_offset[MAX_FILES];
109 static double *input_files_ts_scale[MAX_FILES] = {NULL};
110 static AVCodec **input_codecs = NULL;
111 static int nb_input_codecs = 0;
112 static int nb_input_files_ts_scale[MAX_FILES] = {0};
114 static AVFormatContext *output_files[MAX_FILES];
115 static AVCodec **output_codecs = NULL;
116 static int nb_output_files = 0;
117 static int nb_output_codecs = 0;
119 static AVStreamMap *stream_maps = NULL;
120 static int nb_stream_maps;
122 /* first item specifies output metadata, second is input */
123 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
124 static int nb_meta_data_maps;
125 static int metadata_global_autocopy = 1;
126 static int metadata_streams_autocopy = 1;
127 static int metadata_chapters_autocopy = 1;
129 static AVChapterMap *chapter_maps = NULL;
130 static int nb_chapter_maps;
132 /* indexed by output file stream index */
133 static int *streamid_map = NULL;
134 static int nb_streamid_map = 0;
136 static int frame_width = 0;
137 static int frame_height = 0;
138 static float frame_aspect_ratio = 0;
139 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
140 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
141 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
142 static AVRational frame_rate;
143 static float video_qscale = 0;
144 static uint16_t *intra_matrix = NULL;
145 static uint16_t *inter_matrix = NULL;
146 static const char *video_rc_override_string=NULL;
147 static int video_disable = 0;
148 static int video_discard = 0;
149 static char *video_codec_name = NULL;
150 static unsigned int video_codec_tag = 0;
151 static char *video_language = NULL;
152 static int same_quality = 0;
153 static int do_deinterlace = 0;
154 static int top_field_first = -1;
155 static int me_threshold = 0;
156 static int intra_dc_precision = 8;
157 static int loop_input = 0;
158 static int loop_output = AVFMT_NOOUTPUTLOOP;
159 static int qp_hist = 0;
161 static char *vfilters = NULL;
164 static int intra_only = 0;
165 static int audio_sample_rate = 44100;
166 static int64_t channel_layout = 0;
167 #define QSCALE_NONE -99999
168 static float audio_qscale = QSCALE_NONE;
169 static int audio_disable = 0;
170 static int audio_channels = 1;
171 static char *audio_codec_name = NULL;
172 static unsigned int audio_codec_tag = 0;
173 static char *audio_language = NULL;
175 static int subtitle_disable = 0;
176 static char *subtitle_codec_name = NULL;
177 static char *subtitle_language = NULL;
178 static unsigned int subtitle_codec_tag = 0;
180 static int data_disable = 0;
181 static char *data_codec_name = NULL;
182 static unsigned int data_codec_tag = 0;
184 static float mux_preload= 0.5;
185 static float mux_max_delay= 0.7;
187 static int64_t recording_time = INT64_MAX;
188 static int64_t start_time = 0;
189 static int64_t recording_timestamp = 0;
190 static int64_t input_ts_offset = 0;
191 static int file_overwrite = 0;
192 static AVMetadata *metadata;
193 static int do_benchmark = 0;
194 static int do_hex_dump = 0;
195 static int do_pkt_dump = 0;
196 static int do_psnr = 0;
197 static int do_pass = 0;
198 static char *pass_logfilename_prefix = NULL;
199 static int audio_stream_copy = 0;
200 static int video_stream_copy = 0;
201 static int subtitle_stream_copy = 0;
202 static int data_stream_copy = 0;
203 static int video_sync_method= -1;
204 static int audio_sync_method= 0;
205 static float audio_drift_threshold= 0.1;
206 static int copy_ts= 0;
208 static int opt_shortest = 0;
209 static char *vstats_filename;
210 static FILE *vstats_file;
211 static int opt_programid = 0;
212 static int copy_initial_nonkeyframes = 0;
214 static int rate_emu = 0;
216 static int video_channel = 0;
217 static char *video_standard;
219 static int audio_volume = 256;
221 static int exit_on_error = 0;
222 static int using_stdin = 0;
223 static int verbose = 1;
224 static int thread_count= 1;
225 static int64_t video_size = 0;
226 static int64_t audio_size = 0;
227 static int64_t extra_size = 0;
228 static int nb_frames_dup = 0;
229 static int nb_frames_drop = 0;
230 static int input_sync;
231 static uint64_t limit_filesize = 0;
232 static int force_fps = 0;
233 static char *forced_key_frames = NULL;
235 static float dts_delta_threshold = 10;
237 static int64_t timer_start;
239 static uint8_t *audio_buf;
240 static uint8_t *audio_out;
241 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
243 static short *samples;
245 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
246 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
247 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
249 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
251 struct AVInputStream;
253 typedef struct AVOutputStream {
254 int file_index; /* file index */
255 int index; /* stream index in the output file */
256 int source_index; /* AVInputStream index */
257 AVStream *st; /* stream in the output file */
258 int encoding_needed; /* true if encoding needed for this stream */
260 /* input pts and corresponding output pts
262 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
263 struct AVInputStream *sync_ist; /* input stream to sync against */
264 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
265 AVBitStreamFilterContext *bitstream_filters;
268 AVFrame pict_tmp; /* temporary image for resampling */
269 struct SwsContext *img_resample_ctx; /* for image resampling */
272 int resample_pix_fmt;
274 float frame_aspect_ratio;
276 /* forced key frames */
277 int64_t *forced_kf_pts;
283 ReSampleContext *resample; /* for audio resampling */
284 int resample_sample_fmt;
285 int resample_channels;
286 int resample_sample_rate;
288 AVAudioConvert *reformat_ctx;
289 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
293 AVFilterContext *output_video_filter;
294 AVFilterContext *input_video_filter;
295 AVFilterBufferRef *picref;
297 AVFilterGraph *graph;
303 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
304 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
306 typedef struct AVInputStream {
309 int discard; /* true if stream data should be discarded */
310 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
311 int64_t sample_index; /* current sample */
313 int64_t start; /* time when read started */
314 int64_t next_pts; /* synthetic pts for cases where pkt.pts
316 int64_t pts; /* current pts */
317 PtsCorrectionContext pts_ctx;
318 int is_start; /* is 1 at the start and after a discontinuity */
319 int showed_multi_packet_warning;
320 int is_past_recording_time;
322 AVFrame *filter_frame;
323 int has_filter_frame;
327 typedef struct AVInputFile {
328 AVFormatContext *ctx;
329 int eof_reached; /* true if eof reached */
330 int ist_index; /* index of first stream in ist_table */
331 int buffer_size; /* current total buffer size */
334 static AVInputStream *input_streams = NULL;
335 static int nb_input_streams = 0;
336 static AVInputFile *input_files = NULL;
337 static int nb_input_files = 0;
341 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
343 AVFilterContext *last_filter, *filter;
344 /** filter graph containing all filters including input & output */
345 AVCodecContext *codec = ost->st->codec;
346 AVCodecContext *icodec = ist->st->codec;
347 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
348 AVRational sample_aspect_ratio;
352 ost->graph = avfilter_graph_alloc();
354 if (ist->st->sample_aspect_ratio.num){
355 sample_aspect_ratio = ist->st->sample_aspect_ratio;
357 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
359 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
360 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
361 sample_aspect_ratio.num, sample_aspect_ratio.den);
363 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
364 "src", args, NULL, ost->graph);
367 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
368 "out", NULL, &ffsink_ctx, ost->graph);
371 last_filter = ost->input_video_filter;
373 if (codec->width != icodec->width || codec->height != icodec->height) {
374 snprintf(args, 255, "%d:%d:flags=0x%X",
378 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
379 NULL, args, NULL, ost->graph)) < 0)
381 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
383 last_filter = filter;
386 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
387 ost->graph->scale_sws_opts = av_strdup(args);
390 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
391 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
393 outputs->name = av_strdup("in");
394 outputs->filter_ctx = last_filter;
395 outputs->pad_idx = 0;
396 outputs->next = NULL;
398 inputs->name = av_strdup("out");
399 inputs->filter_ctx = ost->output_video_filter;
403 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
405 av_freep(&ost->avfilter);
407 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
411 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
414 codec->width = ost->output_video_filter->inputs[0]->w;
415 codec->height = ost->output_video_filter->inputs[0]->h;
416 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
417 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
418 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
419 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
423 #endif /* CONFIG_AVFILTER */
425 static void term_exit(void)
427 av_log(NULL, AV_LOG_QUIET, "");
430 static volatile int received_sigterm = 0;
431 static volatile int received_nb_signals = 0;
434 sigterm_handler(int sig)
436 received_sigterm = sig;
437 received_nb_signals++;
441 static void term_init(void)
443 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
444 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
446 signal(SIGXCPU, sigterm_handler);
450 static int decode_interrupt_cb(void)
452 return received_nb_signals > 1;
455 static int ffmpeg_exit(int ret)
460 for(i=0;i<nb_output_files;i++) {
461 AVFormatContext *s = output_files[i];
462 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
464 avformat_free_context(s);
465 av_free(output_streams_for_file[i]);
467 for(i=0;i<nb_input_files;i++) {
468 av_close_input_file(input_files[i].ctx);
469 av_free(input_files_ts_scale[i]);
472 av_free(intra_matrix);
473 av_free(inter_matrix);
477 av_free(vstats_filename);
479 av_free(streamid_map);
480 av_free(input_codecs);
481 av_free(output_codecs);
482 av_free(stream_maps);
483 av_free(meta_data_maps);
485 av_freep(&input_streams);
486 av_freep(&input_files);
488 av_free(video_codec_name);
489 av_free(audio_codec_name);
490 av_free(subtitle_codec_name);
491 av_free(data_codec_name);
493 av_free(video_standard);
498 allocated_audio_buf_size= allocated_audio_out_size= 0;
505 if (received_sigterm) {
507 "Received signal %d: terminating.\n",
508 (int) received_sigterm);
512 exit(ret); /* not all OS-es handle main() return value */
516 /* similar to ff_dynarray_add() and av_fast_realloc() */
517 static void *grow_array(void *array, int elem_size, int *size, int new_size)
519 if (new_size >= INT_MAX / elem_size) {
520 fprintf(stderr, "Array too big.\n");
523 if (*size < new_size) {
524 uint8_t *tmp = av_realloc(array, new_size*elem_size);
526 fprintf(stderr, "Could not alloc buffer.\n");
529 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
536 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
538 if(codec && codec->sample_fmts){
539 const enum AVSampleFormat *p= codec->sample_fmts;
541 if(*p == st->codec->sample_fmt)
545 av_log(NULL, AV_LOG_WARNING,
546 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
547 av_get_sample_fmt_name(st->codec->sample_fmt),
549 av_get_sample_fmt_name(codec->sample_fmts[0]));
550 st->codec->sample_fmt = codec->sample_fmts[0];
556 * Update the requested input sample format based on the output sample format.
557 * This is currently only used to request float output from decoders which
558 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
559 * Ideally this will be removed in the future when decoders do not do format
560 * conversion and only output in their native format.
562 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
565 /* if sample formats match or a decoder sample format has already been
566 requested, just return */
567 if (enc->sample_fmt == dec->sample_fmt ||
568 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
571 /* if decoder supports more than one output format */
572 if (dec_codec && dec_codec->sample_fmts &&
573 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
574 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
575 enum AVSampleFormat *p;
576 int min_dec = -1, min_inc = -1;
578 /* find a matching sample format in the encoder */
579 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
580 if (*p == enc->sample_fmt) {
581 dec->request_sample_fmt = *p;
583 } else if (*p > enc->sample_fmt) {
584 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
586 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
589 /* if none match, provide the one that matches quality closest */
590 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
591 enc->sample_fmt - min_dec;
595 static void choose_sample_rate(AVStream *st, AVCodec *codec)
597 if(codec && codec->supported_samplerates){
598 const int *p= codec->supported_samplerates;
600 int best_dist=INT_MAX;
602 int dist= abs(st->codec->sample_rate - *p);
603 if(dist < best_dist){
609 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
611 st->codec->sample_rate= best;
615 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
617 if(codec && codec->pix_fmts){
618 const enum PixelFormat *p= codec->pix_fmts;
619 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
620 if(st->codec->codec_id==CODEC_ID_MJPEG){
621 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
622 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
623 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};
627 if(*p == st->codec->pix_fmt)
631 if(st->codec->pix_fmt != PIX_FMT_NONE)
632 av_log(NULL, AV_LOG_WARNING,
633 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
634 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
636 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
637 st->codec->pix_fmt = codec->pix_fmts[0];
642 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
644 int idx = oc->nb_streams - 1;
647 output_streams_for_file[file_idx] =
648 grow_array(output_streams_for_file[file_idx],
649 sizeof(*output_streams_for_file[file_idx]),
650 &nb_output_streams_for_file[file_idx],
652 ost = output_streams_for_file[file_idx][idx] =
653 av_mallocz(sizeof(AVOutputStream));
655 fprintf(stderr, "Could not alloc output stream\n");
658 ost->file_index = file_idx;
661 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
665 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
671 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
674 /* copy stream format */
676 s->streams = av_mallocz(sizeof(AVStream *) * ic->nb_streams);
677 for(i=0;i<ic->nb_streams;i++) {
683 // FIXME: a more elegant solution is needed
684 st = av_mallocz(sizeof(AVStream));
685 memcpy(st, ic->streams[i], sizeof(AVStream));
686 st->codec = avcodec_alloc_context();
688 print_error(filename, AVERROR(ENOMEM));
691 avcodec_copy_context(st->codec, ic->streams[i]->codec);
694 codec = avcodec_find_encoder(st->codec->codec_id);
695 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
696 if (audio_stream_copy) {
699 choose_sample_fmt(st, codec);
700 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
701 if (video_stream_copy) {
704 choose_pixel_fmt(st, codec);
707 if(st->codec->flags & CODEC_FLAG_BITEXACT)
710 new_output_stream(s, nb_output_files);
714 s->timestamp = av_gettime();
716 av_close_input_file(ic);
721 get_sync_ipts(const AVOutputStream *ost)
723 const AVInputStream *ist = ost->sync_ist;
724 return (double)(ist->pts - start_time)/AV_TIME_BASE;
727 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
731 AVPacket new_pkt= *pkt;
732 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
733 &new_pkt.data, &new_pkt.size,
734 pkt->data, pkt->size,
735 pkt->flags & AV_PKT_FLAG_KEY);
738 new_pkt.destruct= av_destruct_packet;
740 fprintf(stderr, "%s failed for stream %d, codec %s",
741 bsfc->filter->name, pkt->stream_index,
742 avctx->codec ? avctx->codec->name : "copy");
752 ret= av_interleaved_write_frame(s, pkt);
754 print_error("av_interleaved_write_frame()", ret);
759 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
761 static void do_audio_out(AVFormatContext *s,
764 unsigned char *buf, int size)
767 int64_t audio_out_size, audio_buf_size;
768 int64_t allocated_for_size= size;
770 int size_out, frame_bytes, ret, resample_changed;
771 AVCodecContext *enc= ost->st->codec;
772 AVCodecContext *dec= ist->st->codec;
773 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
774 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
775 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
778 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
779 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
780 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
781 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
782 audio_buf_size*= osize*enc->channels;
784 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
785 if(coded_bps > 8*osize)
786 audio_out_size= audio_out_size * coded_bps / (8*osize);
787 audio_out_size += FF_MIN_BUFFER_SIZE;
789 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
790 fprintf(stderr, "Buffer sizes too large\n");
794 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
795 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
796 if (!audio_buf || !audio_out){
797 fprintf(stderr, "Out of memory in do_audio_out\n");
801 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
802 ost->audio_resample = 1;
804 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
805 ost->resample_channels != dec->channels ||
806 ost->resample_sample_rate != dec->sample_rate;
808 if ((ost->audio_resample && !ost->resample) || resample_changed) {
809 if (resample_changed) {
810 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",
811 ist->file_index, ist->st->index,
812 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
813 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
814 ost->resample_sample_fmt = dec->sample_fmt;
815 ost->resample_channels = dec->channels;
816 ost->resample_sample_rate = dec->sample_rate;
818 audio_resample_close(ost->resample);
820 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
821 if (audio_sync_method <= 1 &&
822 ost->resample_sample_fmt == enc->sample_fmt &&
823 ost->resample_channels == enc->channels &&
824 ost->resample_sample_rate == enc->sample_rate) {
825 ost->resample = NULL;
826 ost->audio_resample = 0;
827 } else if (ost->audio_resample) {
828 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
829 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
830 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
831 enc->sample_rate, dec->sample_rate,
832 enc->sample_fmt, dec->sample_fmt,
834 if (!ost->resample) {
835 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
836 dec->channels, dec->sample_rate,
837 enc->channels, enc->sample_rate);
843 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
844 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
845 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
846 if (ost->reformat_ctx)
847 av_audio_convert_free(ost->reformat_ctx);
848 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
849 dec->sample_fmt, 1, NULL, 0);
850 if (!ost->reformat_ctx) {
851 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
852 av_get_sample_fmt_name(dec->sample_fmt),
853 av_get_sample_fmt_name(enc->sample_fmt));
856 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
859 if(audio_sync_method){
860 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
861 - av_fifo_size(ost->fifo)/(enc->channels * 2);
862 double idelta= delta*dec->sample_rate / enc->sample_rate;
863 int byte_delta= ((int)idelta)*2*dec->channels;
865 //FIXME resample delay
866 if(fabs(delta) > 50){
867 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
869 byte_delta= FFMAX(byte_delta, -size);
873 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
878 static uint8_t *input_tmp= NULL;
879 input_tmp= av_realloc(input_tmp, byte_delta + size);
881 if(byte_delta > allocated_for_size - size){
882 allocated_for_size= byte_delta + (int64_t)size;
887 memset(input_tmp, 0, byte_delta);
888 memcpy(input_tmp + byte_delta, buf, size);
892 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
894 }else if(audio_sync_method>1){
895 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
896 av_assert0(ost->audio_resample);
898 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
899 // 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));
900 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
904 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
905 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
907 if (ost->audio_resample) {
909 size_out = audio_resample(ost->resample,
910 (short *)buftmp, (short *)buf,
911 size / (dec->channels * isize));
912 size_out = size_out * enc->channels * osize;
918 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
919 const void *ibuf[6]= {buftmp};
920 void *obuf[6]= {audio_buf};
921 int istride[6]= {isize};
922 int ostride[6]= {osize};
923 int len= size_out/istride[0];
924 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
925 printf("av_audio_convert() failed\n");
931 size_out = len*osize;
934 /* now encode as many frames as possible */
935 if (enc->frame_size > 1) {
936 /* output resampled raw samples */
937 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
938 fprintf(stderr, "av_fifo_realloc2() failed\n");
941 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
943 frame_bytes = enc->frame_size * osize * enc->channels;
945 while (av_fifo_size(ost->fifo) >= frame_bytes) {
947 av_init_packet(&pkt);
949 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
951 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
953 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
956 fprintf(stderr, "Audio encoding failed\n");
960 pkt.stream_index= ost->index;
963 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
964 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
965 pkt.flags |= AV_PKT_FLAG_KEY;
966 write_frame(s, &pkt, enc, ost->bitstream_filters);
968 ost->sync_opts += enc->frame_size;
972 av_init_packet(&pkt);
974 ost->sync_opts += size_out / (osize * enc->channels);
976 /* output a pcm frame */
977 /* determine the size of the coded buffer */
980 size_out = size_out*coded_bps/8;
982 if(size_out > audio_out_size){
983 fprintf(stderr, "Internal error, buffer size too small\n");
987 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
988 ret = avcodec_encode_audio(enc, audio_out, size_out,
991 fprintf(stderr, "Audio encoding failed\n");
995 pkt.stream_index= ost->index;
998 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
999 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1000 pkt.flags |= AV_PKT_FLAG_KEY;
1001 write_frame(s, &pkt, enc, ost->bitstream_filters);
1005 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1007 AVCodecContext *dec;
1008 AVPicture *picture2;
1009 AVPicture picture_tmp;
1012 dec = ist->st->codec;
1014 /* deinterlace : must be done before any resize */
1015 if (do_deinterlace) {
1018 /* create temporary picture */
1019 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1020 buf = av_malloc(size);
1024 picture2 = &picture_tmp;
1025 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1027 if(avpicture_deinterlace(picture2, picture,
1028 dec->pix_fmt, dec->width, dec->height) < 0) {
1029 /* if error, do not deinterlace */
1030 fprintf(stderr, "Deinterlacing failed\n");
1039 if (picture != picture2)
1040 *picture = *picture2;
1044 /* we begin to correct av delay at this threshold */
1045 #define AV_DELAY_MAX 0.100
1047 static void do_subtitle_out(AVFormatContext *s,
1048 AVOutputStream *ost,
1053 static uint8_t *subtitle_out = NULL;
1054 int subtitle_out_max_size = 1024 * 1024;
1055 int subtitle_out_size, nb, i;
1056 AVCodecContext *enc;
1059 if (pts == AV_NOPTS_VALUE) {
1060 fprintf(stderr, "Subtitle packets must have a pts\n");
1066 enc = ost->st->codec;
1068 if (!subtitle_out) {
1069 subtitle_out = av_malloc(subtitle_out_max_size);
1072 /* Note: DVB subtitle need one packet to draw them and one other
1073 packet to clear them */
1074 /* XXX: signal it in the codec context ? */
1075 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1080 for(i = 0; i < nb; i++) {
1081 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1082 // start_display_time is required to be 0
1083 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1084 sub->end_display_time -= sub->start_display_time;
1085 sub->start_display_time = 0;
1086 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1087 subtitle_out_max_size, sub);
1088 if (subtitle_out_size < 0) {
1089 fprintf(stderr, "Subtitle encoding failed\n");
1093 av_init_packet(&pkt);
1094 pkt.stream_index = ost->index;
1095 pkt.data = subtitle_out;
1096 pkt.size = subtitle_out_size;
1097 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1098 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1099 /* XXX: the pts correction is handled here. Maybe handling
1100 it in the codec would be better */
1102 pkt.pts += 90 * sub->start_display_time;
1104 pkt.pts += 90 * sub->end_display_time;
1106 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1110 static int bit_buffer_size= 1024*256;
1111 static uint8_t *bit_buffer= NULL;
1113 static void do_video_out(AVFormatContext *s,
1114 AVOutputStream *ost,
1116 AVFrame *in_picture,
1119 int nb_frames, i, ret, resample_changed;
1120 AVFrame *final_picture, *formatted_picture;
1121 AVCodecContext *enc, *dec;
1124 enc = ost->st->codec;
1125 dec = ist->st->codec;
1127 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1129 /* by default, we output a single frame */
1134 if(video_sync_method){
1135 double vdelta = sync_ipts - ost->sync_opts;
1136 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1139 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1142 }else if(vdelta>0.6)
1143 ost->sync_opts= lrintf(sync_ipts);
1144 }else if (vdelta > 1.1)
1145 nb_frames = lrintf(vdelta);
1146 //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);
1147 if (nb_frames == 0){
1150 fprintf(stderr, "*** drop!\n");
1151 }else if (nb_frames > 1) {
1152 nb_frames_dup += nb_frames - 1;
1154 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1157 ost->sync_opts= lrintf(sync_ipts);
1159 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1163 formatted_picture = in_picture;
1164 final_picture = formatted_picture;
1166 resample_changed = ost->resample_width != dec->width ||
1167 ost->resample_height != dec->height ||
1168 ost->resample_pix_fmt != dec->pix_fmt;
1170 if (resample_changed) {
1171 av_log(NULL, AV_LOG_INFO,
1172 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1173 ist->file_index, ist->st->index,
1174 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1175 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1176 if(!ost->video_resample)
1180 #if !CONFIG_AVFILTER
1181 if (ost->video_resample) {
1182 final_picture = &ost->pict_tmp;
1183 if (resample_changed) {
1184 /* initialize a new scaler context */
1185 sws_freeContext(ost->img_resample_ctx);
1186 ost->img_resample_ctx = sws_getContext(
1187 ist->st->codec->width,
1188 ist->st->codec->height,
1189 ist->st->codec->pix_fmt,
1190 ost->st->codec->width,
1191 ost->st->codec->height,
1192 ost->st->codec->pix_fmt,
1193 ost->sws_flags, NULL, NULL, NULL);
1194 if (ost->img_resample_ctx == NULL) {
1195 fprintf(stderr, "Cannot get resampling context\n");
1199 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1200 0, ost->resample_height, final_picture->data, final_picture->linesize);
1204 /* duplicates frame if needed */
1205 for(i=0;i<nb_frames;i++) {
1207 av_init_packet(&pkt);
1208 pkt.stream_index= ost->index;
1210 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1211 /* raw pictures are written as AVPicture structure to
1212 avoid any copies. We support temorarily the older
1214 AVFrame* old_frame = enc->coded_frame;
1215 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1216 pkt.data= (uint8_t *)final_picture;
1217 pkt.size= sizeof(AVPicture);
1218 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1219 pkt.flags |= AV_PKT_FLAG_KEY;
1221 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1222 enc->coded_frame = old_frame;
1224 AVFrame big_picture;
1226 big_picture= *final_picture;
1227 /* better than nothing: use input picture interlaced
1229 big_picture.interlaced_frame = in_picture->interlaced_frame;
1230 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1231 if(top_field_first == -1)
1232 big_picture.top_field_first = in_picture->top_field_first;
1234 big_picture.top_field_first = top_field_first;
1237 /* handles sameq here. This is not correct because it may
1238 not be a global option */
1239 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1241 big_picture.pict_type = 0;
1242 // big_picture.pts = AV_NOPTS_VALUE;
1243 big_picture.pts= ost->sync_opts;
1244 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1245 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1246 if (ost->forced_kf_index < ost->forced_kf_count &&
1247 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1248 big_picture.pict_type = AV_PICTURE_TYPE_I;
1249 ost->forced_kf_index++;
1251 ret = avcodec_encode_video(enc,
1252 bit_buffer, bit_buffer_size,
1255 fprintf(stderr, "Video encoding failed\n");
1260 pkt.data= bit_buffer;
1262 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1263 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1264 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1265 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1266 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1268 if(enc->coded_frame->key_frame)
1269 pkt.flags |= AV_PKT_FLAG_KEY;
1270 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1273 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1274 // enc->frame_number-1, ret, enc->pict_type);
1275 /* if two pass, output log */
1276 if (ost->logfile && enc->stats_out) {
1277 fprintf(ost->logfile, "%s", enc->stats_out);
1282 ost->frame_number++;
1286 static double psnr(double d){
1287 return -10.0*log(d)/log(10.0);
1290 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1293 AVCodecContext *enc;
1295 double ti1, bitrate, avg_bitrate;
1297 /* this is executed just the first time do_video_stats is called */
1299 vstats_file = fopen(vstats_filename, "w");
1306 enc = ost->st->codec;
1307 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1308 frame_number = ost->frame_number;
1309 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1310 if (enc->flags&CODEC_FLAG_PSNR)
1311 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1313 fprintf(vstats_file,"f_size= %6d ", frame_size);
1314 /* compute pts value */
1315 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1319 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1320 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1321 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1322 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1323 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1327 static void print_report(AVFormatContext **output_files,
1328 AVOutputStream **ost_table, int nb_ostreams,
1332 AVOutputStream *ost;
1333 AVFormatContext *oc;
1335 AVCodecContext *enc;
1336 int frame_number, vid, i;
1337 double bitrate, ti1, pts;
1338 static int64_t last_time = -1;
1339 static int qp_histogram[52];
1341 if (!is_last_report) {
1343 /* display the report every 0.5 seconds */
1344 cur_time = av_gettime();
1345 if (last_time == -1) {
1346 last_time = cur_time;
1349 if ((cur_time - last_time) < 500000)
1351 last_time = cur_time;
1355 oc = output_files[0];
1357 total_size = avio_size(oc->pb);
1358 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1359 total_size= avio_tell(oc->pb);
1364 for(i=0;i<nb_ostreams;i++) {
1367 enc = ost->st->codec;
1368 if (!ost->st->stream_copy && enc->coded_frame)
1369 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1370 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1371 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1373 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1374 float t = (av_gettime()-timer_start) / 1000000.0;
1376 frame_number = ost->frame_number;
1377 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1378 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1380 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1384 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1389 if (enc->flags&CODEC_FLAG_PSNR){
1391 double error, error_sum=0;
1392 double scale, scale_sum=0;
1393 char type[3]= {'Y','U','V'};
1394 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1397 error= enc->error[j];
1398 scale= enc->width*enc->height*255.0*255.0*frame_number;
1400 error= enc->coded_frame->error[j];
1401 scale= enc->width*enc->height*255.0*255.0;
1406 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1408 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1412 /* compute min output value */
1413 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1414 if ((pts < ti1) && (pts > 0))
1420 if (verbose > 0 || is_last_report) {
1421 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1423 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1424 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1425 (double)total_size / 1024, ti1, bitrate);
1427 if (nb_frames_dup || nb_frames_drop)
1428 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1429 nb_frames_dup, nb_frames_drop);
1432 fprintf(stderr, "%s \r", buf);
1437 if (is_last_report && verbose >= 0){
1438 int64_t raw= audio_size + video_size + extra_size;
1439 fprintf(stderr, "\n");
1440 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1444 100.0*(total_size - raw)/raw
1449 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1451 int fill_char = 0x00;
1452 if (sample_fmt == AV_SAMPLE_FMT_U8)
1454 memset(buf, fill_char, size);
1457 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1458 static int output_packet(AVInputStream *ist, int ist_index,
1459 AVOutputStream **ost_table, int nb_ostreams,
1460 const AVPacket *pkt)
1462 AVFormatContext *os;
1463 AVOutputStream *ost;
1467 void *buffer_to_free = NULL;
1468 static unsigned int samples_size= 0;
1469 AVSubtitle subtitle, *subtitle_to_free;
1470 int64_t pkt_pts = AV_NOPTS_VALUE;
1472 int frame_available;
1476 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1478 if(ist->next_pts == AV_NOPTS_VALUE)
1479 ist->next_pts= ist->pts;
1483 av_init_packet(&avpkt);
1491 if(pkt->dts != AV_NOPTS_VALUE)
1492 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1493 if(pkt->pts != AV_NOPTS_VALUE)
1494 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1496 //while we have more to decode or while the decoder did output something on EOF
1497 while (avpkt.size > 0 || (!pkt && got_output)) {
1498 uint8_t *data_buf, *decoded_data_buf;
1499 int data_size, decoded_data_size;
1501 ist->pts= ist->next_pts;
1503 if(avpkt.size && avpkt.size != pkt->size &&
1504 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1505 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1506 ist->showed_multi_packet_warning=1;
1509 /* decode the packet if needed */
1510 decoded_data_buf = NULL; /* fail safe */
1511 decoded_data_size= 0;
1512 data_buf = avpkt.data;
1513 data_size = avpkt.size;
1514 subtitle_to_free = NULL;
1515 if (ist->decoding_needed) {
1516 switch(ist->st->codec->codec_type) {
1517 case AVMEDIA_TYPE_AUDIO:{
1518 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1519 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1521 samples= av_malloc(samples_size);
1523 decoded_data_size= samples_size;
1524 /* XXX: could avoid copy if PCM 16 bits with same
1525 endianness as CPU */
1526 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1533 got_output = decoded_data_size > 0;
1534 /* Some bug in mpeg audio decoder gives */
1535 /* decoded_data_size < 0, it seems they are overflows */
1537 /* no audio frame */
1540 decoded_data_buf = (uint8_t *)samples;
1541 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1542 (ist->st->codec->sample_rate * ist->st->codec->channels);
1544 case AVMEDIA_TYPE_VIDEO:
1545 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1546 /* XXX: allocate picture correctly */
1547 avcodec_get_frame_defaults(&picture);
1548 avpkt.pts = pkt_pts;
1549 avpkt.dts = ist->pts;
1550 pkt_pts = AV_NOPTS_VALUE;
1552 ret = avcodec_decode_video2(ist->st->codec,
1553 &picture, &got_output, &avpkt);
1554 ist->st->quality= picture.quality;
1558 /* no picture yet */
1559 goto discard_packet;
1561 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1562 if (ist->st->codec->time_base.num != 0) {
1563 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1564 ist->next_pts += ((int64_t)AV_TIME_BASE *
1565 ist->st->codec->time_base.num * ticks) /
1566 ist->st->codec->time_base.den;
1569 buffer_to_free = NULL;
1570 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1572 case AVMEDIA_TYPE_SUBTITLE:
1573 ret = avcodec_decode_subtitle2(ist->st->codec,
1574 &subtitle, &got_output, &avpkt);
1578 goto discard_packet;
1580 subtitle_to_free = &subtitle;
1587 switch(ist->st->codec->codec_type) {
1588 case AVMEDIA_TYPE_AUDIO:
1589 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1590 ist->st->codec->sample_rate;
1592 case AVMEDIA_TYPE_VIDEO:
1593 if (ist->st->codec->time_base.num != 0) {
1594 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1595 ist->next_pts += ((int64_t)AV_TIME_BASE *
1596 ist->st->codec->time_base.num * ticks) /
1597 ist->st->codec->time_base.den;
1606 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1607 for (i = 0; i < nb_ostreams; i++) {
1609 if (ost->input_video_filter && ost->source_index == ist_index) {
1611 if (ist->st->sample_aspect_ratio.num)
1612 sar = ist->st->sample_aspect_ratio;
1614 sar = ist->st->codec->sample_aspect_ratio;
1615 // add it to be filtered
1616 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1624 // preprocess audio (volume)
1625 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1626 if (audio_volume != 256) {
1629 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1630 int v = ((*volp) * audio_volume + 128) >> 8;
1631 if (v < -32768) v = -32768;
1632 if (v > 32767) v = 32767;
1638 /* frame rate emulation */
1640 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1641 int64_t now = av_gettime() - ist->start;
1645 /* if output time reached then transcode raw format,
1646 encode packets and output them */
1647 if (start_time == 0 || ist->pts >= start_time)
1648 for(i=0;i<nb_ostreams;i++) {
1652 if (ost->source_index == ist_index) {
1654 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1655 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1656 while (frame_available) {
1657 AVRational ist_pts_tb;
1658 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1659 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1661 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1663 os = output_files[ost->file_index];
1665 /* set the input output pts pairs */
1666 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1668 if (ost->encoding_needed) {
1669 av_assert0(ist->decoding_needed);
1670 switch(ost->st->codec->codec_type) {
1671 case AVMEDIA_TYPE_AUDIO:
1672 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1674 case AVMEDIA_TYPE_VIDEO:
1676 if (ost->picref->video && !ost->frame_aspect_ratio)
1677 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1679 do_video_out(os, ost, ist, &picture, &frame_size);
1680 if (vstats_filename && frame_size)
1681 do_video_stats(os, ost, frame_size);
1683 case AVMEDIA_TYPE_SUBTITLE:
1684 do_subtitle_out(os, ost, ist, &subtitle,
1691 AVFrame avframe; //FIXME/XXX remove this
1693 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1695 av_init_packet(&opkt);
1697 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1698 #if !CONFIG_AVFILTER
1704 /* no reencoding needed : output the packet directly */
1705 /* force the input stream PTS */
1707 avcodec_get_frame_defaults(&avframe);
1708 ost->st->codec->coded_frame= &avframe;
1709 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1711 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1712 audio_size += data_size;
1713 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1714 video_size += data_size;
1718 opkt.stream_index= ost->index;
1719 if(pkt->pts != AV_NOPTS_VALUE)
1720 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1722 opkt.pts= AV_NOPTS_VALUE;
1724 if (pkt->dts == AV_NOPTS_VALUE)
1725 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1727 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1728 opkt.dts -= ost_tb_start_time;
1730 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1731 opkt.flags= pkt->flags;
1733 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1734 if( ost->st->codec->codec_id != CODEC_ID_H264
1735 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1736 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1738 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1739 opkt.destruct= av_destruct_packet;
1741 opkt.data = data_buf;
1742 opkt.size = data_size;
1745 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1746 ost->st->codec->frame_number++;
1747 ost->frame_number++;
1748 av_free_packet(&opkt);
1752 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1753 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1755 avfilter_unref_buffer(ost->picref);
1761 av_free(buffer_to_free);
1762 /* XXX: allocate the subtitles in the codec ? */
1763 if (subtitle_to_free) {
1764 avsubtitle_free(subtitle_to_free);
1765 subtitle_to_free = NULL;
1772 for(i=0;i<nb_ostreams;i++) {
1774 if (ost->source_index == ist_index) {
1775 AVCodecContext *enc= ost->st->codec;
1776 os = output_files[ost->file_index];
1778 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1780 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1783 if (ost->encoding_needed) {
1787 av_init_packet(&pkt);
1788 pkt.stream_index= ost->index;
1790 switch(ost->st->codec->codec_type) {
1791 case AVMEDIA_TYPE_AUDIO:
1792 fifo_bytes = av_fifo_size(ost->fifo);
1794 /* encode any samples remaining in fifo */
1795 if (fifo_bytes > 0) {
1796 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1797 int fs_tmp = enc->frame_size;
1799 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1800 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1801 enc->frame_size = fifo_bytes / (osize * enc->channels);
1803 int frame_bytes = enc->frame_size*osize*enc->channels;
1804 if (allocated_audio_buf_size < frame_bytes)
1806 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1809 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1810 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1811 ost->st->time_base.num, enc->sample_rate);
1812 enc->frame_size = fs_tmp;
1815 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1818 fprintf(stderr, "Audio encoding failed\n");
1822 pkt.flags |= AV_PKT_FLAG_KEY;
1824 case AVMEDIA_TYPE_VIDEO:
1825 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1827 fprintf(stderr, "Video encoding failed\n");
1831 if(enc->coded_frame && enc->coded_frame->key_frame)
1832 pkt.flags |= AV_PKT_FLAG_KEY;
1833 if (ost->logfile && enc->stats_out) {
1834 fprintf(ost->logfile, "%s", enc->stats_out);
1843 pkt.data= bit_buffer;
1845 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1846 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1847 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1859 static void print_sdp(AVFormatContext **avc, int n)
1863 av_sdp_create(avc, n, sdp, sizeof(sdp));
1864 printf("SDP:\n%s\n", sdp);
1868 static int copy_chapters(int infile, int outfile)
1870 AVFormatContext *is = input_files[infile].ctx;
1871 AVFormatContext *os = output_files[outfile];
1874 for (i = 0; i < is->nb_chapters; i++) {
1875 AVChapter *in_ch = is->chapters[i], *out_ch;
1876 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1877 AV_TIME_BASE_Q, in_ch->time_base);
1878 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1879 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1882 if (in_ch->end < ts_off)
1884 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1887 out_ch = av_mallocz(sizeof(AVChapter));
1889 return AVERROR(ENOMEM);
1891 out_ch->id = in_ch->id;
1892 out_ch->time_base = in_ch->time_base;
1893 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1894 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1896 if (metadata_chapters_autocopy)
1897 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1900 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1902 return AVERROR(ENOMEM);
1903 os->chapters[os->nb_chapters - 1] = out_ch;
1908 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1909 AVCodecContext *avctx)
1915 for (p = kf; *p; p++)
1918 ost->forced_kf_count = n;
1919 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1920 if (!ost->forced_kf_pts) {
1921 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1924 for (i = 0; i < n; i++) {
1925 p = i ? strchr(p, ',') + 1 : kf;
1926 t = parse_time_or_die("force_key_frames", p, 1);
1927 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1932 * The following code is the main loop of the file converter
1934 static int transcode(AVFormatContext **output_files,
1935 int nb_output_files,
1936 AVInputFile *input_files,
1938 AVStreamMap *stream_maps, int nb_stream_maps)
1940 int ret = 0, i, j, k, n, nb_ostreams = 0;
1941 AVFormatContext *is, *os;
1942 AVCodecContext *codec, *icodec;
1943 AVOutputStream *ost, **ost_table = NULL;
1947 uint8_t no_packet[MAX_FILES]={0};
1948 int no_packet_count=0;
1951 for (i = 0; i < nb_input_streams; i++)
1952 input_streams[i].start = av_gettime();
1954 /* output stream init */
1956 for(i=0;i<nb_output_files;i++) {
1957 os = output_files[i];
1958 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1959 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1960 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1961 ret = AVERROR(EINVAL);
1964 nb_ostreams += os->nb_streams;
1966 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1967 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1968 ret = AVERROR(EINVAL);
1972 /* Sanity check the mapping args -- do the input files & streams exist? */
1973 for(i=0;i<nb_stream_maps;i++) {
1974 int fi = stream_maps[i].file_index;
1975 int si = stream_maps[i].stream_index;
1977 if (fi < 0 || fi > nb_input_files - 1 ||
1978 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1979 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1980 ret = AVERROR(EINVAL);
1983 fi = stream_maps[i].sync_file_index;
1984 si = stream_maps[i].sync_stream_index;
1985 if (fi < 0 || fi > nb_input_files - 1 ||
1986 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1987 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1988 ret = AVERROR(EINVAL);
1993 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1997 for(k=0;k<nb_output_files;k++) {
1998 os = output_files[k];
1999 for(i=0;i<os->nb_streams;i++,n++) {
2001 ost = ost_table[n] = output_streams_for_file[k][i];
2002 ost->st = os->streams[i];
2003 if (nb_stream_maps > 0) {
2004 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2005 stream_maps[n].stream_index;
2007 /* Sanity check that the stream types match */
2008 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2009 int i= ost->file_index;
2010 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2011 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2012 stream_maps[n].file_index, stream_maps[n].stream_index,
2013 ost->file_index, ost->index);
2018 int best_nb_frames=-1;
2019 /* get corresponding input stream index : we select the first one with the right type */
2021 for (j = 0; j < nb_input_streams; j++) {
2023 ist = &input_streams[j];
2026 AVFormatContext *f = input_files[ist->file_index].ctx;
2028 for(pi=0; pi<f->nb_programs; pi++){
2029 AVProgram *p= f->programs[pi];
2030 if(p->id == opt_programid)
2031 for(si=0; si<p->nb_stream_indexes; si++){
2032 if(f->streams[ p->stream_index[si] ] == ist->st)
2037 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2038 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2039 if(best_nb_frames < ist->st->codec_info_nb_frames){
2040 best_nb_frames= ist->st->codec_info_nb_frames;
2041 ost->source_index = j;
2048 if(! opt_programid) {
2049 /* try again and reuse existing stream */
2050 for (j = 0; j < nb_input_streams; j++) {
2051 ist = &input_streams[j];
2052 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2053 && ist->st->discard != AVDISCARD_ALL) {
2054 ost->source_index = j;
2060 int i= ost->file_index;
2061 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2062 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2063 ost->file_index, ost->index);
2068 ist = &input_streams[ost->source_index];
2070 ost->sync_ist = (nb_stream_maps > 0) ?
2071 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2072 stream_maps[n].sync_stream_index] : ist;
2076 /* for each output stream, we compute the right encoding parameters */
2077 for(i=0;i<nb_ostreams;i++) {
2079 os = output_files[ost->file_index];
2080 ist = &input_streams[ost->source_index];
2082 codec = ost->st->codec;
2083 icodec = ist->st->codec;
2085 if (metadata_streams_autocopy)
2086 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2087 AV_METADATA_DONT_OVERWRITE);
2089 ost->st->disposition = ist->st->disposition;
2090 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2091 codec->chroma_sample_location = icodec->chroma_sample_location;
2093 if (ost->st->stream_copy) {
2094 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2096 if (extra_size > INT_MAX)
2099 /* if stream_copy is selected, no need to decode or encode */
2100 codec->codec_id = icodec->codec_id;
2101 codec->codec_type = icodec->codec_type;
2103 if(!codec->codec_tag){
2104 if( !os->oformat->codec_tag
2105 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2106 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2107 codec->codec_tag = icodec->codec_tag;
2110 codec->bit_rate = icodec->bit_rate;
2111 codec->rc_max_rate = icodec->rc_max_rate;
2112 codec->rc_buffer_size = icodec->rc_buffer_size;
2113 codec->extradata= av_mallocz(extra_size);
2114 if (!codec->extradata)
2116 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2117 codec->extradata_size= icodec->extradata_size;
2118 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){
2119 codec->time_base = icodec->time_base;
2120 codec->time_base.num *= icodec->ticks_per_frame;
2121 av_reduce(&codec->time_base.num, &codec->time_base.den,
2122 codec->time_base.num, codec->time_base.den, INT_MAX);
2124 codec->time_base = ist->st->time_base;
2125 switch(codec->codec_type) {
2126 case AVMEDIA_TYPE_AUDIO:
2127 if(audio_volume != 256) {
2128 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2131 codec->channel_layout = icodec->channel_layout;
2132 codec->sample_rate = icodec->sample_rate;
2133 codec->channels = icodec->channels;
2134 codec->frame_size = icodec->frame_size;
2135 codec->audio_service_type = icodec->audio_service_type;
2136 codec->block_align= icodec->block_align;
2137 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2138 codec->block_align= 0;
2139 if(codec->codec_id == CODEC_ID_AC3)
2140 codec->block_align= 0;
2142 case AVMEDIA_TYPE_VIDEO:
2143 codec->pix_fmt = icodec->pix_fmt;
2144 codec->width = icodec->width;
2145 codec->height = icodec->height;
2146 codec->has_b_frames = icodec->has_b_frames;
2147 if (!codec->sample_aspect_ratio.num) {
2148 codec->sample_aspect_ratio =
2149 ost->st->sample_aspect_ratio =
2150 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2151 ist->st->codec->sample_aspect_ratio.num ?
2152 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2155 case AVMEDIA_TYPE_SUBTITLE:
2156 codec->width = icodec->width;
2157 codec->height = icodec->height;
2159 case AVMEDIA_TYPE_DATA:
2165 switch(codec->codec_type) {
2166 case AVMEDIA_TYPE_AUDIO:
2167 ost->fifo= av_fifo_alloc(1024);
2170 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2171 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2172 icodec->request_channels = codec->channels;
2173 ist->decoding_needed = 1;
2174 ost->encoding_needed = 1;
2175 ost->resample_sample_fmt = icodec->sample_fmt;
2176 ost->resample_sample_rate = icodec->sample_rate;
2177 ost->resample_channels = icodec->channels;
2179 case AVMEDIA_TYPE_VIDEO:
2180 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2181 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2184 ost->video_resample = codec->width != icodec->width ||
2185 codec->height != icodec->height ||
2186 codec->pix_fmt != icodec->pix_fmt;
2187 if (ost->video_resample) {
2188 #if !CONFIG_AVFILTER
2189 avcodec_get_frame_defaults(&ost->pict_tmp);
2190 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2191 codec->width, codec->height)) {
2192 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2195 ost->img_resample_ctx = sws_getContext(
2202 ost->sws_flags, NULL, NULL, NULL);
2203 if (ost->img_resample_ctx == NULL) {
2204 fprintf(stderr, "Cannot get resampling context\n");
2208 codec->bits_per_raw_sample= 0;
2210 ost->resample_height = icodec->height;
2211 ost->resample_width = icodec->width;
2212 ost->resample_pix_fmt= icodec->pix_fmt;
2213 ost->encoding_needed = 1;
2214 ist->decoding_needed = 1;
2217 if (configure_video_filters(ist, ost)) {
2218 fprintf(stderr, "Error opening filters!\n");
2223 case AVMEDIA_TYPE_SUBTITLE:
2224 ost->encoding_needed = 1;
2225 ist->decoding_needed = 1;
2232 if (ost->encoding_needed &&
2233 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2234 char logfilename[1024];
2237 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2238 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2240 if (codec->flags & CODEC_FLAG_PASS1) {
2241 f = fopen(logfilename, "wb");
2243 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2249 size_t logbuffer_size;
2250 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2251 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2254 codec->stats_in = logbuffer;
2258 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2259 int size= codec->width * codec->height;
2260 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2265 bit_buffer = av_malloc(bit_buffer_size);
2267 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2269 ret = AVERROR(ENOMEM);
2273 /* open each encoder */
2274 for(i=0;i<nb_ostreams;i++) {
2276 if (ost->encoding_needed) {
2277 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2278 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2280 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2282 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2283 ost->st->codec->codec_id, ost->file_index, ost->index);
2284 ret = AVERROR(EINVAL);
2287 if (dec->subtitle_header) {
2288 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2289 if (!ost->st->codec->subtitle_header) {
2290 ret = AVERROR(ENOMEM);
2293 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2294 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2296 if (avcodec_open(ost->st->codec, codec) < 0) {
2297 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2298 ost->file_index, ost->index);
2299 ret = AVERROR(EINVAL);
2302 extra_size += ost->st->codec->extradata_size;
2306 /* open each decoder */
2307 for (i = 0; i < nb_input_streams; i++) {
2308 ist = &input_streams[i];
2309 if (ist->decoding_needed) {
2310 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2312 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2314 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2315 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2316 ret = AVERROR(EINVAL);
2320 /* update requested sample format for the decoder based on the
2321 corresponding encoder sample format */
2322 for (j = 0; j < nb_ostreams; j++) {
2324 if (ost->source_index == i) {
2325 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2330 if (avcodec_open(ist->st->codec, codec) < 0) {
2331 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2332 ist->file_index, ist->st->index);
2333 ret = AVERROR(EINVAL);
2336 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2337 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2342 for (i = 0; i < nb_input_streams; i++) {
2344 ist = &input_streams[i];
2346 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2347 ist->next_pts = AV_NOPTS_VALUE;
2348 init_pts_correction(&ist->pts_ctx);
2352 /* set meta data information from input file if required */
2353 for (i=0;i<nb_meta_data_maps;i++) {
2354 AVFormatContext *files[2];
2355 AVMetadata **meta[2];
2358 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2359 if ((index) < 0 || (index) >= (nb_elems)) {\
2360 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2362 ret = AVERROR(EINVAL);\
2366 int out_file_index = meta_data_maps[i][0].file;
2367 int in_file_index = meta_data_maps[i][1].file;
2368 if (in_file_index < 0 || out_file_index < 0)
2370 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2371 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2373 files[0] = output_files[out_file_index];
2374 files[1] = input_files[in_file_index].ctx;
2376 for (j = 0; j < 2; j++) {
2377 AVMetaDataMap *map = &meta_data_maps[i][j];
2379 switch (map->type) {
2381 meta[j] = &files[j]->metadata;
2384 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2385 meta[j] = &files[j]->streams[map->index]->metadata;
2388 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2389 meta[j] = &files[j]->chapters[map->index]->metadata;
2392 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2393 meta[j] = &files[j]->programs[map->index]->metadata;
2398 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2401 /* copy global metadata by default */
2402 if (metadata_global_autocopy) {
2404 for (i = 0; i < nb_output_files; i++)
2405 av_metadata_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2406 AV_METADATA_DONT_OVERWRITE);
2409 /* copy chapters according to chapter maps */
2410 for (i = 0; i < nb_chapter_maps; i++) {
2411 int infile = chapter_maps[i].in_file;
2412 int outfile = chapter_maps[i].out_file;
2414 if (infile < 0 || outfile < 0)
2416 if (infile >= nb_input_files) {
2417 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2418 ret = AVERROR(EINVAL);
2421 if (outfile >= nb_output_files) {
2422 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2423 ret = AVERROR(EINVAL);
2426 copy_chapters(infile, outfile);
2429 /* copy chapters from the first input file that has them*/
2430 if (!nb_chapter_maps)
2431 for (i = 0; i < nb_input_files; i++) {
2432 if (!input_files[i].ctx->nb_chapters)
2435 for (j = 0; j < nb_output_files; j++)
2436 if ((ret = copy_chapters(i, j)) < 0)
2441 /* open files and write file headers */
2442 for(i=0;i<nb_output_files;i++) {
2443 os = output_files[i];
2444 if (av_write_header(os) < 0) {
2445 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2446 ret = AVERROR(EINVAL);
2449 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2455 /* dump the file output parameters - cannot be done before in case
2457 for(i=0;i<nb_output_files;i++) {
2458 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2461 /* dump the stream mapping */
2463 fprintf(stderr, "Stream mapping:\n");
2464 for(i=0;i<nb_ostreams;i++) {
2466 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2467 input_streams[ost->source_index].file_index,
2468 input_streams[ost->source_index].st->index,
2471 if (ost->sync_ist != &input_streams[ost->source_index])
2472 fprintf(stderr, " [sync #%d.%d]",
2473 ost->sync_ist->file_index,
2474 ost->sync_ist->st->index);
2475 fprintf(stderr, "\n");
2480 fprintf(stderr, "%s\n", error);
2485 print_sdp(output_files, nb_output_files);
2489 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2492 timer_start = av_gettime();
2494 for(; received_sigterm == 0;) {
2495 int file_index, ist_index;
2504 /* select the stream that we must read now by looking at the
2505 smallest output pts */
2507 for(i=0;i<nb_ostreams;i++) {
2510 os = output_files[ost->file_index];
2511 ist = &input_streams[ost->source_index];
2512 if(ist->is_past_recording_time || no_packet[ist->file_index])
2514 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2515 ipts = (double)ist->pts;
2516 if (!input_files[ist->file_index].eof_reached){
2517 if(ipts < ipts_min) {
2519 if(input_sync ) file_index = ist->file_index;
2521 if(opts < opts_min) {
2523 if(!input_sync) file_index = ist->file_index;
2526 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2531 /* if none, if is finished */
2532 if (file_index < 0) {
2533 if(no_packet_count){
2535 memset(no_packet, 0, sizeof(no_packet));
2542 /* finish if limit size exhausted */
2543 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2546 /* read a frame from it and output it in the fifo */
2547 is = input_files[file_index].ctx;
2548 ret= av_read_frame(is, &pkt);
2549 if(ret == AVERROR(EAGAIN)){
2550 no_packet[file_index]=1;
2555 input_files[file_index].eof_reached = 1;
2563 memset(no_packet, 0, sizeof(no_packet));
2566 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2567 is->streams[pkt.stream_index]);
2569 /* the following test is needed in case new streams appear
2570 dynamically in stream : we ignore them */
2571 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2572 goto discard_packet;
2573 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2574 ist = &input_streams[ist_index];
2576 goto discard_packet;
2578 if (pkt.dts != AV_NOPTS_VALUE)
2579 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2580 if (pkt.pts != AV_NOPTS_VALUE)
2581 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2583 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2584 && input_files_ts_scale[file_index][pkt.stream_index]){
2585 if(pkt.pts != AV_NOPTS_VALUE)
2586 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2587 if(pkt.dts != AV_NOPTS_VALUE)
2588 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2591 // 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);
2592 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2593 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2594 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2595 int64_t delta= pkt_dts - ist->next_pts;
2596 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2597 input_files_ts_offset[ist->file_index]-= delta;
2599 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2600 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2601 if(pkt.pts != AV_NOPTS_VALUE)
2602 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2606 /* finish if recording time exhausted */
2607 if (recording_time != INT64_MAX &&
2608 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2609 ist->is_past_recording_time = 1;
2610 goto discard_packet;
2613 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2614 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2617 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2618 ist->file_index, ist->st->index);
2621 av_free_packet(&pkt);
2626 av_free_packet(&pkt);
2628 /* dump report by using the output first video and audio streams */
2629 print_report(output_files, ost_table, nb_ostreams, 0);
2632 /* at the end of stream, we must flush the decoder buffers */
2633 for (i = 0; i < nb_input_streams; i++) {
2634 ist = &input_streams[i];
2635 if (ist->decoding_needed) {
2636 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2642 /* write the trailer if needed and close file */
2643 for(i=0;i<nb_output_files;i++) {
2644 os = output_files[i];
2645 av_write_trailer(os);
2648 /* dump report by using the first video and audio streams */
2649 print_report(output_files, ost_table, nb_ostreams, 1);
2651 /* close each encoder */
2652 for(i=0;i<nb_ostreams;i++) {
2654 if (ost->encoding_needed) {
2655 av_freep(&ost->st->codec->stats_in);
2656 avcodec_close(ost->st->codec);
2659 avfilter_graph_free(&ost->graph);
2663 /* close each decoder */
2664 for (i = 0; i < nb_input_streams; i++) {
2665 ist = &input_streams[i];
2666 if (ist->decoding_needed) {
2667 avcodec_close(ist->st->codec);
2675 av_freep(&bit_buffer);
2678 for(i=0;i<nb_ostreams;i++) {
2681 if (ost->st->stream_copy)
2682 av_freep(&ost->st->codec->extradata);
2684 fclose(ost->logfile);
2685 ost->logfile = NULL;
2687 av_fifo_free(ost->fifo); /* works even if fifo is not
2688 initialized but set to zero */
2689 av_freep(&ost->st->codec->subtitle_header);
2690 av_free(ost->pict_tmp.data[0]);
2691 av_free(ost->forced_kf_pts);
2692 if (ost->video_resample)
2693 sws_freeContext(ost->img_resample_ctx);
2695 audio_resample_close(ost->resample);
2696 if (ost->reformat_ctx)
2697 av_audio_convert_free(ost->reformat_ctx);
2706 static int opt_format(const char *opt, const char *arg)
2708 last_asked_format = arg;
2712 static int opt_video_rc_override_string(const char *opt, const char *arg)
2714 video_rc_override_string = arg;
2718 static int opt_me_threshold(const char *opt, const char *arg)
2720 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2724 static int opt_verbose(const char *opt, const char *arg)
2726 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2730 static int opt_frame_rate(const char *opt, const char *arg)
2732 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2733 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2739 static int opt_bitrate(const char *opt, const char *arg)
2741 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2743 opt_default(opt, arg);
2745 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2746 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2751 static int opt_frame_crop(const char *opt, const char *arg)
2753 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2754 return AVERROR(EINVAL);
2757 static int opt_frame_size(const char *opt, const char *arg)
2759 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2760 fprintf(stderr, "Incorrect frame size\n");
2761 return AVERROR(EINVAL);
2766 static int opt_pad(const char *opt, const char *arg) {
2767 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2771 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2773 if (strcmp(arg, "list")) {
2774 frame_pix_fmt = av_get_pix_fmt(arg);
2775 if (frame_pix_fmt == PIX_FMT_NONE) {
2776 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2777 return AVERROR(EINVAL);
2786 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2793 p = strchr(arg, ':');
2795 x = strtol(arg, &end, 10);
2797 y = strtol(end+1, &end, 10);
2799 ar = (double)x / (double)y;
2801 ar = strtod(arg, NULL);
2804 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2805 return AVERROR(EINVAL);
2807 frame_aspect_ratio = ar;
2811 static int opt_metadata(const char *opt, const char *arg)
2813 char *mid= strchr(arg, '=');
2816 fprintf(stderr, "Missing =\n");
2821 av_metadata_set2(&metadata, arg, mid, 0);
2826 static int opt_qscale(const char *opt, const char *arg)
2828 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2829 if (video_qscale == 0) {
2830 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2831 return AVERROR(EINVAL);
2836 static int opt_top_field_first(const char *opt, const char *arg)
2838 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2842 static int opt_thread_count(const char *opt, const char *arg)
2844 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2847 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2852 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2854 if (strcmp(arg, "list")) {
2855 audio_sample_fmt = av_get_sample_fmt(arg);
2856 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2857 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2858 return AVERROR(EINVAL);
2863 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2864 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2870 static int opt_audio_rate(const char *opt, const char *arg)
2872 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2876 static int opt_audio_channels(const char *opt, const char *arg)
2878 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2882 static int opt_video_channel(const char *opt, const char *arg)
2884 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2888 static int opt_video_standard(const char *opt, const char *arg)
2890 video_standard = av_strdup(arg);
2894 static int opt_codec(int *pstream_copy, char **pcodec_name,
2895 int codec_type, const char *arg)
2897 av_freep(pcodec_name);
2898 if (!strcmp(arg, "copy")) {
2901 *pcodec_name = av_strdup(arg);
2906 static int opt_audio_codec(const char *opt, const char *arg)
2908 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2911 static int opt_video_codec(const char *opt, const char *arg)
2913 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2916 static int opt_subtitle_codec(const char *opt, const char *arg)
2918 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2921 static int opt_data_codec(const char *opt, const char *arg)
2923 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2926 static int opt_codec_tag(const char *opt, const char *arg)
2929 uint32_t *codec_tag;
2931 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2932 !strcmp(opt, "vtag") ? &video_codec_tag :
2933 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2937 *codec_tag = strtol(arg, &tail, 0);
2939 *codec_tag = AV_RL32(arg);
2944 static int opt_map(const char *opt, const char *arg)
2949 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2950 m = &stream_maps[nb_stream_maps-1];
2952 m->file_index = strtol(arg, &p, 0);
2956 m->stream_index = strtol(p, &p, 0);
2959 m->sync_file_index = strtol(p, &p, 0);
2962 m->sync_stream_index = strtol(p, &p, 0);
2964 m->sync_file_index = m->file_index;
2965 m->sync_stream_index = m->stream_index;
2970 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2981 *index = strtol(++arg, endptr, 0);
2984 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2991 static int opt_map_metadata(const char *opt, const char *arg)
2993 AVMetaDataMap *m, *m1;
2996 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2997 &nb_meta_data_maps, nb_meta_data_maps + 1);
2999 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3000 m->file = strtol(arg, &p, 0);
3001 parse_meta_type(p, &m->type, &m->index, &p);
3005 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3006 m1->file = strtol(p, &p, 0);
3007 parse_meta_type(p, &m1->type, &m1->index, &p);
3009 if (m->type == 'g' || m1->type == 'g')
3010 metadata_global_autocopy = 0;
3011 if (m->type == 's' || m1->type == 's')
3012 metadata_streams_autocopy = 0;
3013 if (m->type == 'c' || m1->type == 'c')
3014 metadata_chapters_autocopy = 0;
3019 static int opt_map_meta_data(const char *opt, const char *arg)
3021 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3022 "Use -map_metadata instead.\n");
3023 return opt_map_metadata(opt, arg);
3026 static int opt_map_chapters(const char *opt, const char *arg)
3031 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3032 nb_chapter_maps + 1);
3033 c = &chapter_maps[nb_chapter_maps - 1];
3034 c->out_file = strtol(arg, &p, 0);
3038 c->in_file = strtol(p, &p, 0);
3042 static int opt_input_ts_scale(const char *opt, const char *arg)
3044 unsigned int stream;
3048 stream = strtol(arg, &p, 0);
3051 scale= strtod(p, &p);
3053 if(stream >= MAX_STREAMS)
3056 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);
3057 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 int opt_input_file(const char *opt, 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 /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3207 for (i = 0; i < ic->nb_streams; i++) {
3208 AVCodecContext *dec = ic->streams[i]->codec;
3209 switch (dec->codec_type) {
3210 case AVMEDIA_TYPE_AUDIO:
3211 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3212 AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3215 case AVMEDIA_TYPE_VIDEO:
3216 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3217 AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3223 /* If not enough info to get the stream parameters, we decode the
3224 first frames to get it. (used in mpeg case for example) */
3225 ret = av_find_stream_info(ic);
3226 if (ret < 0 && verbose >= 0) {
3227 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3228 av_close_input_file(ic);
3232 timestamp = start_time;
3233 /* add the stream start time */
3234 if (ic->start_time != AV_NOPTS_VALUE)
3235 timestamp += ic->start_time;
3237 /* if seeking requested, we execute it */
3238 if (start_time != 0) {
3239 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3241 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3242 filename, (double)timestamp / AV_TIME_BASE);
3244 /* reset seek info */
3248 /* update the current parameters so that they match the one of the input stream */
3249 for(i=0;i<ic->nb_streams;i++) {
3250 AVStream *st = ic->streams[i];
3251 AVCodecContext *dec = st->codec;
3254 dec->thread_count = thread_count;
3255 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3257 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3258 ist = &input_streams[nb_input_streams - 1];
3260 ist->file_index = nb_input_files;
3263 switch (dec->codec_type) {
3264 case AVMEDIA_TYPE_AUDIO:
3265 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3266 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]);
3267 channel_layout = dec->channel_layout;
3268 audio_channels = dec->channels;
3269 audio_sample_rate = dec->sample_rate;
3270 audio_sample_fmt = dec->sample_fmt;
3272 st->discard= AVDISCARD_ALL;
3273 /* Note that av_find_stream_info can add more streams, and we
3274 * currently have no chance of setting up lowres decoding
3275 * early enough for them. */
3277 audio_sample_rate >>= dec->lowres;
3279 case AVMEDIA_TYPE_VIDEO:
3280 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3281 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]);
3282 frame_height = dec->height;
3283 frame_width = dec->width;
3284 frame_pix_fmt = dec->pix_fmt;
3285 rfps = ic->streams[i]->r_frame_rate.num;
3286 rfps_base = ic->streams[i]->r_frame_rate.den;
3288 dec->flags |= CODEC_FLAG_EMU_EDGE;
3289 frame_height >>= dec->lowres;
3290 frame_width >>= dec->lowres;
3291 dec->height = frame_height;
3292 dec->width = frame_width;
3295 dec->debug |= FF_DEBUG_MV;
3297 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3300 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3301 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3303 (float)rfps / rfps_base, rfps, rfps_base);
3305 /* update the current frame rate to match the stream frame rate */
3306 frame_rate.num = rfps;
3307 frame_rate.den = rfps_base;
3310 st->discard= AVDISCARD_ALL;
3311 else if(video_discard)
3312 st->discard= video_discard;
3314 case AVMEDIA_TYPE_DATA:
3316 case AVMEDIA_TYPE_SUBTITLE:
3317 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3318 if(subtitle_disable)
3319 st->discard = AVDISCARD_ALL;
3321 case AVMEDIA_TYPE_ATTACHMENT:
3322 case AVMEDIA_TYPE_UNKNOWN:
3329 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3330 /* dump the file content */
3332 av_dump_format(ic, nb_input_files, filename, 0);
3334 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3335 input_files[nb_input_files - 1].ctx = ic;
3336 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3340 av_freep(&video_codec_name);
3341 av_freep(&audio_codec_name);
3342 av_freep(&subtitle_codec_name);
3348 static void check_inputs(int *has_video_ptr,
3350 int *has_subtitle_ptr,
3353 int has_video, has_audio, has_subtitle, has_data, i, j;
3354 AVFormatContext *ic;
3361 for(j=0;j<nb_input_files;j++) {
3362 ic = input_files[j].ctx;
3363 for(i=0;i<ic->nb_streams;i++) {
3364 AVCodecContext *enc = ic->streams[i]->codec;
3365 switch(enc->codec_type) {
3366 case AVMEDIA_TYPE_AUDIO:
3369 case AVMEDIA_TYPE_VIDEO:
3372 case AVMEDIA_TYPE_SUBTITLE:
3375 case AVMEDIA_TYPE_DATA:
3376 case AVMEDIA_TYPE_ATTACHMENT:
3377 case AVMEDIA_TYPE_UNKNOWN:
3385 *has_video_ptr = has_video;
3386 *has_audio_ptr = has_audio;
3387 *has_subtitle_ptr = has_subtitle;
3388 *has_data_ptr = has_data;
3391 static void new_video_stream(AVFormatContext *oc, int file_idx)
3394 AVOutputStream *ost;
3395 AVCodecContext *video_enc;
3396 enum CodecID codec_id = CODEC_ID_NONE;
3397 AVCodec *codec= NULL;
3399 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3401 fprintf(stderr, "Could not alloc stream\n");
3404 ost = new_output_stream(oc, file_idx);
3406 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3407 if(!video_stream_copy){
3408 if (video_codec_name) {
3409 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3410 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3411 codec = avcodec_find_encoder_by_name(video_codec_name);
3412 output_codecs[nb_output_codecs-1] = codec;
3414 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3415 codec = avcodec_find_encoder(codec_id);
3418 ost->frame_aspect_ratio = frame_aspect_ratio;
3419 frame_aspect_ratio = 0;
3421 ost->avfilter= vfilters;
3426 avcodec_get_context_defaults3(st->codec, codec);
3427 ost->bitstream_filters = video_bitstream_filters;
3428 video_bitstream_filters= NULL;
3430 st->codec->thread_count= thread_count;
3432 video_enc = st->codec;
3435 video_enc->codec_tag= video_codec_tag;
3437 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3438 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3439 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3442 if (video_stream_copy) {
3443 st->stream_copy = 1;
3444 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3445 video_enc->sample_aspect_ratio =
3446 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3450 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3452 video_enc->codec_id = codec_id;
3453 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3455 if (codec && codec->supported_framerates && !force_fps)
3456 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3457 video_enc->time_base.den = fps.num;
3458 video_enc->time_base.num = fps.den;
3460 video_enc->width = frame_width;
3461 video_enc->height = frame_height;
3462 video_enc->pix_fmt = frame_pix_fmt;
3463 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3465 choose_pixel_fmt(st, codec);
3468 video_enc->gop_size = 0;
3469 if (video_qscale || same_quality) {
3470 video_enc->flags |= CODEC_FLAG_QSCALE;
3471 video_enc->global_quality=
3472 st->quality = FF_QP2LAMBDA * video_qscale;
3476 video_enc->intra_matrix = intra_matrix;
3478 video_enc->inter_matrix = inter_matrix;
3480 p= video_rc_override_string;
3483 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3485 fprintf(stderr, "error parsing rc_override\n");
3488 video_enc->rc_override=
3489 av_realloc(video_enc->rc_override,
3490 sizeof(RcOverride)*(i+1));
3491 video_enc->rc_override[i].start_frame= start;
3492 video_enc->rc_override[i].end_frame = end;
3494 video_enc->rc_override[i].qscale= q;
3495 video_enc->rc_override[i].quality_factor= 1.0;
3498 video_enc->rc_override[i].qscale= 0;
3499 video_enc->rc_override[i].quality_factor= -q/100.0;
3504 video_enc->rc_override_count=i;
3505 if (!video_enc->rc_initial_buffer_occupancy)
3506 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3507 video_enc->me_threshold= me_threshold;
3508 video_enc->intra_dc_precision= intra_dc_precision - 8;
3511 video_enc->flags|= CODEC_FLAG_PSNR;
3516 video_enc->flags |= CODEC_FLAG_PASS1;
3518 video_enc->flags |= CODEC_FLAG_PASS2;
3522 if (forced_key_frames)
3523 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3525 if (video_language) {
3526 av_metadata_set2(&st->metadata, "language", video_language, 0);
3527 av_freep(&video_language);
3530 /* reset some key parameters */
3532 av_freep(&video_codec_name);
3533 av_freep(&forced_key_frames);
3534 video_stream_copy = 0;
3535 frame_pix_fmt = PIX_FMT_NONE;
3538 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3541 AVOutputStream *ost;
3542 AVCodec *codec= NULL;
3543 AVCodecContext *audio_enc;
3544 enum CodecID codec_id = CODEC_ID_NONE;
3546 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3548 fprintf(stderr, "Could not alloc stream\n");
3551 ost = new_output_stream(oc, file_idx);
3553 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3554 if(!audio_stream_copy){
3555 if (audio_codec_name) {
3556 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3557 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3558 codec = avcodec_find_encoder_by_name(audio_codec_name);
3559 output_codecs[nb_output_codecs-1] = codec;
3561 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3562 codec = avcodec_find_encoder(codec_id);
3566 avcodec_get_context_defaults3(st->codec, codec);
3568 ost->bitstream_filters = audio_bitstream_filters;
3569 audio_bitstream_filters= NULL;
3571 st->codec->thread_count= thread_count;
3573 audio_enc = st->codec;
3574 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3577 audio_enc->codec_tag= audio_codec_tag;
3579 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3580 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3581 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3583 if (audio_stream_copy) {
3584 st->stream_copy = 1;
3585 audio_enc->channels = audio_channels;
3586 audio_enc->sample_rate = audio_sample_rate;
3588 audio_enc->codec_id = codec_id;
3589 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3591 if (audio_qscale > QSCALE_NONE) {
3592 audio_enc->flags |= CODEC_FLAG_QSCALE;
3593 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3595 audio_enc->channels = audio_channels;
3596 audio_enc->sample_fmt = audio_sample_fmt;
3597 audio_enc->sample_rate = audio_sample_rate;
3598 audio_enc->channel_layout = channel_layout;
3599 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3600 audio_enc->channel_layout = 0;
3601 choose_sample_fmt(st, codec);
3602 choose_sample_rate(st, codec);
3604 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3605 if (audio_language) {
3606 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3607 av_freep(&audio_language);
3610 /* reset some key parameters */
3612 av_freep(&audio_codec_name);
3613 audio_stream_copy = 0;
3616 static void new_data_stream(AVFormatContext *oc, int file_idx)
3619 AVCodec *codec=NULL;
3620 AVCodecContext *data_enc;
3622 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3624 fprintf(stderr, "Could not alloc stream\n");
3627 new_output_stream(oc, file_idx);
3628 data_enc = st->codec;
3629 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3630 if (!data_stream_copy) {
3631 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3634 avcodec_get_context_defaults3(st->codec, codec);
3636 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3639 data_enc->codec_tag= data_codec_tag;
3641 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3642 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3643 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3645 if (data_stream_copy) {
3646 st->stream_copy = 1;
3650 av_freep(&data_codec_name);
3651 data_stream_copy = 0;
3654 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3657 AVOutputStream *ost;
3658 AVCodec *codec=NULL;
3659 AVCodecContext *subtitle_enc;
3660 enum CodecID codec_id = CODEC_ID_NONE;
3662 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3664 fprintf(stderr, "Could not alloc stream\n");
3667 ost = new_output_stream(oc, file_idx);
3668 subtitle_enc = st->codec;
3669 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3670 if(!subtitle_stream_copy){
3671 if (subtitle_codec_name) {
3672 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3673 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3674 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3676 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3677 codec = avcodec_find_encoder(codec_id);
3680 avcodec_get_context_defaults3(st->codec, codec);
3682 ost->bitstream_filters = subtitle_bitstream_filters;
3683 subtitle_bitstream_filters= NULL;
3685 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3687 if(subtitle_codec_tag)
3688 subtitle_enc->codec_tag= subtitle_codec_tag;
3690 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3691 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3692 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3694 if (subtitle_stream_copy) {
3695 st->stream_copy = 1;
3697 subtitle_enc->codec_id = codec_id;
3698 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3701 if (subtitle_language) {
3702 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3703 av_freep(&subtitle_language);
3706 subtitle_disable = 0;
3707 av_freep(&subtitle_codec_name);
3708 subtitle_stream_copy = 0;
3711 static int opt_new_stream(const char *opt, const char *arg)
3713 AVFormatContext *oc;
3714 int file_idx = nb_output_files - 1;
3715 if (nb_output_files <= 0) {
3716 fprintf(stderr, "At least one output file must be specified\n");
3719 oc = output_files[file_idx];
3721 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3722 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3723 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3724 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3729 /* arg format is "output-stream-index:streamid-value". */
3730 static int opt_streamid(const char *opt, const char *arg)
3736 av_strlcpy(idx_str, arg, sizeof(idx_str));
3737 p = strchr(idx_str, ':');
3740 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3745 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3746 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3747 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3751 static void opt_output_file(const char *filename)
3753 AVFormatContext *oc;
3754 int err, use_video, use_audio, use_subtitle, use_data;
3755 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3756 AVFormatParameters params, *ap = ¶ms;
3757 AVOutputFormat *file_oformat;
3759 if (!strcmp(filename, "-"))
3762 oc = avformat_alloc_context();
3764 print_error(filename, AVERROR(ENOMEM));
3768 if (last_asked_format) {
3769 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3770 if (!file_oformat) {
3771 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3774 last_asked_format = NULL;
3776 file_oformat = av_guess_format(NULL, filename, NULL);
3777 if (!file_oformat) {
3778 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3784 oc->oformat = file_oformat;
3785 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3787 if (!strcmp(file_oformat->name, "ffm") &&
3788 av_strstart(filename, "http:", NULL)) {
3789 /* special case for files sent to ffserver: we get the stream
3790 parameters from ffserver */
3791 int err = read_ffserver_streams(oc, filename);
3793 print_error(filename, err);
3797 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3798 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3799 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3800 use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3802 /* disable if no corresponding type found and at least one
3804 if (nb_input_files > 0) {
3805 check_inputs(&input_has_video,
3807 &input_has_subtitle,
3810 if (!input_has_video)
3812 if (!input_has_audio)
3814 if (!input_has_subtitle)
3816 if (!input_has_data)
3820 /* manual disable */
3821 if (audio_disable) use_audio = 0;
3822 if (video_disable) use_video = 0;
3823 if (subtitle_disable) use_subtitle = 0;
3824 if (data_disable) use_data = 0;
3826 if (use_video) new_video_stream(oc, nb_output_files);
3827 if (use_audio) new_audio_stream(oc, nb_output_files);
3828 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3829 if (use_data) new_data_stream(oc, nb_output_files);
3831 oc->timestamp = recording_timestamp;
3833 av_metadata_copy(&oc->metadata, metadata, 0);
3834 av_metadata_free(&metadata);
3837 output_files[nb_output_files++] = oc;
3839 /* check filename in case of an image number is expected */
3840 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3841 if (!av_filename_number_test(oc->filename)) {
3842 print_error(oc->filename, AVERROR(EINVAL));
3847 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3848 /* test if it already exists to avoid loosing precious files */
3849 if (!file_overwrite &&
3850 (strchr(filename, ':') == NULL ||
3851 filename[1] == ':' ||
3852 av_strstart(filename, "file:", NULL))) {
3853 if (avio_check(filename, 0) == 0) {
3855 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3857 if (!read_yesno()) {
3858 fprintf(stderr, "Not overwriting - exiting\n");
3863 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3870 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3871 print_error(filename, err);
3876 memset(ap, 0, sizeof(*ap));
3877 if (av_set_parameters(oc, ap) < 0) {
3878 fprintf(stderr, "%s: Invalid encoding parameters\n",
3883 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3884 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3885 oc->loop_output = loop_output;
3886 oc->flags |= AVFMT_FLAG_NONBLOCK;
3888 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3890 av_freep(&forced_key_frames);
3895 /* same option as mencoder */
3896 static int opt_pass(const char *opt, const char *arg)
3898 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3902 static int64_t getutime(void)
3905 struct rusage rusage;
3907 getrusage(RUSAGE_SELF, &rusage);
3908 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3909 #elif HAVE_GETPROCESSTIMES
3911 FILETIME c, e, k, u;
3912 proc = GetCurrentProcess();
3913 GetProcessTimes(proc, &c, &e, &k, &u);
3914 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3916 return av_gettime();
3920 static int64_t getmaxrss(void)
3922 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3923 struct rusage rusage;
3924 getrusage(RUSAGE_SELF, &rusage);
3925 return (int64_t)rusage.ru_maxrss * 1024;
3926 #elif HAVE_GETPROCESSMEMORYINFO
3928 PROCESS_MEMORY_COUNTERS memcounters;
3929 proc = GetCurrentProcess();
3930 memcounters.cb = sizeof(memcounters);
3931 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3932 return memcounters.PeakPagefileUsage;
3938 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3941 const char *p = str;
3948 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3955 static void opt_inter_matrix(const char *arg)
3957 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3958 parse_matrix_coeffs(inter_matrix, arg);
3961 static void opt_intra_matrix(const char *arg)
3963 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3964 parse_matrix_coeffs(intra_matrix, arg);
3967 static void show_usage(void)
3969 printf("Hyper fast Audio and Video encoder\n");
3970 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3974 static void show_help(void)
3977 AVOutputFormat *oformat = NULL;
3979 av_log_set_callback(log_callback_help);
3981 show_help_options(options, "Main options:\n",
3982 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3983 show_help_options(options, "\nAdvanced options:\n",
3984 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3986 show_help_options(options, "\nVideo options:\n",
3987 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3989 show_help_options(options, "\nAdvanced Video options:\n",
3990 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3991 OPT_VIDEO | OPT_EXPERT);
3992 show_help_options(options, "\nAudio options:\n",
3993 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3995 show_help_options(options, "\nAdvanced Audio options:\n",
3996 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3997 OPT_AUDIO | OPT_EXPERT);
3998 show_help_options(options, "\nSubtitle options:\n",
3999 OPT_SUBTITLE | OPT_GRAB,
4001 show_help_options(options, "\nAudio/Video grab options:\n",
4005 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4008 /* individual codec options */
4010 while ((c = av_codec_next(c))) {
4011 if (c->priv_class) {
4012 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4017 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4020 /* individual muxer options */
4021 while ((oformat = av_oformat_next(oformat))) {
4022 if (oformat->priv_class) {
4023 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4028 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4031 static int opt_target(const char *opt, const char *arg)
4033 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4034 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4036 if(!strncmp(arg, "pal-", 4)) {
4039 } else if(!strncmp(arg, "ntsc-", 5)) {
4042 } else if(!strncmp(arg, "film-", 5)) {
4047 /* Calculate FR via float to avoid int overflow */
4048 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4051 } else if((fr == 29970) || (fr == 23976)) {
4054 /* Try to determine PAL/NTSC by peeking in the input files */
4055 if(nb_input_files) {
4057 for (j = 0; j < nb_input_files; j++) {
4058 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4059 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4060 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4062 fr = c->time_base.den * 1000 / c->time_base.num;
4066 } else if((fr == 29970) || (fr == 23976)) {
4076 if(verbose > 0 && norm != UNKNOWN)
4077 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4080 if(norm == UNKNOWN) {
4081 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4082 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4083 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4087 if(!strcmp(arg, "vcd")) {
4088 opt_video_codec("vcodec", "mpeg1video");
4089 opt_audio_codec("vcodec", "mp2");
4090 opt_format("f", "vcd");
4092 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4093 opt_frame_rate("r", frame_rates[norm]);
4094 opt_default("g", norm == PAL ? "15" : "18");
4096 opt_default("b", "1150000");
4097 opt_default("maxrate", "1150000");
4098 opt_default("minrate", "1150000");
4099 opt_default("bufsize", "327680"); // 40*1024*8;
4101 opt_default("ab", "224000");
4102 audio_sample_rate = 44100;
4105 opt_default("packetsize", "2324");
4106 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4108 /* We have to offset the PTS, so that it is consistent with the SCR.
4109 SCR starts at 36000, but the first two packs contain only padding
4110 and the first pack from the other stream, respectively, may also have
4111 been written before.
4112 So the real data starts at SCR 36000+3*1200. */
4113 mux_preload= (36000+3*1200) / 90000.0; //0.44
4114 } else if(!strcmp(arg, "svcd")) {
4116 opt_video_codec("vcodec", "mpeg2video");
4117 opt_audio_codec("acodec", "mp2");
4118 opt_format("f", "svcd");
4120 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4121 opt_frame_rate("r", frame_rates[norm]);
4122 opt_default("g", norm == PAL ? "15" : "18");
4124 opt_default("b", "2040000");
4125 opt_default("maxrate", "2516000");
4126 opt_default("minrate", "0"); //1145000;
4127 opt_default("bufsize", "1835008"); //224*1024*8;
4128 opt_default("flags", "+scan_offset");
4131 opt_default("ab", "224000");
4132 audio_sample_rate = 44100;
4134 opt_default("packetsize", "2324");
4136 } else if(!strcmp(arg, "dvd")) {
4138 opt_video_codec("vcodec", "mpeg2video");
4139 opt_audio_codec("vcodec", "ac3");
4140 opt_format("f", "dvd");
4142 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4143 opt_frame_rate("r", frame_rates[norm]);
4144 opt_default("g", norm == PAL ? "15" : "18");
4146 opt_default("b", "6000000");
4147 opt_default("maxrate", "9000000");
4148 opt_default("minrate", "0"); //1500000;
4149 opt_default("bufsize", "1835008"); //224*1024*8;
4151 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4152 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4154 opt_default("ab", "448000");
4155 audio_sample_rate = 48000;
4157 } else if(!strncmp(arg, "dv", 2)) {
4159 opt_format("f", "dv");
4161 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4162 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4163 norm == PAL ? "yuv420p" : "yuv411p");
4164 opt_frame_rate("r", frame_rates[norm]);
4166 audio_sample_rate = 48000;
4170 fprintf(stderr, "Unknown target: %s\n", arg);
4171 return AVERROR(EINVAL);
4176 static int opt_vstats_file(const char *opt, const char *arg)
4178 av_free (vstats_filename);
4179 vstats_filename=av_strdup (arg);
4183 static int opt_vstats(const char *opt, const char *arg)
4186 time_t today2 = time(NULL);
4187 struct tm *today = localtime(&today2);
4189 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4191 return opt_vstats_file(opt, filename);
4194 static int opt_bsf(const char *opt, const char *arg)
4196 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4197 AVBitStreamFilterContext **bsfp;
4200 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4204 bsfp= *opt == 'v' ? &video_bitstream_filters :
4205 *opt == 'a' ? &audio_bitstream_filters :
4206 &subtitle_bitstream_filters;
4208 bsfp= &(*bsfp)->next;
4215 static int opt_preset(const char *opt, const char *arg)
4218 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4219 char *codec_name = *opt == 'v' ? video_codec_name :
4220 *opt == 'a' ? audio_codec_name :
4221 subtitle_codec_name;
4223 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4224 fprintf(stderr, "File for preset '%s' not found\n", arg);
4229 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4230 if(line[0] == '#' && !e)
4232 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4234 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4237 if(!strcmp(tmp, "acodec")){
4238 opt_audio_codec(tmp, tmp2);
4239 }else if(!strcmp(tmp, "vcodec")){
4240 opt_video_codec(tmp, tmp2);
4241 }else if(!strcmp(tmp, "scodec")){
4242 opt_subtitle_codec(tmp, tmp2);
4243 }else if(!strcmp(tmp, "dcodec")){
4244 opt_data_codec(tmp, tmp2);
4245 }else if(opt_default(tmp, tmp2) < 0){
4246 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4256 static const OptionDef options[] = {
4258 #include "cmdutils_common_opts.h"
4259 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4260 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4261 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4262 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4263 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4264 "outfile[,metadata]:infile[,metadata]" },
4265 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4266 "outfile[,metadata]:infile[,metadata]" },
4267 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4268 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4269 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4270 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4271 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4272 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4273 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4274 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4275 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4276 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4277 "add timings for benchmarking" },
4278 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4279 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4280 "dump each input packet" },
4281 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4282 "when dumping packets, also dump the payload" },
4283 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4284 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4285 { "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)", "" },
4286 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4287 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4288 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4289 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4290 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4291 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4292 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4293 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4294 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4295 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4296 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4297 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4298 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4301 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4302 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4303 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4304 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4305 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4306 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4307 { "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" },
4308 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4309 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4310 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4311 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4312 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4313 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4314 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4315 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4316 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4317 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4318 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4319 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4320 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4321 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4322 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4323 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4324 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4325 "use same quantizer as source (implies VBR)" },
4326 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4327 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4328 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4329 "deinterlace pictures" },
4330 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4331 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4332 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4334 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4336 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4337 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4338 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4339 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4340 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4341 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4342 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4343 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4344 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4345 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4346 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4349 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4350 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4351 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4352 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4353 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4354 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4355 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4356 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4357 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4358 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4359 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4360 { "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" },
4362 /* subtitle options */
4363 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4364 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4365 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4366 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4367 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4370 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4371 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4372 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4375 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4376 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4378 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4379 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4380 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4382 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4383 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4384 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4385 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4386 /* data codec support */
4387 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4389 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4393 int main(int argc, char **argv)
4397 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4399 avcodec_register_all();
4401 avdevice_register_all();
4404 avfilter_register_all();
4408 avio_set_interrupt_cb(decode_interrupt_cb);
4415 parse_options(argc, argv, options, opt_output_file);
4417 if(nb_output_files <= 0 && nb_input_files == 0) {
4419 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4423 /* file converter / grab */
4424 if (nb_output_files <= 0) {
4425 fprintf(stderr, "At least one output file must be specified\n");
4429 if (nb_input_files == 0) {
4430 fprintf(stderr, "At least one input file must be specified\n");
4435 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4436 stream_maps, nb_stream_maps) < 0)
4438 ti = getutime() - ti;
4440 int maxrss = getmaxrss() / 1024;
4441 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4444 return ffmpeg_exit(0);