3 * Copyright (c) 2000-2011 The libav developers.
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[] = "avconv";
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 static const OptionDef options[];
101 static const char *last_asked_format = NULL;
102 static double *ts_scale;
103 static int nb_ts_scale;
105 static AVFormatContext *output_files[MAX_FILES];
106 static AVDictionary *output_opts[MAX_FILES];
107 static int nb_output_files = 0;
109 static StreamMap *stream_maps = NULL;
110 static int nb_stream_maps;
112 /* first item specifies output metadata, second is input */
113 static MetadataMap (*meta_data_maps)[2] = NULL;
114 static int nb_meta_data_maps;
115 static int metadata_global_autocopy = 1;
116 static int metadata_streams_autocopy = 1;
117 static int metadata_chapters_autocopy = 1;
119 static int chapters_input_file = INT_MAX;
121 /* indexed by output file stream index */
122 static int *streamid_map = NULL;
123 static int nb_streamid_map = 0;
125 static int frame_width = 0;
126 static int frame_height = 0;
127 static float frame_aspect_ratio = 0;
128 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
129 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
130 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
131 static AVRational frame_rate;
132 static float video_qscale = 0;
133 static uint16_t *intra_matrix = NULL;
134 static uint16_t *inter_matrix = NULL;
135 static const char *video_rc_override_string=NULL;
136 static int video_disable = 0;
137 static int video_discard = 0;
138 static char *video_codec_name = NULL;
139 static unsigned int video_codec_tag = 0;
140 static char *video_language = NULL;
141 static int same_quality = 0;
142 static int do_deinterlace = 0;
143 static int top_field_first = -1;
144 static int me_threshold = 0;
145 static int intra_dc_precision = 8;
146 static int qp_hist = 0;
148 static char *vfilters = NULL;
151 static int intra_only = 0;
152 static int audio_sample_rate = 0;
153 #define QSCALE_NONE -99999
154 static float audio_qscale = QSCALE_NONE;
155 static int audio_disable = 0;
156 static int audio_channels = 0;
157 static char *audio_codec_name = NULL;
158 static unsigned int audio_codec_tag = 0;
159 static char *audio_language = NULL;
161 static int subtitle_disable = 0;
162 static char *subtitle_codec_name = NULL;
163 static char *subtitle_language = NULL;
164 static unsigned int subtitle_codec_tag = 0;
166 static int data_disable = 0;
167 static char *data_codec_name = NULL;
168 static unsigned int data_codec_tag = 0;
170 static float mux_preload= 0.5;
171 static float mux_max_delay= 0.7;
173 static int64_t recording_time = INT64_MAX;
174 static int64_t start_time = 0;
175 static int64_t input_ts_offset = 0;
176 static int file_overwrite = 0;
177 static AVDictionary *metadata;
178 static int do_benchmark = 0;
179 static int do_hex_dump = 0;
180 static int do_pkt_dump = 0;
181 static int do_psnr = 0;
182 static int do_pass = 0;
183 static char *pass_logfilename_prefix = NULL;
184 static int audio_stream_copy = 0;
185 static int video_stream_copy = 0;
186 static int subtitle_stream_copy = 0;
187 static int data_stream_copy = 0;
188 static int video_sync_method= -1;
189 static int audio_sync_method= 0;
190 static float audio_drift_threshold= 0.1;
191 static int copy_ts= 0;
193 static int opt_shortest = 0;
194 static char *vstats_filename;
195 static FILE *vstats_file;
196 static int opt_programid = 0;
197 static int copy_initial_nonkeyframes = 0;
199 static int rate_emu = 0;
201 static int audio_volume = 256;
203 static int exit_on_error = 0;
204 static int using_stdin = 0;
205 static int verbose = 1;
206 static int thread_count= 1;
207 static int64_t video_size = 0;
208 static int64_t audio_size = 0;
209 static int64_t extra_size = 0;
210 static int nb_frames_dup = 0;
211 static int nb_frames_drop = 0;
212 static int input_sync;
213 static uint64_t limit_filesize = 0;
214 static int force_fps = 0;
215 static char *forced_key_frames = NULL;
217 static float dts_delta_threshold = 10;
219 static int64_t timer_start;
221 static uint8_t *audio_buf;
222 static uint8_t *audio_out;
223 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
225 static short *samples;
227 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
231 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
235 typedef struct OutputStream {
236 int file_index; /* file index */
237 int index; /* stream index in the output file */
238 int source_index; /* InputStream index */
239 AVStream *st; /* stream in the output file */
240 int encoding_needed; /* true if encoding needed for this stream */
242 /* input pts and corresponding output pts
244 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
245 struct InputStream *sync_ist; /* input stream to sync against */
246 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
247 AVBitStreamFilterContext *bitstream_filters;
252 AVFrame pict_tmp; /* temporary image for resampling */
253 struct SwsContext *img_resample_ctx; /* for image resampling */
256 int resample_pix_fmt;
257 AVRational frame_rate;
259 float frame_aspect_ratio;
261 /* forced key frames */
262 int64_t *forced_kf_pts;
268 ReSampleContext *resample; /* for audio resampling */
269 int resample_sample_fmt;
270 int resample_channels;
271 int resample_sample_rate;
273 AVAudioConvert *reformat_ctx;
274 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
278 AVFilterContext *output_video_filter;
279 AVFilterContext *input_video_filter;
280 AVFilterBufferRef *picref;
282 AVFilterGraph *graph;
289 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
290 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
292 typedef struct InputStream {
295 int discard; /* true if stream data should be discarded */
296 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
299 int64_t start; /* time when read started */
300 int64_t next_pts; /* synthetic pts for cases where pkt.pts
302 int64_t pts; /* current pts */
303 PtsCorrectionContext pts_ctx;
305 int is_start; /* is 1 at the start and after a discontinuity */
306 int showed_multi_packet_warning;
307 int is_past_recording_time;
311 typedef struct InputFile {
312 AVFormatContext *ctx;
313 int eof_reached; /* true if eof reached */
314 int ist_index; /* index of first stream in ist_table */
315 int buffer_size; /* current total buffer size */
319 static InputStream *input_streams = NULL;
320 static int nb_input_streams = 0;
321 static InputFile *input_files = NULL;
322 static int nb_input_files = 0;
326 static int configure_video_filters(InputStream *ist, OutputStream *ost)
328 AVFilterContext *last_filter, *filter;
329 /** filter graph containing all filters including input & output */
330 AVCodecContext *codec = ost->st->codec;
331 AVCodecContext *icodec = ist->st->codec;
332 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
333 AVRational sample_aspect_ratio;
337 ost->graph = avfilter_graph_alloc();
339 if (ist->st->sample_aspect_ratio.num){
340 sample_aspect_ratio = ist->st->sample_aspect_ratio;
342 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
344 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
345 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
346 sample_aspect_ratio.num, sample_aspect_ratio.den);
348 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
349 "src", args, NULL, ost->graph);
352 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
353 "out", NULL, &ffsink_ctx, ost->graph);
356 last_filter = ost->input_video_filter;
358 if (codec->width != icodec->width || codec->height != icodec->height) {
359 snprintf(args, 255, "%d:%d:flags=0x%X",
363 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
364 NULL, args, NULL, ost->graph)) < 0)
366 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
368 last_filter = filter;
371 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
372 ost->graph->scale_sws_opts = av_strdup(args);
375 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
376 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
378 outputs->name = av_strdup("in");
379 outputs->filter_ctx = last_filter;
380 outputs->pad_idx = 0;
381 outputs->next = NULL;
383 inputs->name = av_strdup("out");
384 inputs->filter_ctx = ost->output_video_filter;
388 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
390 av_freep(&ost->avfilter);
392 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
396 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
399 codec->width = ost->output_video_filter->inputs[0]->w;
400 codec->height = ost->output_video_filter->inputs[0]->h;
401 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
402 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
403 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
404 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
408 #endif /* CONFIG_AVFILTER */
410 static void term_exit(void)
412 av_log(NULL, AV_LOG_QUIET, "");
415 static volatile int received_sigterm = 0;
416 static volatile int received_nb_signals = 0;
419 sigterm_handler(int sig)
421 received_sigterm = sig;
422 received_nb_signals++;
426 static void term_init(void)
428 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
429 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
431 signal(SIGXCPU, sigterm_handler);
435 static int decode_interrupt_cb(void)
437 return received_nb_signals > 1;
440 static int exit_program(int ret)
445 for(i=0;i<nb_output_files;i++) {
446 AVFormatContext *s = output_files[i];
447 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
449 avformat_free_context(s);
450 av_free(output_streams_for_file[i]);
451 av_dict_free(&output_opts[i]);
453 for(i=0;i<nb_input_files;i++) {
454 av_close_input_file(input_files[i].ctx);
456 for (i = 0; i < nb_input_streams; i++)
457 av_dict_free(&input_streams[i].opts);
459 av_free(intra_matrix);
460 av_free(inter_matrix);
464 av_free(vstats_filename);
466 av_free(streamid_map);
467 av_free(meta_data_maps);
469 av_freep(&input_streams);
470 av_freep(&input_files);
472 av_free(video_codec_name);
473 av_free(audio_codec_name);
474 av_free(subtitle_codec_name);
475 av_free(data_codec_name);
480 allocated_audio_buf_size= allocated_audio_out_size= 0;
487 if (received_sigterm) {
489 "Received signal %d: terminating.\n",
490 (int) received_sigterm);
494 exit(ret); /* not all OS-es handle main() return value */
498 static void assert_avoptions(AVDictionary *m)
500 AVDictionaryEntry *t;
501 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
502 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
507 static void assert_codec_experimental(AVCodecContext *c, int encoder)
509 const char *codec_string = encoder ? "encoder" : "decoder";
511 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
512 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
513 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
514 "results.\nAdd '-strict experimental' if you want to use it.\n",
515 codec_string, c->codec->name);
516 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
517 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
518 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
519 codec_string, codec->name);
524 /* similar to ff_dynarray_add() and av_fast_realloc() */
525 static void *grow_array(void *array, int elem_size, int *size, int new_size)
527 if (new_size >= INT_MAX / elem_size) {
528 fprintf(stderr, "Array too big.\n");
531 if (*size < new_size) {
532 uint8_t *tmp = av_realloc(array, new_size*elem_size);
534 fprintf(stderr, "Could not alloc buffer.\n");
537 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
544 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
546 if(codec && codec->sample_fmts){
547 const enum AVSampleFormat *p= codec->sample_fmts;
549 if(*p == st->codec->sample_fmt)
553 av_log(NULL, AV_LOG_WARNING,
554 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
555 av_get_sample_fmt_name(st->codec->sample_fmt),
557 av_get_sample_fmt_name(codec->sample_fmts[0]));
558 st->codec->sample_fmt = codec->sample_fmts[0];
564 * Update the requested input sample format based on the output sample format.
565 * This is currently only used to request float output from decoders which
566 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
567 * Ideally this will be removed in the future when decoders do not do format
568 * conversion and only output in their native format.
570 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
573 /* if sample formats match or a decoder sample format has already been
574 requested, just return */
575 if (enc->sample_fmt == dec->sample_fmt ||
576 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
579 /* if decoder supports more than one output format */
580 if (dec_codec && dec_codec->sample_fmts &&
581 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
582 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
583 const enum AVSampleFormat *p;
584 int min_dec = -1, min_inc = -1;
586 /* find a matching sample format in the encoder */
587 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
588 if (*p == enc->sample_fmt) {
589 dec->request_sample_fmt = *p;
591 } else if (*p > enc->sample_fmt) {
592 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
594 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
597 /* if none match, provide the one that matches quality closest */
598 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
599 enc->sample_fmt - min_dec;
603 static void choose_sample_rate(AVStream *st, AVCodec *codec)
605 if(codec && codec->supported_samplerates){
606 const int *p= codec->supported_samplerates;
608 int best_dist=INT_MAX;
610 int dist= abs(st->codec->sample_rate - *p);
611 if(dist < best_dist){
617 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
619 st->codec->sample_rate= best;
623 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
625 if(codec && codec->pix_fmts){
626 const enum PixelFormat *p= codec->pix_fmts;
627 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
628 if(st->codec->codec_id==CODEC_ID_MJPEG){
629 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
630 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
631 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};
635 if(*p == st->codec->pix_fmt)
639 if(st->codec->pix_fmt != PIX_FMT_NONE)
640 av_log(NULL, AV_LOG_WARNING,
641 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
642 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
644 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
645 st->codec->pix_fmt = codec->pix_fmts[0];
650 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
653 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
654 int idx = oc->nb_streams - 1;
657 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
661 output_streams_for_file[file_idx] =
662 grow_array(output_streams_for_file[file_idx],
663 sizeof(*output_streams_for_file[file_idx]),
664 &nb_output_streams_for_file[file_idx],
666 ost = output_streams_for_file[file_idx][idx] =
667 av_mallocz(sizeof(OutputStream));
669 fprintf(stderr, "Could not alloc output stream\n");
672 ost->file_index = file_idx;
677 st->codec->codec_type = codec->type;
678 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
681 avcodec_get_context_defaults3(st->codec, codec);
683 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
687 static int read_avserver_streams(AVFormatContext *s, const char *filename)
690 AVFormatContext *ic = NULL;
693 err = avformat_open_input(&ic, filename, NULL, NULL);
696 /* copy stream format */
697 for(i=0;i<ic->nb_streams;i++) {
702 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
703 ost = new_output_stream(s, nb_output_files, codec);
706 // FIXME: a more elegant solution is needed
707 memcpy(st, ic->streams[i], sizeof(AVStream));
709 avcodec_copy_context(st->codec, ic->streams[i]->codec);
711 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
712 if (audio_stream_copy) {
715 choose_sample_fmt(st, codec);
716 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
717 if (video_stream_copy) {
720 choose_pixel_fmt(st, codec);
723 if(st->codec->flags & CODEC_FLAG_BITEXACT)
727 av_close_input_file(ic);
732 get_sync_ipts(const OutputStream *ost)
734 const InputStream *ist = ost->sync_ist;
735 return (double)(ist->pts - start_time)/AV_TIME_BASE;
738 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
742 AVPacket new_pkt= *pkt;
743 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
744 &new_pkt.data, &new_pkt.size,
745 pkt->data, pkt->size,
746 pkt->flags & AV_PKT_FLAG_KEY);
749 new_pkt.destruct= av_destruct_packet;
751 fprintf(stderr, "%s failed for stream %d, codec %s",
752 bsfc->filter->name, pkt->stream_index,
753 avctx->codec ? avctx->codec->name : "copy");
763 ret= av_interleaved_write_frame(s, pkt);
765 print_error("av_interleaved_write_frame()", ret);
770 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
772 static void do_audio_out(AVFormatContext *s,
775 unsigned char *buf, int size)
778 int64_t audio_out_size, audio_buf_size;
779 int64_t allocated_for_size= size;
781 int size_out, frame_bytes, ret, resample_changed;
782 AVCodecContext *enc= ost->st->codec;
783 AVCodecContext *dec= ist->st->codec;
784 int osize = av_get_bytes_per_sample(enc->sample_fmt);
785 int isize = av_get_bytes_per_sample(dec->sample_fmt);
786 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
789 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
790 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
791 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
792 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
793 audio_buf_size*= osize*enc->channels;
795 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
796 if(coded_bps > 8*osize)
797 audio_out_size= audio_out_size * coded_bps / (8*osize);
798 audio_out_size += FF_MIN_BUFFER_SIZE;
800 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
801 fprintf(stderr, "Buffer sizes too large\n");
805 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
806 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
807 if (!audio_buf || !audio_out){
808 fprintf(stderr, "Out of memory in do_audio_out\n");
812 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
813 ost->audio_resample = 1;
815 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
816 ost->resample_channels != dec->channels ||
817 ost->resample_sample_rate != dec->sample_rate;
819 if ((ost->audio_resample && !ost->resample) || resample_changed) {
820 if (resample_changed) {
821 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",
822 ist->file_index, ist->st->index,
823 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
824 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
825 ost->resample_sample_fmt = dec->sample_fmt;
826 ost->resample_channels = dec->channels;
827 ost->resample_sample_rate = dec->sample_rate;
829 audio_resample_close(ost->resample);
831 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
832 if (audio_sync_method <= 1 &&
833 ost->resample_sample_fmt == enc->sample_fmt &&
834 ost->resample_channels == enc->channels &&
835 ost->resample_sample_rate == enc->sample_rate) {
836 ost->resample = NULL;
837 ost->audio_resample = 0;
838 } else if (ost->audio_resample) {
839 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
840 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
841 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
842 enc->sample_rate, dec->sample_rate,
843 enc->sample_fmt, dec->sample_fmt,
845 if (!ost->resample) {
846 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
847 dec->channels, dec->sample_rate,
848 enc->channels, enc->sample_rate);
854 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
855 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
856 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
857 if (ost->reformat_ctx)
858 av_audio_convert_free(ost->reformat_ctx);
859 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
860 dec->sample_fmt, 1, NULL, 0);
861 if (!ost->reformat_ctx) {
862 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
863 av_get_sample_fmt_name(dec->sample_fmt),
864 av_get_sample_fmt_name(enc->sample_fmt));
867 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
870 if(audio_sync_method){
871 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
872 - av_fifo_size(ost->fifo)/(enc->channels * 2);
873 double idelta= delta*dec->sample_rate / enc->sample_rate;
874 int byte_delta= ((int)idelta)*2*dec->channels;
876 //FIXME resample delay
877 if(fabs(delta) > 50){
878 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
880 byte_delta= FFMAX(byte_delta, -size);
884 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
889 static uint8_t *input_tmp= NULL;
890 input_tmp= av_realloc(input_tmp, byte_delta + size);
892 if(byte_delta > allocated_for_size - size){
893 allocated_for_size= byte_delta + (int64_t)size;
898 memset(input_tmp, 0, byte_delta);
899 memcpy(input_tmp + byte_delta, buf, size);
903 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
905 }else if(audio_sync_method>1){
906 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
907 av_assert0(ost->audio_resample);
909 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
910 // 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));
911 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
915 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
916 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
918 if (ost->audio_resample) {
920 size_out = audio_resample(ost->resample,
921 (short *)buftmp, (short *)buf,
922 size / (dec->channels * isize));
923 size_out = size_out * enc->channels * osize;
929 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
930 const void *ibuf[6]= {buftmp};
931 void *obuf[6]= {audio_buf};
932 int istride[6]= {isize};
933 int ostride[6]= {osize};
934 int len= size_out/istride[0];
935 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
936 printf("av_audio_convert() failed\n");
942 size_out = len*osize;
945 /* now encode as many frames as possible */
946 if (enc->frame_size > 1) {
947 /* output resampled raw samples */
948 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
949 fprintf(stderr, "av_fifo_realloc2() failed\n");
952 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
954 frame_bytes = enc->frame_size * osize * enc->channels;
956 while (av_fifo_size(ost->fifo) >= frame_bytes) {
958 av_init_packet(&pkt);
960 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
962 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
964 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
967 fprintf(stderr, "Audio encoding failed\n");
971 pkt.stream_index= ost->index;
974 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
975 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
976 pkt.flags |= AV_PKT_FLAG_KEY;
977 write_frame(s, &pkt, enc, ost->bitstream_filters);
979 ost->sync_opts += enc->frame_size;
983 av_init_packet(&pkt);
985 ost->sync_opts += size_out / (osize * enc->channels);
987 /* output a pcm frame */
988 /* determine the size of the coded buffer */
991 size_out = size_out*coded_bps/8;
993 if(size_out > audio_out_size){
994 fprintf(stderr, "Internal error, buffer size too small\n");
998 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
999 ret = avcodec_encode_audio(enc, audio_out, size_out,
1002 fprintf(stderr, "Audio encoding failed\n");
1006 pkt.stream_index= ost->index;
1007 pkt.data= audio_out;
1009 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1010 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1011 pkt.flags |= AV_PKT_FLAG_KEY;
1012 write_frame(s, &pkt, enc, ost->bitstream_filters);
1016 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1018 AVCodecContext *dec;
1019 AVPicture *picture2;
1020 AVPicture picture_tmp;
1023 dec = ist->st->codec;
1025 /* deinterlace : must be done before any resize */
1026 if (do_deinterlace) {
1029 /* create temporary picture */
1030 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1031 buf = av_malloc(size);
1035 picture2 = &picture_tmp;
1036 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1038 if(avpicture_deinterlace(picture2, picture,
1039 dec->pix_fmt, dec->width, dec->height) < 0) {
1040 /* if error, do not deinterlace */
1041 fprintf(stderr, "Deinterlacing failed\n");
1050 if (picture != picture2)
1051 *picture = *picture2;
1055 /* we begin to correct av delay at this threshold */
1056 #define AV_DELAY_MAX 0.100
1058 static void do_subtitle_out(AVFormatContext *s,
1064 static uint8_t *subtitle_out = NULL;
1065 int subtitle_out_max_size = 1024 * 1024;
1066 int subtitle_out_size, nb, i;
1067 AVCodecContext *enc;
1070 if (pts == AV_NOPTS_VALUE) {
1071 fprintf(stderr, "Subtitle packets must have a pts\n");
1077 enc = ost->st->codec;
1079 if (!subtitle_out) {
1080 subtitle_out = av_malloc(subtitle_out_max_size);
1083 /* Note: DVB subtitle need one packet to draw them and one other
1084 packet to clear them */
1085 /* XXX: signal it in the codec context ? */
1086 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1091 for(i = 0; i < nb; i++) {
1092 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1093 // start_display_time is required to be 0
1094 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1095 sub->end_display_time -= sub->start_display_time;
1096 sub->start_display_time = 0;
1097 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1098 subtitle_out_max_size, sub);
1099 if (subtitle_out_size < 0) {
1100 fprintf(stderr, "Subtitle encoding failed\n");
1104 av_init_packet(&pkt);
1105 pkt.stream_index = ost->index;
1106 pkt.data = subtitle_out;
1107 pkt.size = subtitle_out_size;
1108 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1109 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1110 /* XXX: the pts correction is handled here. Maybe handling
1111 it in the codec would be better */
1113 pkt.pts += 90 * sub->start_display_time;
1115 pkt.pts += 90 * sub->end_display_time;
1117 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1121 static int bit_buffer_size= 1024*256;
1122 static uint8_t *bit_buffer= NULL;
1124 static void do_video_out(AVFormatContext *s,
1127 AVFrame *in_picture,
1128 int *frame_size, float quality)
1130 int nb_frames, i, ret, resample_changed;
1131 AVFrame *final_picture, *formatted_picture;
1132 AVCodecContext *enc, *dec;
1135 enc = ost->st->codec;
1136 dec = ist->st->codec;
1138 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1140 /* by default, we output a single frame */
1145 if(video_sync_method){
1146 double vdelta = sync_ipts - ost->sync_opts;
1147 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1150 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1153 }else if(vdelta>0.6)
1154 ost->sync_opts= lrintf(sync_ipts);
1155 }else if (vdelta > 1.1)
1156 nb_frames = lrintf(vdelta);
1157 //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);
1158 if (nb_frames == 0){
1161 fprintf(stderr, "*** drop!\n");
1162 }else if (nb_frames > 1) {
1163 nb_frames_dup += nb_frames - 1;
1165 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1168 ost->sync_opts= lrintf(sync_ipts);
1170 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1174 formatted_picture = in_picture;
1175 final_picture = formatted_picture;
1177 resample_changed = ost->resample_width != dec->width ||
1178 ost->resample_height != dec->height ||
1179 ost->resample_pix_fmt != dec->pix_fmt;
1181 if (resample_changed) {
1182 av_log(NULL, AV_LOG_INFO,
1183 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1184 ist->file_index, ist->st->index,
1185 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1186 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1187 if(!ost->video_resample)
1191 #if !CONFIG_AVFILTER
1192 if (ost->video_resample) {
1193 final_picture = &ost->pict_tmp;
1194 if (resample_changed) {
1195 /* initialize a new scaler context */
1196 sws_freeContext(ost->img_resample_ctx);
1197 ost->img_resample_ctx = sws_getContext(
1198 ist->st->codec->width,
1199 ist->st->codec->height,
1200 ist->st->codec->pix_fmt,
1201 ost->st->codec->width,
1202 ost->st->codec->height,
1203 ost->st->codec->pix_fmt,
1204 ost->sws_flags, NULL, NULL, NULL);
1205 if (ost->img_resample_ctx == NULL) {
1206 fprintf(stderr, "Cannot get resampling context\n");
1210 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1211 0, ost->resample_height, final_picture->data, final_picture->linesize);
1215 /* duplicates frame if needed */
1216 for(i=0;i<nb_frames;i++) {
1218 av_init_packet(&pkt);
1219 pkt.stream_index= ost->index;
1221 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1222 /* raw pictures are written as AVPicture structure to
1223 avoid any copies. We support temorarily the older
1225 AVFrame* old_frame = enc->coded_frame;
1226 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1227 pkt.data= (uint8_t *)final_picture;
1228 pkt.size= sizeof(AVPicture);
1229 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1230 pkt.flags |= AV_PKT_FLAG_KEY;
1232 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1233 enc->coded_frame = old_frame;
1235 AVFrame big_picture;
1237 big_picture= *final_picture;
1238 /* better than nothing: use input picture interlaced
1240 big_picture.interlaced_frame = in_picture->interlaced_frame;
1241 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1242 if(top_field_first == -1)
1243 big_picture.top_field_first = in_picture->top_field_first;
1245 big_picture.top_field_first = top_field_first;
1248 /* handles sameq here. This is not correct because it may
1249 not be a global option */
1250 big_picture.quality = quality;
1252 big_picture.pict_type = 0;
1253 // big_picture.pts = AV_NOPTS_VALUE;
1254 big_picture.pts= ost->sync_opts;
1255 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1256 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1257 if (ost->forced_kf_index < ost->forced_kf_count &&
1258 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1259 big_picture.pict_type = AV_PICTURE_TYPE_I;
1260 ost->forced_kf_index++;
1262 ret = avcodec_encode_video(enc,
1263 bit_buffer, bit_buffer_size,
1266 fprintf(stderr, "Video encoding failed\n");
1271 pkt.data= bit_buffer;
1273 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1274 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1275 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1276 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1277 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1279 if(enc->coded_frame->key_frame)
1280 pkt.flags |= AV_PKT_FLAG_KEY;
1281 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1284 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1285 // enc->frame_number-1, ret, enc->pict_type);
1286 /* if two pass, output log */
1287 if (ost->logfile && enc->stats_out) {
1288 fprintf(ost->logfile, "%s", enc->stats_out);
1293 ost->frame_number++;
1297 static double psnr(double d){
1298 return -10.0*log(d)/log(10.0);
1301 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1304 AVCodecContext *enc;
1306 double ti1, bitrate, avg_bitrate;
1308 /* this is executed just the first time do_video_stats is called */
1310 vstats_file = fopen(vstats_filename, "w");
1317 enc = ost->st->codec;
1318 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1319 frame_number = ost->frame_number;
1320 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1321 if (enc->flags&CODEC_FLAG_PSNR)
1322 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1324 fprintf(vstats_file,"f_size= %6d ", frame_size);
1325 /* compute pts value */
1326 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1330 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1331 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1332 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1333 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1334 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1338 static void print_report(AVFormatContext **output_files,
1339 OutputStream **ost_table, int nb_ostreams,
1344 AVFormatContext *oc;
1346 AVCodecContext *enc;
1347 int frame_number, vid, i;
1348 double bitrate, ti1, pts;
1349 static int64_t last_time = -1;
1350 static int qp_histogram[52];
1352 if (!is_last_report) {
1354 /* display the report every 0.5 seconds */
1355 cur_time = av_gettime();
1356 if (last_time == -1) {
1357 last_time = cur_time;
1360 if ((cur_time - last_time) < 500000)
1362 last_time = cur_time;
1366 oc = output_files[0];
1368 total_size = avio_size(oc->pb);
1369 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1370 total_size= avio_tell(oc->pb);
1375 for(i=0;i<nb_ostreams;i++) {
1378 enc = ost->st->codec;
1379 if (!ost->st->stream_copy && enc->coded_frame)
1380 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1381 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1384 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1385 float t = (av_gettime()-timer_start) / 1000000.0;
1387 frame_number = ost->frame_number;
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1389 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1391 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1395 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1398 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1400 if (enc->flags&CODEC_FLAG_PSNR){
1402 double error, error_sum=0;
1403 double scale, scale_sum=0;
1404 char type[3]= {'Y','U','V'};
1405 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1408 error= enc->error[j];
1409 scale= enc->width*enc->height*255.0*255.0*frame_number;
1411 error= enc->coded_frame->error[j];
1412 scale= enc->width*enc->height*255.0*255.0;
1417 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1423 /* compute min output value */
1424 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1425 if ((pts < ti1) && (pts > 0))
1431 if (verbose > 0 || is_last_report) {
1432 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1434 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1435 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1436 (double)total_size / 1024, ti1, bitrate);
1438 if (nb_frames_dup || nb_frames_drop)
1439 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1440 nb_frames_dup, nb_frames_drop);
1443 fprintf(stderr, "%s \r", buf);
1448 if (is_last_report && verbose >= 0){
1449 int64_t raw= audio_size + video_size + extra_size;
1450 fprintf(stderr, "\n");
1451 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1455 100.0*(total_size - raw)/raw
1460 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1462 int fill_char = 0x00;
1463 if (sample_fmt == AV_SAMPLE_FMT_U8)
1465 memset(buf, fill_char, size);
1468 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1469 static int output_packet(InputStream *ist, int ist_index,
1470 OutputStream **ost_table, int nb_ostreams,
1471 const AVPacket *pkt)
1473 AVFormatContext *os;
1478 void *buffer_to_free = NULL;
1479 static unsigned int samples_size= 0;
1480 AVSubtitle subtitle, *subtitle_to_free;
1481 int64_t pkt_pts = AV_NOPTS_VALUE;
1483 int frame_available;
1488 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1490 if(ist->next_pts == AV_NOPTS_VALUE)
1491 ist->next_pts= ist->pts;
1495 av_init_packet(&avpkt);
1503 if(pkt->dts != AV_NOPTS_VALUE)
1504 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1505 if(pkt->pts != AV_NOPTS_VALUE)
1506 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1508 //while we have more to decode or while the decoder did output something on EOF
1509 while (avpkt.size > 0 || (!pkt && got_output)) {
1510 uint8_t *data_buf, *decoded_data_buf;
1511 int data_size, decoded_data_size;
1513 ist->pts= ist->next_pts;
1515 if(avpkt.size && avpkt.size != pkt->size &&
1516 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1517 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1518 ist->showed_multi_packet_warning=1;
1521 /* decode the packet if needed */
1522 decoded_data_buf = NULL; /* fail safe */
1523 decoded_data_size= 0;
1524 data_buf = avpkt.data;
1525 data_size = avpkt.size;
1526 subtitle_to_free = NULL;
1527 if (ist->decoding_needed) {
1528 switch(ist->st->codec->codec_type) {
1529 case AVMEDIA_TYPE_AUDIO:{
1530 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1531 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1533 samples= av_malloc(samples_size);
1535 decoded_data_size= samples_size;
1536 /* XXX: could avoid copy if PCM 16 bits with same
1537 endianness as CPU */
1538 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1545 got_output = decoded_data_size > 0;
1546 /* Some bug in mpeg audio decoder gives */
1547 /* decoded_data_size < 0, it seems they are overflows */
1549 /* no audio frame */
1552 decoded_data_buf = (uint8_t *)samples;
1553 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1554 (ist->st->codec->sample_rate * ist->st->codec->channels);
1556 case AVMEDIA_TYPE_VIDEO:
1557 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1558 /* XXX: allocate picture correctly */
1559 avcodec_get_frame_defaults(&picture);
1560 avpkt.pts = pkt_pts;
1561 avpkt.dts = ist->pts;
1562 pkt_pts = AV_NOPTS_VALUE;
1564 ret = avcodec_decode_video2(ist->st->codec,
1565 &picture, &got_output, &avpkt);
1566 quality = same_quality ? picture.quality : 0;
1570 /* no picture yet */
1571 goto discard_packet;
1573 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1574 if (ist->st->codec->time_base.num != 0) {
1575 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1576 ist->next_pts += ((int64_t)AV_TIME_BASE *
1577 ist->st->codec->time_base.num * ticks) /
1578 ist->st->codec->time_base.den;
1581 buffer_to_free = NULL;
1582 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1584 case AVMEDIA_TYPE_SUBTITLE:
1585 ret = avcodec_decode_subtitle2(ist->st->codec,
1586 &subtitle, &got_output, &avpkt);
1590 goto discard_packet;
1592 subtitle_to_free = &subtitle;
1599 switch(ist->st->codec->codec_type) {
1600 case AVMEDIA_TYPE_AUDIO:
1601 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1602 ist->st->codec->sample_rate;
1604 case AVMEDIA_TYPE_VIDEO:
1605 if (ist->st->codec->time_base.num != 0) {
1606 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1607 ist->next_pts += ((int64_t)AV_TIME_BASE *
1608 ist->st->codec->time_base.num * ticks) /
1609 ist->st->codec->time_base.den;
1618 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1619 for (i = 0; i < nb_ostreams; i++) {
1621 if (ost->input_video_filter && ost->source_index == ist_index) {
1623 if (ist->st->sample_aspect_ratio.num)
1624 sar = ist->st->sample_aspect_ratio;
1626 sar = ist->st->codec->sample_aspect_ratio;
1627 // add it to be filtered
1628 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1636 // preprocess audio (volume)
1637 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1638 if (audio_volume != 256) {
1641 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1642 int v = ((*volp) * audio_volume + 128) >> 8;
1643 if (v < -32768) v = -32768;
1644 if (v > 32767) v = 32767;
1650 /* frame rate emulation */
1652 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1653 int64_t now = av_gettime() - ist->start;
1657 /* if output time reached then transcode raw format,
1658 encode packets and output them */
1659 if (start_time == 0 || ist->pts >= start_time)
1660 for(i=0;i<nb_ostreams;i++) {
1664 if (ost->source_index == ist_index) {
1666 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1667 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1668 while (frame_available) {
1669 AVRational ist_pts_tb;
1670 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1671 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1673 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1675 os = output_files[ost->file_index];
1677 /* set the input output pts pairs */
1678 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1680 if (ost->encoding_needed) {
1681 av_assert0(ist->decoding_needed);
1682 switch(ost->st->codec->codec_type) {
1683 case AVMEDIA_TYPE_AUDIO:
1684 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1686 case AVMEDIA_TYPE_VIDEO:
1688 if (ost->picref->video && !ost->frame_aspect_ratio)
1689 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1691 do_video_out(os, ost, ist, &picture, &frame_size,
1692 same_quality ? quality : ost->st->codec->global_quality);
1693 if (vstats_filename && frame_size)
1694 do_video_stats(os, ost, frame_size);
1696 case AVMEDIA_TYPE_SUBTITLE:
1697 do_subtitle_out(os, ost, ist, &subtitle,
1704 AVFrame avframe; //FIXME/XXX remove this
1706 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1708 av_init_packet(&opkt);
1710 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1711 #if !CONFIG_AVFILTER
1717 /* no reencoding needed : output the packet directly */
1718 /* force the input stream PTS */
1720 avcodec_get_frame_defaults(&avframe);
1721 ost->st->codec->coded_frame= &avframe;
1722 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1724 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1725 audio_size += data_size;
1726 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1727 video_size += data_size;
1731 opkt.stream_index= ost->index;
1732 if(pkt->pts != AV_NOPTS_VALUE)
1733 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1735 opkt.pts= AV_NOPTS_VALUE;
1737 if (pkt->dts == AV_NOPTS_VALUE)
1738 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1740 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1741 opkt.dts -= ost_tb_start_time;
1743 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1744 opkt.flags= pkt->flags;
1746 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1747 if( ost->st->codec->codec_id != CODEC_ID_H264
1748 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1749 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1751 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1752 opkt.destruct= av_destruct_packet;
1754 opkt.data = data_buf;
1755 opkt.size = data_size;
1758 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1759 ost->st->codec->frame_number++;
1760 ost->frame_number++;
1761 av_free_packet(&opkt);
1765 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1766 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1768 avfilter_unref_buffer(ost->picref);
1774 av_free(buffer_to_free);
1775 /* XXX: allocate the subtitles in the codec ? */
1776 if (subtitle_to_free) {
1777 avsubtitle_free(subtitle_to_free);
1778 subtitle_to_free = NULL;
1785 for(i=0;i<nb_ostreams;i++) {
1787 if (ost->source_index == ist_index) {
1788 AVCodecContext *enc= ost->st->codec;
1789 os = output_files[ost->file_index];
1791 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1793 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1796 if (ost->encoding_needed) {
1800 av_init_packet(&pkt);
1801 pkt.stream_index= ost->index;
1803 switch(ost->st->codec->codec_type) {
1804 case AVMEDIA_TYPE_AUDIO:
1805 fifo_bytes = av_fifo_size(ost->fifo);
1807 /* encode any samples remaining in fifo */
1808 if (fifo_bytes > 0) {
1809 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1810 int fs_tmp = enc->frame_size;
1812 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1813 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1814 enc->frame_size = fifo_bytes / (osize * enc->channels);
1816 int frame_bytes = enc->frame_size*osize*enc->channels;
1817 if (allocated_audio_buf_size < frame_bytes)
1819 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1822 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1823 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1824 ost->st->time_base.num, enc->sample_rate);
1825 enc->frame_size = fs_tmp;
1828 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1831 fprintf(stderr, "Audio encoding failed\n");
1835 pkt.flags |= AV_PKT_FLAG_KEY;
1837 case AVMEDIA_TYPE_VIDEO:
1838 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1840 fprintf(stderr, "Video encoding failed\n");
1844 if(enc->coded_frame && enc->coded_frame->key_frame)
1845 pkt.flags |= AV_PKT_FLAG_KEY;
1846 if (ost->logfile && enc->stats_out) {
1847 fprintf(ost->logfile, "%s", enc->stats_out);
1856 pkt.data= bit_buffer;
1858 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1859 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1860 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1870 static void print_sdp(AVFormatContext **avc, int n)
1874 av_sdp_create(avc, n, sdp, sizeof(sdp));
1875 printf("SDP:\n%s\n", sdp);
1879 static int copy_chapters(int infile, int outfile)
1881 AVFormatContext *is = input_files[infile].ctx;
1882 AVFormatContext *os = output_files[outfile];
1885 for (i = 0; i < is->nb_chapters; i++) {
1886 AVChapter *in_ch = is->chapters[i], *out_ch;
1887 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1888 AV_TIME_BASE_Q, in_ch->time_base);
1889 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1890 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1893 if (in_ch->end < ts_off)
1895 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1898 out_ch = av_mallocz(sizeof(AVChapter));
1900 return AVERROR(ENOMEM);
1902 out_ch->id = in_ch->id;
1903 out_ch->time_base = in_ch->time_base;
1904 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1905 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1907 if (metadata_chapters_autocopy)
1908 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1911 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1913 return AVERROR(ENOMEM);
1914 os->chapters[os->nb_chapters - 1] = out_ch;
1919 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1920 AVCodecContext *avctx)
1926 for (p = kf; *p; p++)
1929 ost->forced_kf_count = n;
1930 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1931 if (!ost->forced_kf_pts) {
1932 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1935 for (i = 0; i < n; i++) {
1936 p = i ? strchr(p, ',') + 1 : kf;
1937 t = parse_time_or_die("force_key_frames", p, 1);
1938 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1943 * The following code is the main loop of the file converter
1945 static int transcode(AVFormatContext **output_files,
1946 int nb_output_files,
1947 InputFile *input_files,
1950 int ret = 0, i, j, k, n, nb_ostreams = 0;
1951 AVFormatContext *is, *os;
1952 AVCodecContext *codec, *icodec;
1953 OutputStream *ost, **ost_table = NULL;
1957 uint8_t no_packet[MAX_FILES]={0};
1958 int no_packet_count=0;
1961 for (i = 0; i < nb_input_streams; i++)
1962 input_streams[i].start = av_gettime();
1964 /* output stream init */
1966 for(i=0;i<nb_output_files;i++) {
1967 os = output_files[i];
1968 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1969 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1970 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1971 ret = AVERROR(EINVAL);
1974 nb_ostreams += os->nb_streams;
1977 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1981 for(k=0;k<nb_output_files;k++) {
1982 os = output_files[k];
1983 for (i = 0; i < os->nb_streams; i++, n++)
1984 ost_table[n] = output_streams_for_file[k][i];
1987 /* for each output stream, we compute the right encoding parameters */
1988 for(i=0;i<nb_ostreams;i++) {
1990 os = output_files[ost->file_index];
1991 ist = &input_streams[ost->source_index];
1993 codec = ost->st->codec;
1994 icodec = ist->st->codec;
1996 ost->st->disposition = ist->st->disposition;
1997 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1998 codec->chroma_sample_location = icodec->chroma_sample_location;
2000 if (ost->st->stream_copy) {
2001 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2003 if (extra_size > INT_MAX)
2006 /* if stream_copy is selected, no need to decode or encode */
2007 codec->codec_id = icodec->codec_id;
2008 codec->codec_type = icodec->codec_type;
2010 if(!codec->codec_tag){
2011 if( !os->oformat->codec_tag
2012 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2013 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2014 codec->codec_tag = icodec->codec_tag;
2017 codec->bit_rate = icodec->bit_rate;
2018 codec->rc_max_rate = icodec->rc_max_rate;
2019 codec->rc_buffer_size = icodec->rc_buffer_size;
2020 codec->extradata= av_mallocz(extra_size);
2021 if (!codec->extradata)
2023 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2024 codec->extradata_size= icodec->extradata_size;
2025 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){
2026 codec->time_base = icodec->time_base;
2027 codec->time_base.num *= icodec->ticks_per_frame;
2028 av_reduce(&codec->time_base.num, &codec->time_base.den,
2029 codec->time_base.num, codec->time_base.den, INT_MAX);
2031 codec->time_base = ist->st->time_base;
2032 switch(codec->codec_type) {
2033 case AVMEDIA_TYPE_AUDIO:
2034 if(audio_volume != 256) {
2035 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2038 codec->channel_layout = icodec->channel_layout;
2039 codec->sample_rate = icodec->sample_rate;
2040 codec->channels = icodec->channels;
2041 codec->frame_size = icodec->frame_size;
2042 codec->audio_service_type = icodec->audio_service_type;
2043 codec->block_align= icodec->block_align;
2044 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2045 codec->block_align= 0;
2046 if(codec->codec_id == CODEC_ID_AC3)
2047 codec->block_align= 0;
2049 case AVMEDIA_TYPE_VIDEO:
2050 codec->pix_fmt = icodec->pix_fmt;
2051 codec->width = icodec->width;
2052 codec->height = icodec->height;
2053 codec->has_b_frames = icodec->has_b_frames;
2054 if (!codec->sample_aspect_ratio.num) {
2055 codec->sample_aspect_ratio =
2056 ost->st->sample_aspect_ratio =
2057 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2058 ist->st->codec->sample_aspect_ratio.num ?
2059 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2062 case AVMEDIA_TYPE_SUBTITLE:
2063 codec->width = icodec->width;
2064 codec->height = icodec->height;
2066 case AVMEDIA_TYPE_DATA:
2073 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2074 switch(codec->codec_type) {
2075 case AVMEDIA_TYPE_AUDIO:
2076 ost->fifo= av_fifo_alloc(1024);
2079 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2080 if (!codec->sample_rate) {
2081 codec->sample_rate = icodec->sample_rate;
2083 codec->sample_rate >>= icodec->lowres;
2085 choose_sample_rate(ost->st, ost->enc);
2086 codec->time_base = (AVRational){1, codec->sample_rate};
2087 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2088 codec->sample_fmt = icodec->sample_fmt;
2089 choose_sample_fmt(ost->st, ost->enc);
2090 if (!codec->channels)
2091 codec->channels = icodec->channels;
2092 codec->channel_layout = icodec->channel_layout;
2093 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2094 codec->channel_layout = 0;
2095 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2096 icodec->request_channels = codec->channels;
2097 ist->decoding_needed = 1;
2098 ost->encoding_needed = 1;
2099 ost->resample_sample_fmt = icodec->sample_fmt;
2100 ost->resample_sample_rate = icodec->sample_rate;
2101 ost->resample_channels = icodec->channels;
2103 case AVMEDIA_TYPE_VIDEO:
2104 if (codec->pix_fmt == PIX_FMT_NONE)
2105 codec->pix_fmt = icodec->pix_fmt;
2106 choose_pixel_fmt(ost->st, ost->enc);
2108 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2109 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2113 if (!codec->width || !codec->height) {
2114 codec->width = icodec->width;
2115 codec->height = icodec->height;
2118 ost->video_resample = codec->width != icodec->width ||
2119 codec->height != icodec->height ||
2120 codec->pix_fmt != icodec->pix_fmt;
2121 if (ost->video_resample) {
2122 #if !CONFIG_AVFILTER
2123 avcodec_get_frame_defaults(&ost->pict_tmp);
2124 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2125 codec->width, codec->height)) {
2126 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2129 ost->img_resample_ctx = sws_getContext(
2136 ost->sws_flags, NULL, NULL, NULL);
2137 if (ost->img_resample_ctx == NULL) {
2138 fprintf(stderr, "Cannot get resampling context\n");
2142 codec->bits_per_raw_sample= 0;
2145 ost->resample_height = icodec->height;
2146 ost->resample_width = icodec->width;
2147 ost->resample_pix_fmt= icodec->pix_fmt;
2148 ost->encoding_needed = 1;
2149 ist->decoding_needed = 1;
2151 if (!ost->frame_rate.num)
2152 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2153 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2154 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2155 ost->frame_rate = ost->enc->supported_framerates[idx];
2157 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2160 if (configure_video_filters(ist, ost)) {
2161 fprintf(stderr, "Error opening filters!\n");
2166 case AVMEDIA_TYPE_SUBTITLE:
2167 ost->encoding_needed = 1;
2168 ist->decoding_needed = 1;
2175 if (ost->encoding_needed &&
2176 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2177 char logfilename[1024];
2180 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2181 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2183 if (codec->flags & CODEC_FLAG_PASS1) {
2184 f = fopen(logfilename, "wb");
2186 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2192 size_t logbuffer_size;
2193 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2194 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2197 codec->stats_in = logbuffer;
2201 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2202 int size= codec->width * codec->height;
2203 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2208 bit_buffer = av_malloc(bit_buffer_size);
2210 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2212 ret = AVERROR(ENOMEM);
2216 /* open each encoder */
2217 for(i=0;i<nb_ostreams;i++) {
2219 if (ost->encoding_needed) {
2220 AVCodec *codec = ost->enc;
2221 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2223 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2224 ost->st->codec->codec_id, ost->file_index, ost->index);
2225 ret = AVERROR(EINVAL);
2228 if (dec->subtitle_header) {
2229 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2230 if (!ost->st->codec->subtitle_header) {
2231 ret = AVERROR(ENOMEM);
2234 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2235 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2237 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2238 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2239 ost->file_index, ost->index);
2240 ret = AVERROR(EINVAL);
2243 assert_codec_experimental(ost->st->codec, 1);
2244 assert_avoptions(ost->opts);
2245 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2246 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2247 "It takes bits/s as argument, not kbits/s\n");
2248 extra_size += ost->st->codec->extradata_size;
2252 /* open each decoder */
2253 for (i = 0; i < nb_input_streams; i++) {
2254 ist = &input_streams[i];
2255 if (ist->decoding_needed) {
2256 AVCodec *codec = ist->dec;
2258 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2260 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2261 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2262 ret = AVERROR(EINVAL);
2266 /* update requested sample format for the decoder based on the
2267 corresponding encoder sample format */
2268 for (j = 0; j < nb_ostreams; j++) {
2270 if (ost->source_index == i) {
2271 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2276 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2277 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2278 ist->file_index, ist->st->index);
2279 ret = AVERROR(EINVAL);
2282 assert_codec_experimental(ist->st->codec, 0);
2283 assert_avoptions(ost->opts);
2284 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2285 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2290 for (i = 0; i < nb_input_streams; i++) {
2292 ist = &input_streams[i];
2294 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2295 ist->next_pts = AV_NOPTS_VALUE;
2296 init_pts_correction(&ist->pts_ctx);
2300 /* open files and write file headers */
2301 for(i=0;i<nb_output_files;i++) {
2302 os = output_files[i];
2303 if (avformat_write_header(os, &output_opts[i]) < 0) {
2304 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2305 ret = AVERROR(EINVAL);
2308 assert_avoptions(output_opts[i]);
2309 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2315 /* dump the file output parameters - cannot be done before in case
2317 for(i=0;i<nb_output_files;i++) {
2318 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2321 /* dump the stream mapping */
2323 fprintf(stderr, "Stream mapping:\n");
2324 for(i=0;i<nb_ostreams;i++) {
2326 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2327 input_streams[ost->source_index].file_index,
2328 input_streams[ost->source_index].st->index,
2331 if (ost->sync_ist != &input_streams[ost->source_index])
2332 fprintf(stderr, " [sync #%d.%d]",
2333 ost->sync_ist->file_index,
2334 ost->sync_ist->st->index);
2335 fprintf(stderr, "\n");
2340 fprintf(stderr, "%s\n", error);
2345 print_sdp(output_files, nb_output_files);
2349 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2352 timer_start = av_gettime();
2354 for(; received_sigterm == 0;) {
2355 int file_index, ist_index;
2364 /* select the stream that we must read now by looking at the
2365 smallest output pts */
2367 for(i=0;i<nb_ostreams;i++) {
2370 os = output_files[ost->file_index];
2371 ist = &input_streams[ost->source_index];
2372 if(ist->is_past_recording_time || no_packet[ist->file_index])
2374 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2375 ipts = (double)ist->pts;
2376 if (!input_files[ist->file_index].eof_reached){
2377 if(ipts < ipts_min) {
2379 if(input_sync ) file_index = ist->file_index;
2381 if(opts < opts_min) {
2383 if(!input_sync) file_index = ist->file_index;
2386 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2391 /* if none, if is finished */
2392 if (file_index < 0) {
2393 if(no_packet_count){
2395 memset(no_packet, 0, sizeof(no_packet));
2402 /* finish if limit size exhausted */
2403 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2406 /* read a frame from it and output it in the fifo */
2407 is = input_files[file_index].ctx;
2408 ret= av_read_frame(is, &pkt);
2409 if(ret == AVERROR(EAGAIN)){
2410 no_packet[file_index]=1;
2415 input_files[file_index].eof_reached = 1;
2423 memset(no_packet, 0, sizeof(no_packet));
2426 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2427 is->streams[pkt.stream_index]);
2429 /* the following test is needed in case new streams appear
2430 dynamically in stream : we ignore them */
2431 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2432 goto discard_packet;
2433 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2434 ist = &input_streams[ist_index];
2436 goto discard_packet;
2438 if (pkt.dts != AV_NOPTS_VALUE)
2439 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2440 if (pkt.pts != AV_NOPTS_VALUE)
2441 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2443 if (ist->ts_scale) {
2444 if(pkt.pts != AV_NOPTS_VALUE)
2445 pkt.pts *= ist->ts_scale;
2446 if(pkt.dts != AV_NOPTS_VALUE)
2447 pkt.dts *= ist->ts_scale;
2450 // 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);
2451 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2452 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2453 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2454 int64_t delta= pkt_dts - ist->next_pts;
2455 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2456 input_files[ist->file_index].ts_offset -= delta;
2458 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2459 delta, input_files[ist->file_index].ts_offset);
2460 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2461 if(pkt.pts != AV_NOPTS_VALUE)
2462 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2466 /* finish if recording time exhausted */
2467 if (recording_time != INT64_MAX &&
2468 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2469 ist->is_past_recording_time = 1;
2470 goto discard_packet;
2473 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2474 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2477 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2478 ist->file_index, ist->st->index);
2481 av_free_packet(&pkt);
2486 av_free_packet(&pkt);
2488 /* dump report by using the output first video and audio streams */
2489 print_report(output_files, ost_table, nb_ostreams, 0);
2492 /* at the end of stream, we must flush the decoder buffers */
2493 for (i = 0; i < nb_input_streams; i++) {
2494 ist = &input_streams[i];
2495 if (ist->decoding_needed) {
2496 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2502 /* write the trailer if needed and close file */
2503 for(i=0;i<nb_output_files;i++) {
2504 os = output_files[i];
2505 av_write_trailer(os);
2508 /* dump report by using the first video and audio streams */
2509 print_report(output_files, ost_table, nb_ostreams, 1);
2511 /* close each encoder */
2512 for(i=0;i<nb_ostreams;i++) {
2514 if (ost->encoding_needed) {
2515 av_freep(&ost->st->codec->stats_in);
2516 avcodec_close(ost->st->codec);
2519 avfilter_graph_free(&ost->graph);
2523 /* close each decoder */
2524 for (i = 0; i < nb_input_streams; i++) {
2525 ist = &input_streams[i];
2526 if (ist->decoding_needed) {
2527 avcodec_close(ist->st->codec);
2535 av_freep(&bit_buffer);
2538 for(i=0;i<nb_ostreams;i++) {
2541 if (ost->st->stream_copy)
2542 av_freep(&ost->st->codec->extradata);
2544 fclose(ost->logfile);
2545 ost->logfile = NULL;
2547 av_fifo_free(ost->fifo); /* works even if fifo is not
2548 initialized but set to zero */
2549 av_freep(&ost->st->codec->subtitle_header);
2550 av_free(ost->pict_tmp.data[0]);
2551 av_free(ost->forced_kf_pts);
2552 if (ost->video_resample)
2553 sws_freeContext(ost->img_resample_ctx);
2555 audio_resample_close(ost->resample);
2556 if (ost->reformat_ctx)
2557 av_audio_convert_free(ost->reformat_ctx);
2558 av_dict_free(&ost->opts);
2567 static int opt_format(const char *opt, const char *arg)
2569 last_asked_format = arg;
2573 static int opt_video_rc_override_string(const char *opt, const char *arg)
2575 video_rc_override_string = arg;
2579 static int opt_me_threshold(const char *opt, const char *arg)
2581 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2585 static int opt_verbose(const char *opt, const char *arg)
2587 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2591 static int opt_frame_rate(const char *opt, const char *arg)
2593 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2594 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2600 static int opt_frame_crop(const char *opt, const char *arg)
2602 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2603 return AVERROR(EINVAL);
2606 static int opt_frame_size(const char *opt, const char *arg)
2608 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2609 fprintf(stderr, "Incorrect frame size\n");
2610 return AVERROR(EINVAL);
2615 static int opt_pad(const char *opt, const char *arg) {
2616 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2620 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2622 if (strcmp(arg, "list")) {
2623 frame_pix_fmt = av_get_pix_fmt(arg);
2624 if (frame_pix_fmt == PIX_FMT_NONE) {
2625 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2626 return AVERROR(EINVAL);
2635 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2642 p = strchr(arg, ':');
2644 x = strtol(arg, &end, 10);
2646 y = strtol(end+1, &end, 10);
2648 ar = (double)x / (double)y;
2650 ar = strtod(arg, NULL);
2653 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2654 return AVERROR(EINVAL);
2656 frame_aspect_ratio = ar;
2660 static int opt_metadata(const char *opt, const char *arg)
2662 char *mid= strchr(arg, '=');
2665 fprintf(stderr, "Missing =\n");
2670 av_dict_set(&metadata, arg, mid, 0);
2675 static int opt_qscale(const char *opt, const char *arg)
2677 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2678 if (video_qscale == 0) {
2679 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2680 return AVERROR(EINVAL);
2685 static int opt_top_field_first(const char *opt, const char *arg)
2687 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2691 static int opt_thread_count(const char *opt, const char *arg)
2693 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2696 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2701 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2703 if (strcmp(arg, "list")) {
2704 audio_sample_fmt = av_get_sample_fmt(arg);
2705 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2706 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2707 return AVERROR(EINVAL);
2712 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2713 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2719 static int opt_audio_rate(const char *opt, const char *arg)
2721 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2725 static int opt_audio_channels(const char *opt, const char *arg)
2727 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2731 static int opt_codec(int *pstream_copy, char **pcodec_name,
2732 int codec_type, const char *arg)
2734 av_freep(pcodec_name);
2735 if (!strcmp(arg, "copy")) {
2738 *pcodec_name = av_strdup(arg);
2743 static int opt_audio_codec(const char *opt, const char *arg)
2745 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2748 static int opt_video_codec(const char *opt, const char *arg)
2750 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2753 static int opt_subtitle_codec(const char *opt, const char *arg)
2755 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2758 static int opt_data_codec(const char *opt, const char *arg)
2760 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2763 static int opt_codec_tag(const char *opt, const char *arg)
2766 uint32_t *codec_tag;
2768 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2769 !strcmp(opt, "vtag") ? &video_codec_tag :
2770 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2774 *codec_tag = strtol(arg, &tail, 0);
2776 *codec_tag = AV_RL32(arg);
2781 static int opt_map(const char *opt, const char *arg)
2786 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2787 m = &stream_maps[nb_stream_maps-1];
2789 m->file_index = strtol(arg, &p, 0);
2793 m->stream_index = strtol(p, &p, 0);
2796 m->sync_file_index = strtol(p, &p, 0);
2799 m->sync_stream_index = strtol(p, &p, 0);
2801 m->sync_file_index = m->file_index;
2802 m->sync_stream_index = m->stream_index;
2807 static void parse_meta_type(char *arg, char *type, int *index)
2817 if (*(++arg) == ':')
2818 *index = strtol(++arg, NULL, 0);
2821 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2828 static int opt_map_metadata(const char *opt, const char *arg)
2830 MetadataMap *m, *m1;
2833 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2834 &nb_meta_data_maps, nb_meta_data_maps + 1);
2836 m = &meta_data_maps[nb_meta_data_maps - 1][1];
2837 m->file = strtol(arg, &p, 0);
2838 parse_meta_type(p, &m->type, &m->index);
2840 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2841 if (p = strchr(opt, ':'))
2842 parse_meta_type(p, &m1->type, &m1->index);
2846 if (m->type == 'g' || m1->type == 'g')
2847 metadata_global_autocopy = 0;
2848 if (m->type == 's' || m1->type == 's')
2849 metadata_streams_autocopy = 0;
2850 if (m->type == 'c' || m1->type == 'c')
2851 metadata_chapters_autocopy = 0;
2856 static int opt_input_ts_scale(const char *opt, const char *arg)
2858 unsigned int stream;
2862 stream = strtol(arg, &p, 0);
2865 scale= strtod(p, &p);
2867 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
2868 ts_scale[stream] = scale;
2872 static int opt_recording_time(const char *opt, const char *arg)
2874 recording_time = parse_time_or_die(opt, arg, 1);
2878 static int opt_start_time(const char *opt, const char *arg)
2880 start_time = parse_time_or_die(opt, arg, 1);
2884 static int opt_input_ts_offset(const char *opt, const char *arg)
2886 input_ts_offset = parse_time_or_die(opt, arg, 1);
2890 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2892 const char *codec_string = encoder ? "encoder" : "decoder";
2896 return CODEC_ID_NONE;
2898 avcodec_find_encoder_by_name(name) :
2899 avcodec_find_decoder_by_name(name);
2901 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2904 if(codec->type != type) {
2905 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2911 static int opt_input_file(const char *opt, const char *filename)
2913 AVFormatContext *ic;
2914 AVInputFormat *file_iformat = NULL;
2915 int err, i, ret, rfps, rfps_base;
2918 AVDictionary **opts;
2919 int orig_nb_streams; // number of streams before avformat_find_stream_info
2921 if (last_asked_format) {
2922 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2923 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2926 last_asked_format = NULL;
2929 if (!strcmp(filename, "-"))
2932 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2933 !strcmp(filename, "/dev/stdin");
2935 /* get default parameters from command line */
2936 ic = avformat_alloc_context();
2938 print_error(filename, AVERROR(ENOMEM));
2941 if (audio_sample_rate) {
2942 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2943 av_dict_set(&format_opts, "sample_rate", buf, 0);
2945 if (audio_channels) {
2946 snprintf(buf, sizeof(buf), "%d", audio_channels);
2947 av_dict_set(&format_opts, "channels", buf, 0);
2949 if (frame_rate.num) {
2950 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2951 av_dict_set(&format_opts, "framerate", buf, 0);
2953 if (frame_width && frame_height) {
2954 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2955 av_dict_set(&format_opts, "video_size", buf, 0);
2957 if (frame_pix_fmt != PIX_FMT_NONE)
2958 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2960 ic->video_codec_id =
2961 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
2962 ic->audio_codec_id =
2963 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
2964 ic->subtitle_codec_id=
2965 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
2966 ic->flags |= AVFMT_FLAG_NONBLOCK;
2968 /* open the input file with generic libav function */
2969 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2971 print_error(filename, err);
2974 assert_avoptions(format_opts);
2979 for(i=0; i<ic->nb_streams; i++){
2980 ic->streams[i]->discard= AVDISCARD_ALL;
2982 for(i=0; i<ic->nb_programs; i++){
2983 AVProgram *p= ic->programs[i];
2984 if(p->id != opt_programid){
2985 p->discard = AVDISCARD_ALL;
2988 for(j=0; j<p->nb_stream_indexes; j++){
2989 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2994 fprintf(stderr, "Specified program id not found\n");
3000 /* Set AVCodecContext options for avformat_find_stream_info */
3001 opts = setup_find_stream_info_opts(ic, codec_opts);
3002 orig_nb_streams = ic->nb_streams;
3004 /* If not enough info to get the stream parameters, we decode the
3005 first frames to get it. (used in mpeg case for example) */
3006 ret = avformat_find_stream_info(ic, opts);
3007 if (ret < 0 && verbose >= 0) {
3008 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3009 av_close_input_file(ic);
3013 timestamp = start_time;
3014 /* add the stream start time */
3015 if (ic->start_time != AV_NOPTS_VALUE)
3016 timestamp += ic->start_time;
3018 /* if seeking requested, we execute it */
3019 if (start_time != 0) {
3020 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3022 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3023 filename, (double)timestamp / AV_TIME_BASE);
3025 /* reset seek info */
3029 /* update the current parameters so that they match the one of the input stream */
3030 for(i=0;i<ic->nb_streams;i++) {
3031 AVStream *st = ic->streams[i];
3032 AVCodecContext *dec = st->codec;
3035 dec->thread_count = thread_count;
3037 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3038 ist = &input_streams[nb_input_streams - 1];
3040 ist->file_index = nb_input_files;
3042 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3044 if (i < nb_ts_scale)
3045 ist->ts_scale = ts_scale[i];
3047 switch (dec->codec_type) {
3048 case AVMEDIA_TYPE_AUDIO:
3049 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3051 st->discard= AVDISCARD_ALL;
3053 case AVMEDIA_TYPE_VIDEO:
3054 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3055 rfps = ic->streams[i]->r_frame_rate.num;
3056 rfps_base = ic->streams[i]->r_frame_rate.den;
3058 dec->flags |= CODEC_FLAG_EMU_EDGE;
3059 dec->height >>= dec->lowres;
3060 dec->width >>= dec->lowres;
3063 dec->debug |= FF_DEBUG_MV;
3065 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3068 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3069 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3071 (float)rfps / rfps_base, rfps, rfps_base);
3075 st->discard= AVDISCARD_ALL;
3076 else if(video_discard)
3077 st->discard= video_discard;
3079 case AVMEDIA_TYPE_DATA:
3081 case AVMEDIA_TYPE_SUBTITLE:
3082 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3083 if(subtitle_disable)
3084 st->discard = AVDISCARD_ALL;
3086 case AVMEDIA_TYPE_ATTACHMENT:
3087 case AVMEDIA_TYPE_UNKNOWN:
3094 /* dump the file content */
3096 av_dump_format(ic, nb_input_files, filename, 0);
3098 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3099 input_files[nb_input_files - 1].ctx = ic;
3100 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3101 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3103 frame_rate = (AVRational){0, 0};
3104 frame_pix_fmt = PIX_FMT_NONE;
3107 audio_sample_rate = 0;
3109 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3110 av_freep(&ts_scale);
3113 for (i = 0; i < orig_nb_streams; i++)
3114 av_dict_free(&opts[i]);
3116 av_freep(&video_codec_name);
3117 av_freep(&audio_codec_name);
3118 av_freep(&subtitle_codec_name);
3124 static OutputStream *new_video_stream(AVFormatContext *oc, int file_idx)
3128 AVCodecContext *video_enc;
3129 enum CodecID codec_id = CODEC_ID_NONE;
3130 AVCodec *codec= NULL;
3132 if(!video_stream_copy){
3133 if (video_codec_name) {
3134 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3135 codec = avcodec_find_encoder_by_name(video_codec_name);
3137 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3138 codec = avcodec_find_encoder(codec_id);
3142 ost = new_output_stream(oc, file_idx, codec);
3144 if (!video_stream_copy) {
3145 ost->frame_aspect_ratio = frame_aspect_ratio;
3146 frame_aspect_ratio = 0;
3148 ost->avfilter= vfilters;
3153 ost->bitstream_filters = video_bitstream_filters;
3154 video_bitstream_filters= NULL;
3156 st->codec->thread_count= thread_count;
3158 video_enc = st->codec;
3161 video_enc->codec_tag= video_codec_tag;
3163 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3164 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3167 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3168 if (video_stream_copy) {
3169 st->stream_copy = 1;
3170 video_enc->sample_aspect_ratio =
3171 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3177 ost->frame_rate = frame_rate;
3178 video_enc->codec_id = codec_id;
3180 video_enc->width = frame_width;
3181 video_enc->height = frame_height;
3182 video_enc->pix_fmt = frame_pix_fmt;
3183 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3186 video_enc->gop_size = 0;
3187 if (video_qscale || same_quality) {
3188 video_enc->flags |= CODEC_FLAG_QSCALE;
3189 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3193 video_enc->intra_matrix = intra_matrix;
3195 video_enc->inter_matrix = inter_matrix;
3197 p= video_rc_override_string;
3200 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3202 fprintf(stderr, "error parsing rc_override\n");
3205 video_enc->rc_override=
3206 av_realloc(video_enc->rc_override,
3207 sizeof(RcOverride)*(i+1));
3208 video_enc->rc_override[i].start_frame= start;
3209 video_enc->rc_override[i].end_frame = end;
3211 video_enc->rc_override[i].qscale= q;
3212 video_enc->rc_override[i].quality_factor= 1.0;
3215 video_enc->rc_override[i].qscale= 0;
3216 video_enc->rc_override[i].quality_factor= -q/100.0;
3221 video_enc->rc_override_count=i;
3222 if (!video_enc->rc_initial_buffer_occupancy)
3223 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3224 video_enc->me_threshold= me_threshold;
3225 video_enc->intra_dc_precision= intra_dc_precision - 8;
3228 video_enc->flags|= CODEC_FLAG_PSNR;
3233 video_enc->flags |= CODEC_FLAG_PASS1;
3235 video_enc->flags |= CODEC_FLAG_PASS2;
3239 if (forced_key_frames)
3240 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3242 if (video_language) {
3243 av_dict_set(&st->metadata, "language", video_language, 0);
3244 av_freep(&video_language);
3247 /* reset some key parameters */
3249 av_freep(&video_codec_name);
3250 av_freep(&forced_key_frames);
3251 video_stream_copy = 0;
3252 frame_pix_fmt = PIX_FMT_NONE;
3256 static OutputStream *new_audio_stream(AVFormatContext *oc, int file_idx)
3260 AVCodec *codec= NULL;
3261 AVCodecContext *audio_enc;
3262 enum CodecID codec_id = CODEC_ID_NONE;
3264 if(!audio_stream_copy){
3265 if (audio_codec_name) {
3266 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3267 codec = avcodec_find_encoder_by_name(audio_codec_name);
3269 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3270 codec = avcodec_find_encoder(codec_id);
3273 ost = new_output_stream(oc, file_idx, codec);
3276 ost->bitstream_filters = audio_bitstream_filters;
3277 audio_bitstream_filters= NULL;
3279 st->codec->thread_count= thread_count;
3281 audio_enc = st->codec;
3282 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3285 audio_enc->codec_tag= audio_codec_tag;
3287 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3288 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3290 if (audio_stream_copy) {
3291 st->stream_copy = 1;
3293 audio_enc->codec_id = codec_id;
3295 if (audio_qscale > QSCALE_NONE) {
3296 audio_enc->flags |= CODEC_FLAG_QSCALE;
3297 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3300 audio_enc->channels = audio_channels;
3301 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3302 audio_enc->sample_fmt = audio_sample_fmt;
3303 if (audio_sample_rate)
3304 audio_enc->sample_rate = audio_sample_rate;
3306 if (audio_language) {
3307 av_dict_set(&st->metadata, "language", audio_language, 0);
3308 av_freep(&audio_language);
3311 /* reset some key parameters */
3313 av_freep(&audio_codec_name);
3314 audio_stream_copy = 0;
3319 static OutputStream *new_data_stream(AVFormatContext *oc, int file_idx)
3323 AVCodecContext *data_enc;
3325 ost = new_output_stream(oc, file_idx, NULL);
3327 data_enc = st->codec;
3328 if (!data_stream_copy) {
3329 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3333 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3336 data_enc->codec_tag= data_codec_tag;
3338 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3339 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3341 if (data_stream_copy) {
3342 st->stream_copy = 1;
3346 av_freep(&data_codec_name);
3347 data_stream_copy = 0;
3351 static OutputStream *new_subtitle_stream(AVFormatContext *oc, int file_idx)
3355 AVCodec *codec=NULL;
3356 AVCodecContext *subtitle_enc;
3357 enum CodecID codec_id = CODEC_ID_NONE;
3359 if(!subtitle_stream_copy){
3360 if (subtitle_codec_name) {
3361 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3362 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3364 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3365 codec = avcodec_find_encoder(codec_id);
3368 ost = new_output_stream(oc, file_idx, codec);
3370 subtitle_enc = st->codec;
3372 ost->bitstream_filters = subtitle_bitstream_filters;
3373 subtitle_bitstream_filters= NULL;
3375 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3377 if(subtitle_codec_tag)
3378 subtitle_enc->codec_tag= subtitle_codec_tag;
3380 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3381 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3383 if (subtitle_stream_copy) {
3384 st->stream_copy = 1;
3386 subtitle_enc->codec_id = codec_id;
3389 if (subtitle_language) {
3390 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3391 av_freep(&subtitle_language);
3394 subtitle_disable = 0;
3395 av_freep(&subtitle_codec_name);
3396 subtitle_stream_copy = 0;
3400 /* arg format is "output-stream-index:streamid-value". */
3401 static int opt_streamid(const char *opt, const char *arg)
3407 av_strlcpy(idx_str, arg, sizeof(idx_str));
3408 p = strchr(idx_str, ':');
3411 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3416 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3417 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3418 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3422 static void opt_output_file(const char *filename)
3424 AVFormatContext *oc;
3426 AVOutputFormat *file_oformat;
3430 if (!strcmp(filename, "-"))
3433 oc = avformat_alloc_context();
3435 print_error(filename, AVERROR(ENOMEM));
3439 if (last_asked_format) {
3440 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3441 if (!file_oformat) {
3442 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3445 last_asked_format = NULL;
3447 file_oformat = av_guess_format(NULL, filename, NULL);
3448 if (!file_oformat) {
3449 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3455 oc->oformat = file_oformat;
3456 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3458 if (!strcmp(file_oformat->name, "ffm") &&
3459 av_strstart(filename, "http:", NULL)) {
3460 /* special case for files sent to avserver: we get the stream
3461 parameters from avserver */
3462 int err = read_avserver_streams(oc, filename);
3464 print_error(filename, err);
3467 } else if (!nb_stream_maps) {
3468 /* pick the "best" stream of each type */
3469 #define NEW_STREAM(type, index)\
3471 ost = new_ ## type ## _stream(oc, nb_output_files);\
3472 ost->source_index = index;\
3473 ost->sync_ist = &input_streams[index];\
3474 input_streams[index].discard = 0;\
3477 /* video: highest resolution */
3478 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3479 int area = 0, idx = -1;
3480 for (i = 0; i < nb_input_streams; i++) {
3481 ist = &input_streams[i];
3482 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3483 ist->st->codec->width * ist->st->codec->height > area) {
3484 area = ist->st->codec->width * ist->st->codec->height;
3488 NEW_STREAM(video, idx);
3491 /* audio: most channels */
3492 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3493 int channels = 0, idx = -1;
3494 for (i = 0; i < nb_input_streams; i++) {
3495 ist = &input_streams[i];
3496 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3497 ist->st->codec->channels > channels) {
3498 channels = ist->st->codec->channels;
3502 NEW_STREAM(audio, idx);
3505 /* subtitles: pick first */
3506 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3507 for (i = 0; i < nb_input_streams; i++)
3508 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3509 NEW_STREAM(subtitle, i);
3513 /* do something with data? */
3515 for (i = 0; i < nb_stream_maps; i++) {
3516 StreamMap *map = &stream_maps[i];
3517 int fi = map->file_index;
3518 int si = map->stream_index;
3520 if (fi < 0 || fi >= nb_input_files ||
3521 si < 0 || si >= input_files[fi].ctx->nb_streams) {
3522 av_log(NULL, AV_LOG_ERROR, "Input stream #%d.%d does not exist.\n", fi, si);
3525 fi = map->sync_file_index;
3526 si = map->sync_stream_index;
3527 if (fi < 0 || fi >= nb_input_files ||
3528 si < 0 || si >= input_files[fi].ctx->nb_streams) {
3529 av_log(NULL, AV_LOG_ERROR, "Sync stream #%d.%d does not exist.\n", fi, si);
3533 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3534 switch (ist->st->codec->codec_type) {
3535 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc, nb_output_files); break;
3536 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc, nb_output_files); break;
3537 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc, nb_output_files); break;
3538 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc, nb_output_files); break;
3540 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3541 map->file_index, map->stream_index);
3545 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3546 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3547 map->sync_stream_index];
3552 av_dict_copy(&oc->metadata, metadata, 0);
3553 av_dict_free(&metadata);
3555 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3556 output_files[nb_output_files++] = oc;
3558 /* check filename in case of an image number is expected */
3559 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3560 if (!av_filename_number_test(oc->filename)) {
3561 print_error(oc->filename, AVERROR(EINVAL));
3566 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3567 /* test if it already exists to avoid loosing precious files */
3568 if (!file_overwrite &&
3569 (strchr(filename, ':') == NULL ||
3570 filename[1] == ':' ||
3571 av_strstart(filename, "file:", NULL))) {
3572 if (avio_check(filename, 0) == 0) {
3574 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3576 if (!read_yesno()) {
3577 fprintf(stderr, "Not overwriting - exiting\n");
3582 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3589 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3590 print_error(filename, err);
3595 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3596 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3597 oc->flags |= AVFMT_FLAG_NONBLOCK;
3600 if (chapters_input_file >= nb_input_files) {
3601 if (chapters_input_file == INT_MAX) {
3602 /* copy chapters from the first input file that has them*/
3603 chapters_input_file = -1;
3604 for (i = 0; i < nb_input_files; i++)
3605 if (input_files[i].ctx->nb_chapters) {
3606 chapters_input_file = i;
3610 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3611 chapters_input_file);
3615 if (chapters_input_file >= 0)
3616 copy_chapters(chapters_input_file, nb_output_files - 1);
3619 for (i = 0; i < nb_meta_data_maps; i++) {
3620 AVFormatContext *files[2];
3621 AVDictionary **meta[2];
3624 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3625 if ((index) < 0 || (index) >= (nb_elems)) {\
3626 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3631 int in_file_index = meta_data_maps[i][1].file;
3632 if (in_file_index < 0)
3634 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3637 files[1] = input_files[in_file_index].ctx;
3639 for (j = 0; j < 2; j++) {
3640 MetadataMap *map = &meta_data_maps[i][j];
3642 switch (map->type) {
3644 meta[j] = &files[j]->metadata;
3647 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3648 meta[j] = &files[j]->streams[map->index]->metadata;
3651 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3652 meta[j] = &files[j]->chapters[map->index]->metadata;
3655 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3656 meta[j] = &files[j]->programs[map->index]->metadata;
3661 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3664 /* copy global metadata by default */
3665 if (metadata_global_autocopy)
3666 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3667 AV_DICT_DONT_OVERWRITE);
3668 if (metadata_streams_autocopy)
3669 for (i = 0; i < oc->nb_streams; i++) {
3670 InputStream *ist = &input_streams[output_streams_for_file[nb_output_files-1][i]->source_index];
3671 av_dict_copy(&oc->streams[i]->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3674 frame_rate = (AVRational){0, 0};
3677 audio_sample_rate = 0;
3679 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3680 chapters_input_file = INT_MAX;
3682 av_freep(&meta_data_maps);
3683 nb_meta_data_maps = 0;
3684 metadata_global_autocopy = 1;
3685 metadata_streams_autocopy = 1;
3686 metadata_chapters_autocopy = 1;
3687 av_freep(&stream_maps);
3690 av_freep(&forced_key_frames);
3695 /* same option as mencoder */
3696 static int opt_pass(const char *opt, const char *arg)
3698 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3702 static int64_t getutime(void)
3705 struct rusage rusage;
3707 getrusage(RUSAGE_SELF, &rusage);
3708 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3709 #elif HAVE_GETPROCESSTIMES
3711 FILETIME c, e, k, u;
3712 proc = GetCurrentProcess();
3713 GetProcessTimes(proc, &c, &e, &k, &u);
3714 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3716 return av_gettime();
3720 static int64_t getmaxrss(void)
3722 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3723 struct rusage rusage;
3724 getrusage(RUSAGE_SELF, &rusage);
3725 return (int64_t)rusage.ru_maxrss * 1024;
3726 #elif HAVE_GETPROCESSMEMORYINFO
3728 PROCESS_MEMORY_COUNTERS memcounters;
3729 proc = GetCurrentProcess();
3730 memcounters.cb = sizeof(memcounters);
3731 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3732 return memcounters.PeakPagefileUsage;
3738 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3741 const char *p = str;
3748 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3755 static void opt_inter_matrix(const char *arg)
3757 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3758 parse_matrix_coeffs(inter_matrix, arg);
3761 static void opt_intra_matrix(const char *arg)
3763 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3764 parse_matrix_coeffs(intra_matrix, arg);
3767 static void show_usage(void)
3769 printf("Hyper fast Audio and Video encoder\n");
3770 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3774 static void show_help(void)
3777 AVOutputFormat *oformat = NULL;
3778 AVInputFormat *iformat = NULL;
3780 av_log_set_callback(log_callback_help);
3782 show_help_options(options, "Main options:\n",
3783 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3784 show_help_options(options, "\nAdvanced options:\n",
3785 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3787 show_help_options(options, "\nVideo options:\n",
3788 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3790 show_help_options(options, "\nAdvanced Video options:\n",
3791 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3792 OPT_VIDEO | OPT_EXPERT);
3793 show_help_options(options, "\nAudio options:\n",
3794 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3796 show_help_options(options, "\nAdvanced Audio options:\n",
3797 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3798 OPT_AUDIO | OPT_EXPERT);
3799 show_help_options(options, "\nSubtitle options:\n",
3800 OPT_SUBTITLE | OPT_GRAB,
3802 show_help_options(options, "\nAudio/Video grab options:\n",
3806 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3809 /* individual codec options */
3811 while ((c = av_codec_next(c))) {
3812 if (c->priv_class) {
3813 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3818 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3821 /* individual muxer options */
3822 while ((oformat = av_oformat_next(oformat))) {
3823 if (oformat->priv_class) {
3824 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3829 /* individual demuxer options */
3830 while ((iformat = av_iformat_next(iformat))) {
3831 if (iformat->priv_class) {
3832 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3837 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3840 static int opt_target(const char *opt, const char *arg)
3842 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3843 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3845 if(!strncmp(arg, "pal-", 4)) {
3848 } else if(!strncmp(arg, "ntsc-", 5)) {
3851 } else if(!strncmp(arg, "film-", 5)) {
3856 /* Calculate FR via float to avoid int overflow */
3857 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3860 } else if((fr == 29970) || (fr == 23976)) {
3863 /* Try to determine PAL/NTSC by peeking in the input files */
3864 if(nb_input_files) {
3866 for (j = 0; j < nb_input_files; j++) {
3867 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3868 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3869 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3871 fr = c->time_base.den * 1000 / c->time_base.num;
3875 } else if((fr == 29970) || (fr == 23976)) {
3885 if(verbose > 0 && norm != UNKNOWN)
3886 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3889 if(norm == UNKNOWN) {
3890 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3891 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3892 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3896 if(!strcmp(arg, "vcd")) {
3897 opt_video_codec("vcodec", "mpeg1video");
3898 opt_audio_codec("vcodec", "mp2");
3899 opt_format("f", "vcd");
3901 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3902 opt_frame_rate("r", frame_rates[norm]);
3903 opt_default("g", norm == PAL ? "15" : "18");
3905 opt_default("b", "1150000");
3906 opt_default("maxrate", "1150000");
3907 opt_default("minrate", "1150000");
3908 opt_default("bufsize", "327680"); // 40*1024*8;
3910 opt_default("ab", "224000");
3911 audio_sample_rate = 44100;
3914 opt_default("packetsize", "2324");
3915 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3917 /* We have to offset the PTS, so that it is consistent with the SCR.
3918 SCR starts at 36000, but the first two packs contain only padding
3919 and the first pack from the other stream, respectively, may also have
3920 been written before.
3921 So the real data starts at SCR 36000+3*1200. */
3922 mux_preload= (36000+3*1200) / 90000.0; //0.44
3923 } else if(!strcmp(arg, "svcd")) {
3925 opt_video_codec("vcodec", "mpeg2video");
3926 opt_audio_codec("acodec", "mp2");
3927 opt_format("f", "svcd");
3929 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3930 opt_frame_rate("r", frame_rates[norm]);
3931 opt_default("g", norm == PAL ? "15" : "18");
3933 opt_default("b", "2040000");
3934 opt_default("maxrate", "2516000");
3935 opt_default("minrate", "0"); //1145000;
3936 opt_default("bufsize", "1835008"); //224*1024*8;
3937 opt_default("flags", "+scan_offset");
3940 opt_default("ab", "224000");
3941 audio_sample_rate = 44100;
3943 opt_default("packetsize", "2324");
3945 } else if(!strcmp(arg, "dvd")) {
3947 opt_video_codec("vcodec", "mpeg2video");
3948 opt_audio_codec("vcodec", "ac3");
3949 opt_format("f", "dvd");
3951 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3952 opt_frame_rate("r", frame_rates[norm]);
3953 opt_default("g", norm == PAL ? "15" : "18");
3955 opt_default("b", "6000000");
3956 opt_default("maxrate", "9000000");
3957 opt_default("minrate", "0"); //1500000;
3958 opt_default("bufsize", "1835008"); //224*1024*8;
3960 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3961 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3963 opt_default("ab", "448000");
3964 audio_sample_rate = 48000;
3966 } else if(!strncmp(arg, "dv", 2)) {
3968 opt_format("f", "dv");
3970 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3971 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3972 norm == PAL ? "yuv420p" : "yuv411p");
3973 opt_frame_rate("r", frame_rates[norm]);
3975 audio_sample_rate = 48000;
3979 fprintf(stderr, "Unknown target: %s\n", arg);
3980 return AVERROR(EINVAL);
3985 static int opt_vstats_file(const char *opt, const char *arg)
3987 av_free (vstats_filename);
3988 vstats_filename=av_strdup (arg);
3992 static int opt_vstats(const char *opt, const char *arg)
3995 time_t today2 = time(NULL);
3996 struct tm *today = localtime(&today2);
3998 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4000 return opt_vstats_file(opt, filename);
4003 static int opt_bsf(const char *opt, const char *arg)
4005 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4006 AVBitStreamFilterContext **bsfp;
4009 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4013 bsfp= *opt == 'v' ? &video_bitstream_filters :
4014 *opt == 'a' ? &audio_bitstream_filters :
4015 &subtitle_bitstream_filters;
4017 bsfp= &(*bsfp)->next;
4024 static int opt_preset(const char *opt, const char *arg)
4027 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4028 char *codec_name = *opt == 'v' ? video_codec_name :
4029 *opt == 'a' ? audio_codec_name :
4030 subtitle_codec_name;
4032 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4033 fprintf(stderr, "File for preset '%s' not found\n", arg);
4038 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4039 if(line[0] == '#' && !e)
4041 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4043 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4046 if(!strcmp(tmp, "acodec")){
4047 opt_audio_codec(tmp, tmp2);
4048 }else if(!strcmp(tmp, "vcodec")){
4049 opt_video_codec(tmp, tmp2);
4050 }else if(!strcmp(tmp, "scodec")){
4051 opt_subtitle_codec(tmp, tmp2);
4052 }else if(!strcmp(tmp, "dcodec")){
4053 opt_data_codec(tmp, tmp2);
4054 }else if(opt_default(tmp, tmp2) < 0){
4055 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4065 static const OptionDef options[] = {
4067 #include "cmdutils_common_opts.h"
4068 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4069 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4070 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4071 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4072 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4073 "outfile[,metadata]:infile[,metadata]" },
4074 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
4075 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4076 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4077 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4078 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4079 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4080 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4081 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4082 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4083 "add timings for benchmarking" },
4084 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4085 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4086 "dump each input packet" },
4087 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4088 "when dumping packets, also dump the payload" },
4089 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4090 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4091 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4092 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4093 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4094 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4095 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4096 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4097 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4098 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4099 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4100 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4101 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4102 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4105 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4106 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4107 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4108 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4109 { "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" },
4110 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4111 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4112 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4113 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4114 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4115 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4116 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4117 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4118 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4119 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4120 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4121 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4122 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4123 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4124 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4125 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4126 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4127 "use same quantizer as source (implies VBR)" },
4128 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4129 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4130 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4131 "deinterlace pictures" },
4132 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4133 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4134 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4136 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4138 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4139 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4140 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4141 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4142 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4143 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4144 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4145 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4146 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4147 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4150 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4151 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4152 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4153 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4154 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4155 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4156 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4157 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4158 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4159 { "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" },
4161 /* subtitle options */
4162 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4163 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4164 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4165 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4168 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4171 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4172 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4174 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4175 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4176 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4178 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4179 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4180 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4181 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4182 /* data codec support */
4183 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4185 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4189 int main(int argc, char **argv)
4193 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4195 avcodec_register_all();
4197 avdevice_register_all();
4200 avfilter_register_all();
4204 avio_set_interrupt_cb(decode_interrupt_cb);
4211 parse_options(argc, argv, options, opt_output_file);
4213 if(nb_output_files <= 0 && nb_input_files == 0) {
4215 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4219 /* file converter / grab */
4220 if (nb_output_files <= 0) {
4221 fprintf(stderr, "At least one output file must be specified\n");
4225 if (nb_input_files == 0) {
4226 fprintf(stderr, "At least one input file must be specified\n");
4231 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4233 ti = getutime() - ti;
4235 int maxrss = getmaxrss() / 1024;
4236 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4239 return exit_program(0);