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/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "ffmpeg";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
85 int sync_stream_index;
89 * select an input file for an output file
91 typedef struct MetadataMap {
92 int file; ///< file index
93 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
94 int index; ///< stream/chapter/program number
97 typedef struct ChapterMap {
102 static const OptionDef options[];
104 #define MAX_FILES 100
106 static const char *last_asked_format = NULL;
107 static double *ts_scale;
108 static int nb_ts_scale;
110 static AVFormatContext *output_files[MAX_FILES];
111 static AVDictionary *output_opts[MAX_FILES];
112 static int nb_output_files = 0;
114 static StreamMap *stream_maps = NULL;
115 static int nb_stream_maps;
117 /* first item specifies output metadata, second is input */
118 static MetadataMap (*meta_data_maps)[2] = NULL;
119 static int nb_meta_data_maps;
120 static int metadata_global_autocopy = 1;
121 static int metadata_streams_autocopy = 1;
122 static int metadata_chapters_autocopy = 1;
124 static ChapterMap *chapter_maps = NULL;
125 static int nb_chapter_maps;
127 /* indexed by output file stream index */
128 static int *streamid_map = NULL;
129 static int nb_streamid_map = 0;
131 static int frame_width = 0;
132 static int frame_height = 0;
133 static float frame_aspect_ratio = 0;
134 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
135 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
136 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
137 static AVRational frame_rate;
138 static float video_qscale = 0;
139 static uint16_t *intra_matrix = NULL;
140 static uint16_t *inter_matrix = NULL;
141 static const char *video_rc_override_string=NULL;
142 static int video_disable = 0;
143 static int video_discard = 0;
144 static char *video_codec_name = NULL;
145 static unsigned int video_codec_tag = 0;
146 static char *video_language = NULL;
147 static int same_quality = 0;
148 static int do_deinterlace = 0;
149 static int top_field_first = -1;
150 static int me_threshold = 0;
151 static int intra_dc_precision = 8;
152 static int loop_input = 0;
153 static int loop_output = AVFMT_NOOUTPUTLOOP;
154 static int qp_hist = 0;
156 static char *vfilters = NULL;
159 static int intra_only = 0;
160 static int audio_sample_rate = 0;
161 #define QSCALE_NONE -99999
162 static float audio_qscale = QSCALE_NONE;
163 static int audio_disable = 0;
164 static int audio_channels = 0;
165 static char *audio_codec_name = NULL;
166 static unsigned int audio_codec_tag = 0;
167 static char *audio_language = NULL;
169 static int subtitle_disable = 0;
170 static char *subtitle_codec_name = NULL;
171 static char *subtitle_language = NULL;
172 static unsigned int subtitle_codec_tag = 0;
174 static int data_disable = 0;
175 static char *data_codec_name = NULL;
176 static unsigned int data_codec_tag = 0;
178 static float mux_preload= 0.5;
179 static float mux_max_delay= 0.7;
181 static int64_t recording_time = INT64_MAX;
182 static int64_t start_time = 0;
183 static int64_t input_ts_offset = 0;
184 static int file_overwrite = 0;
185 static AVDictionary *metadata;
186 static int do_benchmark = 0;
187 static int do_hex_dump = 0;
188 static int do_pkt_dump = 0;
189 static int do_psnr = 0;
190 static int do_pass = 0;
191 static char *pass_logfilename_prefix = NULL;
192 static int audio_stream_copy = 0;
193 static int video_stream_copy = 0;
194 static int subtitle_stream_copy = 0;
195 static int data_stream_copy = 0;
196 static int video_sync_method= -1;
197 static int audio_sync_method= 0;
198 static float audio_drift_threshold= 0.1;
199 static int copy_ts= 0;
201 static int opt_shortest = 0;
202 static char *vstats_filename;
203 static FILE *vstats_file;
204 static int opt_programid = 0;
205 static int copy_initial_nonkeyframes = 0;
207 static int rate_emu = 0;
209 static int audio_volume = 256;
211 static int exit_on_error = 0;
212 static int using_stdin = 0;
213 static int verbose = 1;
214 static int thread_count= 1;
215 static int64_t video_size = 0;
216 static int64_t audio_size = 0;
217 static int64_t extra_size = 0;
218 static int nb_frames_dup = 0;
219 static int nb_frames_drop = 0;
220 static int input_sync;
221 static uint64_t limit_filesize = 0;
222 static int force_fps = 0;
223 static char *forced_key_frames = NULL;
225 static float dts_delta_threshold = 10;
227 static int64_t timer_start;
229 static uint8_t *audio_buf;
230 static uint8_t *audio_out;
231 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
233 static short *samples;
235 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
236 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
237 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
239 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
243 typedef struct OutputStream {
244 int file_index; /* file index */
245 int index; /* stream index in the output file */
246 int source_index; /* InputStream index */
247 AVStream *st; /* stream in the output file */
248 int encoding_needed; /* true if encoding needed for this stream */
250 /* input pts and corresponding output pts
252 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
253 struct InputStream *sync_ist; /* input stream to sync against */
254 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
255 AVBitStreamFilterContext *bitstream_filters;
260 AVFrame pict_tmp; /* temporary image for resampling */
261 struct SwsContext *img_resample_ctx; /* for image resampling */
264 int resample_pix_fmt;
265 AVRational frame_rate;
267 float frame_aspect_ratio;
269 /* forced key frames */
270 int64_t *forced_kf_pts;
276 ReSampleContext *resample; /* for audio resampling */
277 int resample_sample_fmt;
278 int resample_channels;
279 int resample_sample_rate;
281 AVAudioConvert *reformat_ctx;
282 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
286 AVFilterContext *output_video_filter;
287 AVFilterContext *input_video_filter;
288 AVFilterBufferRef *picref;
290 AVFilterGraph *graph;
297 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
298 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
300 typedef struct InputStream {
303 int discard; /* true if stream data should be discarded */
304 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
307 int64_t start; /* time when read started */
308 int64_t next_pts; /* synthetic pts for cases where pkt.pts
310 int64_t pts; /* current pts */
311 PtsCorrectionContext pts_ctx;
313 int is_start; /* is 1 at the start and after a discontinuity */
314 int showed_multi_packet_warning;
315 int is_past_recording_time;
319 typedef struct InputFile {
320 AVFormatContext *ctx;
321 int eof_reached; /* true if eof reached */
322 int ist_index; /* index of first stream in ist_table */
323 int buffer_size; /* current total buffer size */
327 static InputStream *input_streams = NULL;
328 static int nb_input_streams = 0;
329 static InputFile *input_files = NULL;
330 static int nb_input_files = 0;
334 static int configure_video_filters(InputStream *ist, OutputStream *ost)
336 AVFilterContext *last_filter, *filter;
337 /** filter graph containing all filters including input & output */
338 AVCodecContext *codec = ost->st->codec;
339 AVCodecContext *icodec = ist->st->codec;
340 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
341 AVRational sample_aspect_ratio;
345 ost->graph = avfilter_graph_alloc();
347 if (ist->st->sample_aspect_ratio.num){
348 sample_aspect_ratio = ist->st->sample_aspect_ratio;
350 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
352 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
353 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
354 sample_aspect_ratio.num, sample_aspect_ratio.den);
356 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
357 "src", args, NULL, ost->graph);
360 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
361 "out", NULL, &ffsink_ctx, ost->graph);
364 last_filter = ost->input_video_filter;
366 if (codec->width != icodec->width || codec->height != icodec->height) {
367 snprintf(args, 255, "%d:%d:flags=0x%X",
371 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
372 NULL, args, NULL, ost->graph)) < 0)
374 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
376 last_filter = filter;
379 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
380 ost->graph->scale_sws_opts = av_strdup(args);
383 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
384 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
386 outputs->name = av_strdup("in");
387 outputs->filter_ctx = last_filter;
388 outputs->pad_idx = 0;
389 outputs->next = NULL;
391 inputs->name = av_strdup("out");
392 inputs->filter_ctx = ost->output_video_filter;
396 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
398 av_freep(&ost->avfilter);
400 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
404 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
407 codec->width = ost->output_video_filter->inputs[0]->w;
408 codec->height = ost->output_video_filter->inputs[0]->h;
409 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
410 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
411 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
412 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
416 #endif /* CONFIG_AVFILTER */
418 static void term_exit(void)
420 av_log(NULL, AV_LOG_QUIET, "");
423 static volatile int received_sigterm = 0;
424 static volatile int received_nb_signals = 0;
427 sigterm_handler(int sig)
429 received_sigterm = sig;
430 received_nb_signals++;
434 static void term_init(void)
436 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
437 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
439 signal(SIGXCPU, sigterm_handler);
443 static int decode_interrupt_cb(void)
445 return received_nb_signals > 1;
448 static int ffmpeg_exit(int ret)
453 for(i=0;i<nb_output_files;i++) {
454 AVFormatContext *s = output_files[i];
455 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
457 avformat_free_context(s);
458 av_free(output_streams_for_file[i]);
459 av_dict_free(&output_opts[i]);
461 for(i=0;i<nb_input_files;i++) {
462 av_close_input_file(input_files[i].ctx);
464 for (i = 0; i < nb_input_streams; i++)
465 av_dict_free(&input_streams[i].opts);
467 av_free(intra_matrix);
468 av_free(inter_matrix);
472 av_free(vstats_filename);
474 av_free(streamid_map);
475 av_free(stream_maps);
476 av_free(meta_data_maps);
478 av_freep(&input_streams);
479 av_freep(&input_files);
481 av_free(video_codec_name);
482 av_free(audio_codec_name);
483 av_free(subtitle_codec_name);
484 av_free(data_codec_name);
489 allocated_audio_buf_size= allocated_audio_out_size= 0;
496 if (received_sigterm) {
498 "Received signal %d: terminating.\n",
499 (int) received_sigterm);
503 exit(ret); /* not all OS-es handle main() return value */
507 static void assert_avoptions(AVDictionary *m)
509 AVDictionaryEntry *t;
510 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
511 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
516 static void assert_codec_experimental(AVCodecContext *c, int encoder)
518 const char *codec_string = encoder ? "encoder" : "decoder";
520 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
521 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
522 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
523 "results.\nAdd '-strict experimental' if you want to use it.\n",
524 codec_string, c->codec->name);
525 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
526 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
527 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
528 codec_string, codec->name);
533 /* similar to ff_dynarray_add() and av_fast_realloc() */
534 static void *grow_array(void *array, int elem_size, int *size, int new_size)
536 if (new_size >= INT_MAX / elem_size) {
537 fprintf(stderr, "Array too big.\n");
540 if (*size < new_size) {
541 uint8_t *tmp = av_realloc(array, new_size*elem_size);
543 fprintf(stderr, "Could not alloc buffer.\n");
546 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
553 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
555 if(codec && codec->sample_fmts){
556 const enum AVSampleFormat *p= codec->sample_fmts;
558 if(*p == st->codec->sample_fmt)
562 av_log(NULL, AV_LOG_WARNING,
563 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
564 av_get_sample_fmt_name(st->codec->sample_fmt),
566 av_get_sample_fmt_name(codec->sample_fmts[0]));
567 st->codec->sample_fmt = codec->sample_fmts[0];
573 * Update the requested input sample format based on the output sample format.
574 * This is currently only used to request float output from decoders which
575 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
576 * Ideally this will be removed in the future when decoders do not do format
577 * conversion and only output in their native format.
579 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
582 /* if sample formats match or a decoder sample format has already been
583 requested, just return */
584 if (enc->sample_fmt == dec->sample_fmt ||
585 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
588 /* if decoder supports more than one output format */
589 if (dec_codec && dec_codec->sample_fmts &&
590 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
591 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
592 const enum AVSampleFormat *p;
593 int min_dec = -1, min_inc = -1;
595 /* find a matching sample format in the encoder */
596 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
597 if (*p == enc->sample_fmt) {
598 dec->request_sample_fmt = *p;
600 } else if (*p > enc->sample_fmt) {
601 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
603 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
606 /* if none match, provide the one that matches quality closest */
607 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
608 enc->sample_fmt - min_dec;
612 static void choose_sample_rate(AVStream *st, AVCodec *codec)
614 if(codec && codec->supported_samplerates){
615 const int *p= codec->supported_samplerates;
617 int best_dist=INT_MAX;
619 int dist= abs(st->codec->sample_rate - *p);
620 if(dist < best_dist){
626 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
628 st->codec->sample_rate= best;
632 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
634 if(codec && codec->pix_fmts){
635 const enum PixelFormat *p= codec->pix_fmts;
636 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
637 if(st->codec->codec_id==CODEC_ID_MJPEG){
638 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
639 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
640 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};
644 if(*p == st->codec->pix_fmt)
648 if(st->codec->pix_fmt != PIX_FMT_NONE)
649 av_log(NULL, AV_LOG_WARNING,
650 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
651 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
653 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
654 st->codec->pix_fmt = codec->pix_fmts[0];
659 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
662 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
663 int idx = oc->nb_streams - 1;
666 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
670 output_streams_for_file[file_idx] =
671 grow_array(output_streams_for_file[file_idx],
672 sizeof(*output_streams_for_file[file_idx]),
673 &nb_output_streams_for_file[file_idx],
675 ost = output_streams_for_file[file_idx][idx] =
676 av_mallocz(sizeof(OutputStream));
678 fprintf(stderr, "Could not alloc output stream\n");
681 ost->file_index = file_idx;
686 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
688 avcodec_get_context_defaults3(st->codec, codec);
690 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
694 static int read_avserver_streams(AVFormatContext *s, const char *filename)
697 AVFormatContext *ic = NULL;
699 err = avformat_open_input(&ic, filename, NULL, NULL);
702 /* copy stream format */
703 for(i=0;i<ic->nb_streams;i++) {
708 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
709 ost = new_output_stream(s, nb_output_files, codec);
712 // FIXME: a more elegant solution is needed
713 memcpy(st, ic->streams[i], sizeof(AVStream));
715 avcodec_copy_context(st->codec, ic->streams[i]->codec);
717 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
718 if (audio_stream_copy) {
721 choose_sample_fmt(st, codec);
722 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
723 if (video_stream_copy) {
726 choose_pixel_fmt(st, codec);
730 av_close_input_file(ic);
735 get_sync_ipts(const OutputStream *ost)
737 const InputStream *ist = ost->sync_ist;
738 return (double)(ist->pts - start_time)/AV_TIME_BASE;
741 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
745 AVPacket new_pkt= *pkt;
746 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
747 &new_pkt.data, &new_pkt.size,
748 pkt->data, pkt->size,
749 pkt->flags & AV_PKT_FLAG_KEY);
752 new_pkt.destruct= av_destruct_packet;
754 fprintf(stderr, "%s failed for stream %d, codec %s",
755 bsfc->filter->name, pkt->stream_index,
756 avctx->codec ? avctx->codec->name : "copy");
766 ret= av_interleaved_write_frame(s, pkt);
768 print_error("av_interleaved_write_frame()", ret);
773 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
775 static void do_audio_out(AVFormatContext *s,
778 unsigned char *buf, int size)
781 int64_t audio_out_size, audio_buf_size;
782 int64_t allocated_for_size= size;
784 int size_out, frame_bytes, ret, resample_changed;
785 AVCodecContext *enc= ost->st->codec;
786 AVCodecContext *dec= ist->st->codec;
787 int osize = av_get_bytes_per_sample(enc->sample_fmt);
788 int isize = av_get_bytes_per_sample(dec->sample_fmt);
789 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
792 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
793 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
794 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
795 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
796 audio_buf_size*= osize*enc->channels;
798 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
799 if(coded_bps > 8*osize)
800 audio_out_size= audio_out_size * coded_bps / (8*osize);
801 audio_out_size += FF_MIN_BUFFER_SIZE;
803 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
804 fprintf(stderr, "Buffer sizes too large\n");
808 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
809 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
810 if (!audio_buf || !audio_out){
811 fprintf(stderr, "Out of memory in do_audio_out\n");
815 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
816 ost->audio_resample = 1;
818 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
819 ost->resample_channels != dec->channels ||
820 ost->resample_sample_rate != dec->sample_rate;
822 if ((ost->audio_resample && !ost->resample) || resample_changed) {
823 if (resample_changed) {
824 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",
825 ist->file_index, ist->st->index,
826 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
827 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
828 ost->resample_sample_fmt = dec->sample_fmt;
829 ost->resample_channels = dec->channels;
830 ost->resample_sample_rate = dec->sample_rate;
832 audio_resample_close(ost->resample);
834 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
835 if (audio_sync_method <= 1 &&
836 ost->resample_sample_fmt == enc->sample_fmt &&
837 ost->resample_channels == enc->channels &&
838 ost->resample_sample_rate == enc->sample_rate) {
839 ost->resample = NULL;
840 ost->audio_resample = 0;
841 } else if (ost->audio_resample) {
842 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
843 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
844 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
845 enc->sample_rate, dec->sample_rate,
846 enc->sample_fmt, dec->sample_fmt,
848 if (!ost->resample) {
849 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
850 dec->channels, dec->sample_rate,
851 enc->channels, enc->sample_rate);
857 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
858 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
859 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
860 if (ost->reformat_ctx)
861 av_audio_convert_free(ost->reformat_ctx);
862 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
863 dec->sample_fmt, 1, NULL, 0);
864 if (!ost->reformat_ctx) {
865 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
866 av_get_sample_fmt_name(dec->sample_fmt),
867 av_get_sample_fmt_name(enc->sample_fmt));
870 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
873 if(audio_sync_method){
874 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
875 - av_fifo_size(ost->fifo)/(enc->channels * 2);
876 double idelta= delta*dec->sample_rate / enc->sample_rate;
877 int byte_delta= ((int)idelta)*2*dec->channels;
879 //FIXME resample delay
880 if(fabs(delta) > 50){
881 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
883 byte_delta= FFMAX(byte_delta, -size);
887 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
892 static uint8_t *input_tmp= NULL;
893 input_tmp= av_realloc(input_tmp, byte_delta + size);
895 if(byte_delta > allocated_for_size - size){
896 allocated_for_size= byte_delta + (int64_t)size;
901 memset(input_tmp, 0, byte_delta);
902 memcpy(input_tmp + byte_delta, buf, size);
906 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
908 }else if(audio_sync_method>1){
909 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
910 av_assert0(ost->audio_resample);
912 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
913 // 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));
914 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
918 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
919 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
921 if (ost->audio_resample) {
923 size_out = audio_resample(ost->resample,
924 (short *)buftmp, (short *)buf,
925 size / (dec->channels * isize));
926 size_out = size_out * enc->channels * osize;
932 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
933 const void *ibuf[6]= {buftmp};
934 void *obuf[6]= {audio_buf};
935 int istride[6]= {isize};
936 int ostride[6]= {osize};
937 int len= size_out/istride[0];
938 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
939 printf("av_audio_convert() failed\n");
945 size_out = len*osize;
948 /* now encode as many frames as possible */
949 if (enc->frame_size > 1) {
950 /* output resampled raw samples */
951 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
952 fprintf(stderr, "av_fifo_realloc2() failed\n");
955 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
957 frame_bytes = enc->frame_size * osize * enc->channels;
959 while (av_fifo_size(ost->fifo) >= frame_bytes) {
961 av_init_packet(&pkt);
963 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
965 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
967 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
970 fprintf(stderr, "Audio encoding failed\n");
974 pkt.stream_index= ost->index;
977 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
978 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
979 pkt.flags |= AV_PKT_FLAG_KEY;
980 write_frame(s, &pkt, enc, ost->bitstream_filters);
982 ost->sync_opts += enc->frame_size;
986 av_init_packet(&pkt);
988 ost->sync_opts += size_out / (osize * enc->channels);
990 /* output a pcm frame */
991 /* determine the size of the coded buffer */
994 size_out = size_out*coded_bps/8;
996 if(size_out > audio_out_size){
997 fprintf(stderr, "Internal error, buffer size too small\n");
1001 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1002 ret = avcodec_encode_audio(enc, audio_out, size_out,
1005 fprintf(stderr, "Audio encoding failed\n");
1009 pkt.stream_index= ost->index;
1010 pkt.data= audio_out;
1012 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1013 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1014 pkt.flags |= AV_PKT_FLAG_KEY;
1015 write_frame(s, &pkt, enc, ost->bitstream_filters);
1019 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1021 AVCodecContext *dec;
1022 AVPicture *picture2;
1023 AVPicture picture_tmp;
1026 dec = ist->st->codec;
1028 /* deinterlace : must be done before any resize */
1029 if (do_deinterlace) {
1032 /* create temporary picture */
1033 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1034 buf = av_malloc(size);
1038 picture2 = &picture_tmp;
1039 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1041 if(avpicture_deinterlace(picture2, picture,
1042 dec->pix_fmt, dec->width, dec->height) < 0) {
1043 /* if error, do not deinterlace */
1044 fprintf(stderr, "Deinterlacing failed\n");
1053 if (picture != picture2)
1054 *picture = *picture2;
1058 /* we begin to correct av delay at this threshold */
1059 #define AV_DELAY_MAX 0.100
1061 static void do_subtitle_out(AVFormatContext *s,
1067 static uint8_t *subtitle_out = NULL;
1068 int subtitle_out_max_size = 1024 * 1024;
1069 int subtitle_out_size, nb, i;
1070 AVCodecContext *enc;
1073 if (pts == AV_NOPTS_VALUE) {
1074 fprintf(stderr, "Subtitle packets must have a pts\n");
1080 enc = ost->st->codec;
1082 if (!subtitle_out) {
1083 subtitle_out = av_malloc(subtitle_out_max_size);
1086 /* Note: DVB subtitle need one packet to draw them and one other
1087 packet to clear them */
1088 /* XXX: signal it in the codec context ? */
1089 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1094 for(i = 0; i < nb; i++) {
1095 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1096 // start_display_time is required to be 0
1097 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1098 sub->end_display_time -= sub->start_display_time;
1099 sub->start_display_time = 0;
1100 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1101 subtitle_out_max_size, sub);
1102 if (subtitle_out_size < 0) {
1103 fprintf(stderr, "Subtitle encoding failed\n");
1107 av_init_packet(&pkt);
1108 pkt.stream_index = ost->index;
1109 pkt.data = subtitle_out;
1110 pkt.size = subtitle_out_size;
1111 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1112 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1113 /* XXX: the pts correction is handled here. Maybe handling
1114 it in the codec would be better */
1116 pkt.pts += 90 * sub->start_display_time;
1118 pkt.pts += 90 * sub->end_display_time;
1120 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1124 static int bit_buffer_size= 1024*256;
1125 static uint8_t *bit_buffer= NULL;
1127 static void do_video_out(AVFormatContext *s,
1130 AVFrame *in_picture,
1131 int *frame_size, float quality)
1133 int nb_frames, i, ret, resample_changed;
1134 AVFrame *final_picture, *formatted_picture;
1135 AVCodecContext *enc, *dec;
1138 enc = ost->st->codec;
1139 dec = ist->st->codec;
1141 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1143 /* by default, we output a single frame */
1148 if(video_sync_method){
1149 double vdelta = sync_ipts - ost->sync_opts;
1150 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1153 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1156 }else if(vdelta>0.6)
1157 ost->sync_opts= lrintf(sync_ipts);
1158 }else if (vdelta > 1.1)
1159 nb_frames = lrintf(vdelta);
1160 //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);
1161 if (nb_frames == 0){
1164 fprintf(stderr, "*** drop!\n");
1165 }else if (nb_frames > 1) {
1166 nb_frames_dup += nb_frames - 1;
1168 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1171 ost->sync_opts= lrintf(sync_ipts);
1173 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1177 formatted_picture = in_picture;
1178 final_picture = formatted_picture;
1180 resample_changed = ost->resample_width != dec->width ||
1181 ost->resample_height != dec->height ||
1182 ost->resample_pix_fmt != dec->pix_fmt;
1184 if (resample_changed) {
1185 av_log(NULL, AV_LOG_INFO,
1186 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1187 ist->file_index, ist->st->index,
1188 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1189 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1190 if(!ost->video_resample)
1194 #if !CONFIG_AVFILTER
1195 if (ost->video_resample) {
1196 final_picture = &ost->pict_tmp;
1197 if (resample_changed) {
1198 /* initialize a new scaler context */
1199 sws_freeContext(ost->img_resample_ctx);
1200 ost->img_resample_ctx = sws_getContext(
1201 ist->st->codec->width,
1202 ist->st->codec->height,
1203 ist->st->codec->pix_fmt,
1204 ost->st->codec->width,
1205 ost->st->codec->height,
1206 ost->st->codec->pix_fmt,
1207 ost->sws_flags, NULL, NULL, NULL);
1208 if (ost->img_resample_ctx == NULL) {
1209 fprintf(stderr, "Cannot get resampling context\n");
1213 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1214 0, ost->resample_height, final_picture->data, final_picture->linesize);
1218 /* duplicates frame if needed */
1219 for(i=0;i<nb_frames;i++) {
1221 av_init_packet(&pkt);
1222 pkt.stream_index= ost->index;
1224 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1225 /* raw pictures are written as AVPicture structure to
1226 avoid any copies. We support temorarily the older
1228 AVFrame* old_frame = enc->coded_frame;
1229 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1230 pkt.data= (uint8_t *)final_picture;
1231 pkt.size= sizeof(AVPicture);
1232 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1233 pkt.flags |= AV_PKT_FLAG_KEY;
1235 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1236 enc->coded_frame = old_frame;
1238 AVFrame big_picture;
1240 big_picture= *final_picture;
1241 /* better than nothing: use input picture interlaced
1243 big_picture.interlaced_frame = in_picture->interlaced_frame;
1244 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1245 if(top_field_first == -1)
1246 big_picture.top_field_first = in_picture->top_field_first;
1248 big_picture.top_field_first = top_field_first;
1251 /* handles sameq here. This is not correct because it may
1252 not be a global option */
1253 big_picture.quality = quality;
1255 big_picture.pict_type = 0;
1256 // big_picture.pts = AV_NOPTS_VALUE;
1257 big_picture.pts= ost->sync_opts;
1258 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1259 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1260 if (ost->forced_kf_index < ost->forced_kf_count &&
1261 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1262 big_picture.pict_type = AV_PICTURE_TYPE_I;
1263 ost->forced_kf_index++;
1265 ret = avcodec_encode_video(enc,
1266 bit_buffer, bit_buffer_size,
1269 fprintf(stderr, "Video encoding failed\n");
1274 pkt.data= bit_buffer;
1276 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1277 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1278 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1279 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1280 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1282 if(enc->coded_frame->key_frame)
1283 pkt.flags |= AV_PKT_FLAG_KEY;
1284 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1287 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1288 // enc->frame_number-1, ret, enc->pict_type);
1289 /* if two pass, output log */
1290 if (ost->logfile && enc->stats_out) {
1291 fprintf(ost->logfile, "%s", enc->stats_out);
1296 ost->frame_number++;
1300 static double psnr(double d){
1301 return -10.0*log(d)/log(10.0);
1304 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1307 AVCodecContext *enc;
1309 double ti1, bitrate, avg_bitrate;
1311 /* this is executed just the first time do_video_stats is called */
1313 vstats_file = fopen(vstats_filename, "w");
1320 enc = ost->st->codec;
1321 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1322 frame_number = ost->frame_number;
1323 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1324 if (enc->flags&CODEC_FLAG_PSNR)
1325 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1327 fprintf(vstats_file,"f_size= %6d ", frame_size);
1328 /* compute pts value */
1329 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1333 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1334 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1335 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1336 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1337 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1341 static void print_report(AVFormatContext **output_files,
1342 OutputStream **ost_table, int nb_ostreams,
1347 AVFormatContext *oc;
1349 AVCodecContext *enc;
1350 int frame_number, vid, i;
1351 double bitrate, ti1, pts;
1352 static int64_t last_time = -1;
1353 static int qp_histogram[52];
1355 if (!is_last_report) {
1357 /* display the report every 0.5 seconds */
1358 cur_time = av_gettime();
1359 if (last_time == -1) {
1360 last_time = cur_time;
1363 if ((cur_time - last_time) < 500000)
1365 last_time = cur_time;
1369 oc = output_files[0];
1371 total_size = avio_size(oc->pb);
1372 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1373 total_size= avio_tell(oc->pb);
1378 for(i=0;i<nb_ostreams;i++) {
1381 enc = ost->st->codec;
1382 if (!ost->st->stream_copy && enc->coded_frame)
1383 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1384 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1385 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1387 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1388 float t = (av_gettime()-timer_start) / 1000000.0;
1390 frame_number = ost->frame_number;
1391 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1392 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1394 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1398 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1403 if (enc->flags&CODEC_FLAG_PSNR){
1405 double error, error_sum=0;
1406 double scale, scale_sum=0;
1407 char type[3]= {'Y','U','V'};
1408 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1411 error= enc->error[j];
1412 scale= enc->width*enc->height*255.0*255.0*frame_number;
1414 error= enc->coded_frame->error[j];
1415 scale= enc->width*enc->height*255.0*255.0;
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1422 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1426 /* compute min output value */
1427 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1428 if ((pts < ti1) && (pts > 0))
1434 if (verbose > 0 || is_last_report) {
1435 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1437 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1438 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1439 (double)total_size / 1024, ti1, bitrate);
1441 if (nb_frames_dup || nb_frames_drop)
1442 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1443 nb_frames_dup, nb_frames_drop);
1446 fprintf(stderr, "%s \r", buf);
1451 if (is_last_report && verbose >= 0){
1452 int64_t raw= audio_size + video_size + extra_size;
1453 fprintf(stderr, "\n");
1454 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1458 100.0*(total_size - raw)/raw
1463 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1465 int fill_char = 0x00;
1466 if (sample_fmt == AV_SAMPLE_FMT_U8)
1468 memset(buf, fill_char, size);
1471 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1472 static int output_packet(InputStream *ist, int ist_index,
1473 OutputStream **ost_table, int nb_ostreams,
1474 const AVPacket *pkt)
1476 AVFormatContext *os;
1481 void *buffer_to_free = NULL;
1482 static unsigned int samples_size= 0;
1483 AVSubtitle subtitle, *subtitle_to_free;
1484 int64_t pkt_pts = AV_NOPTS_VALUE;
1486 int frame_available;
1491 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1493 if(ist->next_pts == AV_NOPTS_VALUE)
1494 ist->next_pts= ist->pts;
1498 av_init_packet(&avpkt);
1506 if(pkt->dts != AV_NOPTS_VALUE)
1507 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1508 if(pkt->pts != AV_NOPTS_VALUE)
1509 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1511 //while we have more to decode or while the decoder did output something on EOF
1512 while (avpkt.size > 0 || (!pkt && got_output)) {
1513 uint8_t *data_buf, *decoded_data_buf;
1514 int data_size, decoded_data_size;
1516 ist->pts= ist->next_pts;
1518 if(avpkt.size && avpkt.size != pkt->size &&
1519 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1520 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1521 ist->showed_multi_packet_warning=1;
1524 /* decode the packet if needed */
1525 decoded_data_buf = NULL; /* fail safe */
1526 decoded_data_size= 0;
1527 data_buf = avpkt.data;
1528 data_size = avpkt.size;
1529 subtitle_to_free = NULL;
1530 if (ist->decoding_needed) {
1531 switch(ist->st->codec->codec_type) {
1532 case AVMEDIA_TYPE_AUDIO:{
1533 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1534 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1536 samples= av_malloc(samples_size);
1538 decoded_data_size= samples_size;
1539 /* XXX: could avoid copy if PCM 16 bits with same
1540 endianness as CPU */
1541 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1548 got_output = decoded_data_size > 0;
1549 /* Some bug in mpeg audio decoder gives */
1550 /* decoded_data_size < 0, it seems they are overflows */
1552 /* no audio frame */
1555 decoded_data_buf = (uint8_t *)samples;
1556 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1557 (ist->st->codec->sample_rate * ist->st->codec->channels);
1559 case AVMEDIA_TYPE_VIDEO:
1560 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1561 /* XXX: allocate picture correctly */
1562 avcodec_get_frame_defaults(&picture);
1563 avpkt.pts = pkt_pts;
1564 avpkt.dts = ist->pts;
1565 pkt_pts = AV_NOPTS_VALUE;
1567 ret = avcodec_decode_video2(ist->st->codec,
1568 &picture, &got_output, &avpkt);
1569 quality = same_quality ? picture.quality : 0;
1573 /* no picture yet */
1574 goto discard_packet;
1576 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1577 if (ist->st->codec->time_base.num != 0) {
1578 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1579 ist->next_pts += ((int64_t)AV_TIME_BASE *
1580 ist->st->codec->time_base.num * ticks) /
1581 ist->st->codec->time_base.den;
1584 buffer_to_free = NULL;
1585 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1587 case AVMEDIA_TYPE_SUBTITLE:
1588 ret = avcodec_decode_subtitle2(ist->st->codec,
1589 &subtitle, &got_output, &avpkt);
1593 goto discard_packet;
1595 subtitle_to_free = &subtitle;
1602 switch(ist->st->codec->codec_type) {
1603 case AVMEDIA_TYPE_AUDIO:
1604 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1605 ist->st->codec->sample_rate;
1607 case AVMEDIA_TYPE_VIDEO:
1608 if (ist->st->codec->time_base.num != 0) {
1609 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1610 ist->next_pts += ((int64_t)AV_TIME_BASE *
1611 ist->st->codec->time_base.num * ticks) /
1612 ist->st->codec->time_base.den;
1621 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1622 for (i = 0; i < nb_ostreams; i++) {
1624 if (ost->input_video_filter && ost->source_index == ist_index) {
1626 if (ist->st->sample_aspect_ratio.num)
1627 sar = ist->st->sample_aspect_ratio;
1629 sar = ist->st->codec->sample_aspect_ratio;
1630 // add it to be filtered
1631 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1639 // preprocess audio (volume)
1640 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1641 if (audio_volume != 256) {
1644 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1645 int v = ((*volp) * audio_volume + 128) >> 8;
1646 if (v < -32768) v = -32768;
1647 if (v > 32767) v = 32767;
1653 /* frame rate emulation */
1655 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1656 int64_t now = av_gettime() - ist->start;
1660 /* if output time reached then transcode raw format,
1661 encode packets and output them */
1662 if (start_time == 0 || ist->pts >= start_time)
1663 for(i=0;i<nb_ostreams;i++) {
1667 if (ost->source_index == ist_index) {
1669 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1670 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1671 while (frame_available) {
1672 AVRational ist_pts_tb;
1673 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1674 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1676 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1678 os = output_files[ost->file_index];
1680 /* set the input output pts pairs */
1681 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1683 if (ost->encoding_needed) {
1684 av_assert0(ist->decoding_needed);
1685 switch(ost->st->codec->codec_type) {
1686 case AVMEDIA_TYPE_AUDIO:
1687 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1689 case AVMEDIA_TYPE_VIDEO:
1691 if (ost->picref->video && !ost->frame_aspect_ratio)
1692 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1694 do_video_out(os, ost, ist, &picture, &frame_size,
1695 same_quality ? quality : ost->st->codec->global_quality);
1696 if (vstats_filename && frame_size)
1697 do_video_stats(os, ost, frame_size);
1699 case AVMEDIA_TYPE_SUBTITLE:
1700 do_subtitle_out(os, ost, ist, &subtitle,
1707 AVFrame avframe; //FIXME/XXX remove this
1709 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1711 av_init_packet(&opkt);
1713 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1714 #if !CONFIG_AVFILTER
1720 /* no reencoding needed : output the packet directly */
1721 /* force the input stream PTS */
1723 avcodec_get_frame_defaults(&avframe);
1724 ost->st->codec->coded_frame= &avframe;
1725 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1727 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1728 audio_size += data_size;
1729 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1730 video_size += data_size;
1734 opkt.stream_index= ost->index;
1735 if(pkt->pts != AV_NOPTS_VALUE)
1736 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1738 opkt.pts= AV_NOPTS_VALUE;
1740 if (pkt->dts == AV_NOPTS_VALUE)
1741 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1743 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1744 opkt.dts -= ost_tb_start_time;
1746 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1747 opkt.flags= pkt->flags;
1749 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1750 if( ost->st->codec->codec_id != CODEC_ID_H264
1751 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1752 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1754 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1755 opkt.destruct= av_destruct_packet;
1757 opkt.data = data_buf;
1758 opkt.size = data_size;
1761 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1762 ost->st->codec->frame_number++;
1763 ost->frame_number++;
1764 av_free_packet(&opkt);
1768 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1769 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1771 avfilter_unref_buffer(ost->picref);
1777 av_free(buffer_to_free);
1778 /* XXX: allocate the subtitles in the codec ? */
1779 if (subtitle_to_free) {
1780 avsubtitle_free(subtitle_to_free);
1781 subtitle_to_free = NULL;
1788 for(i=0;i<nb_ostreams;i++) {
1790 if (ost->source_index == ist_index) {
1791 AVCodecContext *enc= ost->st->codec;
1792 os = output_files[ost->file_index];
1794 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1796 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1799 if (ost->encoding_needed) {
1803 av_init_packet(&pkt);
1804 pkt.stream_index= ost->index;
1806 switch(ost->st->codec->codec_type) {
1807 case AVMEDIA_TYPE_AUDIO:
1808 fifo_bytes = av_fifo_size(ost->fifo);
1810 /* encode any samples remaining in fifo */
1811 if (fifo_bytes > 0) {
1812 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1813 int fs_tmp = enc->frame_size;
1815 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1816 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1817 enc->frame_size = fifo_bytes / (osize * enc->channels);
1819 int frame_bytes = enc->frame_size*osize*enc->channels;
1820 if (allocated_audio_buf_size < frame_bytes)
1822 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1825 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1826 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1827 ost->st->time_base.num, enc->sample_rate);
1828 enc->frame_size = fs_tmp;
1831 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1834 fprintf(stderr, "Audio encoding failed\n");
1838 pkt.flags |= AV_PKT_FLAG_KEY;
1840 case AVMEDIA_TYPE_VIDEO:
1841 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1843 fprintf(stderr, "Video encoding failed\n");
1847 if(enc->coded_frame && enc->coded_frame->key_frame)
1848 pkt.flags |= AV_PKT_FLAG_KEY;
1849 if (ost->logfile && enc->stats_out) {
1850 fprintf(ost->logfile, "%s", enc->stats_out);
1859 pkt.data= bit_buffer;
1861 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1862 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1863 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1873 static void print_sdp(AVFormatContext **avc, int n)
1877 av_sdp_create(avc, n, sdp, sizeof(sdp));
1878 printf("SDP:\n%s\n", sdp);
1882 static int copy_chapters(int infile, int outfile)
1884 AVFormatContext *is = input_files[infile].ctx;
1885 AVFormatContext *os = output_files[outfile];
1888 for (i = 0; i < is->nb_chapters; i++) {
1889 AVChapter *in_ch = is->chapters[i], *out_ch;
1890 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1891 AV_TIME_BASE_Q, in_ch->time_base);
1892 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1893 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1896 if (in_ch->end < ts_off)
1898 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1901 out_ch = av_mallocz(sizeof(AVChapter));
1903 return AVERROR(ENOMEM);
1905 out_ch->id = in_ch->id;
1906 out_ch->time_base = in_ch->time_base;
1907 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1908 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1910 if (metadata_chapters_autocopy)
1911 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1914 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1916 return AVERROR(ENOMEM);
1917 os->chapters[os->nb_chapters - 1] = out_ch;
1922 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1923 AVCodecContext *avctx)
1929 for (p = kf; *p; p++)
1932 ost->forced_kf_count = n;
1933 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1934 if (!ost->forced_kf_pts) {
1935 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1938 for (i = 0; i < n; i++) {
1939 p = i ? strchr(p, ',') + 1 : kf;
1940 t = parse_time_or_die("force_key_frames", p, 1);
1941 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1946 * The following code is the main loop of the file converter
1948 static int transcode(AVFormatContext **output_files,
1949 int nb_output_files,
1950 InputFile *input_files,
1952 StreamMap *stream_maps, int nb_stream_maps)
1954 int ret = 0, i, j, k, n, nb_ostreams = 0;
1955 AVFormatContext *is, *os;
1956 AVCodecContext *codec, *icodec;
1957 OutputStream *ost, **ost_table = NULL;
1961 uint8_t no_packet[MAX_FILES]={0};
1962 int no_packet_count=0;
1965 for (i = 0; i < nb_input_streams; i++)
1966 input_streams[i].start = av_gettime();
1968 /* output stream init */
1970 for(i=0;i<nb_output_files;i++) {
1971 os = output_files[i];
1972 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1973 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1974 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1975 ret = AVERROR(EINVAL);
1978 nb_ostreams += os->nb_streams;
1980 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1981 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1982 ret = AVERROR(EINVAL);
1986 /* Sanity check the mapping args -- do the input files & streams exist? */
1987 for(i=0;i<nb_stream_maps;i++) {
1988 int fi = stream_maps[i].file_index;
1989 int si = stream_maps[i].stream_index;
1991 if (fi < 0 || fi > nb_input_files - 1 ||
1992 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1993 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1994 ret = AVERROR(EINVAL);
1997 fi = stream_maps[i].sync_file_index;
1998 si = stream_maps[i].sync_stream_index;
1999 if (fi < 0 || fi > nb_input_files - 1 ||
2000 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2001 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2002 ret = AVERROR(EINVAL);
2007 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2011 for(k=0;k<nb_output_files;k++) {
2012 os = output_files[k];
2013 for(i=0;i<os->nb_streams;i++,n++) {
2015 ost = ost_table[n] = output_streams_for_file[k][i];
2016 if (nb_stream_maps > 0) {
2017 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2018 stream_maps[n].stream_index;
2020 /* Sanity check that the stream types match */
2021 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2022 int i= ost->file_index;
2023 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2024 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2025 stream_maps[n].file_index, stream_maps[n].stream_index,
2026 ost->file_index, ost->index);
2031 int best_nb_frames=-1;
2032 /* get corresponding input stream index : we select the first one with the right type */
2034 for (j = 0; j < nb_input_streams; j++) {
2036 ist = &input_streams[j];
2039 AVFormatContext *f = input_files[ist->file_index].ctx;
2041 for(pi=0; pi<f->nb_programs; pi++){
2042 AVProgram *p= f->programs[pi];
2043 if(p->id == opt_programid)
2044 for(si=0; si<p->nb_stream_indexes; si++){
2045 if(f->streams[ p->stream_index[si] ] == ist->st)
2050 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2051 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2052 if(best_nb_frames < ist->st->codec_info_nb_frames){
2053 best_nb_frames= ist->st->codec_info_nb_frames;
2054 ost->source_index = j;
2061 if(! opt_programid) {
2062 /* try again and reuse existing stream */
2063 for (j = 0; j < nb_input_streams; j++) {
2064 ist = &input_streams[j];
2065 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2066 && ist->st->discard != AVDISCARD_ALL) {
2067 ost->source_index = j;
2073 int i= ost->file_index;
2074 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2075 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2076 ost->file_index, ost->index);
2081 ist = &input_streams[ost->source_index];
2083 ost->sync_ist = (nb_stream_maps > 0) ?
2084 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2085 stream_maps[n].sync_stream_index] : ist;
2089 /* for each output stream, we compute the right encoding parameters */
2090 for(i=0;i<nb_ostreams;i++) {
2092 os = output_files[ost->file_index];
2093 ist = &input_streams[ost->source_index];
2095 codec = ost->st->codec;
2096 icodec = ist->st->codec;
2098 if (metadata_streams_autocopy)
2099 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2100 AV_DICT_DONT_OVERWRITE);
2102 ost->st->disposition = ist->st->disposition;
2103 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2104 codec->chroma_sample_location = icodec->chroma_sample_location;
2106 if (ost->st->stream_copy) {
2107 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2109 if (extra_size > INT_MAX)
2112 /* if stream_copy is selected, no need to decode or encode */
2113 codec->codec_id = icodec->codec_id;
2114 codec->codec_type = icodec->codec_type;
2116 if(!codec->codec_tag){
2117 if( !os->oformat->codec_tag
2118 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2119 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2120 codec->codec_tag = icodec->codec_tag;
2123 codec->bit_rate = icodec->bit_rate;
2124 codec->rc_max_rate = icodec->rc_max_rate;
2125 codec->rc_buffer_size = icodec->rc_buffer_size;
2126 codec->extradata= av_mallocz(extra_size);
2127 if (!codec->extradata)
2129 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2130 codec->extradata_size= icodec->extradata_size;
2131 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){
2132 codec->time_base = icodec->time_base;
2133 codec->time_base.num *= icodec->ticks_per_frame;
2134 av_reduce(&codec->time_base.num, &codec->time_base.den,
2135 codec->time_base.num, codec->time_base.den, INT_MAX);
2137 codec->time_base = ist->st->time_base;
2138 switch(codec->codec_type) {
2139 case AVMEDIA_TYPE_AUDIO:
2140 if(audio_volume != 256) {
2141 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2144 codec->channel_layout = icodec->channel_layout;
2145 codec->sample_rate = icodec->sample_rate;
2146 codec->channels = icodec->channels;
2147 codec->frame_size = icodec->frame_size;
2148 codec->audio_service_type = icodec->audio_service_type;
2149 codec->block_align= icodec->block_align;
2150 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2151 codec->block_align= 0;
2152 if(codec->codec_id == CODEC_ID_AC3)
2153 codec->block_align= 0;
2155 case AVMEDIA_TYPE_VIDEO:
2156 codec->pix_fmt = icodec->pix_fmt;
2157 codec->width = icodec->width;
2158 codec->height = icodec->height;
2159 codec->has_b_frames = icodec->has_b_frames;
2160 if (!codec->sample_aspect_ratio.num) {
2161 codec->sample_aspect_ratio =
2162 ost->st->sample_aspect_ratio =
2163 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2164 ist->st->codec->sample_aspect_ratio.num ?
2165 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2168 case AVMEDIA_TYPE_SUBTITLE:
2169 codec->width = icodec->width;
2170 codec->height = icodec->height;
2172 case AVMEDIA_TYPE_DATA:
2179 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2180 switch(codec->codec_type) {
2181 case AVMEDIA_TYPE_AUDIO:
2182 ost->fifo= av_fifo_alloc(1024);
2185 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2186 if (!codec->sample_rate) {
2187 codec->sample_rate = icodec->sample_rate;
2189 codec->sample_rate >>= icodec->lowres;
2191 choose_sample_rate(ost->st, ost->enc);
2192 codec->time_base = (AVRational){1, codec->sample_rate};
2193 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2194 codec->sample_fmt = icodec->sample_fmt;
2195 choose_sample_fmt(ost->st, ost->enc);
2196 if (!codec->channels)
2197 codec->channels = icodec->channels;
2198 codec->channel_layout = icodec->channel_layout;
2199 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2200 codec->channel_layout = 0;
2201 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2202 icodec->request_channels = codec->channels;
2203 ist->decoding_needed = 1;
2204 ost->encoding_needed = 1;
2205 ost->resample_sample_fmt = icodec->sample_fmt;
2206 ost->resample_sample_rate = icodec->sample_rate;
2207 ost->resample_channels = icodec->channels;
2209 case AVMEDIA_TYPE_VIDEO:
2210 if (codec->pix_fmt == PIX_FMT_NONE)
2211 codec->pix_fmt = icodec->pix_fmt;
2212 choose_pixel_fmt(ost->st, ost->enc);
2214 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2215 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2219 if (!codec->width || !codec->height) {
2220 codec->width = icodec->width;
2221 codec->height = icodec->height;
2224 ost->video_resample = codec->width != icodec->width ||
2225 codec->height != icodec->height ||
2226 codec->pix_fmt != icodec->pix_fmt;
2227 if (ost->video_resample) {
2228 #if !CONFIG_AVFILTER
2229 avcodec_get_frame_defaults(&ost->pict_tmp);
2230 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2231 codec->width, codec->height)) {
2232 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2235 ost->img_resample_ctx = sws_getContext(
2242 ost->sws_flags, NULL, NULL, NULL);
2243 if (ost->img_resample_ctx == NULL) {
2244 fprintf(stderr, "Cannot get resampling context\n");
2248 codec->bits_per_raw_sample= 0;
2251 ost->resample_height = icodec->height;
2252 ost->resample_width = icodec->width;
2253 ost->resample_pix_fmt= icodec->pix_fmt;
2254 ost->encoding_needed = 1;
2255 ist->decoding_needed = 1;
2257 if (!ost->frame_rate.num)
2258 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2259 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2260 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2261 ost->frame_rate = ost->enc->supported_framerates[idx];
2263 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2266 if (configure_video_filters(ist, ost)) {
2267 fprintf(stderr, "Error opening filters!\n");
2272 case AVMEDIA_TYPE_SUBTITLE:
2273 ost->encoding_needed = 1;
2274 ist->decoding_needed = 1;
2281 if (ost->encoding_needed &&
2282 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2283 char logfilename[1024];
2286 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2287 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2289 if (codec->flags & CODEC_FLAG_PASS1) {
2290 f = fopen(logfilename, "wb");
2292 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2298 size_t logbuffer_size;
2299 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2300 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2303 codec->stats_in = logbuffer;
2307 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2308 int size= codec->width * codec->height;
2309 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2314 bit_buffer = av_malloc(bit_buffer_size);
2316 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2318 ret = AVERROR(ENOMEM);
2322 /* open each encoder */
2323 for(i=0;i<nb_ostreams;i++) {
2325 if (ost->encoding_needed) {
2326 AVCodec *codec = ost->enc;
2327 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2329 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2330 ost->st->codec->codec_id, ost->file_index, ost->index);
2331 ret = AVERROR(EINVAL);
2334 if (dec->subtitle_header) {
2335 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2336 if (!ost->st->codec->subtitle_header) {
2337 ret = AVERROR(ENOMEM);
2340 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2341 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2343 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2344 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2345 ost->file_index, ost->index);
2346 ret = AVERROR(EINVAL);
2349 assert_codec_experimental(ost->st->codec, 1);
2350 assert_avoptions(ost->opts);
2351 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2352 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2353 "It takes bits/s as argument, not kbits/s\n");
2354 extra_size += ost->st->codec->extradata_size;
2358 /* open each decoder */
2359 for (i = 0; i < nb_input_streams; i++) {
2360 ist = &input_streams[i];
2361 if (ist->decoding_needed) {
2362 AVCodec *codec = ist->dec;
2364 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2366 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2367 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2368 ret = AVERROR(EINVAL);
2372 /* update requested sample format for the decoder based on the
2373 corresponding encoder sample format */
2374 for (j = 0; j < nb_ostreams; j++) {
2376 if (ost->source_index == i) {
2377 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2382 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2383 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2384 ist->file_index, ist->st->index);
2385 ret = AVERROR(EINVAL);
2388 assert_codec_experimental(ist->st->codec, 0);
2389 assert_avoptions(ost->opts);
2394 for (i = 0; i < nb_input_streams; i++) {
2396 ist = &input_streams[i];
2398 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2399 ist->next_pts = AV_NOPTS_VALUE;
2400 init_pts_correction(&ist->pts_ctx);
2404 /* set meta data information from input file if required */
2405 for (i=0;i<nb_meta_data_maps;i++) {
2406 AVFormatContext *files[2];
2407 AVDictionary **meta[2];
2410 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2411 if ((index) < 0 || (index) >= (nb_elems)) {\
2412 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2414 ret = AVERROR(EINVAL);\
2418 int out_file_index = meta_data_maps[i][0].file;
2419 int in_file_index = meta_data_maps[i][1].file;
2420 if (in_file_index < 0 || out_file_index < 0)
2422 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2423 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2425 files[0] = output_files[out_file_index];
2426 files[1] = input_files[in_file_index].ctx;
2428 for (j = 0; j < 2; j++) {
2429 MetadataMap *map = &meta_data_maps[i][j];
2431 switch (map->type) {
2433 meta[j] = &files[j]->metadata;
2436 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2437 meta[j] = &files[j]->streams[map->index]->metadata;
2440 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2441 meta[j] = &files[j]->chapters[map->index]->metadata;
2444 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2445 meta[j] = &files[j]->programs[map->index]->metadata;
2450 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2453 /* copy global metadata by default */
2454 if (metadata_global_autocopy) {
2456 for (i = 0; i < nb_output_files; i++)
2457 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2458 AV_DICT_DONT_OVERWRITE);
2461 /* copy chapters according to chapter maps */
2462 for (i = 0; i < nb_chapter_maps; i++) {
2463 int infile = chapter_maps[i].in_file;
2464 int outfile = chapter_maps[i].out_file;
2466 if (infile < 0 || outfile < 0)
2468 if (infile >= nb_input_files) {
2469 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2470 ret = AVERROR(EINVAL);
2473 if (outfile >= nb_output_files) {
2474 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2475 ret = AVERROR(EINVAL);
2478 copy_chapters(infile, outfile);
2481 /* copy chapters from the first input file that has them*/
2482 if (!nb_chapter_maps)
2483 for (i = 0; i < nb_input_files; i++) {
2484 if (!input_files[i].ctx->nb_chapters)
2487 for (j = 0; j < nb_output_files; j++)
2488 if ((ret = copy_chapters(i, j)) < 0)
2493 /* open files and write file headers */
2494 for(i=0;i<nb_output_files;i++) {
2495 os = output_files[i];
2496 if (avformat_write_header(os, &output_opts[i]) < 0) {
2497 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2498 ret = AVERROR(EINVAL);
2501 assert_avoptions(output_opts[i]);
2502 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2508 /* dump the file output parameters - cannot be done before in case
2510 for(i=0;i<nb_output_files;i++) {
2511 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2514 /* dump the stream mapping */
2516 fprintf(stderr, "Stream mapping:\n");
2517 for(i=0;i<nb_ostreams;i++) {
2519 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2520 input_streams[ost->source_index].file_index,
2521 input_streams[ost->source_index].st->index,
2524 if (ost->sync_ist != &input_streams[ost->source_index])
2525 fprintf(stderr, " [sync #%d.%d]",
2526 ost->sync_ist->file_index,
2527 ost->sync_ist->st->index);
2528 fprintf(stderr, "\n");
2533 fprintf(stderr, "%s\n", error);
2538 print_sdp(output_files, nb_output_files);
2542 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2545 timer_start = av_gettime();
2547 for(; received_sigterm == 0;) {
2548 int file_index, ist_index;
2557 /* select the stream that we must read now by looking at the
2558 smallest output pts */
2560 for(i=0;i<nb_ostreams;i++) {
2563 os = output_files[ost->file_index];
2564 ist = &input_streams[ost->source_index];
2565 if(ist->is_past_recording_time || no_packet[ist->file_index])
2567 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2568 ipts = (double)ist->pts;
2569 if (!input_files[ist->file_index].eof_reached){
2570 if(ipts < ipts_min) {
2572 if(input_sync ) file_index = ist->file_index;
2574 if(opts < opts_min) {
2576 if(!input_sync) file_index = ist->file_index;
2579 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2584 /* if none, if is finished */
2585 if (file_index < 0) {
2586 if(no_packet_count){
2588 memset(no_packet, 0, sizeof(no_packet));
2595 /* finish if limit size exhausted */
2596 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2599 /* read a frame from it and output it in the fifo */
2600 is = input_files[file_index].ctx;
2601 ret= av_read_frame(is, &pkt);
2602 if(ret == AVERROR(EAGAIN)){
2603 no_packet[file_index]=1;
2608 input_files[file_index].eof_reached = 1;
2616 memset(no_packet, 0, sizeof(no_packet));
2619 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2620 is->streams[pkt.stream_index]);
2622 /* the following test is needed in case new streams appear
2623 dynamically in stream : we ignore them */
2624 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2625 goto discard_packet;
2626 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2627 ist = &input_streams[ist_index];
2629 goto discard_packet;
2631 if (pkt.dts != AV_NOPTS_VALUE)
2632 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2633 if (pkt.pts != AV_NOPTS_VALUE)
2634 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2636 if (ist->ts_scale) {
2637 if(pkt.pts != AV_NOPTS_VALUE)
2638 pkt.pts *= ist->ts_scale;
2639 if(pkt.dts != AV_NOPTS_VALUE)
2640 pkt.dts *= ist->ts_scale;
2643 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2644 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2645 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2646 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2647 int64_t delta= pkt_dts - ist->next_pts;
2648 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2649 input_files[ist->file_index].ts_offset -= delta;
2651 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2652 delta, input_files[ist->file_index].ts_offset);
2653 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2654 if(pkt.pts != AV_NOPTS_VALUE)
2655 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2659 /* finish if recording time exhausted */
2660 if (recording_time != INT64_MAX &&
2661 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2662 ist->is_past_recording_time = 1;
2663 goto discard_packet;
2666 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2667 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2670 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2671 ist->file_index, ist->st->index);
2674 av_free_packet(&pkt);
2679 av_free_packet(&pkt);
2681 /* dump report by using the output first video and audio streams */
2682 print_report(output_files, ost_table, nb_ostreams, 0);
2685 /* at the end of stream, we must flush the decoder buffers */
2686 for (i = 0; i < nb_input_streams; i++) {
2687 ist = &input_streams[i];
2688 if (ist->decoding_needed) {
2689 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2695 /* write the trailer if needed and close file */
2696 for(i=0;i<nb_output_files;i++) {
2697 os = output_files[i];
2698 av_write_trailer(os);
2701 /* dump report by using the first video and audio streams */
2702 print_report(output_files, ost_table, nb_ostreams, 1);
2704 /* close each encoder */
2705 for(i=0;i<nb_ostreams;i++) {
2707 if (ost->encoding_needed) {
2708 av_freep(&ost->st->codec->stats_in);
2709 avcodec_close(ost->st->codec);
2712 avfilter_graph_free(&ost->graph);
2716 /* close each decoder */
2717 for (i = 0; i < nb_input_streams; i++) {
2718 ist = &input_streams[i];
2719 if (ist->decoding_needed) {
2720 avcodec_close(ist->st->codec);
2728 av_freep(&bit_buffer);
2731 for(i=0;i<nb_ostreams;i++) {
2734 if (ost->st->stream_copy)
2735 av_freep(&ost->st->codec->extradata);
2737 fclose(ost->logfile);
2738 ost->logfile = NULL;
2740 av_fifo_free(ost->fifo); /* works even if fifo is not
2741 initialized but set to zero */
2742 av_freep(&ost->st->codec->subtitle_header);
2743 av_free(ost->pict_tmp.data[0]);
2744 av_free(ost->forced_kf_pts);
2745 if (ost->video_resample)
2746 sws_freeContext(ost->img_resample_ctx);
2748 audio_resample_close(ost->resample);
2749 if (ost->reformat_ctx)
2750 av_audio_convert_free(ost->reformat_ctx);
2751 av_dict_free(&ost->opts);
2760 static int opt_format(const char *opt, const char *arg)
2762 last_asked_format = arg;
2766 static int opt_video_rc_override_string(const char *opt, const char *arg)
2768 video_rc_override_string = arg;
2772 static int opt_me_threshold(const char *opt, const char *arg)
2774 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2778 static int opt_verbose(const char *opt, const char *arg)
2780 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2784 static int opt_frame_rate(const char *opt, const char *arg)
2786 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2787 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2793 static int opt_frame_crop(const char *opt, const char *arg)
2795 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2796 return AVERROR(EINVAL);
2799 static int opt_frame_size(const char *opt, const char *arg)
2801 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2802 fprintf(stderr, "Incorrect frame size\n");
2803 return AVERROR(EINVAL);
2808 static int opt_pad(const char *opt, const char *arg) {
2809 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2813 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2815 if (strcmp(arg, "list")) {
2816 frame_pix_fmt = av_get_pix_fmt(arg);
2817 if (frame_pix_fmt == PIX_FMT_NONE) {
2818 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2819 return AVERROR(EINVAL);
2828 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2835 p = strchr(arg, ':');
2837 x = strtol(arg, &end, 10);
2839 y = strtol(end+1, &end, 10);
2841 ar = (double)x / (double)y;
2843 ar = strtod(arg, NULL);
2846 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2847 return AVERROR(EINVAL);
2849 frame_aspect_ratio = ar;
2853 static int opt_metadata(const char *opt, const char *arg)
2855 char *mid= strchr(arg, '=');
2858 fprintf(stderr, "Missing =\n");
2863 av_dict_set(&metadata, arg, mid, 0);
2868 static int opt_qscale(const char *opt, const char *arg)
2870 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2871 if (video_qscale == 0) {
2872 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2873 return AVERROR(EINVAL);
2878 static int opt_top_field_first(const char *opt, const char *arg)
2880 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2884 static int opt_thread_count(const char *opt, const char *arg)
2886 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2889 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2894 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2896 if (strcmp(arg, "list")) {
2897 audio_sample_fmt = av_get_sample_fmt(arg);
2898 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2899 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2900 return AVERROR(EINVAL);
2905 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2906 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2912 static int opt_audio_rate(const char *opt, const char *arg)
2914 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2918 static int opt_audio_channels(const char *opt, const char *arg)
2920 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2924 static int opt_video_channel(const char *opt, const char *arg)
2926 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2927 opt_default("channel", arg);
2931 static int opt_video_standard(const char *opt, const char *arg)
2933 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2934 opt_default("standard", arg);
2938 static int opt_codec(int *pstream_copy, char **pcodec_name,
2939 int codec_type, const char *arg)
2941 av_freep(pcodec_name);
2942 if (!strcmp(arg, "copy")) {
2945 *pcodec_name = av_strdup(arg);
2950 static int opt_audio_codec(const char *opt, const char *arg)
2952 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2955 static int opt_video_codec(const char *opt, const char *arg)
2957 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2960 static int opt_subtitle_codec(const char *opt, const char *arg)
2962 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2965 static int opt_data_codec(const char *opt, const char *arg)
2967 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2970 static int opt_codec_tag(const char *opt, const char *arg)
2973 uint32_t *codec_tag;
2975 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2976 !strcmp(opt, "vtag") ? &video_codec_tag :
2977 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2981 *codec_tag = strtol(arg, &tail, 0);
2983 *codec_tag = AV_RL32(arg);
2988 static int opt_map(const char *opt, const char *arg)
2993 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2994 m = &stream_maps[nb_stream_maps-1];
2996 m->file_index = strtol(arg, &p, 0);
3000 m->stream_index = strtol(p, &p, 0);
3003 m->sync_file_index = strtol(p, &p, 0);
3006 m->sync_stream_index = strtol(p, &p, 0);
3008 m->sync_file_index = m->file_index;
3009 m->sync_stream_index = m->stream_index;
3014 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3025 *index = strtol(++arg, endptr, 0);
3028 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3035 static int opt_map_metadata(const char *opt, const char *arg)
3037 MetadataMap *m, *m1;
3040 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3041 &nb_meta_data_maps, nb_meta_data_maps + 1);
3043 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3044 m->file = strtol(arg, &p, 0);
3045 parse_meta_type(p, &m->type, &m->index, &p);
3049 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3050 m1->file = strtol(p, &p, 0);
3051 parse_meta_type(p, &m1->type, &m1->index, &p);
3053 if (m->type == 'g' || m1->type == 'g')
3054 metadata_global_autocopy = 0;
3055 if (m->type == 's' || m1->type == 's')
3056 metadata_streams_autocopy = 0;
3057 if (m->type == 'c' || m1->type == 'c')
3058 metadata_chapters_autocopy = 0;
3063 static int opt_map_meta_data(const char *opt, const char *arg)
3065 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3066 "Use -map_metadata instead.\n");
3067 return opt_map_metadata(opt, arg);
3070 static int opt_map_chapters(const char *opt, const char *arg)
3075 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3076 nb_chapter_maps + 1);
3077 c = &chapter_maps[nb_chapter_maps - 1];
3078 c->out_file = strtol(arg, &p, 0);
3082 c->in_file = strtol(p, &p, 0);
3086 static int opt_input_ts_scale(const char *opt, const char *arg)
3088 unsigned int stream;
3092 stream = strtol(arg, &p, 0);
3095 scale= strtod(p, &p);
3097 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3098 ts_scale[stream] = scale;
3102 static int opt_recording_time(const char *opt, const char *arg)
3104 recording_time = parse_time_or_die(opt, arg, 1);
3108 static int opt_start_time(const char *opt, const char *arg)
3110 start_time = parse_time_or_die(opt, arg, 1);
3114 static int opt_recording_timestamp(const char *opt, const char *arg)
3117 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3118 struct tm time = *gmtime((time_t*)&recording_timestamp);
3119 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3120 opt_metadata("metadata", buf);
3122 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3123 "tag instead.\n", opt);
3127 static int opt_input_ts_offset(const char *opt, const char *arg)
3129 input_ts_offset = parse_time_or_die(opt, arg, 1);
3133 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3135 const char *codec_string = encoder ? "encoder" : "decoder";
3139 return CODEC_ID_NONE;
3141 avcodec_find_encoder_by_name(name) :
3142 avcodec_find_decoder_by_name(name);
3144 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3147 if(codec->type != type) {
3148 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3154 static int opt_input_file(const char *opt, const char *filename)
3156 AVFormatContext *ic;
3157 AVInputFormat *file_iformat = NULL;
3158 int err, i, ret, rfps, rfps_base;
3161 AVDictionary **opts;
3162 int orig_nb_streams; // number of streams before avformat_find_stream_info
3164 if (last_asked_format) {
3165 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3166 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3169 last_asked_format = NULL;
3172 if (!strcmp(filename, "-"))
3175 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3176 !strcmp(filename, "/dev/stdin");
3178 /* get default parameters from command line */
3179 ic = avformat_alloc_context();
3181 print_error(filename, AVERROR(ENOMEM));
3184 if (audio_sample_rate) {
3185 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3186 av_dict_set(&format_opts, "sample_rate", buf, 0);
3188 if (audio_channels) {
3189 snprintf(buf, sizeof(buf), "%d", audio_channels);
3190 av_dict_set(&format_opts, "channels", buf, 0);
3192 if (frame_rate.num) {
3193 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3194 av_dict_set(&format_opts, "framerate", buf, 0);
3196 if (frame_width && frame_height) {
3197 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3198 av_dict_set(&format_opts, "video_size", buf, 0);
3200 if (frame_pix_fmt != PIX_FMT_NONE)
3201 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3203 ic->video_codec_id =
3204 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3205 ic->audio_codec_id =
3206 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3207 ic->subtitle_codec_id=
3208 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3209 ic->flags |= AVFMT_FLAG_NONBLOCK;
3211 /* open the input file with generic libav function */
3212 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3214 print_error(filename, err);
3217 assert_avoptions(format_opts);
3222 for(i=0; i<ic->nb_streams; i++){
3223 ic->streams[i]->discard= AVDISCARD_ALL;
3225 for(i=0; i<ic->nb_programs; i++){
3226 AVProgram *p= ic->programs[i];
3227 if(p->id != opt_programid){
3228 p->discard = AVDISCARD_ALL;
3231 for(j=0; j<p->nb_stream_indexes; j++){
3232 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3237 fprintf(stderr, "Specified program id not found\n");
3244 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3245 ic->loop_input = loop_input;
3248 /* Set AVCodecContext options for avformat_find_stream_info */
3249 opts = setup_find_stream_info_opts(ic, codec_opts);
3250 orig_nb_streams = ic->nb_streams;
3252 /* If not enough info to get the stream parameters, we decode the
3253 first frames to get it. (used in mpeg case for example) */
3254 ret = avformat_find_stream_info(ic, opts);
3255 if (ret < 0 && verbose >= 0) {
3256 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3257 av_close_input_file(ic);
3261 timestamp = start_time;
3262 /* add the stream start time */
3263 if (ic->start_time != AV_NOPTS_VALUE)
3264 timestamp += ic->start_time;
3266 /* if seeking requested, we execute it */
3267 if (start_time != 0) {
3268 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3270 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3271 filename, (double)timestamp / AV_TIME_BASE);
3273 /* reset seek info */
3277 /* update the current parameters so that they match the one of the input stream */
3278 for(i=0;i<ic->nb_streams;i++) {
3279 AVStream *st = ic->streams[i];
3280 AVCodecContext *dec = st->codec;
3283 dec->thread_count = thread_count;
3285 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3286 ist = &input_streams[nb_input_streams - 1];
3288 ist->file_index = nb_input_files;
3290 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3292 if (i < nb_ts_scale)
3293 ist->ts_scale = ts_scale[i];
3295 switch (dec->codec_type) {
3296 case AVMEDIA_TYPE_AUDIO:
3297 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3299 st->discard= AVDISCARD_ALL;
3301 case AVMEDIA_TYPE_VIDEO:
3302 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3303 rfps = ic->streams[i]->r_frame_rate.num;
3304 rfps_base = ic->streams[i]->r_frame_rate.den;
3306 dec->flags |= CODEC_FLAG_EMU_EDGE;
3307 dec->height >>= dec->lowres;
3308 dec->width >>= dec->lowres;
3311 dec->debug |= FF_DEBUG_MV;
3313 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3316 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3317 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3319 (float)rfps / rfps_base, rfps, rfps_base);
3323 st->discard= AVDISCARD_ALL;
3324 else if(video_discard)
3325 st->discard= video_discard;
3327 case AVMEDIA_TYPE_DATA:
3329 case AVMEDIA_TYPE_SUBTITLE:
3330 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3331 if(subtitle_disable)
3332 st->discard = AVDISCARD_ALL;
3334 case AVMEDIA_TYPE_ATTACHMENT:
3335 case AVMEDIA_TYPE_UNKNOWN:
3342 /* dump the file content */
3344 av_dump_format(ic, nb_input_files, filename, 0);
3346 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3347 input_files[nb_input_files - 1].ctx = ic;
3348 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3349 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3351 frame_rate = (AVRational){0, 0};
3352 frame_pix_fmt = PIX_FMT_NONE;
3355 audio_sample_rate = 0;
3357 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3358 av_freep(&ts_scale);
3361 for (i = 0; i < orig_nb_streams; i++)
3362 av_dict_free(&opts[i]);
3364 av_freep(&video_codec_name);
3365 av_freep(&audio_codec_name);
3366 av_freep(&subtitle_codec_name);
3372 static void check_inputs(int *has_video_ptr,
3374 int *has_subtitle_ptr,
3377 int has_video, has_audio, has_subtitle, has_data, i, j;
3378 AVFormatContext *ic;
3385 for(j=0;j<nb_input_files;j++) {
3386 ic = input_files[j].ctx;
3387 for(i=0;i<ic->nb_streams;i++) {
3388 AVCodecContext *enc = ic->streams[i]->codec;
3389 switch(enc->codec_type) {
3390 case AVMEDIA_TYPE_AUDIO:
3393 case AVMEDIA_TYPE_VIDEO:
3396 case AVMEDIA_TYPE_SUBTITLE:
3399 case AVMEDIA_TYPE_DATA:
3400 case AVMEDIA_TYPE_ATTACHMENT:
3401 case AVMEDIA_TYPE_UNKNOWN:
3409 *has_video_ptr = has_video;
3410 *has_audio_ptr = has_audio;
3411 *has_subtitle_ptr = has_subtitle;
3412 *has_data_ptr = has_data;
3415 static void new_video_stream(AVFormatContext *oc, int file_idx)
3419 AVCodecContext *video_enc;
3420 enum CodecID codec_id = CODEC_ID_NONE;
3421 AVCodec *codec= NULL;
3423 if(!video_stream_copy){
3424 if (video_codec_name) {
3425 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3426 codec = avcodec_find_encoder_by_name(video_codec_name);
3428 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3429 codec = avcodec_find_encoder(codec_id);
3433 ost = new_output_stream(oc, file_idx, codec);
3435 if (!video_stream_copy) {
3436 ost->frame_aspect_ratio = frame_aspect_ratio;
3437 frame_aspect_ratio = 0;
3439 ost->avfilter= vfilters;
3444 ost->bitstream_filters = video_bitstream_filters;
3445 video_bitstream_filters= NULL;
3447 st->codec->thread_count= thread_count;
3449 video_enc = st->codec;
3452 video_enc->codec_tag= video_codec_tag;
3454 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3455 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3458 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3459 if (video_stream_copy) {
3460 st->stream_copy = 1;
3461 video_enc->sample_aspect_ratio =
3462 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3468 ost->frame_rate = frame_rate;
3469 video_enc->codec_id = codec_id;
3471 video_enc->width = frame_width;
3472 video_enc->height = frame_height;
3473 video_enc->pix_fmt = frame_pix_fmt;
3474 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3477 video_enc->gop_size = 0;
3478 if (video_qscale || same_quality) {
3479 video_enc->flags |= CODEC_FLAG_QSCALE;
3480 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3484 video_enc->intra_matrix = intra_matrix;
3486 video_enc->inter_matrix = inter_matrix;
3488 p= video_rc_override_string;
3491 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3493 fprintf(stderr, "error parsing rc_override\n");
3496 video_enc->rc_override=
3497 av_realloc(video_enc->rc_override,
3498 sizeof(RcOverride)*(i+1));
3499 video_enc->rc_override[i].start_frame= start;
3500 video_enc->rc_override[i].end_frame = end;
3502 video_enc->rc_override[i].qscale= q;
3503 video_enc->rc_override[i].quality_factor= 1.0;
3506 video_enc->rc_override[i].qscale= 0;
3507 video_enc->rc_override[i].quality_factor= -q/100.0;
3512 video_enc->rc_override_count=i;
3513 if (!video_enc->rc_initial_buffer_occupancy)
3514 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3515 video_enc->me_threshold= me_threshold;
3516 video_enc->intra_dc_precision= intra_dc_precision - 8;
3519 video_enc->flags|= CODEC_FLAG_PSNR;
3524 video_enc->flags |= CODEC_FLAG_PASS1;
3526 video_enc->flags |= CODEC_FLAG_PASS2;
3530 if (forced_key_frames)
3531 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3533 if (video_language) {
3534 av_dict_set(&st->metadata, "language", video_language, 0);
3535 av_freep(&video_language);
3538 /* reset some key parameters */
3540 av_freep(&video_codec_name);
3541 av_freep(&forced_key_frames);
3542 video_stream_copy = 0;
3543 frame_pix_fmt = PIX_FMT_NONE;
3546 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3550 AVCodec *codec= NULL;
3551 AVCodecContext *audio_enc;
3552 enum CodecID codec_id = CODEC_ID_NONE;
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 codec = avcodec_find_encoder_by_name(audio_codec_name);
3559 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3560 codec = avcodec_find_encoder(codec_id);
3563 ost = new_output_stream(oc, file_idx, codec);
3566 ost->bitstream_filters = audio_bitstream_filters;
3567 audio_bitstream_filters= NULL;
3569 st->codec->thread_count= thread_count;
3571 audio_enc = st->codec;
3572 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3575 audio_enc->codec_tag= audio_codec_tag;
3577 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3578 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3580 if (audio_stream_copy) {
3581 st->stream_copy = 1;
3583 audio_enc->codec_id = codec_id;
3585 if (audio_qscale > QSCALE_NONE) {
3586 audio_enc->flags |= CODEC_FLAG_QSCALE;
3587 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3590 audio_enc->channels = audio_channels;
3591 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3592 audio_enc->sample_fmt = audio_sample_fmt;
3593 if (audio_sample_rate)
3594 audio_enc->sample_rate = audio_sample_rate;
3596 if (audio_language) {
3597 av_dict_set(&st->metadata, "language", audio_language, 0);
3598 av_freep(&audio_language);
3601 /* reset some key parameters */
3603 av_freep(&audio_codec_name);
3604 audio_stream_copy = 0;
3607 static void new_data_stream(AVFormatContext *oc, int file_idx)
3611 AVCodecContext *data_enc;
3613 ost = new_output_stream(oc, file_idx, NULL);
3615 data_enc = st->codec;
3616 if (!data_stream_copy) {
3617 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3621 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3624 data_enc->codec_tag= data_codec_tag;
3626 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3627 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3629 if (data_stream_copy) {
3630 st->stream_copy = 1;
3634 av_freep(&data_codec_name);
3635 data_stream_copy = 0;
3638 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3642 AVCodec *codec=NULL;
3643 AVCodecContext *subtitle_enc;
3644 enum CodecID codec_id = CODEC_ID_NONE;
3646 if(!subtitle_stream_copy){
3647 if (subtitle_codec_name) {
3648 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3649 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3651 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3652 codec = avcodec_find_encoder(codec_id);
3655 ost = new_output_stream(oc, file_idx, codec);
3657 subtitle_enc = st->codec;
3659 ost->bitstream_filters = subtitle_bitstream_filters;
3660 subtitle_bitstream_filters= NULL;
3662 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3664 if(subtitle_codec_tag)
3665 subtitle_enc->codec_tag= subtitle_codec_tag;
3667 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3668 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3670 if (subtitle_stream_copy) {
3671 st->stream_copy = 1;
3673 subtitle_enc->codec_id = codec_id;
3676 if (subtitle_language) {
3677 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3678 av_freep(&subtitle_language);
3681 subtitle_disable = 0;
3682 av_freep(&subtitle_codec_name);
3683 subtitle_stream_copy = 0;
3686 static int opt_new_stream(const char *opt, const char *arg)
3688 AVFormatContext *oc;
3689 int file_idx = nb_output_files - 1;
3690 if (nb_output_files <= 0) {
3691 fprintf(stderr, "At least one output file must be specified\n");
3694 oc = output_files[file_idx];
3696 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3697 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3698 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3699 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3704 /* arg format is "output-stream-index:streamid-value". */
3705 static int opt_streamid(const char *opt, const char *arg)
3711 av_strlcpy(idx_str, arg, sizeof(idx_str));
3712 p = strchr(idx_str, ':');
3715 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3720 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3721 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3722 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3726 static void opt_output_file(const char *filename)
3728 AVFormatContext *oc;
3729 int err, use_video, use_audio, use_subtitle, use_data;
3730 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3731 AVOutputFormat *file_oformat;
3733 if (!strcmp(filename, "-"))
3736 oc = avformat_alloc_context();
3738 print_error(filename, AVERROR(ENOMEM));
3742 if (last_asked_format) {
3743 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3744 if (!file_oformat) {
3745 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3748 last_asked_format = NULL;
3750 file_oformat = av_guess_format(NULL, filename, NULL);
3751 if (!file_oformat) {
3752 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3758 oc->oformat = file_oformat;
3759 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3761 if (!strcmp(file_oformat->name, "ffm") &&
3762 av_strstart(filename, "http:", NULL)) {
3763 /* special case for files sent to avserver: we get the stream
3764 parameters from avserver */
3765 int err = read_avserver_streams(oc, filename);
3767 print_error(filename, err);
3771 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3772 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3773 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3774 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 */
3776 /* disable if no corresponding type found */
3777 check_inputs(&input_has_video,
3779 &input_has_subtitle,
3782 if (!input_has_video)
3784 if (!input_has_audio)
3786 if (!input_has_subtitle)
3788 if (!input_has_data)
3791 /* manual disable */
3792 if (audio_disable) use_audio = 0;
3793 if (video_disable) use_video = 0;
3794 if (subtitle_disable) use_subtitle = 0;
3795 if (data_disable) use_data = 0;
3797 if (use_video) new_video_stream(oc, nb_output_files);
3798 if (use_audio) new_audio_stream(oc, nb_output_files);
3799 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3800 if (use_data) new_data_stream(oc, nb_output_files);
3802 av_dict_copy(&oc->metadata, metadata, 0);
3803 av_dict_free(&metadata);
3806 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3807 output_files[nb_output_files++] = oc;
3809 /* check filename in case of an image number is expected */
3810 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3811 if (!av_filename_number_test(oc->filename)) {
3812 print_error(oc->filename, AVERROR(EINVAL));
3817 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3818 /* test if it already exists to avoid loosing precious files */
3819 if (!file_overwrite &&
3820 (strchr(filename, ':') == NULL ||
3821 filename[1] == ':' ||
3822 av_strstart(filename, "file:", NULL))) {
3823 if (avio_check(filename, 0) == 0) {
3825 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3827 if (!read_yesno()) {
3828 fprintf(stderr, "Not overwriting - exiting\n");
3833 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3840 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3841 print_error(filename, err);
3846 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3847 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3848 if (loop_output >= 0) {
3849 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3850 oc->loop_output = loop_output;
3852 oc->flags |= AVFMT_FLAG_NONBLOCK;
3854 frame_rate = (AVRational){0, 0};
3857 audio_sample_rate = 0;
3859 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3861 av_freep(&forced_key_frames);
3866 /* same option as mencoder */
3867 static int opt_pass(const char *opt, const char *arg)
3869 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3873 static int64_t getutime(void)
3876 struct rusage rusage;
3878 getrusage(RUSAGE_SELF, &rusage);
3879 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3880 #elif HAVE_GETPROCESSTIMES
3882 FILETIME c, e, k, u;
3883 proc = GetCurrentProcess();
3884 GetProcessTimes(proc, &c, &e, &k, &u);
3885 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3887 return av_gettime();
3891 static int64_t getmaxrss(void)
3893 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3894 struct rusage rusage;
3895 getrusage(RUSAGE_SELF, &rusage);
3896 return (int64_t)rusage.ru_maxrss * 1024;
3897 #elif HAVE_GETPROCESSMEMORYINFO
3899 PROCESS_MEMORY_COUNTERS memcounters;
3900 proc = GetCurrentProcess();
3901 memcounters.cb = sizeof(memcounters);
3902 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3903 return memcounters.PeakPagefileUsage;
3909 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3912 const char *p = str;
3919 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3926 static void opt_inter_matrix(const char *arg)
3928 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3929 parse_matrix_coeffs(inter_matrix, arg);
3932 static void opt_intra_matrix(const char *arg)
3934 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3935 parse_matrix_coeffs(intra_matrix, arg);
3938 static void show_usage(void)
3940 printf("Hyper fast Audio and Video encoder\n");
3941 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3945 static void show_help(void)
3948 AVOutputFormat *oformat = NULL;
3949 AVInputFormat *iformat = NULL;
3951 av_log_set_callback(log_callback_help);
3953 show_help_options(options, "Main options:\n",
3954 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3955 show_help_options(options, "\nAdvanced options:\n",
3956 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3958 show_help_options(options, "\nVideo options:\n",
3959 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3961 show_help_options(options, "\nAdvanced Video options:\n",
3962 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3963 OPT_VIDEO | OPT_EXPERT);
3964 show_help_options(options, "\nAudio options:\n",
3965 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3967 show_help_options(options, "\nAdvanced Audio options:\n",
3968 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3969 OPT_AUDIO | OPT_EXPERT);
3970 show_help_options(options, "\nSubtitle options:\n",
3971 OPT_SUBTITLE | OPT_GRAB,
3973 show_help_options(options, "\nAudio/Video grab options:\n",
3977 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3980 /* individual codec options */
3982 while ((c = av_codec_next(c))) {
3983 if (c->priv_class) {
3984 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3989 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3992 /* individual muxer options */
3993 while ((oformat = av_oformat_next(oformat))) {
3994 if (oformat->priv_class) {
3995 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4000 /* individual demuxer options */
4001 while ((iformat = av_iformat_next(iformat))) {
4002 if (iformat->priv_class) {
4003 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4008 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4011 static int opt_target(const char *opt, const char *arg)
4013 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4014 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4016 if(!strncmp(arg, "pal-", 4)) {
4019 } else if(!strncmp(arg, "ntsc-", 5)) {
4022 } else if(!strncmp(arg, "film-", 5)) {
4027 /* Calculate FR via float to avoid int overflow */
4028 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4031 } else if((fr == 29970) || (fr == 23976)) {
4034 /* Try to determine PAL/NTSC by peeking in the input files */
4035 if(nb_input_files) {
4037 for (j = 0; j < nb_input_files; j++) {
4038 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4039 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4040 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4042 fr = c->time_base.den * 1000 / c->time_base.num;
4046 } else if((fr == 29970) || (fr == 23976)) {
4056 if(verbose > 0 && norm != UNKNOWN)
4057 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4060 if(norm == UNKNOWN) {
4061 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4062 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4063 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4067 if(!strcmp(arg, "vcd")) {
4068 opt_video_codec("vcodec", "mpeg1video");
4069 opt_audio_codec("vcodec", "mp2");
4070 opt_format("f", "vcd");
4072 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4073 opt_frame_rate("r", frame_rates[norm]);
4074 opt_default("g", norm == PAL ? "15" : "18");
4076 opt_default("b", "1150000");
4077 opt_default("maxrate", "1150000");
4078 opt_default("minrate", "1150000");
4079 opt_default("bufsize", "327680"); // 40*1024*8;
4081 opt_default("ab", "224000");
4082 audio_sample_rate = 44100;
4085 opt_default("packetsize", "2324");
4086 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4088 /* We have to offset the PTS, so that it is consistent with the SCR.
4089 SCR starts at 36000, but the first two packs contain only padding
4090 and the first pack from the other stream, respectively, may also have
4091 been written before.
4092 So the real data starts at SCR 36000+3*1200. */
4093 mux_preload= (36000+3*1200) / 90000.0; //0.44
4094 } else if(!strcmp(arg, "svcd")) {
4096 opt_video_codec("vcodec", "mpeg2video");
4097 opt_audio_codec("acodec", "mp2");
4098 opt_format("f", "svcd");
4100 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4101 opt_frame_rate("r", frame_rates[norm]);
4102 opt_default("g", norm == PAL ? "15" : "18");
4104 opt_default("b", "2040000");
4105 opt_default("maxrate", "2516000");
4106 opt_default("minrate", "0"); //1145000;
4107 opt_default("bufsize", "1835008"); //224*1024*8;
4108 opt_default("flags", "+scan_offset");
4111 opt_default("ab", "224000");
4112 audio_sample_rate = 44100;
4114 opt_default("packetsize", "2324");
4116 } else if(!strcmp(arg, "dvd")) {
4118 opt_video_codec("vcodec", "mpeg2video");
4119 opt_audio_codec("vcodec", "ac3");
4120 opt_format("f", "dvd");
4122 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4123 opt_frame_rate("r", frame_rates[norm]);
4124 opt_default("g", norm == PAL ? "15" : "18");
4126 opt_default("b", "6000000");
4127 opt_default("maxrate", "9000000");
4128 opt_default("minrate", "0"); //1500000;
4129 opt_default("bufsize", "1835008"); //224*1024*8;
4131 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4132 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4134 opt_default("ab", "448000");
4135 audio_sample_rate = 48000;
4137 } else if(!strncmp(arg, "dv", 2)) {
4139 opt_format("f", "dv");
4141 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4142 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4143 norm == PAL ? "yuv420p" : "yuv411p");
4144 opt_frame_rate("r", frame_rates[norm]);
4146 audio_sample_rate = 48000;
4150 fprintf(stderr, "Unknown target: %s\n", arg);
4151 return AVERROR(EINVAL);
4156 static int opt_vstats_file(const char *opt, const char *arg)
4158 av_free (vstats_filename);
4159 vstats_filename=av_strdup (arg);
4163 static int opt_vstats(const char *opt, const char *arg)
4166 time_t today2 = time(NULL);
4167 struct tm *today = localtime(&today2);
4169 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4171 return opt_vstats_file(opt, filename);
4174 static int opt_bsf(const char *opt, const char *arg)
4176 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4177 AVBitStreamFilterContext **bsfp;
4180 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4184 bsfp= *opt == 'v' ? &video_bitstream_filters :
4185 *opt == 'a' ? &audio_bitstream_filters :
4186 &subtitle_bitstream_filters;
4188 bsfp= &(*bsfp)->next;
4195 static int opt_preset(const char *opt, const char *arg)
4198 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4199 char *codec_name = *opt == 'v' ? video_codec_name :
4200 *opt == 'a' ? audio_codec_name :
4201 subtitle_codec_name;
4203 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4204 fprintf(stderr, "File for preset '%s' not found\n", arg);
4209 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4210 if(line[0] == '#' && !e)
4212 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4214 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4217 if(!strcmp(tmp, "acodec")){
4218 opt_audio_codec(tmp, tmp2);
4219 }else if(!strcmp(tmp, "vcodec")){
4220 opt_video_codec(tmp, tmp2);
4221 }else if(!strcmp(tmp, "scodec")){
4222 opt_subtitle_codec(tmp, tmp2);
4223 }else if(!strcmp(tmp, "dcodec")){
4224 opt_data_codec(tmp, tmp2);
4225 }else if(opt_default(tmp, tmp2) < 0){
4226 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4236 static const OptionDef options[] = {
4238 #include "cmdutils_common_opts.h"
4239 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4240 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4241 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4242 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4243 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4244 "outfile[,metadata]:infile[,metadata]" },
4245 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4246 "outfile[,metadata]:infile[,metadata]" },
4247 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4248 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4249 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4250 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4251 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4252 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4253 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4254 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4255 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4256 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4257 "add timings for benchmarking" },
4258 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4259 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4260 "dump each input packet" },
4261 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4262 "when dumping packets, also dump the payload" },
4263 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4264 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4265 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4266 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4267 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4268 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4269 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4270 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4271 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4272 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4273 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4274 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4275 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4276 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4277 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4278 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4281 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4282 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4283 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4284 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4285 { "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" },
4286 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4287 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4288 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4289 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4290 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4291 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4292 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4293 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4294 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4295 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4296 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4297 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4298 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4299 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4300 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4301 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4302 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4303 "use same quantizer as source (implies VBR)" },
4304 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4305 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4306 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4307 "deinterlace pictures" },
4308 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4309 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4310 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4312 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4314 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4315 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4316 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4317 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4318 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4319 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4320 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4321 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4322 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4323 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4324 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4327 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4328 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4329 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4330 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4331 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4332 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4333 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4334 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4335 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4336 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4337 { "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" },
4339 /* subtitle options */
4340 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4341 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4342 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4343 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4344 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4347 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4348 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4349 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4352 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4353 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4355 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4356 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4357 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4359 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4360 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4361 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4362 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4363 /* data codec support */
4364 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4366 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4370 int main(int argc, char **argv)
4374 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4376 avcodec_register_all();
4378 avdevice_register_all();
4381 avfilter_register_all();
4385 avio_set_interrupt_cb(decode_interrupt_cb);
4391 av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
4392 "provided for compatibility. Use avconv instead "
4393 "(see Changelog for the list of incompatible changes).\n");
4396 parse_options(argc, argv, options, opt_output_file);
4398 if(nb_output_files <= 0 && nb_input_files == 0) {
4400 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4404 /* file converter / grab */
4405 if (nb_output_files <= 0) {
4406 fprintf(stderr, "At least one output file must be specified\n");
4410 if (nb_input_files == 0) {
4411 fprintf(stderr, "At least one input file must be specified\n");
4416 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4417 stream_maps, nb_stream_maps) < 0)
4419 ti = getutime() - ti;
4421 int maxrss = getmaxrss() / 1024;
4422 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4425 return ffmpeg_exit(0);