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 void exit_program(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 */
506 static void assert_avoptions(AVDictionary *m)
508 AVDictionaryEntry *t;
509 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
510 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
515 static void assert_codec_experimental(AVCodecContext *c, int encoder)
517 const char *codec_string = encoder ? "encoder" : "decoder";
519 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
520 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
521 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
522 "results.\nAdd '-strict experimental' if you want to use it.\n",
523 codec_string, c->codec->name);
524 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
525 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
526 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
527 codec_string, codec->name);
532 /* similar to ff_dynarray_add() and av_fast_realloc() */
533 static void *grow_array(void *array, int elem_size, int *size, int new_size)
535 if (new_size >= INT_MAX / elem_size) {
536 fprintf(stderr, "Array too big.\n");
539 if (*size < new_size) {
540 uint8_t *tmp = av_realloc(array, new_size*elem_size);
542 fprintf(stderr, "Could not alloc buffer.\n");
545 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
552 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
554 if(codec && codec->sample_fmts){
555 const enum AVSampleFormat *p= codec->sample_fmts;
557 if(*p == st->codec->sample_fmt)
561 av_log(NULL, AV_LOG_WARNING,
562 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
563 av_get_sample_fmt_name(st->codec->sample_fmt),
565 av_get_sample_fmt_name(codec->sample_fmts[0]));
566 st->codec->sample_fmt = codec->sample_fmts[0];
572 * Update the requested input sample format based on the output sample format.
573 * This is currently only used to request float output from decoders which
574 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
575 * Ideally this will be removed in the future when decoders do not do format
576 * conversion and only output in their native format.
578 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
581 /* if sample formats match or a decoder sample format has already been
582 requested, just return */
583 if (enc->sample_fmt == dec->sample_fmt ||
584 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
587 /* if decoder supports more than one output format */
588 if (dec_codec && dec_codec->sample_fmts &&
589 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
590 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
591 const enum AVSampleFormat *p;
592 int min_dec = -1, min_inc = -1;
594 /* find a matching sample format in the encoder */
595 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
596 if (*p == enc->sample_fmt) {
597 dec->request_sample_fmt = *p;
599 } else if (*p > enc->sample_fmt) {
600 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
602 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
605 /* if none match, provide the one that matches quality closest */
606 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
607 enc->sample_fmt - min_dec;
611 static void choose_sample_rate(AVStream *st, AVCodec *codec)
613 if(codec && codec->supported_samplerates){
614 const int *p= codec->supported_samplerates;
616 int best_dist=INT_MAX;
618 int dist= abs(st->codec->sample_rate - *p);
619 if(dist < best_dist){
625 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
627 st->codec->sample_rate= best;
631 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
633 if(codec && codec->pix_fmts){
634 const enum PixelFormat *p= codec->pix_fmts;
635 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
636 if(st->codec->codec_id==CODEC_ID_MJPEG){
637 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
638 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
639 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};
643 if(*p == st->codec->pix_fmt)
647 if(st->codec->pix_fmt != PIX_FMT_NONE)
648 av_log(NULL, AV_LOG_WARNING,
649 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
650 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
652 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
653 st->codec->pix_fmt = codec->pix_fmts[0];
658 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
661 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
662 int idx = oc->nb_streams - 1;
665 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
669 output_streams_for_file[file_idx] =
670 grow_array(output_streams_for_file[file_idx],
671 sizeof(*output_streams_for_file[file_idx]),
672 &nb_output_streams_for_file[file_idx],
674 ost = output_streams_for_file[file_idx][idx] =
675 av_mallocz(sizeof(OutputStream));
677 fprintf(stderr, "Could not alloc output stream\n");
680 ost->file_index = file_idx;
685 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
687 avcodec_get_context_defaults3(st->codec, codec);
689 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
693 static int read_avserver_streams(AVFormatContext *s, const char *filename)
696 AVFormatContext *ic = NULL;
698 err = avformat_open_input(&ic, filename, NULL, NULL);
701 /* copy stream format */
702 for(i=0;i<ic->nb_streams;i++) {
707 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
708 ost = new_output_stream(s, nb_output_files, codec);
711 // FIXME: a more elegant solution is needed
712 memcpy(st, ic->streams[i], sizeof(AVStream));
714 avcodec_copy_context(st->codec, ic->streams[i]->codec);
716 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
717 if (audio_stream_copy) {
720 choose_sample_fmt(st, codec);
721 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
722 if (video_stream_copy) {
725 choose_pixel_fmt(st, codec);
729 av_close_input_file(ic);
734 get_sync_ipts(const OutputStream *ost)
736 const InputStream *ist = ost->sync_ist;
737 return (double)(ist->pts - start_time)/AV_TIME_BASE;
740 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
744 AVPacket new_pkt= *pkt;
745 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
746 &new_pkt.data, &new_pkt.size,
747 pkt->data, pkt->size,
748 pkt->flags & AV_PKT_FLAG_KEY);
751 new_pkt.destruct= av_destruct_packet;
753 fprintf(stderr, "%s failed for stream %d, codec %s",
754 bsfc->filter->name, pkt->stream_index,
755 avctx->codec ? avctx->codec->name : "copy");
765 ret= av_interleaved_write_frame(s, pkt);
767 print_error("av_interleaved_write_frame()", ret);
772 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
774 static void do_audio_out(AVFormatContext *s,
777 unsigned char *buf, int size)
780 int64_t audio_out_size, audio_buf_size;
781 int64_t allocated_for_size= size;
783 int size_out, frame_bytes, ret, resample_changed;
784 AVCodecContext *enc= ost->st->codec;
785 AVCodecContext *dec= ist->st->codec;
786 int osize = av_get_bytes_per_sample(enc->sample_fmt);
787 int isize = av_get_bytes_per_sample(dec->sample_fmt);
788 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
791 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
792 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
793 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
794 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
795 audio_buf_size*= osize*enc->channels;
797 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
798 if(coded_bps > 8*osize)
799 audio_out_size= audio_out_size * coded_bps / (8*osize);
800 audio_out_size += FF_MIN_BUFFER_SIZE;
802 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
803 fprintf(stderr, "Buffer sizes too large\n");
807 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
808 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
809 if (!audio_buf || !audio_out){
810 fprintf(stderr, "Out of memory in do_audio_out\n");
814 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
815 ost->audio_resample = 1;
817 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
818 ost->resample_channels != dec->channels ||
819 ost->resample_sample_rate != dec->sample_rate;
821 if ((ost->audio_resample && !ost->resample) || resample_changed) {
822 if (resample_changed) {
823 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",
824 ist->file_index, ist->st->index,
825 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
826 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
827 ost->resample_sample_fmt = dec->sample_fmt;
828 ost->resample_channels = dec->channels;
829 ost->resample_sample_rate = dec->sample_rate;
831 audio_resample_close(ost->resample);
833 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
834 if (audio_sync_method <= 1 &&
835 ost->resample_sample_fmt == enc->sample_fmt &&
836 ost->resample_channels == enc->channels &&
837 ost->resample_sample_rate == enc->sample_rate) {
838 ost->resample = NULL;
839 ost->audio_resample = 0;
840 } else if (ost->audio_resample) {
841 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
842 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
843 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
844 enc->sample_rate, dec->sample_rate,
845 enc->sample_fmt, dec->sample_fmt,
847 if (!ost->resample) {
848 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
849 dec->channels, dec->sample_rate,
850 enc->channels, enc->sample_rate);
856 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
857 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
858 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
859 if (ost->reformat_ctx)
860 av_audio_convert_free(ost->reformat_ctx);
861 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
862 dec->sample_fmt, 1, NULL, 0);
863 if (!ost->reformat_ctx) {
864 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
865 av_get_sample_fmt_name(dec->sample_fmt),
866 av_get_sample_fmt_name(enc->sample_fmt));
869 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
872 if(audio_sync_method){
873 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
874 - av_fifo_size(ost->fifo)/(enc->channels * 2);
875 double idelta= delta*dec->sample_rate / enc->sample_rate;
876 int byte_delta= ((int)idelta)*2*dec->channels;
878 //FIXME resample delay
879 if(fabs(delta) > 50){
880 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
882 byte_delta= FFMAX(byte_delta, -size);
886 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
891 static uint8_t *input_tmp= NULL;
892 input_tmp= av_realloc(input_tmp, byte_delta + size);
894 if(byte_delta > allocated_for_size - size){
895 allocated_for_size= byte_delta + (int64_t)size;
900 memset(input_tmp, 0, byte_delta);
901 memcpy(input_tmp + byte_delta, buf, size);
905 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
907 }else if(audio_sync_method>1){
908 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
909 av_assert0(ost->audio_resample);
911 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
912 // 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));
913 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
917 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
918 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
920 if (ost->audio_resample) {
922 size_out = audio_resample(ost->resample,
923 (short *)buftmp, (short *)buf,
924 size / (dec->channels * isize));
925 size_out = size_out * enc->channels * osize;
931 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
932 const void *ibuf[6]= {buftmp};
933 void *obuf[6]= {audio_buf};
934 int istride[6]= {isize};
935 int ostride[6]= {osize};
936 int len= size_out/istride[0];
937 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
938 printf("av_audio_convert() failed\n");
944 size_out = len*osize;
947 /* now encode as many frames as possible */
948 if (enc->frame_size > 1) {
949 /* output resampled raw samples */
950 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
951 fprintf(stderr, "av_fifo_realloc2() failed\n");
954 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
956 frame_bytes = enc->frame_size * osize * enc->channels;
958 while (av_fifo_size(ost->fifo) >= frame_bytes) {
960 av_init_packet(&pkt);
962 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
964 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
966 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
969 fprintf(stderr, "Audio encoding failed\n");
973 pkt.stream_index= ost->index;
976 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
977 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
978 pkt.flags |= AV_PKT_FLAG_KEY;
979 write_frame(s, &pkt, enc, ost->bitstream_filters);
981 ost->sync_opts += enc->frame_size;
985 av_init_packet(&pkt);
987 ost->sync_opts += size_out / (osize * enc->channels);
989 /* output a pcm frame */
990 /* determine the size of the coded buffer */
993 size_out = size_out*coded_bps/8;
995 if(size_out > audio_out_size){
996 fprintf(stderr, "Internal error, buffer size too small\n");
1000 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1001 ret = avcodec_encode_audio(enc, audio_out, size_out,
1004 fprintf(stderr, "Audio encoding failed\n");
1008 pkt.stream_index= ost->index;
1009 pkt.data= audio_out;
1011 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1012 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1013 pkt.flags |= AV_PKT_FLAG_KEY;
1014 write_frame(s, &pkt, enc, ost->bitstream_filters);
1018 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1020 AVCodecContext *dec;
1021 AVPicture *picture2;
1022 AVPicture picture_tmp;
1025 dec = ist->st->codec;
1027 /* deinterlace : must be done before any resize */
1028 if (do_deinterlace) {
1031 /* create temporary picture */
1032 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1033 buf = av_malloc(size);
1037 picture2 = &picture_tmp;
1038 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1040 if(avpicture_deinterlace(picture2, picture,
1041 dec->pix_fmt, dec->width, dec->height) < 0) {
1042 /* if error, do not deinterlace */
1043 fprintf(stderr, "Deinterlacing failed\n");
1052 if (picture != picture2)
1053 *picture = *picture2;
1057 /* we begin to correct av delay at this threshold */
1058 #define AV_DELAY_MAX 0.100
1060 static void do_subtitle_out(AVFormatContext *s,
1066 static uint8_t *subtitle_out = NULL;
1067 int subtitle_out_max_size = 1024 * 1024;
1068 int subtitle_out_size, nb, i;
1069 AVCodecContext *enc;
1072 if (pts == AV_NOPTS_VALUE) {
1073 fprintf(stderr, "Subtitle packets must have a pts\n");
1079 enc = ost->st->codec;
1081 if (!subtitle_out) {
1082 subtitle_out = av_malloc(subtitle_out_max_size);
1085 /* Note: DVB subtitle need one packet to draw them and one other
1086 packet to clear them */
1087 /* XXX: signal it in the codec context ? */
1088 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1093 for(i = 0; i < nb; i++) {
1094 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1095 // start_display_time is required to be 0
1096 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1097 sub->end_display_time -= sub->start_display_time;
1098 sub->start_display_time = 0;
1099 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1100 subtitle_out_max_size, sub);
1101 if (subtitle_out_size < 0) {
1102 fprintf(stderr, "Subtitle encoding failed\n");
1106 av_init_packet(&pkt);
1107 pkt.stream_index = ost->index;
1108 pkt.data = subtitle_out;
1109 pkt.size = subtitle_out_size;
1110 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1111 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1112 /* XXX: the pts correction is handled here. Maybe handling
1113 it in the codec would be better */
1115 pkt.pts += 90 * sub->start_display_time;
1117 pkt.pts += 90 * sub->end_display_time;
1119 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1123 static int bit_buffer_size= 1024*256;
1124 static uint8_t *bit_buffer= NULL;
1126 static void do_video_out(AVFormatContext *s,
1129 AVFrame *in_picture,
1130 int *frame_size, float quality)
1132 int nb_frames, i, ret, resample_changed;
1133 AVFrame *final_picture, *formatted_picture;
1134 AVCodecContext *enc, *dec;
1137 enc = ost->st->codec;
1138 dec = ist->st->codec;
1140 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1142 /* by default, we output a single frame */
1147 if(video_sync_method){
1148 double vdelta = sync_ipts - ost->sync_opts;
1149 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1152 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1155 }else if(vdelta>0.6)
1156 ost->sync_opts= lrintf(sync_ipts);
1157 }else if (vdelta > 1.1)
1158 nb_frames = lrintf(vdelta);
1159 //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);
1160 if (nb_frames == 0){
1163 fprintf(stderr, "*** drop!\n");
1164 }else if (nb_frames > 1) {
1165 nb_frames_dup += nb_frames - 1;
1167 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1170 ost->sync_opts= lrintf(sync_ipts);
1172 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1176 formatted_picture = in_picture;
1177 final_picture = formatted_picture;
1179 resample_changed = ost->resample_width != dec->width ||
1180 ost->resample_height != dec->height ||
1181 ost->resample_pix_fmt != dec->pix_fmt;
1183 if (resample_changed) {
1184 av_log(NULL, AV_LOG_INFO,
1185 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1186 ist->file_index, ist->st->index,
1187 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1188 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1189 if(!ost->video_resample)
1193 #if !CONFIG_AVFILTER
1194 if (ost->video_resample) {
1195 final_picture = &ost->pict_tmp;
1196 if (resample_changed) {
1197 /* initialize a new scaler context */
1198 sws_freeContext(ost->img_resample_ctx);
1199 ost->img_resample_ctx = sws_getContext(
1200 ist->st->codec->width,
1201 ist->st->codec->height,
1202 ist->st->codec->pix_fmt,
1203 ost->st->codec->width,
1204 ost->st->codec->height,
1205 ost->st->codec->pix_fmt,
1206 ost->sws_flags, NULL, NULL, NULL);
1207 if (ost->img_resample_ctx == NULL) {
1208 fprintf(stderr, "Cannot get resampling context\n");
1212 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1213 0, ost->resample_height, final_picture->data, final_picture->linesize);
1217 /* duplicates frame if needed */
1218 for(i=0;i<nb_frames;i++) {
1220 av_init_packet(&pkt);
1221 pkt.stream_index= ost->index;
1223 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1224 /* raw pictures are written as AVPicture structure to
1225 avoid any copies. We support temorarily the older
1227 AVFrame* old_frame = enc->coded_frame;
1228 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1229 pkt.data= (uint8_t *)final_picture;
1230 pkt.size= sizeof(AVPicture);
1231 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1232 pkt.flags |= AV_PKT_FLAG_KEY;
1234 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1235 enc->coded_frame = old_frame;
1237 AVFrame big_picture;
1239 big_picture= *final_picture;
1240 /* better than nothing: use input picture interlaced
1242 big_picture.interlaced_frame = in_picture->interlaced_frame;
1243 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1244 if(top_field_first == -1)
1245 big_picture.top_field_first = in_picture->top_field_first;
1247 big_picture.top_field_first = top_field_first;
1250 /* handles sameq here. This is not correct because it may
1251 not be a global option */
1252 big_picture.quality = quality;
1254 big_picture.pict_type = 0;
1255 // big_picture.pts = AV_NOPTS_VALUE;
1256 big_picture.pts= ost->sync_opts;
1257 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1258 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1259 if (ost->forced_kf_index < ost->forced_kf_count &&
1260 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1261 big_picture.pict_type = AV_PICTURE_TYPE_I;
1262 ost->forced_kf_index++;
1264 ret = avcodec_encode_video(enc,
1265 bit_buffer, bit_buffer_size,
1268 fprintf(stderr, "Video encoding failed\n");
1273 pkt.data= bit_buffer;
1275 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1276 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1277 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1278 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1279 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1281 if(enc->coded_frame->key_frame)
1282 pkt.flags |= AV_PKT_FLAG_KEY;
1283 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1286 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1287 // enc->frame_number-1, ret, enc->pict_type);
1288 /* if two pass, output log */
1289 if (ost->logfile && enc->stats_out) {
1290 fprintf(ost->logfile, "%s", enc->stats_out);
1295 ost->frame_number++;
1299 static double psnr(double d){
1300 return -10.0*log(d)/log(10.0);
1303 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1306 AVCodecContext *enc;
1308 double ti1, bitrate, avg_bitrate;
1310 /* this is executed just the first time do_video_stats is called */
1312 vstats_file = fopen(vstats_filename, "w");
1319 enc = ost->st->codec;
1320 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1321 frame_number = ost->frame_number;
1322 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1323 if (enc->flags&CODEC_FLAG_PSNR)
1324 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1326 fprintf(vstats_file,"f_size= %6d ", frame_size);
1327 /* compute pts value */
1328 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1332 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1333 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1334 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1335 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1336 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1340 static void print_report(AVFormatContext **output_files,
1341 OutputStream **ost_table, int nb_ostreams,
1346 AVFormatContext *oc;
1348 AVCodecContext *enc;
1349 int frame_number, vid, i;
1350 double bitrate, ti1, pts;
1351 static int64_t last_time = -1;
1352 static int qp_histogram[52];
1354 if (!is_last_report) {
1356 /* display the report every 0.5 seconds */
1357 cur_time = av_gettime();
1358 if (last_time == -1) {
1359 last_time = cur_time;
1362 if ((cur_time - last_time) < 500000)
1364 last_time = cur_time;
1368 oc = output_files[0];
1370 total_size = avio_size(oc->pb);
1371 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1372 total_size= avio_tell(oc->pb);
1377 for(i=0;i<nb_ostreams;i++) {
1380 enc = ost->st->codec;
1381 if (!ost->st->stream_copy && enc->coded_frame)
1382 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1383 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1384 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1386 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1387 float t = (av_gettime()-timer_start) / 1000000.0;
1389 frame_number = ost->frame_number;
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1391 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1393 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1397 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1400 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1402 if (enc->flags&CODEC_FLAG_PSNR){
1404 double error, error_sum=0;
1405 double scale, scale_sum=0;
1406 char type[3]= {'Y','U','V'};
1407 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1410 error= enc->error[j];
1411 scale= enc->width*enc->height*255.0*255.0*frame_number;
1413 error= enc->coded_frame->error[j];
1414 scale= enc->width*enc->height*255.0*255.0;
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1421 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1425 /* compute min output value */
1426 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1427 if ((pts < ti1) && (pts > 0))
1433 if (verbose > 0 || is_last_report) {
1434 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1437 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1438 (double)total_size / 1024, ti1, bitrate);
1440 if (nb_frames_dup || nb_frames_drop)
1441 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1442 nb_frames_dup, nb_frames_drop);
1445 fprintf(stderr, "%s \r", buf);
1450 if (is_last_report && verbose >= 0){
1451 int64_t raw= audio_size + video_size + extra_size;
1452 fprintf(stderr, "\n");
1453 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1457 100.0*(total_size - raw)/raw
1462 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1464 int fill_char = 0x00;
1465 if (sample_fmt == AV_SAMPLE_FMT_U8)
1467 memset(buf, fill_char, size);
1470 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1471 static int output_packet(InputStream *ist, int ist_index,
1472 OutputStream **ost_table, int nb_ostreams,
1473 const AVPacket *pkt)
1475 AVFormatContext *os;
1480 void *buffer_to_free = NULL;
1481 static unsigned int samples_size= 0;
1482 AVSubtitle subtitle, *subtitle_to_free;
1483 int64_t pkt_pts = AV_NOPTS_VALUE;
1485 int frame_available;
1490 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1492 if(ist->next_pts == AV_NOPTS_VALUE)
1493 ist->next_pts= ist->pts;
1497 av_init_packet(&avpkt);
1505 if(pkt->dts != AV_NOPTS_VALUE)
1506 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1507 if(pkt->pts != AV_NOPTS_VALUE)
1508 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1510 //while we have more to decode or while the decoder did output something on EOF
1511 while (avpkt.size > 0 || (!pkt && got_output)) {
1512 uint8_t *data_buf, *decoded_data_buf;
1513 int data_size, decoded_data_size;
1515 ist->pts= ist->next_pts;
1517 if(avpkt.size && avpkt.size != pkt->size &&
1518 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1519 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1520 ist->showed_multi_packet_warning=1;
1523 /* decode the packet if needed */
1524 decoded_data_buf = NULL; /* fail safe */
1525 decoded_data_size= 0;
1526 data_buf = avpkt.data;
1527 data_size = avpkt.size;
1528 subtitle_to_free = NULL;
1529 if (ist->decoding_needed) {
1530 switch(ist->st->codec->codec_type) {
1531 case AVMEDIA_TYPE_AUDIO:{
1532 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1533 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1535 samples= av_malloc(samples_size);
1537 decoded_data_size= samples_size;
1538 /* XXX: could avoid copy if PCM 16 bits with same
1539 endianness as CPU */
1540 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1547 got_output = decoded_data_size > 0;
1548 /* Some bug in mpeg audio decoder gives */
1549 /* decoded_data_size < 0, it seems they are overflows */
1551 /* no audio frame */
1554 decoded_data_buf = (uint8_t *)samples;
1555 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1556 (ist->st->codec->sample_rate * ist->st->codec->channels);
1558 case AVMEDIA_TYPE_VIDEO:
1559 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1560 /* XXX: allocate picture correctly */
1561 avcodec_get_frame_defaults(&picture);
1562 avpkt.pts = pkt_pts;
1563 avpkt.dts = ist->pts;
1564 pkt_pts = AV_NOPTS_VALUE;
1566 ret = avcodec_decode_video2(ist->st->codec,
1567 &picture, &got_output, &avpkt);
1568 quality = same_quality ? picture.quality : 0;
1572 /* no picture yet */
1573 goto discard_packet;
1575 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1576 if (ist->st->codec->time_base.num != 0) {
1577 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1578 ist->next_pts += ((int64_t)AV_TIME_BASE *
1579 ist->st->codec->time_base.num * ticks) /
1580 ist->st->codec->time_base.den;
1583 buffer_to_free = NULL;
1584 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1586 case AVMEDIA_TYPE_SUBTITLE:
1587 ret = avcodec_decode_subtitle2(ist->st->codec,
1588 &subtitle, &got_output, &avpkt);
1592 goto discard_packet;
1594 subtitle_to_free = &subtitle;
1601 switch(ist->st->codec->codec_type) {
1602 case AVMEDIA_TYPE_AUDIO:
1603 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1604 ist->st->codec->sample_rate;
1606 case AVMEDIA_TYPE_VIDEO:
1607 if (ist->st->codec->time_base.num != 0) {
1608 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1609 ist->next_pts += ((int64_t)AV_TIME_BASE *
1610 ist->st->codec->time_base.num * ticks) /
1611 ist->st->codec->time_base.den;
1620 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1621 for (i = 0; i < nb_ostreams; i++) {
1623 if (ost->input_video_filter && ost->source_index == ist_index) {
1625 if (ist->st->sample_aspect_ratio.num)
1626 sar = ist->st->sample_aspect_ratio;
1628 sar = ist->st->codec->sample_aspect_ratio;
1629 // add it to be filtered
1630 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1638 // preprocess audio (volume)
1639 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1640 if (audio_volume != 256) {
1643 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1644 int v = ((*volp) * audio_volume + 128) >> 8;
1645 if (v < -32768) v = -32768;
1646 if (v > 32767) v = 32767;
1652 /* frame rate emulation */
1654 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1655 int64_t now = av_gettime() - ist->start;
1659 /* if output time reached then transcode raw format,
1660 encode packets and output them */
1661 if (start_time == 0 || ist->pts >= start_time)
1662 for(i=0;i<nb_ostreams;i++) {
1666 if (ost->source_index == ist_index) {
1668 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1669 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1670 while (frame_available) {
1671 AVRational ist_pts_tb;
1672 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1673 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1675 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1677 os = output_files[ost->file_index];
1679 /* set the input output pts pairs */
1680 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1682 if (ost->encoding_needed) {
1683 av_assert0(ist->decoding_needed);
1684 switch(ost->st->codec->codec_type) {
1685 case AVMEDIA_TYPE_AUDIO:
1686 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1688 case AVMEDIA_TYPE_VIDEO:
1690 if (ost->picref->video && !ost->frame_aspect_ratio)
1691 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1693 do_video_out(os, ost, ist, &picture, &frame_size,
1694 same_quality ? quality : ost->st->codec->global_quality);
1695 if (vstats_filename && frame_size)
1696 do_video_stats(os, ost, frame_size);
1698 case AVMEDIA_TYPE_SUBTITLE:
1699 do_subtitle_out(os, ost, ist, &subtitle,
1706 AVFrame avframe; //FIXME/XXX remove this
1708 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1710 av_init_packet(&opkt);
1712 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1713 #if !CONFIG_AVFILTER
1719 /* no reencoding needed : output the packet directly */
1720 /* force the input stream PTS */
1722 avcodec_get_frame_defaults(&avframe);
1723 ost->st->codec->coded_frame= &avframe;
1724 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1726 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1727 audio_size += data_size;
1728 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1729 video_size += data_size;
1733 opkt.stream_index= ost->index;
1734 if(pkt->pts != AV_NOPTS_VALUE)
1735 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1737 opkt.pts= AV_NOPTS_VALUE;
1739 if (pkt->dts == AV_NOPTS_VALUE)
1740 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1742 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1743 opkt.dts -= ost_tb_start_time;
1745 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1746 opkt.flags= pkt->flags;
1748 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1749 if( ost->st->codec->codec_id != CODEC_ID_H264
1750 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1751 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1753 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1754 opkt.destruct= av_destruct_packet;
1756 opkt.data = data_buf;
1757 opkt.size = data_size;
1760 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1761 ost->st->codec->frame_number++;
1762 ost->frame_number++;
1763 av_free_packet(&opkt);
1767 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1768 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1770 avfilter_unref_buffer(ost->picref);
1776 av_free(buffer_to_free);
1777 /* XXX: allocate the subtitles in the codec ? */
1778 if (subtitle_to_free) {
1779 avsubtitle_free(subtitle_to_free);
1780 subtitle_to_free = NULL;
1787 for(i=0;i<nb_ostreams;i++) {
1789 if (ost->source_index == ist_index) {
1790 AVCodecContext *enc= ost->st->codec;
1791 os = output_files[ost->file_index];
1793 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1795 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1798 if (ost->encoding_needed) {
1802 av_init_packet(&pkt);
1803 pkt.stream_index= ost->index;
1805 switch(ost->st->codec->codec_type) {
1806 case AVMEDIA_TYPE_AUDIO:
1807 fifo_bytes = av_fifo_size(ost->fifo);
1809 /* encode any samples remaining in fifo */
1810 if (fifo_bytes > 0) {
1811 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1812 int fs_tmp = enc->frame_size;
1814 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1815 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1816 enc->frame_size = fifo_bytes / (osize * enc->channels);
1818 int frame_bytes = enc->frame_size*osize*enc->channels;
1819 if (allocated_audio_buf_size < frame_bytes)
1821 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1824 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1825 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1826 ost->st->time_base.num, enc->sample_rate);
1827 enc->frame_size = fs_tmp;
1830 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1833 fprintf(stderr, "Audio encoding failed\n");
1837 pkt.flags |= AV_PKT_FLAG_KEY;
1839 case AVMEDIA_TYPE_VIDEO:
1840 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1842 fprintf(stderr, "Video encoding failed\n");
1846 if(enc->coded_frame && enc->coded_frame->key_frame)
1847 pkt.flags |= AV_PKT_FLAG_KEY;
1848 if (ost->logfile && enc->stats_out) {
1849 fprintf(ost->logfile, "%s", enc->stats_out);
1858 pkt.data= bit_buffer;
1860 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1861 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1862 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1872 static void print_sdp(AVFormatContext **avc, int n)
1876 av_sdp_create(avc, n, sdp, sizeof(sdp));
1877 printf("SDP:\n%s\n", sdp);
1881 static int copy_chapters(int infile, int outfile)
1883 AVFormatContext *is = input_files[infile].ctx;
1884 AVFormatContext *os = output_files[outfile];
1887 for (i = 0; i < is->nb_chapters; i++) {
1888 AVChapter *in_ch = is->chapters[i], *out_ch;
1889 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1890 AV_TIME_BASE_Q, in_ch->time_base);
1891 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1892 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1895 if (in_ch->end < ts_off)
1897 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1900 out_ch = av_mallocz(sizeof(AVChapter));
1902 return AVERROR(ENOMEM);
1904 out_ch->id = in_ch->id;
1905 out_ch->time_base = in_ch->time_base;
1906 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1907 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1909 if (metadata_chapters_autocopy)
1910 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1913 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1915 return AVERROR(ENOMEM);
1916 os->chapters[os->nb_chapters - 1] = out_ch;
1921 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1922 AVCodecContext *avctx)
1928 for (p = kf; *p; p++)
1931 ost->forced_kf_count = n;
1932 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1933 if (!ost->forced_kf_pts) {
1934 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1937 for (i = 0; i < n; i++) {
1938 p = i ? strchr(p, ',') + 1 : kf;
1939 t = parse_time_or_die("force_key_frames", p, 1);
1940 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1945 * The following code is the main loop of the file converter
1947 static int transcode(AVFormatContext **output_files,
1948 int nb_output_files,
1949 InputFile *input_files,
1951 StreamMap *stream_maps, int nb_stream_maps)
1953 int ret = 0, i, j, k, n, nb_ostreams = 0;
1954 AVFormatContext *is, *os;
1955 AVCodecContext *codec, *icodec;
1956 OutputStream *ost, **ost_table = NULL;
1960 uint8_t no_packet[MAX_FILES]={0};
1961 int no_packet_count=0;
1964 for (i = 0; i < nb_input_streams; i++)
1965 input_streams[i].start = av_gettime();
1967 /* output stream init */
1969 for(i=0;i<nb_output_files;i++) {
1970 os = output_files[i];
1971 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1972 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1973 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1974 ret = AVERROR(EINVAL);
1977 nb_ostreams += os->nb_streams;
1979 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1980 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1981 ret = AVERROR(EINVAL);
1985 /* Sanity check the mapping args -- do the input files & streams exist? */
1986 for(i=0;i<nb_stream_maps;i++) {
1987 int fi = stream_maps[i].file_index;
1988 int si = stream_maps[i].stream_index;
1990 if (fi < 0 || fi > nb_input_files - 1 ||
1991 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1992 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1993 ret = AVERROR(EINVAL);
1996 fi = stream_maps[i].sync_file_index;
1997 si = stream_maps[i].sync_stream_index;
1998 if (fi < 0 || fi > nb_input_files - 1 ||
1999 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2000 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2001 ret = AVERROR(EINVAL);
2006 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2010 for(k=0;k<nb_output_files;k++) {
2011 os = output_files[k];
2012 for(i=0;i<os->nb_streams;i++,n++) {
2014 ost = ost_table[n] = output_streams_for_file[k][i];
2015 if (nb_stream_maps > 0) {
2016 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2017 stream_maps[n].stream_index;
2019 /* Sanity check that the stream types match */
2020 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2021 int i= ost->file_index;
2022 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2023 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2024 stream_maps[n].file_index, stream_maps[n].stream_index,
2025 ost->file_index, ost->index);
2030 int best_nb_frames=-1;
2031 /* get corresponding input stream index : we select the first one with the right type */
2033 for (j = 0; j < nb_input_streams; j++) {
2035 ist = &input_streams[j];
2038 AVFormatContext *f = input_files[ist->file_index].ctx;
2040 for(pi=0; pi<f->nb_programs; pi++){
2041 AVProgram *p= f->programs[pi];
2042 if(p->id == opt_programid)
2043 for(si=0; si<p->nb_stream_indexes; si++){
2044 if(f->streams[ p->stream_index[si] ] == ist->st)
2049 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2050 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2051 if(best_nb_frames < ist->st->codec_info_nb_frames){
2052 best_nb_frames= ist->st->codec_info_nb_frames;
2053 ost->source_index = j;
2060 if(! opt_programid) {
2061 /* try again and reuse existing stream */
2062 for (j = 0; j < nb_input_streams; j++) {
2063 ist = &input_streams[j];
2064 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2065 && ist->st->discard != AVDISCARD_ALL) {
2066 ost->source_index = j;
2072 int i= ost->file_index;
2073 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2074 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2075 ost->file_index, ost->index);
2080 ist = &input_streams[ost->source_index];
2082 ost->sync_ist = (nb_stream_maps > 0) ?
2083 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2084 stream_maps[n].sync_stream_index] : ist;
2088 /* for each output stream, we compute the right encoding parameters */
2089 for(i=0;i<nb_ostreams;i++) {
2091 os = output_files[ost->file_index];
2092 ist = &input_streams[ost->source_index];
2094 codec = ost->st->codec;
2095 icodec = ist->st->codec;
2097 if (metadata_streams_autocopy)
2098 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2099 AV_DICT_DONT_OVERWRITE);
2101 ost->st->disposition = ist->st->disposition;
2102 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2103 codec->chroma_sample_location = icodec->chroma_sample_location;
2105 if (ost->st->stream_copy) {
2106 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2108 if (extra_size > INT_MAX)
2111 /* if stream_copy is selected, no need to decode or encode */
2112 codec->codec_id = icodec->codec_id;
2113 codec->codec_type = icodec->codec_type;
2115 if(!codec->codec_tag){
2116 if( !os->oformat->codec_tag
2117 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2118 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2119 codec->codec_tag = icodec->codec_tag;
2122 codec->bit_rate = icodec->bit_rate;
2123 codec->rc_max_rate = icodec->rc_max_rate;
2124 codec->rc_buffer_size = icodec->rc_buffer_size;
2125 codec->extradata= av_mallocz(extra_size);
2126 if (!codec->extradata)
2128 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2129 codec->extradata_size= icodec->extradata_size;
2130 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){
2131 codec->time_base = icodec->time_base;
2132 codec->time_base.num *= icodec->ticks_per_frame;
2133 av_reduce(&codec->time_base.num, &codec->time_base.den,
2134 codec->time_base.num, codec->time_base.den, INT_MAX);
2136 codec->time_base = ist->st->time_base;
2137 switch(codec->codec_type) {
2138 case AVMEDIA_TYPE_AUDIO:
2139 if(audio_volume != 256) {
2140 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2143 codec->channel_layout = icodec->channel_layout;
2144 codec->sample_rate = icodec->sample_rate;
2145 codec->channels = icodec->channels;
2146 codec->frame_size = icodec->frame_size;
2147 codec->audio_service_type = icodec->audio_service_type;
2148 codec->block_align= icodec->block_align;
2149 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2150 codec->block_align= 0;
2151 if(codec->codec_id == CODEC_ID_AC3)
2152 codec->block_align= 0;
2154 case AVMEDIA_TYPE_VIDEO:
2155 codec->pix_fmt = icodec->pix_fmt;
2156 codec->width = icodec->width;
2157 codec->height = icodec->height;
2158 codec->has_b_frames = icodec->has_b_frames;
2159 if (!codec->sample_aspect_ratio.num) {
2160 codec->sample_aspect_ratio =
2161 ost->st->sample_aspect_ratio =
2162 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2163 ist->st->codec->sample_aspect_ratio.num ?
2164 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2167 case AVMEDIA_TYPE_SUBTITLE:
2168 codec->width = icodec->width;
2169 codec->height = icodec->height;
2171 case AVMEDIA_TYPE_DATA:
2178 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2179 switch(codec->codec_type) {
2180 case AVMEDIA_TYPE_AUDIO:
2181 ost->fifo= av_fifo_alloc(1024);
2184 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2185 if (!codec->sample_rate) {
2186 codec->sample_rate = icodec->sample_rate;
2188 codec->sample_rate >>= icodec->lowres;
2190 choose_sample_rate(ost->st, ost->enc);
2191 codec->time_base = (AVRational){1, codec->sample_rate};
2192 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2193 codec->sample_fmt = icodec->sample_fmt;
2194 choose_sample_fmt(ost->st, ost->enc);
2195 if (!codec->channels)
2196 codec->channels = icodec->channels;
2197 codec->channel_layout = icodec->channel_layout;
2198 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2199 codec->channel_layout = 0;
2200 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2201 icodec->request_channels = codec->channels;
2202 ist->decoding_needed = 1;
2203 ost->encoding_needed = 1;
2204 ost->resample_sample_fmt = icodec->sample_fmt;
2205 ost->resample_sample_rate = icodec->sample_rate;
2206 ost->resample_channels = icodec->channels;
2208 case AVMEDIA_TYPE_VIDEO:
2209 if (codec->pix_fmt == PIX_FMT_NONE)
2210 codec->pix_fmt = icodec->pix_fmt;
2211 choose_pixel_fmt(ost->st, ost->enc);
2213 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2214 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2218 if (!codec->width || !codec->height) {
2219 codec->width = icodec->width;
2220 codec->height = icodec->height;
2223 ost->video_resample = codec->width != icodec->width ||
2224 codec->height != icodec->height ||
2225 codec->pix_fmt != icodec->pix_fmt;
2226 if (ost->video_resample) {
2227 #if !CONFIG_AVFILTER
2228 avcodec_get_frame_defaults(&ost->pict_tmp);
2229 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2230 codec->width, codec->height)) {
2231 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2234 ost->img_resample_ctx = sws_getContext(
2241 ost->sws_flags, NULL, NULL, NULL);
2242 if (ost->img_resample_ctx == NULL) {
2243 fprintf(stderr, "Cannot get resampling context\n");
2247 codec->bits_per_raw_sample= 0;
2250 ost->resample_height = icodec->height;
2251 ost->resample_width = icodec->width;
2252 ost->resample_pix_fmt= icodec->pix_fmt;
2253 ost->encoding_needed = 1;
2254 ist->decoding_needed = 1;
2256 if (!ost->frame_rate.num)
2257 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2258 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2259 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2260 ost->frame_rate = ost->enc->supported_framerates[idx];
2262 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2265 if (configure_video_filters(ist, ost)) {
2266 fprintf(stderr, "Error opening filters!\n");
2271 case AVMEDIA_TYPE_SUBTITLE:
2272 ost->encoding_needed = 1;
2273 ist->decoding_needed = 1;
2280 if (ost->encoding_needed &&
2281 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2282 char logfilename[1024];
2285 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2286 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2288 if (codec->flags & CODEC_FLAG_PASS1) {
2289 f = fopen(logfilename, "wb");
2291 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2297 size_t logbuffer_size;
2298 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2299 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2302 codec->stats_in = logbuffer;
2306 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2307 int size= codec->width * codec->height;
2308 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2313 bit_buffer = av_malloc(bit_buffer_size);
2315 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2317 ret = AVERROR(ENOMEM);
2321 /* open each encoder */
2322 for(i=0;i<nb_ostreams;i++) {
2324 if (ost->encoding_needed) {
2325 AVCodec *codec = ost->enc;
2326 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2328 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2329 ost->st->codec->codec_id, ost->file_index, ost->index);
2330 ret = AVERROR(EINVAL);
2333 if (dec->subtitle_header) {
2334 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2335 if (!ost->st->codec->subtitle_header) {
2336 ret = AVERROR(ENOMEM);
2339 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2340 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2342 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2343 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2344 ost->file_index, ost->index);
2345 ret = AVERROR(EINVAL);
2348 assert_codec_experimental(ost->st->codec, 1);
2349 assert_avoptions(ost->opts);
2350 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2351 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2352 "It takes bits/s as argument, not kbits/s\n");
2353 extra_size += ost->st->codec->extradata_size;
2357 /* open each decoder */
2358 for (i = 0; i < nb_input_streams; i++) {
2359 ist = &input_streams[i];
2360 if (ist->decoding_needed) {
2361 AVCodec *codec = ist->dec;
2363 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2365 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2366 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2367 ret = AVERROR(EINVAL);
2371 /* update requested sample format for the decoder based on the
2372 corresponding encoder sample format */
2373 for (j = 0; j < nb_ostreams; j++) {
2375 if (ost->source_index == i) {
2376 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2381 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2382 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2383 ist->file_index, ist->st->index);
2384 ret = AVERROR(EINVAL);
2387 assert_codec_experimental(ist->st->codec, 0);
2388 assert_avoptions(ost->opts);
2393 for (i = 0; i < nb_input_streams; i++) {
2395 ist = &input_streams[i];
2397 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2398 ist->next_pts = AV_NOPTS_VALUE;
2399 init_pts_correction(&ist->pts_ctx);
2403 /* set meta data information from input file if required */
2404 for (i=0;i<nb_meta_data_maps;i++) {
2405 AVFormatContext *files[2];
2406 AVDictionary **meta[2];
2409 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2410 if ((index) < 0 || (index) >= (nb_elems)) {\
2411 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2413 ret = AVERROR(EINVAL);\
2417 int out_file_index = meta_data_maps[i][0].file;
2418 int in_file_index = meta_data_maps[i][1].file;
2419 if (in_file_index < 0 || out_file_index < 0)
2421 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2422 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2424 files[0] = output_files[out_file_index];
2425 files[1] = input_files[in_file_index].ctx;
2427 for (j = 0; j < 2; j++) {
2428 MetadataMap *map = &meta_data_maps[i][j];
2430 switch (map->type) {
2432 meta[j] = &files[j]->metadata;
2435 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2436 meta[j] = &files[j]->streams[map->index]->metadata;
2439 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2440 meta[j] = &files[j]->chapters[map->index]->metadata;
2443 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2444 meta[j] = &files[j]->programs[map->index]->metadata;
2449 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2452 /* copy global metadata by default */
2453 if (metadata_global_autocopy) {
2455 for (i = 0; i < nb_output_files; i++)
2456 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2457 AV_DICT_DONT_OVERWRITE);
2460 /* copy chapters according to chapter maps */
2461 for (i = 0; i < nb_chapter_maps; i++) {
2462 int infile = chapter_maps[i].in_file;
2463 int outfile = chapter_maps[i].out_file;
2465 if (infile < 0 || outfile < 0)
2467 if (infile >= nb_input_files) {
2468 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2469 ret = AVERROR(EINVAL);
2472 if (outfile >= nb_output_files) {
2473 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2474 ret = AVERROR(EINVAL);
2477 copy_chapters(infile, outfile);
2480 /* copy chapters from the first input file that has them*/
2481 if (!nb_chapter_maps)
2482 for (i = 0; i < nb_input_files; i++) {
2483 if (!input_files[i].ctx->nb_chapters)
2486 for (j = 0; j < nb_output_files; j++)
2487 if ((ret = copy_chapters(i, j)) < 0)
2492 /* open files and write file headers */
2493 for(i=0;i<nb_output_files;i++) {
2494 os = output_files[i];
2495 if (avformat_write_header(os, &output_opts[i]) < 0) {
2496 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2497 ret = AVERROR(EINVAL);
2500 assert_avoptions(output_opts[i]);
2501 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2507 /* dump the file output parameters - cannot be done before in case
2509 for(i=0;i<nb_output_files;i++) {
2510 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2513 /* dump the stream mapping */
2515 fprintf(stderr, "Stream mapping:\n");
2516 for(i=0;i<nb_ostreams;i++) {
2518 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2519 input_streams[ost->source_index].file_index,
2520 input_streams[ost->source_index].st->index,
2523 if (ost->sync_ist != &input_streams[ost->source_index])
2524 fprintf(stderr, " [sync #%d.%d]",
2525 ost->sync_ist->file_index,
2526 ost->sync_ist->st->index);
2527 fprintf(stderr, "\n");
2532 fprintf(stderr, "%s\n", error);
2537 print_sdp(output_files, nb_output_files);
2541 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2544 timer_start = av_gettime();
2546 for(; received_sigterm == 0;) {
2547 int file_index, ist_index;
2556 /* select the stream that we must read now by looking at the
2557 smallest output pts */
2559 for(i=0;i<nb_ostreams;i++) {
2562 os = output_files[ost->file_index];
2563 ist = &input_streams[ost->source_index];
2564 if(ist->is_past_recording_time || no_packet[ist->file_index])
2566 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2567 ipts = (double)ist->pts;
2568 if (!input_files[ist->file_index].eof_reached){
2569 if(ipts < ipts_min) {
2571 if(input_sync ) file_index = ist->file_index;
2573 if(opts < opts_min) {
2575 if(!input_sync) file_index = ist->file_index;
2578 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2583 /* if none, if is finished */
2584 if (file_index < 0) {
2585 if(no_packet_count){
2587 memset(no_packet, 0, sizeof(no_packet));
2594 /* finish if limit size exhausted */
2595 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2598 /* read a frame from it and output it in the fifo */
2599 is = input_files[file_index].ctx;
2600 ret= av_read_frame(is, &pkt);
2601 if(ret == AVERROR(EAGAIN)){
2602 no_packet[file_index]=1;
2607 input_files[file_index].eof_reached = 1;
2615 memset(no_packet, 0, sizeof(no_packet));
2618 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2619 is->streams[pkt.stream_index]);
2621 /* the following test is needed in case new streams appear
2622 dynamically in stream : we ignore them */
2623 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2624 goto discard_packet;
2625 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2626 ist = &input_streams[ist_index];
2628 goto discard_packet;
2630 if (pkt.dts != AV_NOPTS_VALUE)
2631 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2632 if (pkt.pts != AV_NOPTS_VALUE)
2633 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2635 if (ist->ts_scale) {
2636 if(pkt.pts != AV_NOPTS_VALUE)
2637 pkt.pts *= ist->ts_scale;
2638 if(pkt.dts != AV_NOPTS_VALUE)
2639 pkt.dts *= ist->ts_scale;
2642 // 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);
2643 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2644 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2645 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2646 int64_t delta= pkt_dts - ist->next_pts;
2647 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2648 input_files[ist->file_index].ts_offset -= delta;
2650 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2651 delta, input_files[ist->file_index].ts_offset);
2652 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2653 if(pkt.pts != AV_NOPTS_VALUE)
2654 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2658 /* finish if recording time exhausted */
2659 if (recording_time != INT64_MAX &&
2660 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2661 ist->is_past_recording_time = 1;
2662 goto discard_packet;
2665 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2666 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2669 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2670 ist->file_index, ist->st->index);
2673 av_free_packet(&pkt);
2678 av_free_packet(&pkt);
2680 /* dump report by using the output first video and audio streams */
2681 print_report(output_files, ost_table, nb_ostreams, 0);
2684 /* at the end of stream, we must flush the decoder buffers */
2685 for (i = 0; i < nb_input_streams; i++) {
2686 ist = &input_streams[i];
2687 if (ist->decoding_needed) {
2688 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2694 /* write the trailer if needed and close file */
2695 for(i=0;i<nb_output_files;i++) {
2696 os = output_files[i];
2697 av_write_trailer(os);
2700 /* dump report by using the first video and audio streams */
2701 print_report(output_files, ost_table, nb_ostreams, 1);
2703 /* close each encoder */
2704 for(i=0;i<nb_ostreams;i++) {
2706 if (ost->encoding_needed) {
2707 av_freep(&ost->st->codec->stats_in);
2708 avcodec_close(ost->st->codec);
2711 avfilter_graph_free(&ost->graph);
2715 /* close each decoder */
2716 for (i = 0; i < nb_input_streams; i++) {
2717 ist = &input_streams[i];
2718 if (ist->decoding_needed) {
2719 avcodec_close(ist->st->codec);
2727 av_freep(&bit_buffer);
2730 for(i=0;i<nb_ostreams;i++) {
2733 if (ost->st->stream_copy)
2734 av_freep(&ost->st->codec->extradata);
2736 fclose(ost->logfile);
2737 ost->logfile = NULL;
2739 av_fifo_free(ost->fifo); /* works even if fifo is not
2740 initialized but set to zero */
2741 av_freep(&ost->st->codec->subtitle_header);
2742 av_free(ost->pict_tmp.data[0]);
2743 av_free(ost->forced_kf_pts);
2744 if (ost->video_resample)
2745 sws_freeContext(ost->img_resample_ctx);
2747 audio_resample_close(ost->resample);
2748 if (ost->reformat_ctx)
2749 av_audio_convert_free(ost->reformat_ctx);
2750 av_dict_free(&ost->opts);
2759 static int opt_format(const char *opt, const char *arg)
2761 last_asked_format = arg;
2765 static int opt_video_rc_override_string(const char *opt, const char *arg)
2767 video_rc_override_string = arg;
2771 static int opt_me_threshold(const char *opt, const char *arg)
2773 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2777 static int opt_verbose(const char *opt, const char *arg)
2779 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2783 static int opt_frame_rate(const char *opt, const char *arg)
2785 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2786 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2792 static int opt_frame_crop(const char *opt, const char *arg)
2794 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2795 return AVERROR(EINVAL);
2798 static int opt_frame_size(const char *opt, const char *arg)
2800 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2801 fprintf(stderr, "Incorrect frame size\n");
2802 return AVERROR(EINVAL);
2807 static int opt_pad(const char *opt, const char *arg) {
2808 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2812 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2814 if (strcmp(arg, "list")) {
2815 frame_pix_fmt = av_get_pix_fmt(arg);
2816 if (frame_pix_fmt == PIX_FMT_NONE) {
2817 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2818 return AVERROR(EINVAL);
2827 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2834 p = strchr(arg, ':');
2836 x = strtol(arg, &end, 10);
2838 y = strtol(end+1, &end, 10);
2840 ar = (double)x / (double)y;
2842 ar = strtod(arg, NULL);
2845 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2846 return AVERROR(EINVAL);
2848 frame_aspect_ratio = ar;
2852 static int opt_metadata(const char *opt, const char *arg)
2854 char *mid= strchr(arg, '=');
2857 fprintf(stderr, "Missing =\n");
2862 av_dict_set(&metadata, arg, mid, 0);
2867 static int opt_qscale(const char *opt, const char *arg)
2869 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2870 if (video_qscale == 0) {
2871 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2872 return AVERROR(EINVAL);
2877 static int opt_top_field_first(const char *opt, const char *arg)
2879 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2883 static int opt_thread_count(const char *opt, const char *arg)
2885 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2888 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2893 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2895 if (strcmp(arg, "list")) {
2896 audio_sample_fmt = av_get_sample_fmt(arg);
2897 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2898 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2899 return AVERROR(EINVAL);
2904 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2905 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2911 static int opt_audio_rate(const char *opt, const char *arg)
2913 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2917 static int opt_audio_channels(const char *opt, const char *arg)
2919 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2923 static int opt_video_channel(const char *opt, const char *arg)
2925 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2926 opt_default("channel", arg);
2930 static int opt_video_standard(const char *opt, const char *arg)
2932 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2933 opt_default("standard", arg);
2937 static int opt_codec(int *pstream_copy, char **pcodec_name,
2938 int codec_type, const char *arg)
2940 av_freep(pcodec_name);
2941 if (!strcmp(arg, "copy")) {
2944 *pcodec_name = av_strdup(arg);
2949 static int opt_audio_codec(const char *opt, const char *arg)
2951 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2954 static int opt_video_codec(const char *opt, const char *arg)
2956 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2959 static int opt_subtitle_codec(const char *opt, const char *arg)
2961 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2964 static int opt_data_codec(const char *opt, const char *arg)
2966 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2969 static int opt_codec_tag(const char *opt, const char *arg)
2972 uint32_t *codec_tag;
2974 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2975 !strcmp(opt, "vtag") ? &video_codec_tag :
2976 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2980 *codec_tag = strtol(arg, &tail, 0);
2982 *codec_tag = AV_RL32(arg);
2987 static int opt_map(const char *opt, const char *arg)
2992 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2993 m = &stream_maps[nb_stream_maps-1];
2995 m->file_index = strtol(arg, &p, 0);
2999 m->stream_index = strtol(p, &p, 0);
3002 m->sync_file_index = strtol(p, &p, 0);
3005 m->sync_stream_index = strtol(p, &p, 0);
3007 m->sync_file_index = m->file_index;
3008 m->sync_stream_index = m->stream_index;
3013 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3024 *index = strtol(++arg, endptr, 0);
3027 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3034 static int opt_map_metadata(const char *opt, const char *arg)
3036 MetadataMap *m, *m1;
3039 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3040 &nb_meta_data_maps, nb_meta_data_maps + 1);
3042 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3043 m->file = strtol(arg, &p, 0);
3044 parse_meta_type(p, &m->type, &m->index, &p);
3048 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3049 m1->file = strtol(p, &p, 0);
3050 parse_meta_type(p, &m1->type, &m1->index, &p);
3052 if (m->type == 'g' || m1->type == 'g')
3053 metadata_global_autocopy = 0;
3054 if (m->type == 's' || m1->type == 's')
3055 metadata_streams_autocopy = 0;
3056 if (m->type == 'c' || m1->type == 'c')
3057 metadata_chapters_autocopy = 0;
3062 static int opt_map_meta_data(const char *opt, const char *arg)
3064 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3065 "Use -map_metadata instead.\n");
3066 return opt_map_metadata(opt, arg);
3069 static int opt_map_chapters(const char *opt, const char *arg)
3074 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3075 nb_chapter_maps + 1);
3076 c = &chapter_maps[nb_chapter_maps - 1];
3077 c->out_file = strtol(arg, &p, 0);
3081 c->in_file = strtol(p, &p, 0);
3085 static int opt_input_ts_scale(const char *opt, const char *arg)
3087 unsigned int stream;
3091 stream = strtol(arg, &p, 0);
3094 scale= strtod(p, &p);
3096 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3097 ts_scale[stream] = scale;
3101 static int opt_recording_time(const char *opt, const char *arg)
3103 recording_time = parse_time_or_die(opt, arg, 1);
3107 static int opt_start_time(const char *opt, const char *arg)
3109 start_time = parse_time_or_die(opt, arg, 1);
3113 static int opt_recording_timestamp(const char *opt, const char *arg)
3116 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3117 struct tm time = *gmtime((time_t*)&recording_timestamp);
3118 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3119 opt_metadata("metadata", buf);
3121 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3122 "tag instead.\n", opt);
3126 static int opt_input_ts_offset(const char *opt, const char *arg)
3128 input_ts_offset = parse_time_or_die(opt, arg, 1);
3132 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3134 const char *codec_string = encoder ? "encoder" : "decoder";
3138 return CODEC_ID_NONE;
3140 avcodec_find_encoder_by_name(name) :
3141 avcodec_find_decoder_by_name(name);
3143 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3146 if(codec->type != type) {
3147 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3153 static int opt_input_file(const char *opt, const char *filename)
3155 AVFormatContext *ic;
3156 AVInputFormat *file_iformat = NULL;
3157 int err, i, ret, rfps, rfps_base;
3160 AVDictionary **opts;
3161 int orig_nb_streams; // number of streams before avformat_find_stream_info
3163 if (last_asked_format) {
3164 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3165 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3168 last_asked_format = NULL;
3171 if (!strcmp(filename, "-"))
3174 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3175 !strcmp(filename, "/dev/stdin");
3177 /* get default parameters from command line */
3178 ic = avformat_alloc_context();
3180 print_error(filename, AVERROR(ENOMEM));
3183 if (audio_sample_rate) {
3184 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3185 av_dict_set(&format_opts, "sample_rate", buf, 0);
3187 if (audio_channels) {
3188 snprintf(buf, sizeof(buf), "%d", audio_channels);
3189 av_dict_set(&format_opts, "channels", buf, 0);
3191 if (frame_rate.num) {
3192 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3193 av_dict_set(&format_opts, "framerate", buf, 0);
3195 if (frame_width && frame_height) {
3196 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3197 av_dict_set(&format_opts, "video_size", buf, 0);
3199 if (frame_pix_fmt != PIX_FMT_NONE)
3200 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3202 ic->video_codec_id =
3203 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3204 ic->audio_codec_id =
3205 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3206 ic->subtitle_codec_id=
3207 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3208 ic->flags |= AVFMT_FLAG_NONBLOCK;
3210 /* open the input file with generic libav function */
3211 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3213 print_error(filename, err);
3216 assert_avoptions(format_opts);
3221 for(i=0; i<ic->nb_streams; i++){
3222 ic->streams[i]->discard= AVDISCARD_ALL;
3224 for(i=0; i<ic->nb_programs; i++){
3225 AVProgram *p= ic->programs[i];
3226 if(p->id != opt_programid){
3227 p->discard = AVDISCARD_ALL;
3230 for(j=0; j<p->nb_stream_indexes; j++){
3231 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3236 fprintf(stderr, "Specified program id not found\n");
3243 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3244 ic->loop_input = loop_input;
3247 /* Set AVCodecContext options for avformat_find_stream_info */
3248 opts = setup_find_stream_info_opts(ic, codec_opts);
3249 orig_nb_streams = ic->nb_streams;
3251 /* If not enough info to get the stream parameters, we decode the
3252 first frames to get it. (used in mpeg case for example) */
3253 ret = avformat_find_stream_info(ic, opts);
3254 if (ret < 0 && verbose >= 0) {
3255 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3256 av_close_input_file(ic);
3260 timestamp = start_time;
3261 /* add the stream start time */
3262 if (ic->start_time != AV_NOPTS_VALUE)
3263 timestamp += ic->start_time;
3265 /* if seeking requested, we execute it */
3266 if (start_time != 0) {
3267 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3269 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3270 filename, (double)timestamp / AV_TIME_BASE);
3272 /* reset seek info */
3276 /* update the current parameters so that they match the one of the input stream */
3277 for(i=0;i<ic->nb_streams;i++) {
3278 AVStream *st = ic->streams[i];
3279 AVCodecContext *dec = st->codec;
3282 dec->thread_count = thread_count;
3284 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3285 ist = &input_streams[nb_input_streams - 1];
3287 ist->file_index = nb_input_files;
3289 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3291 if (i < nb_ts_scale)
3292 ist->ts_scale = ts_scale[i];
3294 switch (dec->codec_type) {
3295 case AVMEDIA_TYPE_AUDIO:
3296 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3298 st->discard= AVDISCARD_ALL;
3300 case AVMEDIA_TYPE_VIDEO:
3301 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3302 rfps = ic->streams[i]->r_frame_rate.num;
3303 rfps_base = ic->streams[i]->r_frame_rate.den;
3305 dec->flags |= CODEC_FLAG_EMU_EDGE;
3306 dec->height >>= dec->lowres;
3307 dec->width >>= dec->lowres;
3310 dec->debug |= FF_DEBUG_MV;
3312 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3315 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3316 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3318 (float)rfps / rfps_base, rfps, rfps_base);
3322 st->discard= AVDISCARD_ALL;
3323 else if(video_discard)
3324 st->discard= video_discard;
3326 case AVMEDIA_TYPE_DATA:
3328 case AVMEDIA_TYPE_SUBTITLE:
3329 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3330 if(subtitle_disable)
3331 st->discard = AVDISCARD_ALL;
3333 case AVMEDIA_TYPE_ATTACHMENT:
3334 case AVMEDIA_TYPE_UNKNOWN:
3341 /* dump the file content */
3343 av_dump_format(ic, nb_input_files, filename, 0);
3345 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3346 input_files[nb_input_files - 1].ctx = ic;
3347 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3348 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3350 frame_rate = (AVRational){0, 0};
3351 frame_pix_fmt = PIX_FMT_NONE;
3354 audio_sample_rate = 0;
3356 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3357 av_freep(&ts_scale);
3360 for (i = 0; i < orig_nb_streams; i++)
3361 av_dict_free(&opts[i]);
3363 av_freep(&video_codec_name);
3364 av_freep(&audio_codec_name);
3365 av_freep(&subtitle_codec_name);
3371 static void check_inputs(int *has_video_ptr,
3373 int *has_subtitle_ptr,
3376 int has_video, has_audio, has_subtitle, has_data, i, j;
3377 AVFormatContext *ic;
3384 for(j=0;j<nb_input_files;j++) {
3385 ic = input_files[j].ctx;
3386 for(i=0;i<ic->nb_streams;i++) {
3387 AVCodecContext *enc = ic->streams[i]->codec;
3388 switch(enc->codec_type) {
3389 case AVMEDIA_TYPE_AUDIO:
3392 case AVMEDIA_TYPE_VIDEO:
3395 case AVMEDIA_TYPE_SUBTITLE:
3398 case AVMEDIA_TYPE_DATA:
3399 case AVMEDIA_TYPE_ATTACHMENT:
3400 case AVMEDIA_TYPE_UNKNOWN:
3408 *has_video_ptr = has_video;
3409 *has_audio_ptr = has_audio;
3410 *has_subtitle_ptr = has_subtitle;
3411 *has_data_ptr = has_data;
3414 static void new_video_stream(AVFormatContext *oc, int file_idx)
3418 AVCodecContext *video_enc;
3419 enum CodecID codec_id = CODEC_ID_NONE;
3420 AVCodec *codec= NULL;
3422 if(!video_stream_copy){
3423 if (video_codec_name) {
3424 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3425 codec = avcodec_find_encoder_by_name(video_codec_name);
3427 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3428 codec = avcodec_find_encoder(codec_id);
3432 ost = new_output_stream(oc, file_idx, codec);
3434 if (!video_stream_copy) {
3435 ost->frame_aspect_ratio = frame_aspect_ratio;
3436 frame_aspect_ratio = 0;
3438 ost->avfilter= vfilters;
3443 ost->bitstream_filters = video_bitstream_filters;
3444 video_bitstream_filters= NULL;
3446 st->codec->thread_count= thread_count;
3448 video_enc = st->codec;
3451 video_enc->codec_tag= video_codec_tag;
3453 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3454 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3457 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3458 if (video_stream_copy) {
3459 st->stream_copy = 1;
3460 video_enc->sample_aspect_ratio =
3461 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3467 ost->frame_rate = frame_rate;
3468 video_enc->codec_id = codec_id;
3470 video_enc->width = frame_width;
3471 video_enc->height = frame_height;
3472 video_enc->pix_fmt = frame_pix_fmt;
3473 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3476 video_enc->gop_size = 0;
3477 if (video_qscale || same_quality) {
3478 video_enc->flags |= CODEC_FLAG_QSCALE;
3479 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3483 video_enc->intra_matrix = intra_matrix;
3485 video_enc->inter_matrix = inter_matrix;
3487 p= video_rc_override_string;
3490 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3492 fprintf(stderr, "error parsing rc_override\n");
3495 video_enc->rc_override=
3496 av_realloc(video_enc->rc_override,
3497 sizeof(RcOverride)*(i+1));
3498 video_enc->rc_override[i].start_frame= start;
3499 video_enc->rc_override[i].end_frame = end;
3501 video_enc->rc_override[i].qscale= q;
3502 video_enc->rc_override[i].quality_factor= 1.0;
3505 video_enc->rc_override[i].qscale= 0;
3506 video_enc->rc_override[i].quality_factor= -q/100.0;
3511 video_enc->rc_override_count=i;
3512 if (!video_enc->rc_initial_buffer_occupancy)
3513 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3514 video_enc->me_threshold= me_threshold;
3515 video_enc->intra_dc_precision= intra_dc_precision - 8;
3518 video_enc->flags|= CODEC_FLAG_PSNR;
3523 video_enc->flags |= CODEC_FLAG_PASS1;
3525 video_enc->flags |= CODEC_FLAG_PASS2;
3529 if (forced_key_frames)
3530 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3532 if (video_language) {
3533 av_dict_set(&st->metadata, "language", video_language, 0);
3534 av_freep(&video_language);
3537 /* reset some key parameters */
3539 av_freep(&video_codec_name);
3540 av_freep(&forced_key_frames);
3541 video_stream_copy = 0;
3542 frame_pix_fmt = PIX_FMT_NONE;
3545 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3549 AVCodec *codec= NULL;
3550 AVCodecContext *audio_enc;
3551 enum CodecID codec_id = CODEC_ID_NONE;
3553 if(!audio_stream_copy){
3554 if (audio_codec_name) {
3555 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3556 codec = avcodec_find_encoder_by_name(audio_codec_name);
3558 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3559 codec = avcodec_find_encoder(codec_id);
3562 ost = new_output_stream(oc, file_idx, codec);
3565 ost->bitstream_filters = audio_bitstream_filters;
3566 audio_bitstream_filters= NULL;
3568 st->codec->thread_count= thread_count;
3570 audio_enc = st->codec;
3571 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3574 audio_enc->codec_tag= audio_codec_tag;
3576 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3577 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3579 if (audio_stream_copy) {
3580 st->stream_copy = 1;
3582 audio_enc->codec_id = codec_id;
3584 if (audio_qscale > QSCALE_NONE) {
3585 audio_enc->flags |= CODEC_FLAG_QSCALE;
3586 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3589 audio_enc->channels = audio_channels;
3590 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3591 audio_enc->sample_fmt = audio_sample_fmt;
3592 if (audio_sample_rate)
3593 audio_enc->sample_rate = audio_sample_rate;
3595 if (audio_language) {
3596 av_dict_set(&st->metadata, "language", audio_language, 0);
3597 av_freep(&audio_language);
3600 /* reset some key parameters */
3602 av_freep(&audio_codec_name);
3603 audio_stream_copy = 0;
3606 static void new_data_stream(AVFormatContext *oc, int file_idx)
3610 AVCodecContext *data_enc;
3612 ost = new_output_stream(oc, file_idx, NULL);
3614 data_enc = st->codec;
3615 if (!data_stream_copy) {
3616 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3620 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3623 data_enc->codec_tag= data_codec_tag;
3625 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3626 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3628 if (data_stream_copy) {
3629 st->stream_copy = 1;
3633 av_freep(&data_codec_name);
3634 data_stream_copy = 0;
3637 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3641 AVCodec *codec=NULL;
3642 AVCodecContext *subtitle_enc;
3643 enum CodecID codec_id = CODEC_ID_NONE;
3645 if(!subtitle_stream_copy){
3646 if (subtitle_codec_name) {
3647 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3648 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3650 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3651 codec = avcodec_find_encoder(codec_id);
3654 ost = new_output_stream(oc, file_idx, codec);
3656 subtitle_enc = st->codec;
3658 ost->bitstream_filters = subtitle_bitstream_filters;
3659 subtitle_bitstream_filters= NULL;
3661 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3663 if(subtitle_codec_tag)
3664 subtitle_enc->codec_tag= subtitle_codec_tag;
3666 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3667 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3669 if (subtitle_stream_copy) {
3670 st->stream_copy = 1;
3672 subtitle_enc->codec_id = codec_id;
3675 if (subtitle_language) {
3676 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3677 av_freep(&subtitle_language);
3680 subtitle_disable = 0;
3681 av_freep(&subtitle_codec_name);
3682 subtitle_stream_copy = 0;
3685 static int opt_new_stream(const char *opt, const char *arg)
3687 AVFormatContext *oc;
3688 int file_idx = nb_output_files - 1;
3689 if (nb_output_files <= 0) {
3690 fprintf(stderr, "At least one output file must be specified\n");
3693 oc = output_files[file_idx];
3695 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3696 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3697 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3698 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3703 /* arg format is "output-stream-index:streamid-value". */
3704 static int opt_streamid(const char *opt, const char *arg)
3710 av_strlcpy(idx_str, arg, sizeof(idx_str));
3711 p = strchr(idx_str, ':');
3714 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3719 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3720 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3721 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3725 static void opt_output_file(const char *filename)
3727 AVFormatContext *oc;
3728 int err, use_video, use_audio, use_subtitle, use_data;
3729 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3730 AVOutputFormat *file_oformat;
3732 if (!strcmp(filename, "-"))
3735 oc = avformat_alloc_context();
3737 print_error(filename, AVERROR(ENOMEM));
3741 if (last_asked_format) {
3742 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3743 if (!file_oformat) {
3744 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3747 last_asked_format = NULL;
3749 file_oformat = av_guess_format(NULL, filename, NULL);
3750 if (!file_oformat) {
3751 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3757 oc->oformat = file_oformat;
3758 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3760 if (!strcmp(file_oformat->name, "ffm") &&
3761 av_strstart(filename, "http:", NULL)) {
3762 /* special case for files sent to avserver: we get the stream
3763 parameters from avserver */
3764 int err = read_avserver_streams(oc, filename);
3766 print_error(filename, err);
3770 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3771 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3772 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3773 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 */
3775 /* disable if no corresponding type found */
3776 check_inputs(&input_has_video,
3778 &input_has_subtitle,
3781 if (!input_has_video)
3783 if (!input_has_audio)
3785 if (!input_has_subtitle)
3787 if (!input_has_data)
3790 /* manual disable */
3791 if (audio_disable) use_audio = 0;
3792 if (video_disable) use_video = 0;
3793 if (subtitle_disable) use_subtitle = 0;
3794 if (data_disable) use_data = 0;
3796 if (use_video) new_video_stream(oc, nb_output_files);
3797 if (use_audio) new_audio_stream(oc, nb_output_files);
3798 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3799 if (use_data) new_data_stream(oc, nb_output_files);
3801 av_dict_copy(&oc->metadata, metadata, 0);
3802 av_dict_free(&metadata);
3805 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3806 output_files[nb_output_files++] = oc;
3808 /* check filename in case of an image number is expected */
3809 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3810 if (!av_filename_number_test(oc->filename)) {
3811 print_error(oc->filename, AVERROR(EINVAL));
3816 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3817 /* test if it already exists to avoid loosing precious files */
3818 if (!file_overwrite &&
3819 (strchr(filename, ':') == NULL ||
3820 filename[1] == ':' ||
3821 av_strstart(filename, "file:", NULL))) {
3822 if (avio_check(filename, 0) == 0) {
3824 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3826 if (!read_yesno()) {
3827 fprintf(stderr, "Not overwriting - exiting\n");
3832 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3839 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3840 print_error(filename, err);
3845 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3846 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3847 if (loop_output >= 0) {
3848 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3849 oc->loop_output = loop_output;
3851 oc->flags |= AVFMT_FLAG_NONBLOCK;
3853 frame_rate = (AVRational){0, 0};
3856 audio_sample_rate = 0;
3858 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3860 av_freep(&forced_key_frames);
3865 /* same option as mencoder */
3866 static int opt_pass(const char *opt, const char *arg)
3868 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3872 static int64_t getutime(void)
3875 struct rusage rusage;
3877 getrusage(RUSAGE_SELF, &rusage);
3878 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3879 #elif HAVE_GETPROCESSTIMES
3881 FILETIME c, e, k, u;
3882 proc = GetCurrentProcess();
3883 GetProcessTimes(proc, &c, &e, &k, &u);
3884 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3886 return av_gettime();
3890 static int64_t getmaxrss(void)
3892 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3893 struct rusage rusage;
3894 getrusage(RUSAGE_SELF, &rusage);
3895 return (int64_t)rusage.ru_maxrss * 1024;
3896 #elif HAVE_GETPROCESSMEMORYINFO
3898 PROCESS_MEMORY_COUNTERS memcounters;
3899 proc = GetCurrentProcess();
3900 memcounters.cb = sizeof(memcounters);
3901 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3902 return memcounters.PeakPagefileUsage;
3908 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3911 const char *p = str;
3918 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3925 static void opt_inter_matrix(const char *arg)
3927 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3928 parse_matrix_coeffs(inter_matrix, arg);
3931 static void opt_intra_matrix(const char *arg)
3933 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3934 parse_matrix_coeffs(intra_matrix, arg);
3937 static void show_usage(void)
3939 printf("Hyper fast Audio and Video encoder\n");
3940 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3944 static void show_help(void)
3947 AVOutputFormat *oformat = NULL;
3948 AVInputFormat *iformat = NULL;
3949 const AVClass *class;
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 class = avcodec_get_class();
3978 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3981 /* individual codec options */
3983 while ((c = av_codec_next(c))) {
3984 if (c->priv_class) {
3985 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3990 class = avformat_get_class();
3991 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3994 /* individual muxer options */
3995 while ((oformat = av_oformat_next(oformat))) {
3996 if (oformat->priv_class) {
3997 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4002 /* individual demuxer options */
4003 while ((iformat = av_iformat_next(iformat))) {
4004 if (iformat->priv_class) {
4005 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4010 class = sws_get_class();
4011 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4014 static int opt_target(const char *opt, const char *arg)
4016 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4017 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4019 if(!strncmp(arg, "pal-", 4)) {
4022 } else if(!strncmp(arg, "ntsc-", 5)) {
4025 } else if(!strncmp(arg, "film-", 5)) {
4030 /* Calculate FR via float to avoid int overflow */
4031 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4034 } else if((fr == 29970) || (fr == 23976)) {
4037 /* Try to determine PAL/NTSC by peeking in the input files */
4038 if(nb_input_files) {
4040 for (j = 0; j < nb_input_files; j++) {
4041 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4042 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4043 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4045 fr = c->time_base.den * 1000 / c->time_base.num;
4049 } else if((fr == 29970) || (fr == 23976)) {
4059 if(verbose > 0 && norm != UNKNOWN)
4060 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4063 if(norm == UNKNOWN) {
4064 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4065 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4066 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4070 if(!strcmp(arg, "vcd")) {
4071 opt_video_codec("vcodec", "mpeg1video");
4072 opt_audio_codec("vcodec", "mp2");
4073 opt_format("f", "vcd");
4075 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4076 opt_frame_rate("r", frame_rates[norm]);
4077 opt_default("g", norm == PAL ? "15" : "18");
4079 opt_default("b", "1150000");
4080 opt_default("maxrate", "1150000");
4081 opt_default("minrate", "1150000");
4082 opt_default("bufsize", "327680"); // 40*1024*8;
4084 opt_default("ab", "224000");
4085 audio_sample_rate = 44100;
4088 opt_default("packetsize", "2324");
4089 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4091 /* We have to offset the PTS, so that it is consistent with the SCR.
4092 SCR starts at 36000, but the first two packs contain only padding
4093 and the first pack from the other stream, respectively, may also have
4094 been written before.
4095 So the real data starts at SCR 36000+3*1200. */
4096 mux_preload= (36000+3*1200) / 90000.0; //0.44
4097 } else if(!strcmp(arg, "svcd")) {
4099 opt_video_codec("vcodec", "mpeg2video");
4100 opt_audio_codec("acodec", "mp2");
4101 opt_format("f", "svcd");
4103 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4104 opt_frame_rate("r", frame_rates[norm]);
4105 opt_default("g", norm == PAL ? "15" : "18");
4107 opt_default("b", "2040000");
4108 opt_default("maxrate", "2516000");
4109 opt_default("minrate", "0"); //1145000;
4110 opt_default("bufsize", "1835008"); //224*1024*8;
4111 opt_default("flags", "+scan_offset");
4114 opt_default("ab", "224000");
4115 audio_sample_rate = 44100;
4117 opt_default("packetsize", "2324");
4119 } else if(!strcmp(arg, "dvd")) {
4121 opt_video_codec("vcodec", "mpeg2video");
4122 opt_audio_codec("vcodec", "ac3");
4123 opt_format("f", "dvd");
4125 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4126 opt_frame_rate("r", frame_rates[norm]);
4127 opt_default("g", norm == PAL ? "15" : "18");
4129 opt_default("b", "6000000");
4130 opt_default("maxrate", "9000000");
4131 opt_default("minrate", "0"); //1500000;
4132 opt_default("bufsize", "1835008"); //224*1024*8;
4134 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4135 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4137 opt_default("ab", "448000");
4138 audio_sample_rate = 48000;
4140 } else if(!strncmp(arg, "dv", 2)) {
4142 opt_format("f", "dv");
4144 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4145 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4146 norm == PAL ? "yuv420p" : "yuv411p");
4147 opt_frame_rate("r", frame_rates[norm]);
4149 audio_sample_rate = 48000;
4153 fprintf(stderr, "Unknown target: %s\n", arg);
4154 return AVERROR(EINVAL);
4159 static int opt_vstats_file(const char *opt, const char *arg)
4161 av_free (vstats_filename);
4162 vstats_filename=av_strdup (arg);
4166 static int opt_vstats(const char *opt, const char *arg)
4169 time_t today2 = time(NULL);
4170 struct tm *today = localtime(&today2);
4172 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4174 return opt_vstats_file(opt, filename);
4177 static int opt_bsf(const char *opt, const char *arg)
4179 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4180 AVBitStreamFilterContext **bsfp;
4183 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4187 bsfp= *opt == 'v' ? &video_bitstream_filters :
4188 *opt == 'a' ? &audio_bitstream_filters :
4189 &subtitle_bitstream_filters;
4191 bsfp= &(*bsfp)->next;
4198 static int opt_preset(const char *opt, const char *arg)
4201 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4202 char *codec_name = *opt == 'v' ? video_codec_name :
4203 *opt == 'a' ? audio_codec_name :
4204 subtitle_codec_name;
4206 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4207 fprintf(stderr, "File for preset '%s' not found\n", arg);
4212 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4213 if(line[0] == '#' && !e)
4215 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4217 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4220 if(!strcmp(tmp, "acodec")){
4221 opt_audio_codec(tmp, tmp2);
4222 }else if(!strcmp(tmp, "vcodec")){
4223 opt_video_codec(tmp, tmp2);
4224 }else if(!strcmp(tmp, "scodec")){
4225 opt_subtitle_codec(tmp, tmp2);
4226 }else if(!strcmp(tmp, "dcodec")){
4227 opt_data_codec(tmp, tmp2);
4228 }else if(opt_default(tmp, tmp2) < 0){
4229 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4239 static const OptionDef options[] = {
4241 #include "cmdutils_common_opts.h"
4242 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4243 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4244 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4245 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4246 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4247 "outfile[,metadata]:infile[,metadata]" },
4248 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4249 "outfile[,metadata]:infile[,metadata]" },
4250 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4251 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4252 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4253 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4254 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4255 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4256 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4257 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4258 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4259 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4260 "add timings for benchmarking" },
4261 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4262 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4263 "dump each input packet" },
4264 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4265 "when dumping packets, also dump the payload" },
4266 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4267 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4268 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4269 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4270 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4271 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4272 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4273 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4274 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4275 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4276 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4277 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4278 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4279 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4280 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4281 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4284 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4285 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4286 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4287 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4288 { "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" },
4289 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4290 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4291 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4292 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4293 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4294 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4295 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4296 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4297 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4298 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4299 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4300 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4301 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4302 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4303 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4304 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4305 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4306 "use same quantizer as source (implies VBR)" },
4307 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4308 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4309 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4310 "deinterlace pictures" },
4311 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4312 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4313 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4315 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4317 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4318 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4319 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4320 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4321 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4322 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4323 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4324 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4325 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4326 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4327 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4330 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4331 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4332 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4333 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4334 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4335 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4336 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4337 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4338 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4339 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4340 { "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" },
4342 /* subtitle options */
4343 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4344 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4345 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4346 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4347 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4350 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4351 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4352 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4355 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4356 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4358 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4359 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4360 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4362 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4363 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4364 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4365 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4366 /* data codec support */
4367 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4369 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4373 int main(int argc, char **argv)
4377 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4379 avcodec_register_all();
4381 avdevice_register_all();
4384 avfilter_register_all();
4388 avio_set_interrupt_cb(decode_interrupt_cb);
4394 av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
4395 "provided for compatibility. Use avconv instead "
4396 "(see Changelog for the list of incompatible changes).\n");
4399 parse_options(argc, argv, options, opt_output_file);
4401 if(nb_output_files <= 0 && nb_input_files == 0) {
4403 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4407 /* file converter / grab */
4408 if (nb_output_files <= 0) {
4409 fprintf(stderr, "At least one output file must be specified\n");
4413 if (nb_input_files == 0) {
4414 fprintf(stderr, "At least one input file must be specified\n");
4419 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4420 stream_maps, nb_stream_maps) < 0)
4422 ti = getutime() - ti;
4424 int maxrss = getmaxrss() / 1024;
4425 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);