3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "ffmpeg";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
85 int sync_stream_index;
89 * select an input file for an output file
91 typedef struct MetadataMap {
92 int file; ///< file index
93 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
94 int index; ///< stream/chapter/program number
97 typedef struct ChapterMap {
102 static const OptionDef options[];
104 #define MAX_FILES 100
106 static const char *last_asked_format = NULL;
107 static double *ts_scale;
108 static int nb_ts_scale;
110 static AVFormatContext *output_files[MAX_FILES];
111 static AVDictionary *output_opts[MAX_FILES];
112 static int nb_output_files = 0;
114 static StreamMap *stream_maps = NULL;
115 static int nb_stream_maps;
117 /* first item specifies output metadata, second is input */
118 static MetadataMap (*meta_data_maps)[2] = NULL;
119 static int nb_meta_data_maps;
120 static int metadata_global_autocopy = 1;
121 static int metadata_streams_autocopy = 1;
122 static int metadata_chapters_autocopy = 1;
124 static ChapterMap *chapter_maps = NULL;
125 static int nb_chapter_maps;
127 /* indexed by output file stream index */
128 static int *streamid_map = NULL;
129 static int nb_streamid_map = 0;
131 static int frame_width = 0;
132 static int frame_height = 0;
133 static float frame_aspect_ratio = 0;
134 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
135 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
136 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
137 static AVRational frame_rate;
138 static float video_qscale = 0;
139 static uint16_t *intra_matrix = NULL;
140 static uint16_t *inter_matrix = NULL;
141 static const char *video_rc_override_string=NULL;
142 static int video_disable = 0;
143 static int video_discard = 0;
144 static char *video_codec_name = NULL;
145 static unsigned int video_codec_tag = 0;
146 static char *video_language = NULL;
147 static int same_quality = 0;
148 static int do_deinterlace = 0;
149 static int top_field_first = -1;
150 static int me_threshold = 0;
151 static int intra_dc_precision = 8;
152 static int loop_input = 0;
153 static int loop_output = AVFMT_NOOUTPUTLOOP;
154 static int qp_hist = 0;
156 static char *vfilters = NULL;
159 static int intra_only = 0;
160 static int audio_sample_rate = 0;
161 #define QSCALE_NONE -99999
162 static float audio_qscale = QSCALE_NONE;
163 static int audio_disable = 0;
164 static int audio_channels = 0;
165 static char *audio_codec_name = NULL;
166 static unsigned int audio_codec_tag = 0;
167 static char *audio_language = NULL;
169 static int subtitle_disable = 0;
170 static char *subtitle_codec_name = NULL;
171 static char *subtitle_language = NULL;
172 static unsigned int subtitle_codec_tag = 0;
174 static int data_disable = 0;
175 static char *data_codec_name = NULL;
176 static unsigned int data_codec_tag = 0;
178 static float mux_preload= 0.5;
179 static float mux_max_delay= 0.7;
181 static int64_t recording_time = INT64_MAX;
182 static int64_t start_time = 0;
183 static int64_t input_ts_offset = 0;
184 static int file_overwrite = 0;
185 static AVDictionary *metadata;
186 static int do_benchmark = 0;
187 static int do_hex_dump = 0;
188 static int do_pkt_dump = 0;
189 static int do_psnr = 0;
190 static int do_pass = 0;
191 static char *pass_logfilename_prefix = NULL;
192 static int audio_stream_copy = 0;
193 static int video_stream_copy = 0;
194 static int subtitle_stream_copy = 0;
195 static int data_stream_copy = 0;
196 static int video_sync_method= -1;
197 static int audio_sync_method= 0;
198 static float audio_drift_threshold= 0.1;
199 static int copy_ts= 0;
201 static int opt_shortest = 0;
202 static char *vstats_filename;
203 static FILE *vstats_file;
204 static int opt_programid = 0;
205 static int copy_initial_nonkeyframes = 0;
207 static int rate_emu = 0;
209 static int audio_volume = 256;
211 static int exit_on_error = 0;
212 static int using_stdin = 0;
213 static int verbose = 1;
214 static int thread_count= 1;
215 static int64_t video_size = 0;
216 static int64_t audio_size = 0;
217 static int64_t extra_size = 0;
218 static int nb_frames_dup = 0;
219 static int nb_frames_drop = 0;
220 static int input_sync;
221 static uint64_t limit_filesize = 0;
222 static int force_fps = 0;
223 static char *forced_key_frames = NULL;
225 static float dts_delta_threshold = 10;
227 static int64_t timer_start;
229 static uint8_t *audio_buf;
230 static uint8_t *audio_out;
231 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
233 static short *samples;
235 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
236 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
237 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
239 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
243 typedef struct OutputStream {
244 int file_index; /* file index */
245 int index; /* stream index in the output file */
246 int source_index; /* InputStream index */
247 AVStream *st; /* stream in the output file */
248 int encoding_needed; /* true if encoding needed for this stream */
250 /* input pts and corresponding output pts
252 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
253 struct InputStream *sync_ist; /* input stream to sync against */
254 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
255 AVBitStreamFilterContext *bitstream_filters;
260 AVFrame pict_tmp; /* temporary image for resampling */
261 struct SwsContext *img_resample_ctx; /* for image resampling */
264 int resample_pix_fmt;
265 AVRational frame_rate;
267 float frame_aspect_ratio;
269 /* forced key frames */
270 int64_t *forced_kf_pts;
276 ReSampleContext *resample; /* for audio resampling */
277 int resample_sample_fmt;
278 int resample_channels;
279 int resample_sample_rate;
281 AVAudioConvert *reformat_ctx;
282 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
286 AVFilterContext *output_video_filter;
287 AVFilterContext *input_video_filter;
288 AVFilterBufferRef *picref;
290 AVFilterGraph *graph;
297 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
298 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
300 typedef struct InputStream {
303 int discard; /* true if stream data should be discarded */
304 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
307 int64_t start; /* time when read started */
308 int64_t next_pts; /* synthetic pts for cases where pkt.pts
310 int64_t pts; /* current pts */
311 PtsCorrectionContext pts_ctx;
313 int is_start; /* is 1 at the start and after a discontinuity */
314 int showed_multi_packet_warning;
315 int is_past_recording_time;
319 typedef struct InputFile {
320 AVFormatContext *ctx;
321 int eof_reached; /* true if eof reached */
322 int ist_index; /* index of first stream in ist_table */
323 int buffer_size; /* current total buffer size */
325 int nb_streams; /* nb streams we are aware of */
328 static InputStream *input_streams = NULL;
329 static int nb_input_streams = 0;
330 static InputFile *input_files = NULL;
331 static int nb_input_files = 0;
335 static int configure_video_filters(InputStream *ist, OutputStream *ost)
337 AVFilterContext *last_filter, *filter;
338 /** filter graph containing all filters including input & output */
339 AVCodecContext *codec = ost->st->codec;
340 AVCodecContext *icodec = ist->st->codec;
341 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
342 AVRational sample_aspect_ratio;
346 ost->graph = avfilter_graph_alloc();
348 if (ist->st->sample_aspect_ratio.num){
349 sample_aspect_ratio = ist->st->sample_aspect_ratio;
351 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
353 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
354 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
355 sample_aspect_ratio.num, sample_aspect_ratio.den);
357 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
358 "src", args, NULL, ost->graph);
361 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
362 "out", NULL, &ffsink_ctx, ost->graph);
365 last_filter = ost->input_video_filter;
367 if (codec->width != icodec->width || codec->height != icodec->height) {
368 snprintf(args, 255, "%d:%d:flags=0x%X",
372 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
373 NULL, args, NULL, ost->graph)) < 0)
375 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
377 last_filter = filter;
380 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
381 ost->graph->scale_sws_opts = av_strdup(args);
384 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
385 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
387 outputs->name = av_strdup("in");
388 outputs->filter_ctx = last_filter;
389 outputs->pad_idx = 0;
390 outputs->next = NULL;
392 inputs->name = av_strdup("out");
393 inputs->filter_ctx = ost->output_video_filter;
397 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
399 av_freep(&ost->avfilter);
401 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
405 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
408 codec->width = ost->output_video_filter->inputs[0]->w;
409 codec->height = ost->output_video_filter->inputs[0]->h;
410 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
411 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
412 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
413 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
417 #endif /* CONFIG_AVFILTER */
419 static void term_exit(void)
421 av_log(NULL, AV_LOG_QUIET, "");
424 static volatile int received_sigterm = 0;
425 static volatile int received_nb_signals = 0;
428 sigterm_handler(int sig)
430 received_sigterm = sig;
431 received_nb_signals++;
435 static void term_init(void)
437 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
438 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
440 signal(SIGXCPU, sigterm_handler);
444 static int decode_interrupt_cb(void)
446 return received_nb_signals > 1;
449 void exit_program(int ret)
454 for(i=0;i<nb_output_files;i++) {
455 AVFormatContext *s = output_files[i];
456 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
458 avformat_free_context(s);
459 av_free(output_streams_for_file[i]);
460 av_dict_free(&output_opts[i]);
462 for(i=0;i<nb_input_files;i++) {
463 av_close_input_file(input_files[i].ctx);
465 for (i = 0; i < nb_input_streams; i++)
466 av_dict_free(&input_streams[i].opts);
468 av_free(intra_matrix);
469 av_free(inter_matrix);
473 av_free(vstats_filename);
475 av_free(streamid_map);
476 av_free(stream_maps);
477 av_free(meta_data_maps);
479 av_freep(&input_streams);
480 av_freep(&input_files);
482 av_free(video_codec_name);
483 av_free(audio_codec_name);
484 av_free(subtitle_codec_name);
485 av_free(data_codec_name);
490 allocated_audio_buf_size= allocated_audio_out_size= 0;
496 avformat_network_deinit();
498 if (received_sigterm) {
500 "Received signal %d: terminating.\n",
501 (int) received_sigterm);
505 exit(ret); /* not all OS-es handle main() return value */
508 static void assert_avoptions(AVDictionary *m)
510 AVDictionaryEntry *t;
511 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
512 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
517 static void assert_codec_experimental(AVCodecContext *c, int encoder)
519 const char *codec_string = encoder ? "encoder" : "decoder";
521 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
522 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
523 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
524 "results.\nAdd '-strict experimental' if you want to use it.\n",
525 codec_string, c->codec->name);
526 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
527 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
528 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
529 codec_string, codec->name);
534 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
536 if(codec && codec->sample_fmts){
537 const enum AVSampleFormat *p= codec->sample_fmts;
539 if(*p == st->codec->sample_fmt)
543 av_log(NULL, AV_LOG_WARNING,
544 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
545 av_get_sample_fmt_name(st->codec->sample_fmt),
547 av_get_sample_fmt_name(codec->sample_fmts[0]));
548 st->codec->sample_fmt = codec->sample_fmts[0];
554 * Update the requested input sample format based on the output sample format.
555 * This is currently only used to request float output from decoders which
556 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
557 * Ideally this will be removed in the future when decoders do not do format
558 * conversion and only output in their native format.
560 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
563 /* if sample formats match or a decoder sample format has already been
564 requested, just return */
565 if (enc->sample_fmt == dec->sample_fmt ||
566 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
569 /* if decoder supports more than one output format */
570 if (dec_codec && dec_codec->sample_fmts &&
571 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
572 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
573 const enum AVSampleFormat *p;
574 int min_dec = -1, min_inc = -1;
576 /* find a matching sample format in the encoder */
577 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
578 if (*p == enc->sample_fmt) {
579 dec->request_sample_fmt = *p;
581 } else if (*p > enc->sample_fmt) {
582 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
584 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
587 /* if none match, provide the one that matches quality closest */
588 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
589 enc->sample_fmt - min_dec;
593 static void choose_sample_rate(AVStream *st, AVCodec *codec)
595 if(codec && codec->supported_samplerates){
596 const int *p= codec->supported_samplerates;
598 int best_dist=INT_MAX;
600 int dist= abs(st->codec->sample_rate - *p);
601 if(dist < best_dist){
607 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
609 st->codec->sample_rate= best;
613 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
615 if(codec && codec->pix_fmts){
616 const enum PixelFormat *p= codec->pix_fmts;
617 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
618 if(st->codec->codec_id==CODEC_ID_MJPEG){
619 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
620 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
621 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};
625 if(*p == st->codec->pix_fmt)
629 if(st->codec->pix_fmt != PIX_FMT_NONE)
630 av_log(NULL, AV_LOG_WARNING,
631 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
632 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
634 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
635 st->codec->pix_fmt = codec->pix_fmts[0];
640 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
643 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
644 int idx = oc->nb_streams - 1;
647 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
651 output_streams_for_file[file_idx] =
652 grow_array(output_streams_for_file[file_idx],
653 sizeof(*output_streams_for_file[file_idx]),
654 &nb_output_streams_for_file[file_idx],
656 ost = output_streams_for_file[file_idx][idx] =
657 av_mallocz(sizeof(OutputStream));
659 fprintf(stderr, "Could not alloc output stream\n");
662 ost->file_index = file_idx;
667 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
669 avcodec_get_context_defaults3(st->codec, codec);
671 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
675 static int read_avserver_streams(AVFormatContext *s, const char *filename)
678 AVFormatContext *ic = NULL;
680 err = avformat_open_input(&ic, filename, NULL, NULL);
683 /* copy stream format */
684 for(i=0;i<ic->nb_streams;i++) {
689 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
690 ost = new_output_stream(s, nb_output_files, codec);
693 // FIXME: a more elegant solution is needed
694 memcpy(st, ic->streams[i], sizeof(AVStream));
696 avcodec_copy_context(st->codec, ic->streams[i]->codec);
698 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
699 if (audio_stream_copy) {
702 choose_sample_fmt(st, codec);
703 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
704 if (video_stream_copy) {
707 choose_pixel_fmt(st, codec);
711 av_close_input_file(ic);
716 get_sync_ipts(const OutputStream *ost)
718 const InputStream *ist = ost->sync_ist;
719 return (double)(ist->pts - start_time)/AV_TIME_BASE;
722 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
726 AVPacket new_pkt= *pkt;
727 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
728 &new_pkt.data, &new_pkt.size,
729 pkt->data, pkt->size,
730 pkt->flags & AV_PKT_FLAG_KEY);
733 new_pkt.destruct= av_destruct_packet;
735 fprintf(stderr, "%s failed for stream %d, codec %s",
736 bsfc->filter->name, pkt->stream_index,
737 avctx->codec ? avctx->codec->name : "copy");
747 ret= av_interleaved_write_frame(s, pkt);
749 print_error("av_interleaved_write_frame()", ret);
754 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
756 static void do_audio_out(AVFormatContext *s,
759 unsigned char *buf, int size)
762 int64_t audio_out_size, audio_buf_size;
763 int64_t allocated_for_size= size;
765 int size_out, frame_bytes, ret, resample_changed;
766 AVCodecContext *enc= ost->st->codec;
767 AVCodecContext *dec= ist->st->codec;
768 int osize = av_get_bytes_per_sample(enc->sample_fmt);
769 int isize = av_get_bytes_per_sample(dec->sample_fmt);
770 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
773 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
774 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
775 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
776 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
777 audio_buf_size*= osize*enc->channels;
779 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
780 if(coded_bps > 8*osize)
781 audio_out_size= audio_out_size * coded_bps / (8*osize);
782 audio_out_size += FF_MIN_BUFFER_SIZE;
784 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
785 fprintf(stderr, "Buffer sizes too large\n");
789 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
790 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
791 if (!audio_buf || !audio_out){
792 fprintf(stderr, "Out of memory in do_audio_out\n");
796 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
797 ost->audio_resample = 1;
799 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
800 ost->resample_channels != dec->channels ||
801 ost->resample_sample_rate != dec->sample_rate;
803 if ((ost->audio_resample && !ost->resample) || resample_changed) {
804 if (resample_changed) {
805 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",
806 ist->file_index, ist->st->index,
807 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
808 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
809 ost->resample_sample_fmt = dec->sample_fmt;
810 ost->resample_channels = dec->channels;
811 ost->resample_sample_rate = dec->sample_rate;
813 audio_resample_close(ost->resample);
815 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
816 if (audio_sync_method <= 1 &&
817 ost->resample_sample_fmt == enc->sample_fmt &&
818 ost->resample_channels == enc->channels &&
819 ost->resample_sample_rate == enc->sample_rate) {
820 ost->resample = NULL;
821 ost->audio_resample = 0;
822 } else if (ost->audio_resample) {
823 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
824 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
825 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
826 enc->sample_rate, dec->sample_rate,
827 enc->sample_fmt, dec->sample_fmt,
829 if (!ost->resample) {
830 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
831 dec->channels, dec->sample_rate,
832 enc->channels, enc->sample_rate);
838 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
839 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
840 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
841 if (ost->reformat_ctx)
842 av_audio_convert_free(ost->reformat_ctx);
843 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
844 dec->sample_fmt, 1, NULL, 0);
845 if (!ost->reformat_ctx) {
846 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
847 av_get_sample_fmt_name(dec->sample_fmt),
848 av_get_sample_fmt_name(enc->sample_fmt));
851 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
854 if(audio_sync_method){
855 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
856 - av_fifo_size(ost->fifo)/(enc->channels * 2);
857 double idelta= delta*dec->sample_rate / enc->sample_rate;
858 int byte_delta= ((int)idelta)*2*dec->channels;
860 //FIXME resample delay
861 if(fabs(delta) > 50){
862 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
864 byte_delta= FFMAX(byte_delta, -size);
868 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
873 static uint8_t *input_tmp= NULL;
874 input_tmp= av_realloc(input_tmp, byte_delta + size);
876 if(byte_delta > allocated_for_size - size){
877 allocated_for_size= byte_delta + (int64_t)size;
882 memset(input_tmp, 0, byte_delta);
883 memcpy(input_tmp + byte_delta, buf, size);
887 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
889 }else if(audio_sync_method>1){
890 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
891 av_assert0(ost->audio_resample);
893 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
894 // 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));
895 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
899 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
900 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
902 if (ost->audio_resample) {
904 size_out = audio_resample(ost->resample,
905 (short *)buftmp, (short *)buf,
906 size / (dec->channels * isize));
907 size_out = size_out * enc->channels * osize;
913 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
914 const void *ibuf[6]= {buftmp};
915 void *obuf[6]= {audio_buf};
916 int istride[6]= {isize};
917 int ostride[6]= {osize};
918 int len= size_out/istride[0];
919 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
920 printf("av_audio_convert() failed\n");
926 size_out = len*osize;
929 /* now encode as many frames as possible */
930 if (enc->frame_size > 1) {
931 /* output resampled raw samples */
932 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
933 fprintf(stderr, "av_fifo_realloc2() failed\n");
936 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
938 frame_bytes = enc->frame_size * osize * enc->channels;
940 while (av_fifo_size(ost->fifo) >= frame_bytes) {
942 av_init_packet(&pkt);
944 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
946 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
948 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
951 fprintf(stderr, "Audio encoding failed\n");
955 pkt.stream_index= ost->index;
958 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
959 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
960 pkt.flags |= AV_PKT_FLAG_KEY;
961 write_frame(s, &pkt, enc, ost->bitstream_filters);
963 ost->sync_opts += enc->frame_size;
967 av_init_packet(&pkt);
969 ost->sync_opts += size_out / (osize * enc->channels);
971 /* output a pcm frame */
972 /* determine the size of the coded buffer */
975 size_out = size_out*coded_bps/8;
977 if(size_out > audio_out_size){
978 fprintf(stderr, "Internal error, buffer size too small\n");
982 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
983 ret = avcodec_encode_audio(enc, audio_out, size_out,
986 fprintf(stderr, "Audio encoding failed\n");
990 pkt.stream_index= ost->index;
993 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
994 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
995 pkt.flags |= AV_PKT_FLAG_KEY;
996 write_frame(s, &pkt, enc, ost->bitstream_filters);
1000 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1002 AVCodecContext *dec;
1003 AVPicture *picture2;
1004 AVPicture picture_tmp;
1007 dec = ist->st->codec;
1009 /* deinterlace : must be done before any resize */
1010 if (do_deinterlace) {
1013 /* create temporary picture */
1014 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1015 buf = av_malloc(size);
1019 picture2 = &picture_tmp;
1020 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1022 if(avpicture_deinterlace(picture2, picture,
1023 dec->pix_fmt, dec->width, dec->height) < 0) {
1024 /* if error, do not deinterlace */
1025 fprintf(stderr, "Deinterlacing failed\n");
1034 if (picture != picture2)
1035 *picture = *picture2;
1039 /* we begin to correct av delay at this threshold */
1040 #define AV_DELAY_MAX 0.100
1042 static void do_subtitle_out(AVFormatContext *s,
1048 static uint8_t *subtitle_out = NULL;
1049 int subtitle_out_max_size = 1024 * 1024;
1050 int subtitle_out_size, nb, i;
1051 AVCodecContext *enc;
1054 if (pts == AV_NOPTS_VALUE) {
1055 fprintf(stderr, "Subtitle packets must have a pts\n");
1061 enc = ost->st->codec;
1063 if (!subtitle_out) {
1064 subtitle_out = av_malloc(subtitle_out_max_size);
1067 /* Note: DVB subtitle need one packet to draw them and one other
1068 packet to clear them */
1069 /* XXX: signal it in the codec context ? */
1070 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1075 for(i = 0; i < nb; i++) {
1076 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1077 // start_display_time is required to be 0
1078 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1079 sub->end_display_time -= sub->start_display_time;
1080 sub->start_display_time = 0;
1081 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1082 subtitle_out_max_size, sub);
1083 if (subtitle_out_size < 0) {
1084 fprintf(stderr, "Subtitle encoding failed\n");
1088 av_init_packet(&pkt);
1089 pkt.stream_index = ost->index;
1090 pkt.data = subtitle_out;
1091 pkt.size = subtitle_out_size;
1092 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1093 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1094 /* XXX: the pts correction is handled here. Maybe handling
1095 it in the codec would be better */
1097 pkt.pts += 90 * sub->start_display_time;
1099 pkt.pts += 90 * sub->end_display_time;
1101 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1105 static int bit_buffer_size= 1024*256;
1106 static uint8_t *bit_buffer= NULL;
1108 static void do_video_out(AVFormatContext *s,
1111 AVFrame *in_picture,
1112 int *frame_size, float quality)
1114 int nb_frames, i, ret, resample_changed;
1115 AVFrame *final_picture, *formatted_picture;
1116 AVCodecContext *enc, *dec;
1119 enc = ost->st->codec;
1120 dec = ist->st->codec;
1122 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1124 /* by default, we output a single frame */
1129 if(video_sync_method){
1130 double vdelta = sync_ipts - ost->sync_opts;
1131 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1134 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1137 }else if(vdelta>0.6)
1138 ost->sync_opts= lrintf(sync_ipts);
1139 }else if (vdelta > 1.1)
1140 nb_frames = lrintf(vdelta);
1141 //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);
1142 if (nb_frames == 0){
1145 fprintf(stderr, "*** drop!\n");
1146 }else if (nb_frames > 1) {
1147 nb_frames_dup += nb_frames - 1;
1149 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1152 ost->sync_opts= lrintf(sync_ipts);
1154 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1158 formatted_picture = in_picture;
1159 final_picture = formatted_picture;
1161 resample_changed = ost->resample_width != dec->width ||
1162 ost->resample_height != dec->height ||
1163 ost->resample_pix_fmt != dec->pix_fmt;
1165 if (resample_changed) {
1166 av_log(NULL, AV_LOG_INFO,
1167 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1168 ist->file_index, ist->st->index,
1169 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1170 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1171 if(!ost->video_resample)
1175 #if !CONFIG_AVFILTER
1176 if (ost->video_resample) {
1177 final_picture = &ost->pict_tmp;
1178 if (resample_changed) {
1179 /* initialize a new scaler context */
1180 sws_freeContext(ost->img_resample_ctx);
1181 ost->img_resample_ctx = sws_getContext(
1182 ist->st->codec->width,
1183 ist->st->codec->height,
1184 ist->st->codec->pix_fmt,
1185 ost->st->codec->width,
1186 ost->st->codec->height,
1187 ost->st->codec->pix_fmt,
1188 ost->sws_flags, NULL, NULL, NULL);
1189 if (ost->img_resample_ctx == NULL) {
1190 fprintf(stderr, "Cannot get resampling context\n");
1194 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1195 0, ost->resample_height, final_picture->data, final_picture->linesize);
1199 /* duplicates frame if needed */
1200 for(i=0;i<nb_frames;i++) {
1202 av_init_packet(&pkt);
1203 pkt.stream_index= ost->index;
1205 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1206 /* raw pictures are written as AVPicture structure to
1207 avoid any copies. We support temorarily the older
1209 AVFrame* old_frame = enc->coded_frame;
1210 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1211 pkt.data= (uint8_t *)final_picture;
1212 pkt.size= sizeof(AVPicture);
1213 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1214 pkt.flags |= AV_PKT_FLAG_KEY;
1216 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1217 enc->coded_frame = old_frame;
1219 AVFrame big_picture;
1221 big_picture= *final_picture;
1222 /* better than nothing: use input picture interlaced
1224 big_picture.interlaced_frame = in_picture->interlaced_frame;
1225 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1226 if(top_field_first == -1)
1227 big_picture.top_field_first = in_picture->top_field_first;
1229 big_picture.top_field_first = top_field_first;
1232 /* handles sameq here. This is not correct because it may
1233 not be a global option */
1234 big_picture.quality = quality;
1236 big_picture.pict_type = 0;
1237 // big_picture.pts = AV_NOPTS_VALUE;
1238 big_picture.pts= ost->sync_opts;
1239 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1240 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1241 if (ost->forced_kf_index < ost->forced_kf_count &&
1242 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1243 big_picture.pict_type = AV_PICTURE_TYPE_I;
1244 ost->forced_kf_index++;
1246 ret = avcodec_encode_video(enc,
1247 bit_buffer, bit_buffer_size,
1250 fprintf(stderr, "Video encoding failed\n");
1255 pkt.data= bit_buffer;
1257 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1258 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1259 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1260 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1261 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1263 if(enc->coded_frame->key_frame)
1264 pkt.flags |= AV_PKT_FLAG_KEY;
1265 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1268 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1269 // enc->frame_number-1, ret, enc->pict_type);
1270 /* if two pass, output log */
1271 if (ost->logfile && enc->stats_out) {
1272 fprintf(ost->logfile, "%s", enc->stats_out);
1277 ost->frame_number++;
1281 static double psnr(double d){
1282 return -10.0*log(d)/log(10.0);
1285 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1288 AVCodecContext *enc;
1290 double ti1, bitrate, avg_bitrate;
1292 /* this is executed just the first time do_video_stats is called */
1294 vstats_file = fopen(vstats_filename, "w");
1301 enc = ost->st->codec;
1302 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1303 frame_number = ost->frame_number;
1304 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1305 if (enc->flags&CODEC_FLAG_PSNR)
1306 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1308 fprintf(vstats_file,"f_size= %6d ", frame_size);
1309 /* compute pts value */
1310 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1314 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1315 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1316 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1317 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1318 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1322 static void print_report(AVFormatContext **output_files,
1323 OutputStream **ost_table, int nb_ostreams,
1328 AVFormatContext *oc;
1330 AVCodecContext *enc;
1331 int frame_number, vid, i;
1332 double bitrate, ti1, pts;
1333 static int64_t last_time = -1;
1334 static int qp_histogram[52];
1336 if (!is_last_report) {
1338 /* display the report every 0.5 seconds */
1339 cur_time = av_gettime();
1340 if (last_time == -1) {
1341 last_time = cur_time;
1344 if ((cur_time - last_time) < 500000)
1346 last_time = cur_time;
1350 oc = output_files[0];
1352 total_size = avio_size(oc->pb);
1353 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1354 total_size= avio_tell(oc->pb);
1359 for(i=0;i<nb_ostreams;i++) {
1362 enc = ost->st->codec;
1363 if (!ost->st->stream_copy && enc->coded_frame)
1364 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1365 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1368 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1369 float t = (av_gettime()-timer_start) / 1000000.0;
1371 frame_number = ost->frame_number;
1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1373 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1375 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1379 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1384 if (enc->flags&CODEC_FLAG_PSNR){
1386 double error, error_sum=0;
1387 double scale, scale_sum=0;
1388 char type[3]= {'Y','U','V'};
1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1392 error= enc->error[j];
1393 scale= enc->width*enc->height*255.0*255.0*frame_number;
1395 error= enc->coded_frame->error[j];
1396 scale= enc->width*enc->height*255.0*255.0;
1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1403 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1407 /* compute min output value */
1408 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1409 if ((pts < ti1) && (pts > 0))
1415 if (verbose > 0 || is_last_report) {
1416 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1419 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1420 (double)total_size / 1024, ti1, bitrate);
1422 if (nb_frames_dup || nb_frames_drop)
1423 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1424 nb_frames_dup, nb_frames_drop);
1427 fprintf(stderr, "%s \r", buf);
1432 if (is_last_report && verbose >= 0){
1433 int64_t raw= audio_size + video_size + extra_size;
1434 fprintf(stderr, "\n");
1435 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1439 100.0*(total_size - raw)/raw
1444 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1446 int fill_char = 0x00;
1447 if (sample_fmt == AV_SAMPLE_FMT_U8)
1449 memset(buf, fill_char, size);
1452 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1453 static int output_packet(InputStream *ist, int ist_index,
1454 OutputStream **ost_table, int nb_ostreams,
1455 const AVPacket *pkt)
1457 AVFormatContext *os;
1462 void *buffer_to_free = NULL;
1463 static unsigned int samples_size= 0;
1464 AVSubtitle subtitle, *subtitle_to_free;
1465 int64_t pkt_pts = AV_NOPTS_VALUE;
1467 int frame_available;
1472 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1474 if(ist->next_pts == AV_NOPTS_VALUE)
1475 ist->next_pts= ist->pts;
1479 av_init_packet(&avpkt);
1487 if(pkt->dts != AV_NOPTS_VALUE)
1488 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1489 if(pkt->pts != AV_NOPTS_VALUE)
1490 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1492 //while we have more to decode or while the decoder did output something on EOF
1493 while (avpkt.size > 0 || (!pkt && got_output)) {
1494 uint8_t *data_buf, *decoded_data_buf;
1495 int data_size, decoded_data_size;
1497 ist->pts= ist->next_pts;
1499 if(avpkt.size && avpkt.size != pkt->size &&
1500 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1501 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1502 ist->showed_multi_packet_warning=1;
1505 /* decode the packet if needed */
1506 decoded_data_buf = NULL; /* fail safe */
1507 decoded_data_size= 0;
1508 data_buf = avpkt.data;
1509 data_size = avpkt.size;
1510 subtitle_to_free = NULL;
1511 if (ist->decoding_needed) {
1512 switch(ist->st->codec->codec_type) {
1513 case AVMEDIA_TYPE_AUDIO:{
1514 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1515 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1517 samples= av_malloc(samples_size);
1519 decoded_data_size= samples_size;
1520 /* XXX: could avoid copy if PCM 16 bits with same
1521 endianness as CPU */
1522 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1529 got_output = decoded_data_size > 0;
1530 /* Some bug in mpeg audio decoder gives */
1531 /* decoded_data_size < 0, it seems they are overflows */
1533 /* no audio frame */
1536 decoded_data_buf = (uint8_t *)samples;
1537 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1538 (ist->st->codec->sample_rate * ist->st->codec->channels);
1540 case AVMEDIA_TYPE_VIDEO:
1541 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1542 /* XXX: allocate picture correctly */
1543 avcodec_get_frame_defaults(&picture);
1544 avpkt.pts = pkt_pts;
1545 avpkt.dts = ist->pts;
1546 pkt_pts = AV_NOPTS_VALUE;
1548 ret = avcodec_decode_video2(ist->st->codec,
1549 &picture, &got_output, &avpkt);
1550 quality = same_quality ? picture.quality : 0;
1554 /* no picture yet */
1555 goto discard_packet;
1557 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1558 if (ist->st->codec->time_base.num != 0) {
1559 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1560 ist->next_pts += ((int64_t)AV_TIME_BASE *
1561 ist->st->codec->time_base.num * ticks) /
1562 ist->st->codec->time_base.den;
1565 buffer_to_free = NULL;
1566 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1568 case AVMEDIA_TYPE_SUBTITLE:
1569 ret = avcodec_decode_subtitle2(ist->st->codec,
1570 &subtitle, &got_output, &avpkt);
1574 goto discard_packet;
1576 subtitle_to_free = &subtitle;
1583 switch(ist->st->codec->codec_type) {
1584 case AVMEDIA_TYPE_AUDIO:
1585 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1586 ist->st->codec->sample_rate;
1588 case AVMEDIA_TYPE_VIDEO:
1589 if (ist->st->codec->time_base.num != 0) {
1590 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1591 ist->next_pts += ((int64_t)AV_TIME_BASE *
1592 ist->st->codec->time_base.num * ticks) /
1593 ist->st->codec->time_base.den;
1602 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1603 for (i = 0; i < nb_ostreams; i++) {
1605 if (ost->input_video_filter && ost->source_index == ist_index) {
1607 if (ist->st->sample_aspect_ratio.num)
1608 sar = ist->st->sample_aspect_ratio;
1610 sar = ist->st->codec->sample_aspect_ratio;
1611 // add it to be filtered
1612 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1620 // preprocess audio (volume)
1621 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1622 if (audio_volume != 256) {
1625 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1626 int v = ((*volp) * audio_volume + 128) >> 8;
1627 if (v < -32768) v = -32768;
1628 if (v > 32767) v = 32767;
1634 /* frame rate emulation */
1636 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1637 int64_t now = av_gettime() - ist->start;
1641 /* if output time reached then transcode raw format,
1642 encode packets and output them */
1643 if (start_time == 0 || ist->pts >= start_time)
1644 for(i=0;i<nb_ostreams;i++) {
1648 if (ost->source_index == ist_index) {
1650 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1651 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1652 while (frame_available) {
1653 AVRational ist_pts_tb;
1654 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1655 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1657 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1659 os = output_files[ost->file_index];
1661 /* set the input output pts pairs */
1662 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1664 if (ost->encoding_needed) {
1665 av_assert0(ist->decoding_needed);
1666 switch(ost->st->codec->codec_type) {
1667 case AVMEDIA_TYPE_AUDIO:
1668 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1670 case AVMEDIA_TYPE_VIDEO:
1672 if (ost->picref->video && !ost->frame_aspect_ratio)
1673 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1675 do_video_out(os, ost, ist, &picture, &frame_size,
1676 same_quality ? quality : ost->st->codec->global_quality);
1677 if (vstats_filename && frame_size)
1678 do_video_stats(os, ost, frame_size);
1680 case AVMEDIA_TYPE_SUBTITLE:
1681 do_subtitle_out(os, ost, ist, &subtitle,
1688 AVFrame avframe; //FIXME/XXX remove this
1690 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1692 av_init_packet(&opkt);
1694 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1695 #if !CONFIG_AVFILTER
1701 /* no reencoding needed : output the packet directly */
1702 /* force the input stream PTS */
1704 avcodec_get_frame_defaults(&avframe);
1705 ost->st->codec->coded_frame= &avframe;
1706 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1708 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1709 audio_size += data_size;
1710 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1711 video_size += data_size;
1715 opkt.stream_index= ost->index;
1716 if(pkt->pts != AV_NOPTS_VALUE)
1717 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1719 opkt.pts= AV_NOPTS_VALUE;
1721 if (pkt->dts == AV_NOPTS_VALUE)
1722 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1724 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1725 opkt.dts -= ost_tb_start_time;
1727 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1728 opkt.flags= pkt->flags;
1730 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1731 if( ost->st->codec->codec_id != CODEC_ID_H264
1732 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1733 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1735 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1736 opkt.destruct= av_destruct_packet;
1738 opkt.data = data_buf;
1739 opkt.size = data_size;
1742 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1743 ost->st->codec->frame_number++;
1744 ost->frame_number++;
1745 av_free_packet(&opkt);
1749 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1750 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1752 avfilter_unref_buffer(ost->picref);
1758 av_free(buffer_to_free);
1759 /* XXX: allocate the subtitles in the codec ? */
1760 if (subtitle_to_free) {
1761 avsubtitle_free(subtitle_to_free);
1762 subtitle_to_free = NULL;
1769 for(i=0;i<nb_ostreams;i++) {
1771 if (ost->source_index == ist_index) {
1772 AVCodecContext *enc= ost->st->codec;
1773 os = output_files[ost->file_index];
1775 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1777 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1780 if (ost->encoding_needed) {
1784 av_init_packet(&pkt);
1785 pkt.stream_index= ost->index;
1787 switch(ost->st->codec->codec_type) {
1788 case AVMEDIA_TYPE_AUDIO:
1789 fifo_bytes = av_fifo_size(ost->fifo);
1791 /* encode any samples remaining in fifo */
1792 if (fifo_bytes > 0) {
1793 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1794 int fs_tmp = enc->frame_size;
1796 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1797 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1798 enc->frame_size = fifo_bytes / (osize * enc->channels);
1800 int frame_bytes = enc->frame_size*osize*enc->channels;
1801 if (allocated_audio_buf_size < frame_bytes)
1803 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1806 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1807 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1808 ost->st->time_base.num, enc->sample_rate);
1809 enc->frame_size = fs_tmp;
1812 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1815 fprintf(stderr, "Audio encoding failed\n");
1819 pkt.flags |= AV_PKT_FLAG_KEY;
1821 case AVMEDIA_TYPE_VIDEO:
1822 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1824 fprintf(stderr, "Video encoding failed\n");
1828 if(enc->coded_frame && enc->coded_frame->key_frame)
1829 pkt.flags |= AV_PKT_FLAG_KEY;
1830 if (ost->logfile && enc->stats_out) {
1831 fprintf(ost->logfile, "%s", enc->stats_out);
1840 pkt.data= bit_buffer;
1842 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1843 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1844 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1854 static void print_sdp(AVFormatContext **avc, int n)
1858 av_sdp_create(avc, n, sdp, sizeof(sdp));
1859 printf("SDP:\n%s\n", sdp);
1863 static int copy_chapters(int infile, int outfile)
1865 AVFormatContext *is = input_files[infile].ctx;
1866 AVFormatContext *os = output_files[outfile];
1869 for (i = 0; i < is->nb_chapters; i++) {
1870 AVChapter *in_ch = is->chapters[i], *out_ch;
1871 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1872 AV_TIME_BASE_Q, in_ch->time_base);
1873 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1874 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1877 if (in_ch->end < ts_off)
1879 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1882 out_ch = av_mallocz(sizeof(AVChapter));
1884 return AVERROR(ENOMEM);
1886 out_ch->id = in_ch->id;
1887 out_ch->time_base = in_ch->time_base;
1888 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1889 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1891 if (metadata_chapters_autocopy)
1892 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1895 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1897 return AVERROR(ENOMEM);
1898 os->chapters[os->nb_chapters - 1] = out_ch;
1903 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1904 AVCodecContext *avctx)
1910 for (p = kf; *p; p++)
1913 ost->forced_kf_count = n;
1914 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1915 if (!ost->forced_kf_pts) {
1916 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1919 for (i = 0; i < n; i++) {
1920 p = i ? strchr(p, ',') + 1 : kf;
1921 t = parse_time_or_die("force_key_frames", p, 1);
1922 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1927 * The following code is the main loop of the file converter
1929 static int transcode(AVFormatContext **output_files,
1930 int nb_output_files,
1931 InputFile *input_files,
1933 StreamMap *stream_maps, int nb_stream_maps)
1935 int ret = 0, i, j, k, n, nb_ostreams = 0;
1936 AVFormatContext *is, *os;
1937 AVCodecContext *codec, *icodec;
1938 OutputStream *ost, **ost_table = NULL;
1942 uint8_t no_packet[MAX_FILES]={0};
1943 int no_packet_count=0;
1946 for (i = 0; i < nb_input_streams; i++)
1947 input_streams[i].start = av_gettime();
1949 /* output stream init */
1951 for(i=0;i<nb_output_files;i++) {
1952 os = output_files[i];
1953 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1954 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1955 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1956 ret = AVERROR(EINVAL);
1959 nb_ostreams += os->nb_streams;
1961 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1962 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1963 ret = AVERROR(EINVAL);
1967 /* Sanity check the mapping args -- do the input files & streams exist? */
1968 for(i=0;i<nb_stream_maps;i++) {
1969 int fi = stream_maps[i].file_index;
1970 int si = stream_maps[i].stream_index;
1972 if (fi < 0 || fi > nb_input_files - 1 ||
1973 si < 0 || si > input_files[fi].nb_streams - 1) {
1974 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1975 ret = AVERROR(EINVAL);
1978 fi = stream_maps[i].sync_file_index;
1979 si = stream_maps[i].sync_stream_index;
1980 if (fi < 0 || fi > nb_input_files - 1 ||
1981 si < 0 || si > input_files[fi].nb_streams - 1) {
1982 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1983 ret = AVERROR(EINVAL);
1988 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1992 for(k=0;k<nb_output_files;k++) {
1993 os = output_files[k];
1994 for(i=0;i<os->nb_streams;i++,n++) {
1996 ost = ost_table[n] = output_streams_for_file[k][i];
1997 if (nb_stream_maps > 0) {
1998 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
1999 stream_maps[n].stream_index;
2001 /* Sanity check that the stream types match */
2002 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2003 int i= ost->file_index;
2004 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2005 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2006 stream_maps[n].file_index, stream_maps[n].stream_index,
2007 ost->file_index, ost->index);
2012 int best_nb_frames=-1;
2013 /* get corresponding input stream index : we select the first one with the right type */
2015 for (j = 0; j < nb_input_streams; j++) {
2017 ist = &input_streams[j];
2020 AVFormatContext *f = input_files[ist->file_index].ctx;
2022 for(pi=0; pi<f->nb_programs; pi++){
2023 AVProgram *p= f->programs[pi];
2024 if(p->id == opt_programid)
2025 for(si=0; si<p->nb_stream_indexes; si++){
2026 if(f->streams[ p->stream_index[si] ] == ist->st)
2031 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2032 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2033 if(best_nb_frames < ist->st->codec_info_nb_frames){
2034 best_nb_frames= ist->st->codec_info_nb_frames;
2035 ost->source_index = j;
2042 if(! opt_programid) {
2043 /* try again and reuse existing stream */
2044 for (j = 0; j < nb_input_streams; j++) {
2045 ist = &input_streams[j];
2046 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2047 && ist->st->discard != AVDISCARD_ALL) {
2048 ost->source_index = j;
2054 int i= ost->file_index;
2055 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2056 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2057 ost->file_index, ost->index);
2062 ist = &input_streams[ost->source_index];
2064 ost->sync_ist = (nb_stream_maps > 0) ?
2065 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2066 stream_maps[n].sync_stream_index] : ist;
2070 /* for each output stream, we compute the right encoding parameters */
2071 for(i=0;i<nb_ostreams;i++) {
2073 os = output_files[ost->file_index];
2074 ist = &input_streams[ost->source_index];
2076 codec = ost->st->codec;
2077 icodec = ist->st->codec;
2079 if (metadata_streams_autocopy)
2080 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2081 AV_DICT_DONT_OVERWRITE);
2083 ost->st->disposition = ist->st->disposition;
2084 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2085 codec->chroma_sample_location = icodec->chroma_sample_location;
2087 if (ost->st->stream_copy) {
2088 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2090 if (extra_size > INT_MAX)
2093 /* if stream_copy is selected, no need to decode or encode */
2094 codec->codec_id = icodec->codec_id;
2095 codec->codec_type = icodec->codec_type;
2097 if(!codec->codec_tag){
2098 if( !os->oformat->codec_tag
2099 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2100 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2101 codec->codec_tag = icodec->codec_tag;
2104 codec->bit_rate = icodec->bit_rate;
2105 codec->rc_max_rate = icodec->rc_max_rate;
2106 codec->rc_buffer_size = icodec->rc_buffer_size;
2107 codec->extradata= av_mallocz(extra_size);
2108 if (!codec->extradata)
2110 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2111 codec->extradata_size= icodec->extradata_size;
2112 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){
2113 codec->time_base = icodec->time_base;
2114 codec->time_base.num *= icodec->ticks_per_frame;
2115 av_reduce(&codec->time_base.num, &codec->time_base.den,
2116 codec->time_base.num, codec->time_base.den, INT_MAX);
2118 codec->time_base = ist->st->time_base;
2119 switch(codec->codec_type) {
2120 case AVMEDIA_TYPE_AUDIO:
2121 if(audio_volume != 256) {
2122 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2125 codec->channel_layout = icodec->channel_layout;
2126 codec->sample_rate = icodec->sample_rate;
2127 codec->channels = icodec->channels;
2128 codec->frame_size = icodec->frame_size;
2129 codec->audio_service_type = icodec->audio_service_type;
2130 codec->block_align= icodec->block_align;
2131 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2132 codec->block_align= 0;
2133 if(codec->codec_id == CODEC_ID_AC3)
2134 codec->block_align= 0;
2136 case AVMEDIA_TYPE_VIDEO:
2137 codec->pix_fmt = icodec->pix_fmt;
2138 codec->width = icodec->width;
2139 codec->height = icodec->height;
2140 codec->has_b_frames = icodec->has_b_frames;
2141 if (!codec->sample_aspect_ratio.num) {
2142 codec->sample_aspect_ratio =
2143 ost->st->sample_aspect_ratio =
2144 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2145 ist->st->codec->sample_aspect_ratio.num ?
2146 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2149 case AVMEDIA_TYPE_SUBTITLE:
2150 codec->width = icodec->width;
2151 codec->height = icodec->height;
2153 case AVMEDIA_TYPE_DATA:
2160 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2161 switch(codec->codec_type) {
2162 case AVMEDIA_TYPE_AUDIO:
2163 ost->fifo= av_fifo_alloc(1024);
2166 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2167 if (!codec->sample_rate) {
2168 codec->sample_rate = icodec->sample_rate;
2170 codec->sample_rate >>= icodec->lowres;
2172 choose_sample_rate(ost->st, ost->enc);
2173 codec->time_base = (AVRational){1, codec->sample_rate};
2174 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2175 codec->sample_fmt = icodec->sample_fmt;
2176 choose_sample_fmt(ost->st, ost->enc);
2177 if (!codec->channels)
2178 codec->channels = icodec->channels;
2179 codec->channel_layout = icodec->channel_layout;
2180 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2181 codec->channel_layout = 0;
2182 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2183 icodec->request_channels = codec->channels;
2184 ist->decoding_needed = 1;
2185 ost->encoding_needed = 1;
2186 ost->resample_sample_fmt = icodec->sample_fmt;
2187 ost->resample_sample_rate = icodec->sample_rate;
2188 ost->resample_channels = icodec->channels;
2190 case AVMEDIA_TYPE_VIDEO:
2191 if (codec->pix_fmt == PIX_FMT_NONE)
2192 codec->pix_fmt = icodec->pix_fmt;
2193 choose_pixel_fmt(ost->st, ost->enc);
2195 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2196 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2200 if (!codec->width || !codec->height) {
2201 codec->width = icodec->width;
2202 codec->height = icodec->height;
2205 ost->video_resample = codec->width != icodec->width ||
2206 codec->height != icodec->height ||
2207 codec->pix_fmt != icodec->pix_fmt;
2208 if (ost->video_resample) {
2209 #if !CONFIG_AVFILTER
2210 avcodec_get_frame_defaults(&ost->pict_tmp);
2211 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2212 codec->width, codec->height)) {
2213 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2216 ost->img_resample_ctx = sws_getContext(
2223 ost->sws_flags, NULL, NULL, NULL);
2224 if (ost->img_resample_ctx == NULL) {
2225 fprintf(stderr, "Cannot get resampling context\n");
2229 codec->bits_per_raw_sample= 0;
2232 ost->resample_height = icodec->height;
2233 ost->resample_width = icodec->width;
2234 ost->resample_pix_fmt= icodec->pix_fmt;
2235 ost->encoding_needed = 1;
2236 ist->decoding_needed = 1;
2238 if (!ost->frame_rate.num)
2239 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2240 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2241 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2242 ost->frame_rate = ost->enc->supported_framerates[idx];
2244 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2247 if (configure_video_filters(ist, ost)) {
2248 fprintf(stderr, "Error opening filters!\n");
2253 case AVMEDIA_TYPE_SUBTITLE:
2254 ost->encoding_needed = 1;
2255 ist->decoding_needed = 1;
2262 if (ost->encoding_needed &&
2263 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2264 char logfilename[1024];
2267 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2268 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2270 if (codec->flags & CODEC_FLAG_PASS1) {
2271 f = fopen(logfilename, "wb");
2273 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2279 size_t logbuffer_size;
2280 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2281 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2284 codec->stats_in = logbuffer;
2288 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2289 int size= codec->width * codec->height;
2290 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2295 bit_buffer = av_malloc(bit_buffer_size);
2297 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2299 ret = AVERROR(ENOMEM);
2303 /* open each encoder */
2304 for(i=0;i<nb_ostreams;i++) {
2306 if (ost->encoding_needed) {
2307 AVCodec *codec = ost->enc;
2308 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2310 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2311 ost->st->codec->codec_id, ost->file_index, ost->index);
2312 ret = AVERROR(EINVAL);
2315 if (dec->subtitle_header) {
2316 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2317 if (!ost->st->codec->subtitle_header) {
2318 ret = AVERROR(ENOMEM);
2321 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2322 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2324 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2325 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2326 ost->file_index, ost->index);
2327 ret = AVERROR(EINVAL);
2330 assert_codec_experimental(ost->st->codec, 1);
2331 assert_avoptions(ost->opts);
2332 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2333 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2334 "It takes bits/s as argument, not kbits/s\n");
2335 extra_size += ost->st->codec->extradata_size;
2339 /* open each decoder */
2340 for (i = 0; i < nb_input_streams; i++) {
2341 ist = &input_streams[i];
2342 if (ist->decoding_needed) {
2343 AVCodec *codec = ist->dec;
2345 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2347 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2348 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2349 ret = AVERROR(EINVAL);
2353 /* update requested sample format for the decoder based on the
2354 corresponding encoder sample format */
2355 for (j = 0; j < nb_ostreams; j++) {
2357 if (ost->source_index == i) {
2358 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2363 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2364 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2365 ist->file_index, ist->st->index);
2366 ret = AVERROR(EINVAL);
2369 assert_codec_experimental(ist->st->codec, 0);
2370 assert_avoptions(ost->opts);
2375 for (i = 0; i < nb_input_streams; i++) {
2377 ist = &input_streams[i];
2379 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2380 ist->next_pts = AV_NOPTS_VALUE;
2381 init_pts_correction(&ist->pts_ctx);
2385 /* set meta data information from input file if required */
2386 for (i=0;i<nb_meta_data_maps;i++) {
2387 AVFormatContext *files[2];
2388 AVDictionary **meta[2];
2391 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2392 if ((index) < 0 || (index) >= (nb_elems)) {\
2393 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2395 ret = AVERROR(EINVAL);\
2399 int out_file_index = meta_data_maps[i][0].file;
2400 int in_file_index = meta_data_maps[i][1].file;
2401 if (in_file_index < 0 || out_file_index < 0)
2403 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2404 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2406 files[0] = output_files[out_file_index];
2407 files[1] = input_files[in_file_index].ctx;
2409 for (j = 0; j < 2; j++) {
2410 MetadataMap *map = &meta_data_maps[i][j];
2412 switch (map->type) {
2414 meta[j] = &files[j]->metadata;
2417 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2418 meta[j] = &files[j]->streams[map->index]->metadata;
2421 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2422 meta[j] = &files[j]->chapters[map->index]->metadata;
2425 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2426 meta[j] = &files[j]->programs[map->index]->metadata;
2431 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2434 /* copy global metadata by default */
2435 if (metadata_global_autocopy) {
2437 for (i = 0; i < nb_output_files; i++)
2438 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2439 AV_DICT_DONT_OVERWRITE);
2442 /* copy chapters according to chapter maps */
2443 for (i = 0; i < nb_chapter_maps; i++) {
2444 int infile = chapter_maps[i].in_file;
2445 int outfile = chapter_maps[i].out_file;
2447 if (infile < 0 || outfile < 0)
2449 if (infile >= nb_input_files) {
2450 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2451 ret = AVERROR(EINVAL);
2454 if (outfile >= nb_output_files) {
2455 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2456 ret = AVERROR(EINVAL);
2459 copy_chapters(infile, outfile);
2462 /* copy chapters from the first input file that has them*/
2463 if (!nb_chapter_maps)
2464 for (i = 0; i < nb_input_files; i++) {
2465 if (!input_files[i].ctx->nb_chapters)
2468 for (j = 0; j < nb_output_files; j++)
2469 if ((ret = copy_chapters(i, j)) < 0)
2474 /* open files and write file headers */
2475 for(i=0;i<nb_output_files;i++) {
2476 os = output_files[i];
2477 if (avformat_write_header(os, &output_opts[i]) < 0) {
2478 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2479 ret = AVERROR(EINVAL);
2482 assert_avoptions(output_opts[i]);
2483 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2489 /* dump the file output parameters - cannot be done before in case
2491 for(i=0;i<nb_output_files;i++) {
2492 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2495 /* dump the stream mapping */
2497 fprintf(stderr, "Stream mapping:\n");
2498 for(i=0;i<nb_ostreams;i++) {
2500 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2501 input_streams[ost->source_index].file_index,
2502 input_streams[ost->source_index].st->index,
2505 if (ost->sync_ist != &input_streams[ost->source_index])
2506 fprintf(stderr, " [sync #%d.%d]",
2507 ost->sync_ist->file_index,
2508 ost->sync_ist->st->index);
2509 fprintf(stderr, "\n");
2514 fprintf(stderr, "%s\n", error);
2519 print_sdp(output_files, nb_output_files);
2523 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2526 timer_start = av_gettime();
2528 for(; received_sigterm == 0;) {
2529 int file_index, ist_index;
2538 /* select the stream that we must read now by looking at the
2539 smallest output pts */
2541 for(i=0;i<nb_ostreams;i++) {
2544 os = output_files[ost->file_index];
2545 ist = &input_streams[ost->source_index];
2546 if(ist->is_past_recording_time || no_packet[ist->file_index])
2548 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2549 ipts = (double)ist->pts;
2550 if (!input_files[ist->file_index].eof_reached){
2551 if(ipts < ipts_min) {
2553 if(input_sync ) file_index = ist->file_index;
2555 if(opts < opts_min) {
2557 if(!input_sync) file_index = ist->file_index;
2560 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2565 /* if none, if is finished */
2566 if (file_index < 0) {
2567 if(no_packet_count){
2569 memset(no_packet, 0, sizeof(no_packet));
2576 /* finish if limit size exhausted */
2577 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2580 /* read a frame from it and output it in the fifo */
2581 is = input_files[file_index].ctx;
2582 ret= av_read_frame(is, &pkt);
2583 if(ret == AVERROR(EAGAIN)){
2584 no_packet[file_index]=1;
2589 input_files[file_index].eof_reached = 1;
2597 memset(no_packet, 0, sizeof(no_packet));
2600 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2601 is->streams[pkt.stream_index]);
2603 /* the following test is needed in case new streams appear
2604 dynamically in stream : we ignore them */
2605 if (pkt.stream_index >= input_files[file_index].nb_streams)
2606 goto discard_packet;
2607 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2608 ist = &input_streams[ist_index];
2610 goto discard_packet;
2612 if (pkt.dts != AV_NOPTS_VALUE)
2613 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2614 if (pkt.pts != AV_NOPTS_VALUE)
2615 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2617 if (ist->ts_scale) {
2618 if(pkt.pts != AV_NOPTS_VALUE)
2619 pkt.pts *= ist->ts_scale;
2620 if(pkt.dts != AV_NOPTS_VALUE)
2621 pkt.dts *= ist->ts_scale;
2624 // 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);
2625 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2626 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2627 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2628 int64_t delta= pkt_dts - ist->next_pts;
2629 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2630 input_files[ist->file_index].ts_offset -= delta;
2632 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2633 delta, input_files[ist->file_index].ts_offset);
2634 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2635 if(pkt.pts != AV_NOPTS_VALUE)
2636 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2640 /* finish if recording time exhausted */
2641 if (recording_time != INT64_MAX &&
2642 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2643 ist->is_past_recording_time = 1;
2644 goto discard_packet;
2647 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2648 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2651 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2652 ist->file_index, ist->st->index);
2655 av_free_packet(&pkt);
2660 av_free_packet(&pkt);
2662 /* dump report by using the output first video and audio streams */
2663 print_report(output_files, ost_table, nb_ostreams, 0);
2666 /* at the end of stream, we must flush the decoder buffers */
2667 for (i = 0; i < nb_input_streams; i++) {
2668 ist = &input_streams[i];
2669 if (ist->decoding_needed) {
2670 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2676 /* write the trailer if needed and close file */
2677 for(i=0;i<nb_output_files;i++) {
2678 os = output_files[i];
2679 av_write_trailer(os);
2682 /* dump report by using the first video and audio streams */
2683 print_report(output_files, ost_table, nb_ostreams, 1);
2685 /* close each encoder */
2686 for(i=0;i<nb_ostreams;i++) {
2688 if (ost->encoding_needed) {
2689 av_freep(&ost->st->codec->stats_in);
2690 avcodec_close(ost->st->codec);
2693 avfilter_graph_free(&ost->graph);
2697 /* close each decoder */
2698 for (i = 0; i < nb_input_streams; i++) {
2699 ist = &input_streams[i];
2700 if (ist->decoding_needed) {
2701 avcodec_close(ist->st->codec);
2709 av_freep(&bit_buffer);
2712 for(i=0;i<nb_ostreams;i++) {
2715 if (ost->st->stream_copy)
2716 av_freep(&ost->st->codec->extradata);
2718 fclose(ost->logfile);
2719 ost->logfile = NULL;
2721 av_fifo_free(ost->fifo); /* works even if fifo is not
2722 initialized but set to zero */
2723 av_freep(&ost->st->codec->subtitle_header);
2724 av_free(ost->pict_tmp.data[0]);
2725 av_free(ost->forced_kf_pts);
2726 if (ost->video_resample)
2727 sws_freeContext(ost->img_resample_ctx);
2729 audio_resample_close(ost->resample);
2730 if (ost->reformat_ctx)
2731 av_audio_convert_free(ost->reformat_ctx);
2732 av_dict_free(&ost->opts);
2741 static int opt_format(const char *opt, const char *arg)
2743 last_asked_format = arg;
2747 static int opt_video_rc_override_string(const char *opt, const char *arg)
2749 video_rc_override_string = arg;
2753 static int opt_me_threshold(const char *opt, const char *arg)
2755 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2759 static int opt_verbose(const char *opt, const char *arg)
2761 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2765 static int opt_frame_rate(const char *opt, const char *arg)
2767 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2768 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2774 static int opt_frame_crop(const char *opt, const char *arg)
2776 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2777 return AVERROR(EINVAL);
2780 static int opt_frame_size(const char *opt, const char *arg)
2782 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2783 fprintf(stderr, "Incorrect frame size\n");
2784 return AVERROR(EINVAL);
2789 static int opt_pad(const char *opt, const char *arg) {
2790 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2794 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2796 if (strcmp(arg, "list")) {
2797 frame_pix_fmt = av_get_pix_fmt(arg);
2798 if (frame_pix_fmt == PIX_FMT_NONE) {
2799 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2800 return AVERROR(EINVAL);
2809 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2816 p = strchr(arg, ':');
2818 x = strtol(arg, &end, 10);
2820 y = strtol(end+1, &end, 10);
2822 ar = (double)x / (double)y;
2824 ar = strtod(arg, NULL);
2827 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2828 return AVERROR(EINVAL);
2830 frame_aspect_ratio = ar;
2834 static int opt_metadata(const char *opt, const char *arg)
2836 char *mid= strchr(arg, '=');
2839 fprintf(stderr, "Missing =\n");
2844 av_dict_set(&metadata, arg, mid, 0);
2849 static int opt_qscale(const char *opt, const char *arg)
2851 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2852 if (video_qscale == 0) {
2853 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2854 return AVERROR(EINVAL);
2859 static int opt_top_field_first(const char *opt, const char *arg)
2861 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2865 static int opt_thread_count(const char *opt, const char *arg)
2867 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2870 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2875 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2877 if (strcmp(arg, "list")) {
2878 audio_sample_fmt = av_get_sample_fmt(arg);
2879 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2880 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2881 return AVERROR(EINVAL);
2886 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2887 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2893 static int opt_audio_rate(const char *opt, const char *arg)
2895 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2899 static int opt_audio_channels(const char *opt, const char *arg)
2901 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2905 static int opt_video_channel(const char *opt, const char *arg)
2907 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2908 opt_default("channel", arg);
2912 static int opt_video_standard(const char *opt, const char *arg)
2914 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2915 opt_default("standard", arg);
2919 static int opt_codec(int *pstream_copy, char **pcodec_name,
2920 int codec_type, const char *arg)
2922 av_freep(pcodec_name);
2923 if (!strcmp(arg, "copy")) {
2926 *pcodec_name = av_strdup(arg);
2931 static int opt_audio_codec(const char *opt, const char *arg)
2933 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2936 static int opt_video_codec(const char *opt, const char *arg)
2938 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2941 static int opt_subtitle_codec(const char *opt, const char *arg)
2943 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2946 static int opt_data_codec(const char *opt, const char *arg)
2948 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2951 static int opt_codec_tag(const char *opt, const char *arg)
2954 uint32_t *codec_tag;
2956 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2957 !strcmp(opt, "vtag") ? &video_codec_tag :
2958 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2962 *codec_tag = strtol(arg, &tail, 0);
2964 *codec_tag = AV_RL32(arg);
2969 static int opt_map(const char *opt, const char *arg)
2974 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2975 m = &stream_maps[nb_stream_maps-1];
2977 m->file_index = strtol(arg, &p, 0);
2981 m->stream_index = strtol(p, &p, 0);
2984 m->sync_file_index = strtol(p, &p, 0);
2987 m->sync_stream_index = strtol(p, &p, 0);
2989 m->sync_file_index = m->file_index;
2990 m->sync_stream_index = m->stream_index;
2995 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3006 *index = strtol(++arg, endptr, 0);
3009 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3016 static int opt_map_metadata(const char *opt, const char *arg)
3018 MetadataMap *m, *m1;
3021 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3022 &nb_meta_data_maps, nb_meta_data_maps + 1);
3024 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3025 m->file = strtol(arg, &p, 0);
3026 parse_meta_type(p, &m->type, &m->index, &p);
3030 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3031 m1->file = strtol(p, &p, 0);
3032 parse_meta_type(p, &m1->type, &m1->index, &p);
3034 if (m->type == 'g' || m1->type == 'g')
3035 metadata_global_autocopy = 0;
3036 if (m->type == 's' || m1->type == 's')
3037 metadata_streams_autocopy = 0;
3038 if (m->type == 'c' || m1->type == 'c')
3039 metadata_chapters_autocopy = 0;
3044 static int opt_map_meta_data(const char *opt, const char *arg)
3046 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3047 "Use -map_metadata instead.\n");
3048 return opt_map_metadata(opt, arg);
3051 static int opt_map_chapters(const char *opt, const char *arg)
3056 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3057 nb_chapter_maps + 1);
3058 c = &chapter_maps[nb_chapter_maps - 1];
3059 c->out_file = strtol(arg, &p, 0);
3063 c->in_file = strtol(p, &p, 0);
3067 static int opt_input_ts_scale(const char *opt, const char *arg)
3069 unsigned int stream;
3073 stream = strtol(arg, &p, 0);
3076 scale= strtod(p, &p);
3078 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3079 ts_scale[stream] = scale;
3083 static int opt_recording_time(const char *opt, const char *arg)
3085 recording_time = parse_time_or_die(opt, arg, 1);
3089 static int opt_start_time(const char *opt, const char *arg)
3091 start_time = parse_time_or_die(opt, arg, 1);
3095 static int opt_recording_timestamp(const char *opt, const char *arg)
3098 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3099 struct tm time = *gmtime((time_t*)&recording_timestamp);
3100 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3101 opt_metadata("metadata", buf);
3103 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3104 "tag instead.\n", opt);
3108 static int opt_input_ts_offset(const char *opt, const char *arg)
3110 input_ts_offset = parse_time_or_die(opt, arg, 1);
3114 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3116 const char *codec_string = encoder ? "encoder" : "decoder";
3120 return CODEC_ID_NONE;
3122 avcodec_find_encoder_by_name(name) :
3123 avcodec_find_decoder_by_name(name);
3125 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3128 if(codec->type != type) {
3129 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3135 static int opt_input_file(const char *opt, const char *filename)
3137 AVFormatContext *ic;
3138 AVInputFormat *file_iformat = NULL;
3139 int err, i, ret, rfps, rfps_base;
3142 AVDictionary **opts;
3143 int orig_nb_streams; // number of streams before avformat_find_stream_info
3145 if (last_asked_format) {
3146 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3147 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3150 last_asked_format = NULL;
3153 if (!strcmp(filename, "-"))
3156 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3157 !strcmp(filename, "/dev/stdin");
3159 /* get default parameters from command line */
3160 ic = avformat_alloc_context();
3162 print_error(filename, AVERROR(ENOMEM));
3165 if (audio_sample_rate) {
3166 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3167 av_dict_set(&format_opts, "sample_rate", buf, 0);
3169 if (audio_channels) {
3170 snprintf(buf, sizeof(buf), "%d", audio_channels);
3171 av_dict_set(&format_opts, "channels", buf, 0);
3173 if (frame_rate.num) {
3174 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3175 av_dict_set(&format_opts, "framerate", buf, 0);
3177 if (frame_width && frame_height) {
3178 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3179 av_dict_set(&format_opts, "video_size", buf, 0);
3181 if (frame_pix_fmt != PIX_FMT_NONE)
3182 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3184 ic->video_codec_id =
3185 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3186 ic->audio_codec_id =
3187 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3188 ic->subtitle_codec_id=
3189 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3190 ic->flags |= AVFMT_FLAG_NONBLOCK;
3192 /* open the input file with generic libav function */
3193 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3195 print_error(filename, err);
3198 assert_avoptions(format_opts);
3203 for(i=0; i<ic->nb_streams; i++){
3204 ic->streams[i]->discard= AVDISCARD_ALL;
3206 for(i=0; i<ic->nb_programs; i++){
3207 AVProgram *p= ic->programs[i];
3208 if(p->id != opt_programid){
3209 p->discard = AVDISCARD_ALL;
3212 for(j=0; j<p->nb_stream_indexes; j++){
3213 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3218 fprintf(stderr, "Specified program id not found\n");
3225 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3226 ic->loop_input = loop_input;
3229 /* Set AVCodecContext options for avformat_find_stream_info */
3230 opts = setup_find_stream_info_opts(ic, codec_opts);
3231 orig_nb_streams = ic->nb_streams;
3233 /* If not enough info to get the stream parameters, we decode the
3234 first frames to get it. (used in mpeg case for example) */
3235 ret = avformat_find_stream_info(ic, opts);
3236 if (ret < 0 && verbose >= 0) {
3237 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3238 av_close_input_file(ic);
3242 timestamp = start_time;
3243 /* add the stream start time */
3244 if (ic->start_time != AV_NOPTS_VALUE)
3245 timestamp += ic->start_time;
3247 /* if seeking requested, we execute it */
3248 if (start_time != 0) {
3249 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3251 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3252 filename, (double)timestamp / AV_TIME_BASE);
3254 /* reset seek info */
3258 /* update the current parameters so that they match the one of the input stream */
3259 for(i=0;i<ic->nb_streams;i++) {
3260 AVStream *st = ic->streams[i];
3261 AVCodecContext *dec = st->codec;
3264 dec->thread_count = thread_count;
3266 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3267 ist = &input_streams[nb_input_streams - 1];
3269 ist->file_index = nb_input_files;
3271 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3273 if (i < nb_ts_scale)
3274 ist->ts_scale = ts_scale[i];
3276 switch (dec->codec_type) {
3277 case AVMEDIA_TYPE_AUDIO:
3278 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3280 st->discard= AVDISCARD_ALL;
3282 case AVMEDIA_TYPE_VIDEO:
3283 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3284 rfps = ic->streams[i]->r_frame_rate.num;
3285 rfps_base = ic->streams[i]->r_frame_rate.den;
3287 dec->flags |= CODEC_FLAG_EMU_EDGE;
3288 dec->height >>= dec->lowres;
3289 dec->width >>= dec->lowres;
3292 dec->debug |= FF_DEBUG_MV;
3294 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3297 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3298 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3300 (float)rfps / rfps_base, rfps, rfps_base);
3304 st->discard= AVDISCARD_ALL;
3305 else if(video_discard)
3306 st->discard= video_discard;
3308 case AVMEDIA_TYPE_DATA:
3310 case AVMEDIA_TYPE_SUBTITLE:
3311 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3312 if(subtitle_disable)
3313 st->discard = AVDISCARD_ALL;
3315 case AVMEDIA_TYPE_ATTACHMENT:
3316 case AVMEDIA_TYPE_UNKNOWN:
3323 /* dump the file content */
3325 av_dump_format(ic, nb_input_files, filename, 0);
3327 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3328 input_files[nb_input_files - 1].ctx = ic;
3329 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3330 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3331 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3333 frame_rate = (AVRational){0, 0};
3334 frame_pix_fmt = PIX_FMT_NONE;
3337 audio_sample_rate = 0;
3339 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3340 av_freep(&ts_scale);
3343 for (i = 0; i < orig_nb_streams; i++)
3344 av_dict_free(&opts[i]);
3346 av_freep(&video_codec_name);
3347 av_freep(&audio_codec_name);
3348 av_freep(&subtitle_codec_name);
3354 static void check_inputs(int *has_video_ptr,
3356 int *has_subtitle_ptr,
3359 int has_video, has_audio, has_subtitle, has_data, i, j;
3360 AVFormatContext *ic;
3367 for(j=0;j<nb_input_files;j++) {
3368 ic = input_files[j].ctx;
3369 for(i=0;i<ic->nb_streams;i++) {
3370 AVCodecContext *enc = ic->streams[i]->codec;
3371 switch(enc->codec_type) {
3372 case AVMEDIA_TYPE_AUDIO:
3375 case AVMEDIA_TYPE_VIDEO:
3378 case AVMEDIA_TYPE_SUBTITLE:
3381 case AVMEDIA_TYPE_DATA:
3382 case AVMEDIA_TYPE_ATTACHMENT:
3383 case AVMEDIA_TYPE_UNKNOWN:
3391 *has_video_ptr = has_video;
3392 *has_audio_ptr = has_audio;
3393 *has_subtitle_ptr = has_subtitle;
3394 *has_data_ptr = has_data;
3397 static void new_video_stream(AVFormatContext *oc, int file_idx)
3401 AVCodecContext *video_enc;
3402 enum CodecID codec_id = CODEC_ID_NONE;
3403 AVCodec *codec= NULL;
3405 if(!video_stream_copy){
3406 if (video_codec_name) {
3407 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3408 codec = avcodec_find_encoder_by_name(video_codec_name);
3410 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3411 codec = avcodec_find_encoder(codec_id);
3415 ost = new_output_stream(oc, file_idx, codec);
3417 if (!video_stream_copy) {
3418 ost->frame_aspect_ratio = frame_aspect_ratio;
3419 frame_aspect_ratio = 0;
3421 ost->avfilter= vfilters;
3426 ost->bitstream_filters = video_bitstream_filters;
3427 video_bitstream_filters= NULL;
3429 st->codec->thread_count= thread_count;
3431 video_enc = st->codec;
3434 video_enc->codec_tag= video_codec_tag;
3436 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3437 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3440 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3441 if (video_stream_copy) {
3442 st->stream_copy = 1;
3443 video_enc->sample_aspect_ratio =
3444 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3450 ost->frame_rate = frame_rate;
3451 video_enc->codec_id = codec_id;
3453 video_enc->width = frame_width;
3454 video_enc->height = frame_height;
3455 video_enc->pix_fmt = frame_pix_fmt;
3456 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3459 video_enc->gop_size = 0;
3460 if (video_qscale || same_quality) {
3461 video_enc->flags |= CODEC_FLAG_QSCALE;
3462 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3466 video_enc->intra_matrix = intra_matrix;
3468 video_enc->inter_matrix = inter_matrix;
3470 p= video_rc_override_string;
3473 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3475 fprintf(stderr, "error parsing rc_override\n");
3478 video_enc->rc_override=
3479 av_realloc(video_enc->rc_override,
3480 sizeof(RcOverride)*(i+1));
3481 video_enc->rc_override[i].start_frame= start;
3482 video_enc->rc_override[i].end_frame = end;
3484 video_enc->rc_override[i].qscale= q;
3485 video_enc->rc_override[i].quality_factor= 1.0;
3488 video_enc->rc_override[i].qscale= 0;
3489 video_enc->rc_override[i].quality_factor= -q/100.0;
3494 video_enc->rc_override_count=i;
3495 if (!video_enc->rc_initial_buffer_occupancy)
3496 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3497 video_enc->me_threshold= me_threshold;
3498 video_enc->intra_dc_precision= intra_dc_precision - 8;
3501 video_enc->flags|= CODEC_FLAG_PSNR;
3506 video_enc->flags |= CODEC_FLAG_PASS1;
3508 video_enc->flags |= CODEC_FLAG_PASS2;
3512 if (forced_key_frames)
3513 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3515 if (video_language) {
3516 av_dict_set(&st->metadata, "language", video_language, 0);
3517 av_freep(&video_language);
3520 /* reset some key parameters */
3522 av_freep(&video_codec_name);
3523 av_freep(&forced_key_frames);
3524 video_stream_copy = 0;
3525 frame_pix_fmt = PIX_FMT_NONE;
3528 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3532 AVCodec *codec= NULL;
3533 AVCodecContext *audio_enc;
3534 enum CodecID codec_id = CODEC_ID_NONE;
3536 if(!audio_stream_copy){
3537 if (audio_codec_name) {
3538 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3539 codec = avcodec_find_encoder_by_name(audio_codec_name);
3541 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3542 codec = avcodec_find_encoder(codec_id);
3545 ost = new_output_stream(oc, file_idx, codec);
3548 ost->bitstream_filters = audio_bitstream_filters;
3549 audio_bitstream_filters= NULL;
3551 st->codec->thread_count= thread_count;
3553 audio_enc = st->codec;
3554 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3557 audio_enc->codec_tag= audio_codec_tag;
3559 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3560 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3562 if (audio_stream_copy) {
3563 st->stream_copy = 1;
3565 audio_enc->codec_id = codec_id;
3567 if (audio_qscale > QSCALE_NONE) {
3568 audio_enc->flags |= CODEC_FLAG_QSCALE;
3569 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3572 audio_enc->channels = audio_channels;
3573 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3574 audio_enc->sample_fmt = audio_sample_fmt;
3575 if (audio_sample_rate)
3576 audio_enc->sample_rate = audio_sample_rate;
3578 if (audio_language) {
3579 av_dict_set(&st->metadata, "language", audio_language, 0);
3580 av_freep(&audio_language);
3583 /* reset some key parameters */
3585 av_freep(&audio_codec_name);
3586 audio_stream_copy = 0;
3589 static void new_data_stream(AVFormatContext *oc, int file_idx)
3593 AVCodecContext *data_enc;
3595 ost = new_output_stream(oc, file_idx, NULL);
3597 data_enc = st->codec;
3598 if (!data_stream_copy) {
3599 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3603 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3606 data_enc->codec_tag= data_codec_tag;
3608 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3609 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3611 if (data_stream_copy) {
3612 st->stream_copy = 1;
3616 av_freep(&data_codec_name);
3617 data_stream_copy = 0;
3620 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3624 AVCodec *codec=NULL;
3625 AVCodecContext *subtitle_enc;
3626 enum CodecID codec_id = CODEC_ID_NONE;
3628 if(!subtitle_stream_copy){
3629 if (subtitle_codec_name) {
3630 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3631 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3633 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3634 codec = avcodec_find_encoder(codec_id);
3637 ost = new_output_stream(oc, file_idx, codec);
3639 subtitle_enc = st->codec;
3641 ost->bitstream_filters = subtitle_bitstream_filters;
3642 subtitle_bitstream_filters= NULL;
3644 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3646 if(subtitle_codec_tag)
3647 subtitle_enc->codec_tag= subtitle_codec_tag;
3649 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3650 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3652 if (subtitle_stream_copy) {
3653 st->stream_copy = 1;
3655 subtitle_enc->codec_id = codec_id;
3658 if (subtitle_language) {
3659 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3660 av_freep(&subtitle_language);
3663 subtitle_disable = 0;
3664 av_freep(&subtitle_codec_name);
3665 subtitle_stream_copy = 0;
3668 static int opt_new_stream(const char *opt, const char *arg)
3670 AVFormatContext *oc;
3671 int file_idx = nb_output_files - 1;
3672 if (nb_output_files <= 0) {
3673 fprintf(stderr, "At least one output file must be specified\n");
3676 oc = output_files[file_idx];
3678 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3679 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3680 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3681 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3686 /* arg format is "output-stream-index:streamid-value". */
3687 static int opt_streamid(const char *opt, const char *arg)
3693 av_strlcpy(idx_str, arg, sizeof(idx_str));
3694 p = strchr(idx_str, ':');
3697 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3702 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3703 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3704 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3708 static void opt_output_file(void *optctx, const char *filename)
3710 AVFormatContext *oc;
3711 int err, use_video, use_audio, use_subtitle, use_data;
3712 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3713 AVOutputFormat *file_oformat;
3715 if (!strcmp(filename, "-"))
3718 oc = avformat_alloc_context();
3720 print_error(filename, AVERROR(ENOMEM));
3724 if (last_asked_format) {
3725 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3726 if (!file_oformat) {
3727 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3730 last_asked_format = NULL;
3732 file_oformat = av_guess_format(NULL, filename, NULL);
3733 if (!file_oformat) {
3734 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3740 oc->oformat = file_oformat;
3741 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3743 if (!strcmp(file_oformat->name, "ffm") &&
3744 av_strstart(filename, "http:", NULL)) {
3745 /* special case for files sent to avserver: we get the stream
3746 parameters from avserver */
3747 int err = read_avserver_streams(oc, filename);
3749 print_error(filename, err);
3753 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3754 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3755 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3756 use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3758 /* disable if no corresponding type found */
3759 check_inputs(&input_has_video,
3761 &input_has_subtitle,
3764 if (!input_has_video)
3766 if (!input_has_audio)
3768 if (!input_has_subtitle)
3770 if (!input_has_data)
3773 /* manual disable */
3774 if (audio_disable) use_audio = 0;
3775 if (video_disable) use_video = 0;
3776 if (subtitle_disable) use_subtitle = 0;
3777 if (data_disable) use_data = 0;
3779 if (use_video) new_video_stream(oc, nb_output_files);
3780 if (use_audio) new_audio_stream(oc, nb_output_files);
3781 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3782 if (use_data) new_data_stream(oc, nb_output_files);
3784 av_dict_copy(&oc->metadata, metadata, 0);
3785 av_dict_free(&metadata);
3788 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3789 output_files[nb_output_files++] = oc;
3791 /* check filename in case of an image number is expected */
3792 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3793 if (!av_filename_number_test(oc->filename)) {
3794 print_error(oc->filename, AVERROR(EINVAL));
3799 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3800 /* test if it already exists to avoid losing precious files */
3801 if (!file_overwrite &&
3802 (strchr(filename, ':') == NULL ||
3803 filename[1] == ':' ||
3804 av_strstart(filename, "file:", NULL))) {
3805 if (avio_check(filename, 0) == 0) {
3807 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3809 if (!read_yesno()) {
3810 fprintf(stderr, "Not overwriting - exiting\n");
3815 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3822 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3823 print_error(filename, err);
3828 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3829 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3830 if (loop_output >= 0) {
3831 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3832 oc->loop_output = loop_output;
3834 oc->flags |= AVFMT_FLAG_NONBLOCK;
3836 frame_rate = (AVRational){0, 0};
3839 audio_sample_rate = 0;
3841 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3843 av_freep(&forced_key_frames);
3848 /* same option as mencoder */
3849 static int opt_pass(const char *opt, const char *arg)
3851 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3855 static int64_t getutime(void)
3858 struct rusage rusage;
3860 getrusage(RUSAGE_SELF, &rusage);
3861 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3862 #elif HAVE_GETPROCESSTIMES
3864 FILETIME c, e, k, u;
3865 proc = GetCurrentProcess();
3866 GetProcessTimes(proc, &c, &e, &k, &u);
3867 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3869 return av_gettime();
3873 static int64_t getmaxrss(void)
3875 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3876 struct rusage rusage;
3877 getrusage(RUSAGE_SELF, &rusage);
3878 return (int64_t)rusage.ru_maxrss * 1024;
3879 #elif HAVE_GETPROCESSMEMORYINFO
3881 PROCESS_MEMORY_COUNTERS memcounters;
3882 proc = GetCurrentProcess();
3883 memcounters.cb = sizeof(memcounters);
3884 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3885 return memcounters.PeakPagefileUsage;
3891 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3894 const char *p = str;
3901 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3908 static void opt_inter_matrix(const char *arg)
3910 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3911 parse_matrix_coeffs(inter_matrix, arg);
3914 static void opt_intra_matrix(const char *arg)
3916 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3917 parse_matrix_coeffs(intra_matrix, arg);
3920 static void show_usage(void)
3922 printf("Hyper fast Audio and Video encoder\n");
3923 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3927 static void show_help(void)
3930 AVOutputFormat *oformat = NULL;
3931 AVInputFormat *iformat = NULL;
3932 const AVClass *class;
3934 av_log_set_callback(log_callback_help);
3936 show_help_options(options, "Main options:\n",
3937 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3938 show_help_options(options, "\nAdvanced options:\n",
3939 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3941 show_help_options(options, "\nVideo options:\n",
3942 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3944 show_help_options(options, "\nAdvanced Video options:\n",
3945 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3946 OPT_VIDEO | OPT_EXPERT);
3947 show_help_options(options, "\nAudio options:\n",
3948 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3950 show_help_options(options, "\nAdvanced Audio options:\n",
3951 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3952 OPT_AUDIO | OPT_EXPERT);
3953 show_help_options(options, "\nSubtitle options:\n",
3954 OPT_SUBTITLE | OPT_GRAB,
3956 show_help_options(options, "\nAudio/Video grab options:\n",
3960 class = avcodec_get_class();
3961 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3964 /* individual codec options */
3966 while ((c = av_codec_next(c))) {
3967 if (c->priv_class) {
3968 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3973 class = avformat_get_class();
3974 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3977 /* individual muxer options */
3978 while ((oformat = av_oformat_next(oformat))) {
3979 if (oformat->priv_class) {
3980 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3985 /* individual demuxer options */
3986 while ((iformat = av_iformat_next(iformat))) {
3987 if (iformat->priv_class) {
3988 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3993 class = sws_get_class();
3994 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3997 static int opt_target(const char *opt, const char *arg)
3999 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4000 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4002 if(!strncmp(arg, "pal-", 4)) {
4005 } else if(!strncmp(arg, "ntsc-", 5)) {
4008 } else if(!strncmp(arg, "film-", 5)) {
4013 /* Calculate FR via float to avoid int overflow */
4014 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4017 } else if((fr == 29970) || (fr == 23976)) {
4020 /* Try to determine PAL/NTSC by peeking in the input files */
4021 if(nb_input_files) {
4023 for (j = 0; j < nb_input_files; j++) {
4024 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4025 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4026 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4028 fr = c->time_base.den * 1000 / c->time_base.num;
4032 } else if((fr == 29970) || (fr == 23976)) {
4042 if(verbose > 0 && norm != UNKNOWN)
4043 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4046 if(norm == UNKNOWN) {
4047 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4048 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4049 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4053 if(!strcmp(arg, "vcd")) {
4054 opt_video_codec("vcodec", "mpeg1video");
4055 opt_audio_codec("vcodec", "mp2");
4056 opt_format("f", "vcd");
4058 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4059 opt_frame_rate("r", frame_rates[norm]);
4060 opt_default("g", norm == PAL ? "15" : "18");
4062 opt_default("b", "1150000");
4063 opt_default("maxrate", "1150000");
4064 opt_default("minrate", "1150000");
4065 opt_default("bufsize", "327680"); // 40*1024*8;
4067 opt_default("ab", "224000");
4068 audio_sample_rate = 44100;
4071 opt_default("packetsize", "2324");
4072 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4074 /* We have to offset the PTS, so that it is consistent with the SCR.
4075 SCR starts at 36000, but the first two packs contain only padding
4076 and the first pack from the other stream, respectively, may also have
4077 been written before.
4078 So the real data starts at SCR 36000+3*1200. */
4079 mux_preload= (36000+3*1200) / 90000.0; //0.44
4080 } else if(!strcmp(arg, "svcd")) {
4082 opt_video_codec("vcodec", "mpeg2video");
4083 opt_audio_codec("acodec", "mp2");
4084 opt_format("f", "svcd");
4086 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4087 opt_frame_rate("r", frame_rates[norm]);
4088 opt_default("g", norm == PAL ? "15" : "18");
4090 opt_default("b", "2040000");
4091 opt_default("maxrate", "2516000");
4092 opt_default("minrate", "0"); //1145000;
4093 opt_default("bufsize", "1835008"); //224*1024*8;
4094 opt_default("flags", "+scan_offset");
4097 opt_default("ab", "224000");
4098 audio_sample_rate = 44100;
4100 opt_default("packetsize", "2324");
4102 } else if(!strcmp(arg, "dvd")) {
4104 opt_video_codec("vcodec", "mpeg2video");
4105 opt_audio_codec("vcodec", "ac3");
4106 opt_format("f", "dvd");
4108 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4109 opt_frame_rate("r", frame_rates[norm]);
4110 opt_default("g", norm == PAL ? "15" : "18");
4112 opt_default("b", "6000000");
4113 opt_default("maxrate", "9000000");
4114 opt_default("minrate", "0"); //1500000;
4115 opt_default("bufsize", "1835008"); //224*1024*8;
4117 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4118 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4120 opt_default("ab", "448000");
4121 audio_sample_rate = 48000;
4123 } else if(!strncmp(arg, "dv", 2)) {
4125 opt_format("f", "dv");
4127 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4128 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4129 norm == PAL ? "yuv420p" : "yuv411p");
4130 opt_frame_rate("r", frame_rates[norm]);
4132 audio_sample_rate = 48000;
4136 fprintf(stderr, "Unknown target: %s\n", arg);
4137 return AVERROR(EINVAL);
4142 static int opt_vstats_file(const char *opt, const char *arg)
4144 av_free (vstats_filename);
4145 vstats_filename=av_strdup (arg);
4149 static int opt_vstats(const char *opt, const char *arg)
4152 time_t today2 = time(NULL);
4153 struct tm *today = localtime(&today2);
4155 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4157 return opt_vstats_file(opt, filename);
4160 static int opt_bsf(const char *opt, const char *arg)
4162 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4163 AVBitStreamFilterContext **bsfp;
4166 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4170 bsfp= *opt == 'v' ? &video_bitstream_filters :
4171 *opt == 'a' ? &audio_bitstream_filters :
4172 &subtitle_bitstream_filters;
4174 bsfp= &(*bsfp)->next;
4181 static int opt_preset(const char *opt, const char *arg)
4184 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4185 char *codec_name = *opt == 'v' ? video_codec_name :
4186 *opt == 'a' ? audio_codec_name :
4187 subtitle_codec_name;
4189 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4190 fprintf(stderr, "File for preset '%s' not found\n", arg);
4195 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4196 if(line[0] == '#' && !e)
4198 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4200 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4203 if(!strcmp(tmp, "acodec")){
4204 opt_audio_codec(tmp, tmp2);
4205 }else if(!strcmp(tmp, "vcodec")){
4206 opt_video_codec(tmp, tmp2);
4207 }else if(!strcmp(tmp, "scodec")){
4208 opt_subtitle_codec(tmp, tmp2);
4209 }else if(!strcmp(tmp, "dcodec")){
4210 opt_data_codec(tmp, tmp2);
4211 }else if(opt_default(tmp, tmp2) < 0){
4212 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4222 static const OptionDef options[] = {
4224 #include "cmdutils_common_opts.h"
4225 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4226 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4227 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4228 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4229 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4230 "outfile[,metadata]:infile[,metadata]" },
4231 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4232 "outfile[,metadata]:infile[,metadata]" },
4233 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4234 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4235 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4236 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4237 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4238 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4239 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4240 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4241 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4242 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4243 "add timings for benchmarking" },
4244 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4245 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4246 "dump each input packet" },
4247 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4248 "when dumping packets, also dump the payload" },
4249 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4250 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4251 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4252 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4253 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4254 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4255 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4256 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4257 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4258 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4259 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4260 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4261 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4262 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4263 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4264 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4267 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4268 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4269 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4270 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4271 { "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" },
4272 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4273 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4274 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4275 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4276 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4277 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4278 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4279 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4280 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4281 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4282 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4283 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4284 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4285 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4286 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4287 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4288 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4289 "use same quantizer as source (implies VBR)" },
4290 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4291 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4292 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4293 "deinterlace pictures" },
4294 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4295 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4296 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4298 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4300 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4301 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4302 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4303 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4304 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4305 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4306 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4307 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4308 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4309 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4310 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4313 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4314 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4315 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4316 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4317 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4318 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4319 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4320 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4321 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4322 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4323 { "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" },
4325 /* subtitle options */
4326 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4327 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4328 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4329 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4330 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4333 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4334 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4335 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4338 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4339 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4341 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4342 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4343 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4345 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4346 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4347 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4348 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4349 /* data codec support */
4350 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4352 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4356 int main(int argc, char **argv)
4360 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4361 parse_loglevel(argc, argv, options);
4363 avcodec_register_all();
4365 avdevice_register_all();
4368 avfilter_register_all();
4371 avformat_network_init();
4373 avio_set_interrupt_cb(decode_interrupt_cb);
4379 av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
4380 "provided for compatibility. Use avconv instead "
4381 "(see Changelog for the list of incompatible changes).\n");
4384 parse_options(NULL, argc, argv, options, opt_output_file);
4386 if(nb_output_files <= 0 && nb_input_files == 0) {
4388 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4392 /* file converter / grab */
4393 if (nb_output_files <= 0) {
4394 fprintf(stderr, "At least one output file must be specified\n");
4398 if (nb_input_files == 0) {
4399 fprintf(stderr, "At least one input file must be specified\n");
4404 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4405 stream_maps, nb_stream_maps) < 0)
4407 ti = getutime() - ti;
4409 int maxrss = getmaxrss() / 1024;
4410 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);