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;
497 if (received_sigterm) {
499 "Received signal %d: terminating.\n",
500 (int) received_sigterm);
504 exit(ret); /* not all OS-es handle main() return value */
507 static void assert_avoptions(AVDictionary *m)
509 AVDictionaryEntry *t;
510 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
511 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
516 static void assert_codec_experimental(AVCodecContext *c, int encoder)
518 const char *codec_string = encoder ? "encoder" : "decoder";
520 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
521 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
522 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
523 "results.\nAdd '-strict experimental' if you want to use it.\n",
524 codec_string, c->codec->name);
525 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
526 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
527 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
528 codec_string, codec->name);
533 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
535 if(codec && codec->sample_fmts){
536 const enum AVSampleFormat *p= codec->sample_fmts;
538 if(*p == st->codec->sample_fmt)
542 av_log(NULL, AV_LOG_WARNING,
543 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
544 av_get_sample_fmt_name(st->codec->sample_fmt),
546 av_get_sample_fmt_name(codec->sample_fmts[0]));
547 st->codec->sample_fmt = codec->sample_fmts[0];
553 * Update the requested input sample format based on the output sample format.
554 * This is currently only used to request float output from decoders which
555 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
556 * Ideally this will be removed in the future when decoders do not do format
557 * conversion and only output in their native format.
559 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
562 /* if sample formats match or a decoder sample format has already been
563 requested, just return */
564 if (enc->sample_fmt == dec->sample_fmt ||
565 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
568 /* if decoder supports more than one output format */
569 if (dec_codec && dec_codec->sample_fmts &&
570 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
571 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
572 const enum AVSampleFormat *p;
573 int min_dec = -1, min_inc = -1;
575 /* find a matching sample format in the encoder */
576 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
577 if (*p == enc->sample_fmt) {
578 dec->request_sample_fmt = *p;
580 } else if (*p > enc->sample_fmt) {
581 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
583 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
586 /* if none match, provide the one that matches quality closest */
587 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
588 enc->sample_fmt - min_dec;
592 static void choose_sample_rate(AVStream *st, AVCodec *codec)
594 if(codec && codec->supported_samplerates){
595 const int *p= codec->supported_samplerates;
597 int best_dist=INT_MAX;
599 int dist= abs(st->codec->sample_rate - *p);
600 if(dist < best_dist){
606 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
608 st->codec->sample_rate= best;
612 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
614 if(codec && codec->pix_fmts){
615 const enum PixelFormat *p= codec->pix_fmts;
616 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
617 if(st->codec->codec_id==CODEC_ID_MJPEG){
618 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
619 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
620 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};
624 if(*p == st->codec->pix_fmt)
628 if(st->codec->pix_fmt != PIX_FMT_NONE)
629 av_log(NULL, AV_LOG_WARNING,
630 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
631 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
633 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
634 st->codec->pix_fmt = codec->pix_fmts[0];
639 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
642 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
643 int idx = oc->nb_streams - 1;
646 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
650 output_streams_for_file[file_idx] =
651 grow_array(output_streams_for_file[file_idx],
652 sizeof(*output_streams_for_file[file_idx]),
653 &nb_output_streams_for_file[file_idx],
655 ost = output_streams_for_file[file_idx][idx] =
656 av_mallocz(sizeof(OutputStream));
658 fprintf(stderr, "Could not alloc output stream\n");
661 ost->file_index = file_idx;
666 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
668 avcodec_get_context_defaults3(st->codec, codec);
670 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
674 static int read_avserver_streams(AVFormatContext *s, const char *filename)
677 AVFormatContext *ic = NULL;
679 err = avformat_open_input(&ic, filename, NULL, NULL);
682 /* copy stream format */
683 for(i=0;i<ic->nb_streams;i++) {
688 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
689 ost = new_output_stream(s, nb_output_files, codec);
692 // FIXME: a more elegant solution is needed
693 memcpy(st, ic->streams[i], sizeof(AVStream));
695 avcodec_copy_context(st->codec, ic->streams[i]->codec);
697 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
698 if (audio_stream_copy) {
701 choose_sample_fmt(st, codec);
702 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
703 if (video_stream_copy) {
706 choose_pixel_fmt(st, codec);
710 av_close_input_file(ic);
715 get_sync_ipts(const OutputStream *ost)
717 const InputStream *ist = ost->sync_ist;
718 return (double)(ist->pts - start_time)/AV_TIME_BASE;
721 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
725 AVPacket new_pkt= *pkt;
726 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
727 &new_pkt.data, &new_pkt.size,
728 pkt->data, pkt->size,
729 pkt->flags & AV_PKT_FLAG_KEY);
732 new_pkt.destruct= av_destruct_packet;
734 fprintf(stderr, "%s failed for stream %d, codec %s",
735 bsfc->filter->name, pkt->stream_index,
736 avctx->codec ? avctx->codec->name : "copy");
746 ret= av_interleaved_write_frame(s, pkt);
748 print_error("av_interleaved_write_frame()", ret);
753 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
755 static void do_audio_out(AVFormatContext *s,
758 unsigned char *buf, int size)
761 int64_t audio_out_size, audio_buf_size;
762 int64_t allocated_for_size= size;
764 int size_out, frame_bytes, ret, resample_changed;
765 AVCodecContext *enc= ost->st->codec;
766 AVCodecContext *dec= ist->st->codec;
767 int osize = av_get_bytes_per_sample(enc->sample_fmt);
768 int isize = av_get_bytes_per_sample(dec->sample_fmt);
769 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
772 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
773 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
774 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
775 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
776 audio_buf_size*= osize*enc->channels;
778 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
779 if(coded_bps > 8*osize)
780 audio_out_size= audio_out_size * coded_bps / (8*osize);
781 audio_out_size += FF_MIN_BUFFER_SIZE;
783 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
784 fprintf(stderr, "Buffer sizes too large\n");
788 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
789 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
790 if (!audio_buf || !audio_out){
791 fprintf(stderr, "Out of memory in do_audio_out\n");
795 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
796 ost->audio_resample = 1;
798 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
799 ost->resample_channels != dec->channels ||
800 ost->resample_sample_rate != dec->sample_rate;
802 if ((ost->audio_resample && !ost->resample) || resample_changed) {
803 if (resample_changed) {
804 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",
805 ist->file_index, ist->st->index,
806 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
807 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
808 ost->resample_sample_fmt = dec->sample_fmt;
809 ost->resample_channels = dec->channels;
810 ost->resample_sample_rate = dec->sample_rate;
812 audio_resample_close(ost->resample);
814 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
815 if (audio_sync_method <= 1 &&
816 ost->resample_sample_fmt == enc->sample_fmt &&
817 ost->resample_channels == enc->channels &&
818 ost->resample_sample_rate == enc->sample_rate) {
819 ost->resample = NULL;
820 ost->audio_resample = 0;
821 } else if (ost->audio_resample) {
822 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
823 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
824 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
825 enc->sample_rate, dec->sample_rate,
826 enc->sample_fmt, dec->sample_fmt,
828 if (!ost->resample) {
829 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
830 dec->channels, dec->sample_rate,
831 enc->channels, enc->sample_rate);
837 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
838 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
839 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
840 if (ost->reformat_ctx)
841 av_audio_convert_free(ost->reformat_ctx);
842 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
843 dec->sample_fmt, 1, NULL, 0);
844 if (!ost->reformat_ctx) {
845 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
846 av_get_sample_fmt_name(dec->sample_fmt),
847 av_get_sample_fmt_name(enc->sample_fmt));
850 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
853 if(audio_sync_method){
854 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
855 - av_fifo_size(ost->fifo)/(enc->channels * 2);
856 double idelta= delta*dec->sample_rate / enc->sample_rate;
857 int byte_delta= ((int)idelta)*2*dec->channels;
859 //FIXME resample delay
860 if(fabs(delta) > 50){
861 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
863 byte_delta= FFMAX(byte_delta, -size);
867 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
872 static uint8_t *input_tmp= NULL;
873 input_tmp= av_realloc(input_tmp, byte_delta + size);
875 if(byte_delta > allocated_for_size - size){
876 allocated_for_size= byte_delta + (int64_t)size;
881 memset(input_tmp, 0, byte_delta);
882 memcpy(input_tmp + byte_delta, buf, size);
886 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
888 }else if(audio_sync_method>1){
889 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
890 av_assert0(ost->audio_resample);
892 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
893 // 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));
894 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
898 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
899 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
901 if (ost->audio_resample) {
903 size_out = audio_resample(ost->resample,
904 (short *)buftmp, (short *)buf,
905 size / (dec->channels * isize));
906 size_out = size_out * enc->channels * osize;
912 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
913 const void *ibuf[6]= {buftmp};
914 void *obuf[6]= {audio_buf};
915 int istride[6]= {isize};
916 int ostride[6]= {osize};
917 int len= size_out/istride[0];
918 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
919 printf("av_audio_convert() failed\n");
925 size_out = len*osize;
928 /* now encode as many frames as possible */
929 if (enc->frame_size > 1) {
930 /* output resampled raw samples */
931 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
932 fprintf(stderr, "av_fifo_realloc2() failed\n");
935 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
937 frame_bytes = enc->frame_size * osize * enc->channels;
939 while (av_fifo_size(ost->fifo) >= frame_bytes) {
941 av_init_packet(&pkt);
943 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
945 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
947 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
950 fprintf(stderr, "Audio encoding failed\n");
954 pkt.stream_index= ost->index;
957 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
958 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
959 pkt.flags |= AV_PKT_FLAG_KEY;
960 write_frame(s, &pkt, enc, ost->bitstream_filters);
962 ost->sync_opts += enc->frame_size;
966 av_init_packet(&pkt);
968 ost->sync_opts += size_out / (osize * enc->channels);
970 /* output a pcm frame */
971 /* determine the size of the coded buffer */
974 size_out = size_out*coded_bps/8;
976 if(size_out > audio_out_size){
977 fprintf(stderr, "Internal error, buffer size too small\n");
981 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
982 ret = avcodec_encode_audio(enc, audio_out, size_out,
985 fprintf(stderr, "Audio encoding failed\n");
989 pkt.stream_index= ost->index;
992 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
993 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
994 pkt.flags |= AV_PKT_FLAG_KEY;
995 write_frame(s, &pkt, enc, ost->bitstream_filters);
999 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1001 AVCodecContext *dec;
1002 AVPicture *picture2;
1003 AVPicture picture_tmp;
1006 dec = ist->st->codec;
1008 /* deinterlace : must be done before any resize */
1009 if (do_deinterlace) {
1012 /* create temporary picture */
1013 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1014 buf = av_malloc(size);
1018 picture2 = &picture_tmp;
1019 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1021 if(avpicture_deinterlace(picture2, picture,
1022 dec->pix_fmt, dec->width, dec->height) < 0) {
1023 /* if error, do not deinterlace */
1024 fprintf(stderr, "Deinterlacing failed\n");
1033 if (picture != picture2)
1034 *picture = *picture2;
1038 /* we begin to correct av delay at this threshold */
1039 #define AV_DELAY_MAX 0.100
1041 static void do_subtitle_out(AVFormatContext *s,
1047 static uint8_t *subtitle_out = NULL;
1048 int subtitle_out_max_size = 1024 * 1024;
1049 int subtitle_out_size, nb, i;
1050 AVCodecContext *enc;
1053 if (pts == AV_NOPTS_VALUE) {
1054 fprintf(stderr, "Subtitle packets must have a pts\n");
1060 enc = ost->st->codec;
1062 if (!subtitle_out) {
1063 subtitle_out = av_malloc(subtitle_out_max_size);
1066 /* Note: DVB subtitle need one packet to draw them and one other
1067 packet to clear them */
1068 /* XXX: signal it in the codec context ? */
1069 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1074 for(i = 0; i < nb; i++) {
1075 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1076 // start_display_time is required to be 0
1077 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1078 sub->end_display_time -= sub->start_display_time;
1079 sub->start_display_time = 0;
1080 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1081 subtitle_out_max_size, sub);
1082 if (subtitle_out_size < 0) {
1083 fprintf(stderr, "Subtitle encoding failed\n");
1087 av_init_packet(&pkt);
1088 pkt.stream_index = ost->index;
1089 pkt.data = subtitle_out;
1090 pkt.size = subtitle_out_size;
1091 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1092 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1093 /* XXX: the pts correction is handled here. Maybe handling
1094 it in the codec would be better */
1096 pkt.pts += 90 * sub->start_display_time;
1098 pkt.pts += 90 * sub->end_display_time;
1100 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1104 static int bit_buffer_size= 1024*256;
1105 static uint8_t *bit_buffer= NULL;
1107 static void do_video_out(AVFormatContext *s,
1110 AVFrame *in_picture,
1111 int *frame_size, float quality)
1113 int nb_frames, i, ret, resample_changed;
1114 AVFrame *final_picture, *formatted_picture;
1115 AVCodecContext *enc, *dec;
1118 enc = ost->st->codec;
1119 dec = ist->st->codec;
1121 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1123 /* by default, we output a single frame */
1128 if(video_sync_method){
1129 double vdelta = sync_ipts - ost->sync_opts;
1130 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1133 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1136 }else if(vdelta>0.6)
1137 ost->sync_opts= lrintf(sync_ipts);
1138 }else if (vdelta > 1.1)
1139 nb_frames = lrintf(vdelta);
1140 //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);
1141 if (nb_frames == 0){
1144 fprintf(stderr, "*** drop!\n");
1145 }else if (nb_frames > 1) {
1146 nb_frames_dup += nb_frames - 1;
1148 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1151 ost->sync_opts= lrintf(sync_ipts);
1153 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1157 formatted_picture = in_picture;
1158 final_picture = formatted_picture;
1160 resample_changed = ost->resample_width != dec->width ||
1161 ost->resample_height != dec->height ||
1162 ost->resample_pix_fmt != dec->pix_fmt;
1164 if (resample_changed) {
1165 av_log(NULL, AV_LOG_INFO,
1166 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1167 ist->file_index, ist->st->index,
1168 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1169 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1170 if(!ost->video_resample)
1174 #if !CONFIG_AVFILTER
1175 if (ost->video_resample) {
1176 final_picture = &ost->pict_tmp;
1177 if (resample_changed) {
1178 /* initialize a new scaler context */
1179 sws_freeContext(ost->img_resample_ctx);
1180 ost->img_resample_ctx = sws_getContext(
1181 ist->st->codec->width,
1182 ist->st->codec->height,
1183 ist->st->codec->pix_fmt,
1184 ost->st->codec->width,
1185 ost->st->codec->height,
1186 ost->st->codec->pix_fmt,
1187 ost->sws_flags, NULL, NULL, NULL);
1188 if (ost->img_resample_ctx == NULL) {
1189 fprintf(stderr, "Cannot get resampling context\n");
1193 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1194 0, ost->resample_height, final_picture->data, final_picture->linesize);
1198 /* duplicates frame if needed */
1199 for(i=0;i<nb_frames;i++) {
1201 av_init_packet(&pkt);
1202 pkt.stream_index= ost->index;
1204 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1205 /* raw pictures are written as AVPicture structure to
1206 avoid any copies. We support temorarily the older
1208 AVFrame* old_frame = enc->coded_frame;
1209 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1210 pkt.data= (uint8_t *)final_picture;
1211 pkt.size= sizeof(AVPicture);
1212 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1213 pkt.flags |= AV_PKT_FLAG_KEY;
1215 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1216 enc->coded_frame = old_frame;
1218 AVFrame big_picture;
1220 big_picture= *final_picture;
1221 /* better than nothing: use input picture interlaced
1223 big_picture.interlaced_frame = in_picture->interlaced_frame;
1224 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1225 if(top_field_first == -1)
1226 big_picture.top_field_first = in_picture->top_field_first;
1228 big_picture.top_field_first = top_field_first;
1231 /* handles sameq here. This is not correct because it may
1232 not be a global option */
1233 big_picture.quality = quality;
1235 big_picture.pict_type = 0;
1236 // big_picture.pts = AV_NOPTS_VALUE;
1237 big_picture.pts= ost->sync_opts;
1238 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1239 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1240 if (ost->forced_kf_index < ost->forced_kf_count &&
1241 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1242 big_picture.pict_type = AV_PICTURE_TYPE_I;
1243 ost->forced_kf_index++;
1245 ret = avcodec_encode_video(enc,
1246 bit_buffer, bit_buffer_size,
1249 fprintf(stderr, "Video encoding failed\n");
1254 pkt.data= bit_buffer;
1256 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1257 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1258 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1259 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1260 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1262 if(enc->coded_frame->key_frame)
1263 pkt.flags |= AV_PKT_FLAG_KEY;
1264 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1267 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1268 // enc->frame_number-1, ret, enc->pict_type);
1269 /* if two pass, output log */
1270 if (ost->logfile && enc->stats_out) {
1271 fprintf(ost->logfile, "%s", enc->stats_out);
1276 ost->frame_number++;
1280 static double psnr(double d){
1281 return -10.0*log(d)/log(10.0);
1284 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1287 AVCodecContext *enc;
1289 double ti1, bitrate, avg_bitrate;
1291 /* this is executed just the first time do_video_stats is called */
1293 vstats_file = fopen(vstats_filename, "w");
1300 enc = ost->st->codec;
1301 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1302 frame_number = ost->frame_number;
1303 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1304 if (enc->flags&CODEC_FLAG_PSNR)
1305 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1307 fprintf(vstats_file,"f_size= %6d ", frame_size);
1308 /* compute pts value */
1309 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1313 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1314 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1315 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1316 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1317 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1321 static void print_report(AVFormatContext **output_files,
1322 OutputStream **ost_table, int nb_ostreams,
1327 AVFormatContext *oc;
1329 AVCodecContext *enc;
1330 int frame_number, vid, i;
1331 double bitrate, ti1, pts;
1332 static int64_t last_time = -1;
1333 static int qp_histogram[52];
1335 if (!is_last_report) {
1337 /* display the report every 0.5 seconds */
1338 cur_time = av_gettime();
1339 if (last_time == -1) {
1340 last_time = cur_time;
1343 if ((cur_time - last_time) < 500000)
1345 last_time = cur_time;
1349 oc = output_files[0];
1351 total_size = avio_size(oc->pb);
1352 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1353 total_size= avio_tell(oc->pb);
1358 for(i=0;i<nb_ostreams;i++) {
1361 enc = ost->st->codec;
1362 if (!ost->st->stream_copy && enc->coded_frame)
1363 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1364 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1365 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1367 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1368 float t = (av_gettime()-timer_start) / 1000000.0;
1370 frame_number = ost->frame_number;
1371 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1372 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1374 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1378 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1381 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1383 if (enc->flags&CODEC_FLAG_PSNR){
1385 double error, error_sum=0;
1386 double scale, scale_sum=0;
1387 char type[3]= {'Y','U','V'};
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1391 error= enc->error[j];
1392 scale= enc->width*enc->height*255.0*255.0*frame_number;
1394 error= enc->coded_frame->error[j];
1395 scale= enc->width*enc->height*255.0*255.0;
1400 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1406 /* compute min output value */
1407 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1408 if ((pts < ti1) && (pts > 0))
1414 if (verbose > 0 || is_last_report) {
1415 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1417 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1418 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1419 (double)total_size / 1024, ti1, bitrate);
1421 if (nb_frames_dup || nb_frames_drop)
1422 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1423 nb_frames_dup, nb_frames_drop);
1426 fprintf(stderr, "%s \r", buf);
1431 if (is_last_report && verbose >= 0){
1432 int64_t raw= audio_size + video_size + extra_size;
1433 fprintf(stderr, "\n");
1434 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1438 100.0*(total_size - raw)/raw
1443 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1445 int fill_char = 0x00;
1446 if (sample_fmt == AV_SAMPLE_FMT_U8)
1448 memset(buf, fill_char, size);
1451 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1452 static int output_packet(InputStream *ist, int ist_index,
1453 OutputStream **ost_table, int nb_ostreams,
1454 const AVPacket *pkt)
1456 AVFormatContext *os;
1461 void *buffer_to_free = NULL;
1462 static unsigned int samples_size= 0;
1463 AVSubtitle subtitle, *subtitle_to_free;
1464 int64_t pkt_pts = AV_NOPTS_VALUE;
1466 int frame_available;
1471 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1473 if(ist->next_pts == AV_NOPTS_VALUE)
1474 ist->next_pts= ist->pts;
1478 av_init_packet(&avpkt);
1486 if(pkt->dts != AV_NOPTS_VALUE)
1487 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1488 if(pkt->pts != AV_NOPTS_VALUE)
1489 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1491 //while we have more to decode or while the decoder did output something on EOF
1492 while (avpkt.size > 0 || (!pkt && got_output)) {
1493 uint8_t *data_buf, *decoded_data_buf;
1494 int data_size, decoded_data_size;
1496 ist->pts= ist->next_pts;
1498 if(avpkt.size && avpkt.size != pkt->size &&
1499 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1500 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1501 ist->showed_multi_packet_warning=1;
1504 /* decode the packet if needed */
1505 decoded_data_buf = NULL; /* fail safe */
1506 decoded_data_size= 0;
1507 data_buf = avpkt.data;
1508 data_size = avpkt.size;
1509 subtitle_to_free = NULL;
1510 if (ist->decoding_needed) {
1511 switch(ist->st->codec->codec_type) {
1512 case AVMEDIA_TYPE_AUDIO:{
1513 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1514 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1516 samples= av_malloc(samples_size);
1518 decoded_data_size= samples_size;
1519 /* XXX: could avoid copy if PCM 16 bits with same
1520 endianness as CPU */
1521 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1528 got_output = decoded_data_size > 0;
1529 /* Some bug in mpeg audio decoder gives */
1530 /* decoded_data_size < 0, it seems they are overflows */
1532 /* no audio frame */
1535 decoded_data_buf = (uint8_t *)samples;
1536 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1537 (ist->st->codec->sample_rate * ist->st->codec->channels);
1539 case AVMEDIA_TYPE_VIDEO:
1540 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1541 /* XXX: allocate picture correctly */
1542 avcodec_get_frame_defaults(&picture);
1543 avpkt.pts = pkt_pts;
1544 avpkt.dts = ist->pts;
1545 pkt_pts = AV_NOPTS_VALUE;
1547 ret = avcodec_decode_video2(ist->st->codec,
1548 &picture, &got_output, &avpkt);
1549 quality = same_quality ? picture.quality : 0;
1553 /* no picture yet */
1554 goto discard_packet;
1556 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1557 if (ist->st->codec->time_base.num != 0) {
1558 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1559 ist->next_pts += ((int64_t)AV_TIME_BASE *
1560 ist->st->codec->time_base.num * ticks) /
1561 ist->st->codec->time_base.den;
1564 buffer_to_free = NULL;
1565 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1567 case AVMEDIA_TYPE_SUBTITLE:
1568 ret = avcodec_decode_subtitle2(ist->st->codec,
1569 &subtitle, &got_output, &avpkt);
1573 goto discard_packet;
1575 subtitle_to_free = &subtitle;
1582 switch(ist->st->codec->codec_type) {
1583 case AVMEDIA_TYPE_AUDIO:
1584 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1585 ist->st->codec->sample_rate;
1587 case AVMEDIA_TYPE_VIDEO:
1588 if (ist->st->codec->time_base.num != 0) {
1589 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1590 ist->next_pts += ((int64_t)AV_TIME_BASE *
1591 ist->st->codec->time_base.num * ticks) /
1592 ist->st->codec->time_base.den;
1601 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1602 for (i = 0; i < nb_ostreams; i++) {
1604 if (ost->input_video_filter && ost->source_index == ist_index) {
1606 if (ist->st->sample_aspect_ratio.num)
1607 sar = ist->st->sample_aspect_ratio;
1609 sar = ist->st->codec->sample_aspect_ratio;
1610 // add it to be filtered
1611 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1619 // preprocess audio (volume)
1620 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1621 if (audio_volume != 256) {
1624 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1625 int v = ((*volp) * audio_volume + 128) >> 8;
1626 if (v < -32768) v = -32768;
1627 if (v > 32767) v = 32767;
1633 /* frame rate emulation */
1635 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1636 int64_t now = av_gettime() - ist->start;
1640 /* if output time reached then transcode raw format,
1641 encode packets and output them */
1642 if (start_time == 0 || ist->pts >= start_time)
1643 for(i=0;i<nb_ostreams;i++) {
1647 if (ost->source_index == ist_index) {
1649 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1650 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1651 while (frame_available) {
1652 AVRational ist_pts_tb;
1653 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1654 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1656 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1658 os = output_files[ost->file_index];
1660 /* set the input output pts pairs */
1661 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1663 if (ost->encoding_needed) {
1664 av_assert0(ist->decoding_needed);
1665 switch(ost->st->codec->codec_type) {
1666 case AVMEDIA_TYPE_AUDIO:
1667 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1669 case AVMEDIA_TYPE_VIDEO:
1671 if (ost->picref->video && !ost->frame_aspect_ratio)
1672 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1674 do_video_out(os, ost, ist, &picture, &frame_size,
1675 same_quality ? quality : ost->st->codec->global_quality);
1676 if (vstats_filename && frame_size)
1677 do_video_stats(os, ost, frame_size);
1679 case AVMEDIA_TYPE_SUBTITLE:
1680 do_subtitle_out(os, ost, ist, &subtitle,
1687 AVFrame avframe; //FIXME/XXX remove this
1689 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1691 av_init_packet(&opkt);
1693 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1694 #if !CONFIG_AVFILTER
1700 /* no reencoding needed : output the packet directly */
1701 /* force the input stream PTS */
1703 avcodec_get_frame_defaults(&avframe);
1704 ost->st->codec->coded_frame= &avframe;
1705 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1707 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1708 audio_size += data_size;
1709 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1710 video_size += data_size;
1714 opkt.stream_index= ost->index;
1715 if(pkt->pts != AV_NOPTS_VALUE)
1716 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1718 opkt.pts= AV_NOPTS_VALUE;
1720 if (pkt->dts == AV_NOPTS_VALUE)
1721 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1723 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1724 opkt.dts -= ost_tb_start_time;
1726 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1727 opkt.flags= pkt->flags;
1729 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1730 if( ost->st->codec->codec_id != CODEC_ID_H264
1731 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1732 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1734 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1735 opkt.destruct= av_destruct_packet;
1737 opkt.data = data_buf;
1738 opkt.size = data_size;
1741 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1742 ost->st->codec->frame_number++;
1743 ost->frame_number++;
1744 av_free_packet(&opkt);
1748 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1749 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1751 avfilter_unref_buffer(ost->picref);
1757 av_free(buffer_to_free);
1758 /* XXX: allocate the subtitles in the codec ? */
1759 if (subtitle_to_free) {
1760 avsubtitle_free(subtitle_to_free);
1761 subtitle_to_free = NULL;
1768 for(i=0;i<nb_ostreams;i++) {
1770 if (ost->source_index == ist_index) {
1771 AVCodecContext *enc= ost->st->codec;
1772 os = output_files[ost->file_index];
1774 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1776 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1779 if (ost->encoding_needed) {
1783 av_init_packet(&pkt);
1784 pkt.stream_index= ost->index;
1786 switch(ost->st->codec->codec_type) {
1787 case AVMEDIA_TYPE_AUDIO:
1788 fifo_bytes = av_fifo_size(ost->fifo);
1790 /* encode any samples remaining in fifo */
1791 if (fifo_bytes > 0) {
1792 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1793 int fs_tmp = enc->frame_size;
1795 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1796 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1797 enc->frame_size = fifo_bytes / (osize * enc->channels);
1799 int frame_bytes = enc->frame_size*osize*enc->channels;
1800 if (allocated_audio_buf_size < frame_bytes)
1802 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1805 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1806 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1807 ost->st->time_base.num, enc->sample_rate);
1808 enc->frame_size = fs_tmp;
1811 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1814 fprintf(stderr, "Audio encoding failed\n");
1818 pkt.flags |= AV_PKT_FLAG_KEY;
1820 case AVMEDIA_TYPE_VIDEO:
1821 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1823 fprintf(stderr, "Video encoding failed\n");
1827 if(enc->coded_frame && enc->coded_frame->key_frame)
1828 pkt.flags |= AV_PKT_FLAG_KEY;
1829 if (ost->logfile && enc->stats_out) {
1830 fprintf(ost->logfile, "%s", enc->stats_out);
1839 pkt.data= bit_buffer;
1841 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1842 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1843 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1853 static void print_sdp(AVFormatContext **avc, int n)
1857 av_sdp_create(avc, n, sdp, sizeof(sdp));
1858 printf("SDP:\n%s\n", sdp);
1862 static int copy_chapters(int infile, int outfile)
1864 AVFormatContext *is = input_files[infile].ctx;
1865 AVFormatContext *os = output_files[outfile];
1868 for (i = 0; i < is->nb_chapters; i++) {
1869 AVChapter *in_ch = is->chapters[i], *out_ch;
1870 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1871 AV_TIME_BASE_Q, in_ch->time_base);
1872 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1873 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1876 if (in_ch->end < ts_off)
1878 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1881 out_ch = av_mallocz(sizeof(AVChapter));
1883 return AVERROR(ENOMEM);
1885 out_ch->id = in_ch->id;
1886 out_ch->time_base = in_ch->time_base;
1887 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1888 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1890 if (metadata_chapters_autocopy)
1891 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1894 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1896 return AVERROR(ENOMEM);
1897 os->chapters[os->nb_chapters - 1] = out_ch;
1902 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1903 AVCodecContext *avctx)
1909 for (p = kf; *p; p++)
1912 ost->forced_kf_count = n;
1913 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1914 if (!ost->forced_kf_pts) {
1915 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1918 for (i = 0; i < n; i++) {
1919 p = i ? strchr(p, ',') + 1 : kf;
1920 t = parse_time_or_die("force_key_frames", p, 1);
1921 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1926 * The following code is the main loop of the file converter
1928 static int transcode(AVFormatContext **output_files,
1929 int nb_output_files,
1930 InputFile *input_files,
1932 StreamMap *stream_maps, int nb_stream_maps)
1934 int ret = 0, i, j, k, n, nb_ostreams = 0;
1935 AVFormatContext *is, *os;
1936 AVCodecContext *codec, *icodec;
1937 OutputStream *ost, **ost_table = NULL;
1941 uint8_t no_packet[MAX_FILES]={0};
1942 int no_packet_count=0;
1945 for (i = 0; i < nb_input_streams; i++)
1946 input_streams[i].start = av_gettime();
1948 /* output stream init */
1950 for(i=0;i<nb_output_files;i++) {
1951 os = output_files[i];
1952 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1953 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1954 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1955 ret = AVERROR(EINVAL);
1958 nb_ostreams += os->nb_streams;
1960 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1961 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1962 ret = AVERROR(EINVAL);
1966 /* Sanity check the mapping args -- do the input files & streams exist? */
1967 for(i=0;i<nb_stream_maps;i++) {
1968 int fi = stream_maps[i].file_index;
1969 int si = stream_maps[i].stream_index;
1971 if (fi < 0 || fi > nb_input_files - 1 ||
1972 si < 0 || si > input_files[fi].nb_streams - 1) {
1973 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1974 ret = AVERROR(EINVAL);
1977 fi = stream_maps[i].sync_file_index;
1978 si = stream_maps[i].sync_stream_index;
1979 if (fi < 0 || fi > nb_input_files - 1 ||
1980 si < 0 || si > input_files[fi].nb_streams - 1) {
1981 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1982 ret = AVERROR(EINVAL);
1987 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1991 for(k=0;k<nb_output_files;k++) {
1992 os = output_files[k];
1993 for(i=0;i<os->nb_streams;i++,n++) {
1995 ost = ost_table[n] = output_streams_for_file[k][i];
1996 if (nb_stream_maps > 0) {
1997 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
1998 stream_maps[n].stream_index;
2000 /* Sanity check that the stream types match */
2001 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2002 int i= ost->file_index;
2003 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2004 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2005 stream_maps[n].file_index, stream_maps[n].stream_index,
2006 ost->file_index, ost->index);
2011 int best_nb_frames=-1;
2012 /* get corresponding input stream index : we select the first one with the right type */
2014 for (j = 0; j < nb_input_streams; j++) {
2016 ist = &input_streams[j];
2019 AVFormatContext *f = input_files[ist->file_index].ctx;
2021 for(pi=0; pi<f->nb_programs; pi++){
2022 AVProgram *p= f->programs[pi];
2023 if(p->id == opt_programid)
2024 for(si=0; si<p->nb_stream_indexes; si++){
2025 if(f->streams[ p->stream_index[si] ] == ist->st)
2030 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2031 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2032 if(best_nb_frames < ist->st->codec_info_nb_frames){
2033 best_nb_frames= ist->st->codec_info_nb_frames;
2034 ost->source_index = j;
2041 if(! opt_programid) {
2042 /* try again and reuse existing stream */
2043 for (j = 0; j < nb_input_streams; j++) {
2044 ist = &input_streams[j];
2045 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2046 && ist->st->discard != AVDISCARD_ALL) {
2047 ost->source_index = j;
2053 int i= ost->file_index;
2054 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2055 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2056 ost->file_index, ost->index);
2061 ist = &input_streams[ost->source_index];
2063 ost->sync_ist = (nb_stream_maps > 0) ?
2064 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2065 stream_maps[n].sync_stream_index] : ist;
2069 /* for each output stream, we compute the right encoding parameters */
2070 for(i=0;i<nb_ostreams;i++) {
2072 os = output_files[ost->file_index];
2073 ist = &input_streams[ost->source_index];
2075 codec = ost->st->codec;
2076 icodec = ist->st->codec;
2078 if (metadata_streams_autocopy)
2079 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2080 AV_DICT_DONT_OVERWRITE);
2082 ost->st->disposition = ist->st->disposition;
2083 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2084 codec->chroma_sample_location = icodec->chroma_sample_location;
2086 if (ost->st->stream_copy) {
2087 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2089 if (extra_size > INT_MAX)
2092 /* if stream_copy is selected, no need to decode or encode */
2093 codec->codec_id = icodec->codec_id;
2094 codec->codec_type = icodec->codec_type;
2096 if(!codec->codec_tag){
2097 if( !os->oformat->codec_tag
2098 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2099 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2100 codec->codec_tag = icodec->codec_tag;
2103 codec->bit_rate = icodec->bit_rate;
2104 codec->rc_max_rate = icodec->rc_max_rate;
2105 codec->rc_buffer_size = icodec->rc_buffer_size;
2106 codec->extradata= av_mallocz(extra_size);
2107 if (!codec->extradata)
2109 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2110 codec->extradata_size= icodec->extradata_size;
2111 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){
2112 codec->time_base = icodec->time_base;
2113 codec->time_base.num *= icodec->ticks_per_frame;
2114 av_reduce(&codec->time_base.num, &codec->time_base.den,
2115 codec->time_base.num, codec->time_base.den, INT_MAX);
2117 codec->time_base = ist->st->time_base;
2118 switch(codec->codec_type) {
2119 case AVMEDIA_TYPE_AUDIO:
2120 if(audio_volume != 256) {
2121 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2124 codec->channel_layout = icodec->channel_layout;
2125 codec->sample_rate = icodec->sample_rate;
2126 codec->channels = icodec->channels;
2127 codec->frame_size = icodec->frame_size;
2128 codec->audio_service_type = icodec->audio_service_type;
2129 codec->block_align= icodec->block_align;
2130 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2131 codec->block_align= 0;
2132 if(codec->codec_id == CODEC_ID_AC3)
2133 codec->block_align= 0;
2135 case AVMEDIA_TYPE_VIDEO:
2136 codec->pix_fmt = icodec->pix_fmt;
2137 codec->width = icodec->width;
2138 codec->height = icodec->height;
2139 codec->has_b_frames = icodec->has_b_frames;
2140 if (!codec->sample_aspect_ratio.num) {
2141 codec->sample_aspect_ratio =
2142 ost->st->sample_aspect_ratio =
2143 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2144 ist->st->codec->sample_aspect_ratio.num ?
2145 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2148 case AVMEDIA_TYPE_SUBTITLE:
2149 codec->width = icodec->width;
2150 codec->height = icodec->height;
2152 case AVMEDIA_TYPE_DATA:
2159 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2160 switch(codec->codec_type) {
2161 case AVMEDIA_TYPE_AUDIO:
2162 ost->fifo= av_fifo_alloc(1024);
2165 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2166 if (!codec->sample_rate) {
2167 codec->sample_rate = icodec->sample_rate;
2169 codec->sample_rate >>= icodec->lowres;
2171 choose_sample_rate(ost->st, ost->enc);
2172 codec->time_base = (AVRational){1, codec->sample_rate};
2173 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2174 codec->sample_fmt = icodec->sample_fmt;
2175 choose_sample_fmt(ost->st, ost->enc);
2176 if (!codec->channels)
2177 codec->channels = icodec->channels;
2178 codec->channel_layout = icodec->channel_layout;
2179 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2180 codec->channel_layout = 0;
2181 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2182 icodec->request_channels = codec->channels;
2183 ist->decoding_needed = 1;
2184 ost->encoding_needed = 1;
2185 ost->resample_sample_fmt = icodec->sample_fmt;
2186 ost->resample_sample_rate = icodec->sample_rate;
2187 ost->resample_channels = icodec->channels;
2189 case AVMEDIA_TYPE_VIDEO:
2190 if (codec->pix_fmt == PIX_FMT_NONE)
2191 codec->pix_fmt = icodec->pix_fmt;
2192 choose_pixel_fmt(ost->st, ost->enc);
2194 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2195 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2199 if (!codec->width || !codec->height) {
2200 codec->width = icodec->width;
2201 codec->height = icodec->height;
2204 ost->video_resample = codec->width != icodec->width ||
2205 codec->height != icodec->height ||
2206 codec->pix_fmt != icodec->pix_fmt;
2207 if (ost->video_resample) {
2208 #if !CONFIG_AVFILTER
2209 avcodec_get_frame_defaults(&ost->pict_tmp);
2210 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2211 codec->width, codec->height)) {
2212 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2215 ost->img_resample_ctx = sws_getContext(
2222 ost->sws_flags, NULL, NULL, NULL);
2223 if (ost->img_resample_ctx == NULL) {
2224 fprintf(stderr, "Cannot get resampling context\n");
2228 codec->bits_per_raw_sample= 0;
2231 ost->resample_height = icodec->height;
2232 ost->resample_width = icodec->width;
2233 ost->resample_pix_fmt= icodec->pix_fmt;
2234 ost->encoding_needed = 1;
2235 ist->decoding_needed = 1;
2237 if (!ost->frame_rate.num)
2238 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2239 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2240 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2241 ost->frame_rate = ost->enc->supported_framerates[idx];
2243 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2246 if (configure_video_filters(ist, ost)) {
2247 fprintf(stderr, "Error opening filters!\n");
2252 case AVMEDIA_TYPE_SUBTITLE:
2253 ost->encoding_needed = 1;
2254 ist->decoding_needed = 1;
2261 if (ost->encoding_needed &&
2262 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2263 char logfilename[1024];
2266 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2267 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2269 if (codec->flags & CODEC_FLAG_PASS1) {
2270 f = fopen(logfilename, "wb");
2272 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2278 size_t logbuffer_size;
2279 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2280 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2283 codec->stats_in = logbuffer;
2287 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2288 int size= codec->width * codec->height;
2289 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2294 bit_buffer = av_malloc(bit_buffer_size);
2296 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2298 ret = AVERROR(ENOMEM);
2302 /* open each encoder */
2303 for(i=0;i<nb_ostreams;i++) {
2305 if (ost->encoding_needed) {
2306 AVCodec *codec = ost->enc;
2307 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2309 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2310 ost->st->codec->codec_id, ost->file_index, ost->index);
2311 ret = AVERROR(EINVAL);
2314 if (dec->subtitle_header) {
2315 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2316 if (!ost->st->codec->subtitle_header) {
2317 ret = AVERROR(ENOMEM);
2320 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2321 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2323 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2324 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2325 ost->file_index, ost->index);
2326 ret = AVERROR(EINVAL);
2329 assert_codec_experimental(ost->st->codec, 1);
2330 assert_avoptions(ost->opts);
2331 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2332 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2333 "It takes bits/s as argument, not kbits/s\n");
2334 extra_size += ost->st->codec->extradata_size;
2338 /* open each decoder */
2339 for (i = 0; i < nb_input_streams; i++) {
2340 ist = &input_streams[i];
2341 if (ist->decoding_needed) {
2342 AVCodec *codec = ist->dec;
2344 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2346 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2347 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2348 ret = AVERROR(EINVAL);
2352 /* update requested sample format for the decoder based on the
2353 corresponding encoder sample format */
2354 for (j = 0; j < nb_ostreams; j++) {
2356 if (ost->source_index == i) {
2357 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2362 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2363 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2364 ist->file_index, ist->st->index);
2365 ret = AVERROR(EINVAL);
2368 assert_codec_experimental(ist->st->codec, 0);
2369 assert_avoptions(ost->opts);
2374 for (i = 0; i < nb_input_streams; i++) {
2376 ist = &input_streams[i];
2378 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2379 ist->next_pts = AV_NOPTS_VALUE;
2380 init_pts_correction(&ist->pts_ctx);
2384 /* set meta data information from input file if required */
2385 for (i=0;i<nb_meta_data_maps;i++) {
2386 AVFormatContext *files[2];
2387 AVDictionary **meta[2];
2390 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2391 if ((index) < 0 || (index) >= (nb_elems)) {\
2392 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2394 ret = AVERROR(EINVAL);\
2398 int out_file_index = meta_data_maps[i][0].file;
2399 int in_file_index = meta_data_maps[i][1].file;
2400 if (in_file_index < 0 || out_file_index < 0)
2402 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2403 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2405 files[0] = output_files[out_file_index];
2406 files[1] = input_files[in_file_index].ctx;
2408 for (j = 0; j < 2; j++) {
2409 MetadataMap *map = &meta_data_maps[i][j];
2411 switch (map->type) {
2413 meta[j] = &files[j]->metadata;
2416 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2417 meta[j] = &files[j]->streams[map->index]->metadata;
2420 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2421 meta[j] = &files[j]->chapters[map->index]->metadata;
2424 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2425 meta[j] = &files[j]->programs[map->index]->metadata;
2430 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2433 /* copy global metadata by default */
2434 if (metadata_global_autocopy) {
2436 for (i = 0; i < nb_output_files; i++)
2437 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2438 AV_DICT_DONT_OVERWRITE);
2441 /* copy chapters according to chapter maps */
2442 for (i = 0; i < nb_chapter_maps; i++) {
2443 int infile = chapter_maps[i].in_file;
2444 int outfile = chapter_maps[i].out_file;
2446 if (infile < 0 || outfile < 0)
2448 if (infile >= nb_input_files) {
2449 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2450 ret = AVERROR(EINVAL);
2453 if (outfile >= nb_output_files) {
2454 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2455 ret = AVERROR(EINVAL);
2458 copy_chapters(infile, outfile);
2461 /* copy chapters from the first input file that has them*/
2462 if (!nb_chapter_maps)
2463 for (i = 0; i < nb_input_files; i++) {
2464 if (!input_files[i].ctx->nb_chapters)
2467 for (j = 0; j < nb_output_files; j++)
2468 if ((ret = copy_chapters(i, j)) < 0)
2473 /* open files and write file headers */
2474 for(i=0;i<nb_output_files;i++) {
2475 os = output_files[i];
2476 if (avformat_write_header(os, &output_opts[i]) < 0) {
2477 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2478 ret = AVERROR(EINVAL);
2481 assert_avoptions(output_opts[i]);
2482 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2488 /* dump the file output parameters - cannot be done before in case
2490 for(i=0;i<nb_output_files;i++) {
2491 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2494 /* dump the stream mapping */
2496 fprintf(stderr, "Stream mapping:\n");
2497 for(i=0;i<nb_ostreams;i++) {
2499 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2500 input_streams[ost->source_index].file_index,
2501 input_streams[ost->source_index].st->index,
2504 if (ost->sync_ist != &input_streams[ost->source_index])
2505 fprintf(stderr, " [sync #%d.%d]",
2506 ost->sync_ist->file_index,
2507 ost->sync_ist->st->index);
2508 fprintf(stderr, "\n");
2513 fprintf(stderr, "%s\n", error);
2518 print_sdp(output_files, nb_output_files);
2522 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2525 timer_start = av_gettime();
2527 for(; received_sigterm == 0;) {
2528 int file_index, ist_index;
2537 /* select the stream that we must read now by looking at the
2538 smallest output pts */
2540 for(i=0;i<nb_ostreams;i++) {
2543 os = output_files[ost->file_index];
2544 ist = &input_streams[ost->source_index];
2545 if(ist->is_past_recording_time || no_packet[ist->file_index])
2547 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2548 ipts = (double)ist->pts;
2549 if (!input_files[ist->file_index].eof_reached){
2550 if(ipts < ipts_min) {
2552 if(input_sync ) file_index = ist->file_index;
2554 if(opts < opts_min) {
2556 if(!input_sync) file_index = ist->file_index;
2559 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2564 /* if none, if is finished */
2565 if (file_index < 0) {
2566 if(no_packet_count){
2568 memset(no_packet, 0, sizeof(no_packet));
2575 /* finish if limit size exhausted */
2576 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2579 /* read a frame from it and output it in the fifo */
2580 is = input_files[file_index].ctx;
2581 ret= av_read_frame(is, &pkt);
2582 if(ret == AVERROR(EAGAIN)){
2583 no_packet[file_index]=1;
2588 input_files[file_index].eof_reached = 1;
2596 memset(no_packet, 0, sizeof(no_packet));
2599 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2600 is->streams[pkt.stream_index]);
2602 /* the following test is needed in case new streams appear
2603 dynamically in stream : we ignore them */
2604 if (pkt.stream_index >= input_files[file_index].nb_streams)
2605 goto discard_packet;
2606 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2607 ist = &input_streams[ist_index];
2609 goto discard_packet;
2611 if (pkt.dts != AV_NOPTS_VALUE)
2612 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2613 if (pkt.pts != AV_NOPTS_VALUE)
2614 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2616 if (ist->ts_scale) {
2617 if(pkt.pts != AV_NOPTS_VALUE)
2618 pkt.pts *= ist->ts_scale;
2619 if(pkt.dts != AV_NOPTS_VALUE)
2620 pkt.dts *= ist->ts_scale;
2623 // 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);
2624 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2625 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2626 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2627 int64_t delta= pkt_dts - ist->next_pts;
2628 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2629 input_files[ist->file_index].ts_offset -= delta;
2631 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2632 delta, input_files[ist->file_index].ts_offset);
2633 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2634 if(pkt.pts != AV_NOPTS_VALUE)
2635 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2639 /* finish if recording time exhausted */
2640 if (recording_time != INT64_MAX &&
2641 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2642 ist->is_past_recording_time = 1;
2643 goto discard_packet;
2646 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2647 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2650 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2651 ist->file_index, ist->st->index);
2654 av_free_packet(&pkt);
2659 av_free_packet(&pkt);
2661 /* dump report by using the output first video and audio streams */
2662 print_report(output_files, ost_table, nb_ostreams, 0);
2665 /* at the end of stream, we must flush the decoder buffers */
2666 for (i = 0; i < nb_input_streams; i++) {
2667 ist = &input_streams[i];
2668 if (ist->decoding_needed) {
2669 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2675 /* write the trailer if needed and close file */
2676 for(i=0;i<nb_output_files;i++) {
2677 os = output_files[i];
2678 av_write_trailer(os);
2681 /* dump report by using the first video and audio streams */
2682 print_report(output_files, ost_table, nb_ostreams, 1);
2684 /* close each encoder */
2685 for(i=0;i<nb_ostreams;i++) {
2687 if (ost->encoding_needed) {
2688 av_freep(&ost->st->codec->stats_in);
2689 avcodec_close(ost->st->codec);
2692 avfilter_graph_free(&ost->graph);
2696 /* close each decoder */
2697 for (i = 0; i < nb_input_streams; i++) {
2698 ist = &input_streams[i];
2699 if (ist->decoding_needed) {
2700 avcodec_close(ist->st->codec);
2708 av_freep(&bit_buffer);
2711 for(i=0;i<nb_ostreams;i++) {
2714 if (ost->st->stream_copy)
2715 av_freep(&ost->st->codec->extradata);
2717 fclose(ost->logfile);
2718 ost->logfile = NULL;
2720 av_fifo_free(ost->fifo); /* works even if fifo is not
2721 initialized but set to zero */
2722 av_freep(&ost->st->codec->subtitle_header);
2723 av_free(ost->pict_tmp.data[0]);
2724 av_free(ost->forced_kf_pts);
2725 if (ost->video_resample)
2726 sws_freeContext(ost->img_resample_ctx);
2728 audio_resample_close(ost->resample);
2729 if (ost->reformat_ctx)
2730 av_audio_convert_free(ost->reformat_ctx);
2731 av_dict_free(&ost->opts);
2740 static int opt_format(const char *opt, const char *arg)
2742 last_asked_format = arg;
2746 static int opt_video_rc_override_string(const char *opt, const char *arg)
2748 video_rc_override_string = arg;
2752 static int opt_me_threshold(const char *opt, const char *arg)
2754 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2758 static int opt_verbose(const char *opt, const char *arg)
2760 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2764 static int opt_frame_rate(const char *opt, const char *arg)
2766 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2767 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2773 static int opt_frame_crop(const char *opt, const char *arg)
2775 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2776 return AVERROR(EINVAL);
2779 static int opt_frame_size(const char *opt, const char *arg)
2781 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2782 fprintf(stderr, "Incorrect frame size\n");
2783 return AVERROR(EINVAL);
2788 static int opt_pad(const char *opt, const char *arg) {
2789 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2793 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2795 if (strcmp(arg, "list")) {
2796 frame_pix_fmt = av_get_pix_fmt(arg);
2797 if (frame_pix_fmt == PIX_FMT_NONE) {
2798 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2799 return AVERROR(EINVAL);
2808 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2815 p = strchr(arg, ':');
2817 x = strtol(arg, &end, 10);
2819 y = strtol(end+1, &end, 10);
2821 ar = (double)x / (double)y;
2823 ar = strtod(arg, NULL);
2826 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2827 return AVERROR(EINVAL);
2829 frame_aspect_ratio = ar;
2833 static int opt_metadata(const char *opt, const char *arg)
2835 char *mid= strchr(arg, '=');
2838 fprintf(stderr, "Missing =\n");
2843 av_dict_set(&metadata, arg, mid, 0);
2848 static int opt_qscale(const char *opt, const char *arg)
2850 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2851 if (video_qscale == 0) {
2852 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2853 return AVERROR(EINVAL);
2858 static int opt_top_field_first(const char *opt, const char *arg)
2860 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2864 static int opt_thread_count(const char *opt, const char *arg)
2866 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2869 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2874 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2876 if (strcmp(arg, "list")) {
2877 audio_sample_fmt = av_get_sample_fmt(arg);
2878 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2879 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2880 return AVERROR(EINVAL);
2885 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2886 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2892 static int opt_audio_rate(const char *opt, const char *arg)
2894 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2898 static int opt_audio_channels(const char *opt, const char *arg)
2900 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2904 static int opt_video_channel(const char *opt, const char *arg)
2906 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2907 opt_default("channel", arg);
2911 static int opt_video_standard(const char *opt, const char *arg)
2913 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2914 opt_default("standard", arg);
2918 static int opt_codec(int *pstream_copy, char **pcodec_name,
2919 int codec_type, const char *arg)
2921 av_freep(pcodec_name);
2922 if (!strcmp(arg, "copy")) {
2925 *pcodec_name = av_strdup(arg);
2930 static int opt_audio_codec(const char *opt, const char *arg)
2932 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2935 static int opt_video_codec(const char *opt, const char *arg)
2937 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2940 static int opt_subtitle_codec(const char *opt, const char *arg)
2942 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2945 static int opt_data_codec(const char *opt, const char *arg)
2947 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2950 static int opt_codec_tag(const char *opt, const char *arg)
2953 uint32_t *codec_tag;
2955 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2956 !strcmp(opt, "vtag") ? &video_codec_tag :
2957 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2961 *codec_tag = strtol(arg, &tail, 0);
2963 *codec_tag = AV_RL32(arg);
2968 static int opt_map(const char *opt, const char *arg)
2973 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2974 m = &stream_maps[nb_stream_maps-1];
2976 m->file_index = strtol(arg, &p, 0);
2980 m->stream_index = strtol(p, &p, 0);
2983 m->sync_file_index = strtol(p, &p, 0);
2986 m->sync_stream_index = strtol(p, &p, 0);
2988 m->sync_file_index = m->file_index;
2989 m->sync_stream_index = m->stream_index;
2994 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3005 *index = strtol(++arg, endptr, 0);
3008 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3015 static int opt_map_metadata(const char *opt, const char *arg)
3017 MetadataMap *m, *m1;
3020 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3021 &nb_meta_data_maps, nb_meta_data_maps + 1);
3023 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3024 m->file = strtol(arg, &p, 0);
3025 parse_meta_type(p, &m->type, &m->index, &p);
3029 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3030 m1->file = strtol(p, &p, 0);
3031 parse_meta_type(p, &m1->type, &m1->index, &p);
3033 if (m->type == 'g' || m1->type == 'g')
3034 metadata_global_autocopy = 0;
3035 if (m->type == 's' || m1->type == 's')
3036 metadata_streams_autocopy = 0;
3037 if (m->type == 'c' || m1->type == 'c')
3038 metadata_chapters_autocopy = 0;
3043 static int opt_map_meta_data(const char *opt, const char *arg)
3045 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3046 "Use -map_metadata instead.\n");
3047 return opt_map_metadata(opt, arg);
3050 static int opt_map_chapters(const char *opt, const char *arg)
3055 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3056 nb_chapter_maps + 1);
3057 c = &chapter_maps[nb_chapter_maps - 1];
3058 c->out_file = strtol(arg, &p, 0);
3062 c->in_file = strtol(p, &p, 0);
3066 static int opt_input_ts_scale(const char *opt, const char *arg)
3068 unsigned int stream;
3072 stream = strtol(arg, &p, 0);
3075 scale= strtod(p, &p);
3077 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3078 ts_scale[stream] = scale;
3082 static int opt_recording_time(const char *opt, const char *arg)
3084 recording_time = parse_time_or_die(opt, arg, 1);
3088 static int opt_start_time(const char *opt, const char *arg)
3090 start_time = parse_time_or_die(opt, arg, 1);
3094 static int opt_recording_timestamp(const char *opt, const char *arg)
3097 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3098 struct tm time = *gmtime((time_t*)&recording_timestamp);
3099 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3100 opt_metadata("metadata", buf);
3102 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3103 "tag instead.\n", opt);
3107 static int opt_input_ts_offset(const char *opt, const char *arg)
3109 input_ts_offset = parse_time_or_die(opt, arg, 1);
3113 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3115 const char *codec_string = encoder ? "encoder" : "decoder";
3119 return CODEC_ID_NONE;
3121 avcodec_find_encoder_by_name(name) :
3122 avcodec_find_decoder_by_name(name);
3124 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3127 if(codec->type != type) {
3128 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3134 static int opt_input_file(const char *opt, const char *filename)
3136 AVFormatContext *ic;
3137 AVInputFormat *file_iformat = NULL;
3138 int err, i, ret, rfps, rfps_base;
3141 AVDictionary **opts;
3142 int orig_nb_streams; // number of streams before avformat_find_stream_info
3144 if (last_asked_format) {
3145 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3146 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3149 last_asked_format = NULL;
3152 if (!strcmp(filename, "-"))
3155 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3156 !strcmp(filename, "/dev/stdin");
3158 /* get default parameters from command line */
3159 ic = avformat_alloc_context();
3161 print_error(filename, AVERROR(ENOMEM));
3164 if (audio_sample_rate) {
3165 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3166 av_dict_set(&format_opts, "sample_rate", buf, 0);
3168 if (audio_channels) {
3169 snprintf(buf, sizeof(buf), "%d", audio_channels);
3170 av_dict_set(&format_opts, "channels", buf, 0);
3172 if (frame_rate.num) {
3173 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3174 av_dict_set(&format_opts, "framerate", buf, 0);
3176 if (frame_width && frame_height) {
3177 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3178 av_dict_set(&format_opts, "video_size", buf, 0);
3180 if (frame_pix_fmt != PIX_FMT_NONE)
3181 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3183 ic->video_codec_id =
3184 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3185 ic->audio_codec_id =
3186 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3187 ic->subtitle_codec_id=
3188 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3189 ic->flags |= AVFMT_FLAG_NONBLOCK;
3191 /* open the input file with generic libav function */
3192 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3194 print_error(filename, err);
3197 assert_avoptions(format_opts);
3202 for(i=0; i<ic->nb_streams; i++){
3203 ic->streams[i]->discard= AVDISCARD_ALL;
3205 for(i=0; i<ic->nb_programs; i++){
3206 AVProgram *p= ic->programs[i];
3207 if(p->id != opt_programid){
3208 p->discard = AVDISCARD_ALL;
3211 for(j=0; j<p->nb_stream_indexes; j++){
3212 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3217 fprintf(stderr, "Specified program id not found\n");
3224 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3225 ic->loop_input = loop_input;
3228 /* Set AVCodecContext options for avformat_find_stream_info */
3229 opts = setup_find_stream_info_opts(ic, codec_opts);
3230 orig_nb_streams = ic->nb_streams;
3232 /* If not enough info to get the stream parameters, we decode the
3233 first frames to get it. (used in mpeg case for example) */
3234 ret = avformat_find_stream_info(ic, opts);
3235 if (ret < 0 && verbose >= 0) {
3236 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3237 av_close_input_file(ic);
3241 timestamp = start_time;
3242 /* add the stream start time */
3243 if (ic->start_time != AV_NOPTS_VALUE)
3244 timestamp += ic->start_time;
3246 /* if seeking requested, we execute it */
3247 if (start_time != 0) {
3248 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3250 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3251 filename, (double)timestamp / AV_TIME_BASE);
3253 /* reset seek info */
3257 /* update the current parameters so that they match the one of the input stream */
3258 for(i=0;i<ic->nb_streams;i++) {
3259 AVStream *st = ic->streams[i];
3260 AVCodecContext *dec = st->codec;
3263 dec->thread_count = thread_count;
3265 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3266 ist = &input_streams[nb_input_streams - 1];
3268 ist->file_index = nb_input_files;
3270 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3272 if (i < nb_ts_scale)
3273 ist->ts_scale = ts_scale[i];
3275 switch (dec->codec_type) {
3276 case AVMEDIA_TYPE_AUDIO:
3277 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3279 st->discard= AVDISCARD_ALL;
3281 case AVMEDIA_TYPE_VIDEO:
3282 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3283 rfps = ic->streams[i]->r_frame_rate.num;
3284 rfps_base = ic->streams[i]->r_frame_rate.den;
3286 dec->flags |= CODEC_FLAG_EMU_EDGE;
3287 dec->height >>= dec->lowres;
3288 dec->width >>= dec->lowres;
3291 dec->debug |= FF_DEBUG_MV;
3293 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3296 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3297 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3299 (float)rfps / rfps_base, rfps, rfps_base);
3303 st->discard= AVDISCARD_ALL;
3304 else if(video_discard)
3305 st->discard= video_discard;
3307 case AVMEDIA_TYPE_DATA:
3309 case AVMEDIA_TYPE_SUBTITLE:
3310 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3311 if(subtitle_disable)
3312 st->discard = AVDISCARD_ALL;
3314 case AVMEDIA_TYPE_ATTACHMENT:
3315 case AVMEDIA_TYPE_UNKNOWN:
3322 /* dump the file content */
3324 av_dump_format(ic, nb_input_files, filename, 0);
3326 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3327 input_files[nb_input_files - 1].ctx = ic;
3328 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3329 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3330 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3332 frame_rate = (AVRational){0, 0};
3333 frame_pix_fmt = PIX_FMT_NONE;
3336 audio_sample_rate = 0;
3338 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3339 av_freep(&ts_scale);
3342 for (i = 0; i < orig_nb_streams; i++)
3343 av_dict_free(&opts[i]);
3345 av_freep(&video_codec_name);
3346 av_freep(&audio_codec_name);
3347 av_freep(&subtitle_codec_name);
3353 static void check_inputs(int *has_video_ptr,
3355 int *has_subtitle_ptr,
3358 int has_video, has_audio, has_subtitle, has_data, i, j;
3359 AVFormatContext *ic;
3366 for(j=0;j<nb_input_files;j++) {
3367 ic = input_files[j].ctx;
3368 for(i=0;i<ic->nb_streams;i++) {
3369 AVCodecContext *enc = ic->streams[i]->codec;
3370 switch(enc->codec_type) {
3371 case AVMEDIA_TYPE_AUDIO:
3374 case AVMEDIA_TYPE_VIDEO:
3377 case AVMEDIA_TYPE_SUBTITLE:
3380 case AVMEDIA_TYPE_DATA:
3381 case AVMEDIA_TYPE_ATTACHMENT:
3382 case AVMEDIA_TYPE_UNKNOWN:
3390 *has_video_ptr = has_video;
3391 *has_audio_ptr = has_audio;
3392 *has_subtitle_ptr = has_subtitle;
3393 *has_data_ptr = has_data;
3396 static void new_video_stream(AVFormatContext *oc, int file_idx)
3400 AVCodecContext *video_enc;
3401 enum CodecID codec_id = CODEC_ID_NONE;
3402 AVCodec *codec= NULL;
3404 if(!video_stream_copy){
3405 if (video_codec_name) {
3406 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3407 codec = avcodec_find_encoder_by_name(video_codec_name);
3409 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3410 codec = avcodec_find_encoder(codec_id);
3414 ost = new_output_stream(oc, file_idx, codec);
3416 if (!video_stream_copy) {
3417 ost->frame_aspect_ratio = frame_aspect_ratio;
3418 frame_aspect_ratio = 0;
3420 ost->avfilter= vfilters;
3425 ost->bitstream_filters = video_bitstream_filters;
3426 video_bitstream_filters= NULL;
3428 st->codec->thread_count= thread_count;
3430 video_enc = st->codec;
3433 video_enc->codec_tag= video_codec_tag;
3435 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3436 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3439 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3440 if (video_stream_copy) {
3441 st->stream_copy = 1;
3442 video_enc->sample_aspect_ratio =
3443 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3449 ost->frame_rate = frame_rate;
3450 video_enc->codec_id = codec_id;
3452 video_enc->width = frame_width;
3453 video_enc->height = frame_height;
3454 video_enc->pix_fmt = frame_pix_fmt;
3455 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3458 video_enc->gop_size = 0;
3459 if (video_qscale || same_quality) {
3460 video_enc->flags |= CODEC_FLAG_QSCALE;
3461 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3465 video_enc->intra_matrix = intra_matrix;
3467 video_enc->inter_matrix = inter_matrix;
3469 p= video_rc_override_string;
3472 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3474 fprintf(stderr, "error parsing rc_override\n");
3477 video_enc->rc_override=
3478 av_realloc(video_enc->rc_override,
3479 sizeof(RcOverride)*(i+1));
3480 video_enc->rc_override[i].start_frame= start;
3481 video_enc->rc_override[i].end_frame = end;
3483 video_enc->rc_override[i].qscale= q;
3484 video_enc->rc_override[i].quality_factor= 1.0;
3487 video_enc->rc_override[i].qscale= 0;
3488 video_enc->rc_override[i].quality_factor= -q/100.0;
3493 video_enc->rc_override_count=i;
3494 if (!video_enc->rc_initial_buffer_occupancy)
3495 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3496 video_enc->me_threshold= me_threshold;
3497 video_enc->intra_dc_precision= intra_dc_precision - 8;
3500 video_enc->flags|= CODEC_FLAG_PSNR;
3505 video_enc->flags |= CODEC_FLAG_PASS1;
3507 video_enc->flags |= CODEC_FLAG_PASS2;
3511 if (forced_key_frames)
3512 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3514 if (video_language) {
3515 av_dict_set(&st->metadata, "language", video_language, 0);
3516 av_freep(&video_language);
3519 /* reset some key parameters */
3521 av_freep(&video_codec_name);
3522 av_freep(&forced_key_frames);
3523 video_stream_copy = 0;
3524 frame_pix_fmt = PIX_FMT_NONE;
3527 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3531 AVCodec *codec= NULL;
3532 AVCodecContext *audio_enc;
3533 enum CodecID codec_id = CODEC_ID_NONE;
3535 if(!audio_stream_copy){
3536 if (audio_codec_name) {
3537 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3538 codec = avcodec_find_encoder_by_name(audio_codec_name);
3540 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3541 codec = avcodec_find_encoder(codec_id);
3544 ost = new_output_stream(oc, file_idx, codec);
3547 ost->bitstream_filters = audio_bitstream_filters;
3548 audio_bitstream_filters= NULL;
3550 st->codec->thread_count= thread_count;
3552 audio_enc = st->codec;
3553 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3556 audio_enc->codec_tag= audio_codec_tag;
3558 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3559 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3561 if (audio_stream_copy) {
3562 st->stream_copy = 1;
3564 audio_enc->codec_id = codec_id;
3566 if (audio_qscale > QSCALE_NONE) {
3567 audio_enc->flags |= CODEC_FLAG_QSCALE;
3568 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3571 audio_enc->channels = audio_channels;
3572 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3573 audio_enc->sample_fmt = audio_sample_fmt;
3574 if (audio_sample_rate)
3575 audio_enc->sample_rate = audio_sample_rate;
3577 if (audio_language) {
3578 av_dict_set(&st->metadata, "language", audio_language, 0);
3579 av_freep(&audio_language);
3582 /* reset some key parameters */
3584 av_freep(&audio_codec_name);
3585 audio_stream_copy = 0;
3588 static void new_data_stream(AVFormatContext *oc, int file_idx)
3592 AVCodecContext *data_enc;
3594 ost = new_output_stream(oc, file_idx, NULL);
3596 data_enc = st->codec;
3597 if (!data_stream_copy) {
3598 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3602 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3605 data_enc->codec_tag= data_codec_tag;
3607 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3608 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3610 if (data_stream_copy) {
3611 st->stream_copy = 1;
3615 av_freep(&data_codec_name);
3616 data_stream_copy = 0;
3619 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3623 AVCodec *codec=NULL;
3624 AVCodecContext *subtitle_enc;
3625 enum CodecID codec_id = CODEC_ID_NONE;
3627 if(!subtitle_stream_copy){
3628 if (subtitle_codec_name) {
3629 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3630 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3632 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3633 codec = avcodec_find_encoder(codec_id);
3636 ost = new_output_stream(oc, file_idx, codec);
3638 subtitle_enc = st->codec;
3640 ost->bitstream_filters = subtitle_bitstream_filters;
3641 subtitle_bitstream_filters= NULL;
3643 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3645 if(subtitle_codec_tag)
3646 subtitle_enc->codec_tag= subtitle_codec_tag;
3648 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3649 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3651 if (subtitle_stream_copy) {
3652 st->stream_copy = 1;
3654 subtitle_enc->codec_id = codec_id;
3657 if (subtitle_language) {
3658 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3659 av_freep(&subtitle_language);
3662 subtitle_disable = 0;
3663 av_freep(&subtitle_codec_name);
3664 subtitle_stream_copy = 0;
3667 static int opt_new_stream(const char *opt, const char *arg)
3669 AVFormatContext *oc;
3670 int file_idx = nb_output_files - 1;
3671 if (nb_output_files <= 0) {
3672 fprintf(stderr, "At least one output file must be specified\n");
3675 oc = output_files[file_idx];
3677 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3678 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3679 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3680 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3685 /* arg format is "output-stream-index:streamid-value". */
3686 static int opt_streamid(const char *opt, const char *arg)
3692 av_strlcpy(idx_str, arg, sizeof(idx_str));
3693 p = strchr(idx_str, ':');
3696 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3701 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3702 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3703 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3707 static void opt_output_file(void *optctx, const char *filename)
3709 AVFormatContext *oc;
3710 int err, use_video, use_audio, use_subtitle, use_data;
3711 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3712 AVOutputFormat *file_oformat;
3714 if (!strcmp(filename, "-"))
3717 oc = avformat_alloc_context();
3719 print_error(filename, AVERROR(ENOMEM));
3723 if (last_asked_format) {
3724 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3725 if (!file_oformat) {
3726 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3729 last_asked_format = NULL;
3731 file_oformat = av_guess_format(NULL, filename, NULL);
3732 if (!file_oformat) {
3733 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3739 oc->oformat = file_oformat;
3740 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3742 if (!strcmp(file_oformat->name, "ffm") &&
3743 av_strstart(filename, "http:", NULL)) {
3744 /* special case for files sent to avserver: we get the stream
3745 parameters from avserver */
3746 int err = read_avserver_streams(oc, filename);
3748 print_error(filename, err);
3752 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3753 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3754 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3755 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 */
3757 /* disable if no corresponding type found */
3758 check_inputs(&input_has_video,
3760 &input_has_subtitle,
3763 if (!input_has_video)
3765 if (!input_has_audio)
3767 if (!input_has_subtitle)
3769 if (!input_has_data)
3772 /* manual disable */
3773 if (audio_disable) use_audio = 0;
3774 if (video_disable) use_video = 0;
3775 if (subtitle_disable) use_subtitle = 0;
3776 if (data_disable) use_data = 0;
3778 if (use_video) new_video_stream(oc, nb_output_files);
3779 if (use_audio) new_audio_stream(oc, nb_output_files);
3780 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3781 if (use_data) new_data_stream(oc, nb_output_files);
3783 av_dict_copy(&oc->metadata, metadata, 0);
3784 av_dict_free(&metadata);
3787 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3788 output_files[nb_output_files++] = oc;
3790 /* check filename in case of an image number is expected */
3791 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3792 if (!av_filename_number_test(oc->filename)) {
3793 print_error(oc->filename, AVERROR(EINVAL));
3798 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3799 /* test if it already exists to avoid loosing precious files */
3800 if (!file_overwrite &&
3801 (strchr(filename, ':') == NULL ||
3802 filename[1] == ':' ||
3803 av_strstart(filename, "file:", NULL))) {
3804 if (avio_check(filename, 0) == 0) {
3806 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3808 if (!read_yesno()) {
3809 fprintf(stderr, "Not overwriting - exiting\n");
3814 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3821 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3822 print_error(filename, err);
3827 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3828 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3829 if (loop_output >= 0) {
3830 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3831 oc->loop_output = loop_output;
3833 oc->flags |= AVFMT_FLAG_NONBLOCK;
3835 frame_rate = (AVRational){0, 0};
3838 audio_sample_rate = 0;
3840 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3842 av_freep(&forced_key_frames);
3847 /* same option as mencoder */
3848 static int opt_pass(const char *opt, const char *arg)
3850 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3854 static int64_t getutime(void)
3857 struct rusage rusage;
3859 getrusage(RUSAGE_SELF, &rusage);
3860 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3861 #elif HAVE_GETPROCESSTIMES
3863 FILETIME c, e, k, u;
3864 proc = GetCurrentProcess();
3865 GetProcessTimes(proc, &c, &e, &k, &u);
3866 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3868 return av_gettime();
3872 static int64_t getmaxrss(void)
3874 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3875 struct rusage rusage;
3876 getrusage(RUSAGE_SELF, &rusage);
3877 return (int64_t)rusage.ru_maxrss * 1024;
3878 #elif HAVE_GETPROCESSMEMORYINFO
3880 PROCESS_MEMORY_COUNTERS memcounters;
3881 proc = GetCurrentProcess();
3882 memcounters.cb = sizeof(memcounters);
3883 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3884 return memcounters.PeakPagefileUsage;
3890 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3893 const char *p = str;
3900 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3907 static void opt_inter_matrix(const char *arg)
3909 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3910 parse_matrix_coeffs(inter_matrix, arg);
3913 static void opt_intra_matrix(const char *arg)
3915 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3916 parse_matrix_coeffs(intra_matrix, arg);
3919 static void show_usage(void)
3921 printf("Hyper fast Audio and Video encoder\n");
3922 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3926 static void show_help(void)
3929 AVOutputFormat *oformat = NULL;
3930 AVInputFormat *iformat = NULL;
3931 const AVClass *class;
3933 av_log_set_callback(log_callback_help);
3935 show_help_options(options, "Main options:\n",
3936 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3937 show_help_options(options, "\nAdvanced options:\n",
3938 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3940 show_help_options(options, "\nVideo options:\n",
3941 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3943 show_help_options(options, "\nAdvanced Video options:\n",
3944 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3945 OPT_VIDEO | OPT_EXPERT);
3946 show_help_options(options, "\nAudio options:\n",
3947 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3949 show_help_options(options, "\nAdvanced Audio options:\n",
3950 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3951 OPT_AUDIO | OPT_EXPERT);
3952 show_help_options(options, "\nSubtitle options:\n",
3953 OPT_SUBTITLE | OPT_GRAB,
3955 show_help_options(options, "\nAudio/Video grab options:\n",
3959 class = avcodec_get_class();
3960 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3963 /* individual codec options */
3965 while ((c = av_codec_next(c))) {
3966 if (c->priv_class) {
3967 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3972 class = avformat_get_class();
3973 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3976 /* individual muxer options */
3977 while ((oformat = av_oformat_next(oformat))) {
3978 if (oformat->priv_class) {
3979 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3984 /* individual demuxer options */
3985 while ((iformat = av_iformat_next(iformat))) {
3986 if (iformat->priv_class) {
3987 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3992 class = sws_get_class();
3993 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3996 static int opt_target(const char *opt, const char *arg)
3998 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3999 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4001 if(!strncmp(arg, "pal-", 4)) {
4004 } else if(!strncmp(arg, "ntsc-", 5)) {
4007 } else if(!strncmp(arg, "film-", 5)) {
4012 /* Calculate FR via float to avoid int overflow */
4013 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4016 } else if((fr == 29970) || (fr == 23976)) {
4019 /* Try to determine PAL/NTSC by peeking in the input files */
4020 if(nb_input_files) {
4022 for (j = 0; j < nb_input_files; j++) {
4023 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4024 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4025 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4027 fr = c->time_base.den * 1000 / c->time_base.num;
4031 } else if((fr == 29970) || (fr == 23976)) {
4041 if(verbose > 0 && norm != UNKNOWN)
4042 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4045 if(norm == UNKNOWN) {
4046 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4047 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4048 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4052 if(!strcmp(arg, "vcd")) {
4053 opt_video_codec("vcodec", "mpeg1video");
4054 opt_audio_codec("vcodec", "mp2");
4055 opt_format("f", "vcd");
4057 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4058 opt_frame_rate("r", frame_rates[norm]);
4059 opt_default("g", norm == PAL ? "15" : "18");
4061 opt_default("b", "1150000");
4062 opt_default("maxrate", "1150000");
4063 opt_default("minrate", "1150000");
4064 opt_default("bufsize", "327680"); // 40*1024*8;
4066 opt_default("ab", "224000");
4067 audio_sample_rate = 44100;
4070 opt_default("packetsize", "2324");
4071 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4073 /* We have to offset the PTS, so that it is consistent with the SCR.
4074 SCR starts at 36000, but the first two packs contain only padding
4075 and the first pack from the other stream, respectively, may also have
4076 been written before.
4077 So the real data starts at SCR 36000+3*1200. */
4078 mux_preload= (36000+3*1200) / 90000.0; //0.44
4079 } else if(!strcmp(arg, "svcd")) {
4081 opt_video_codec("vcodec", "mpeg2video");
4082 opt_audio_codec("acodec", "mp2");
4083 opt_format("f", "svcd");
4085 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4086 opt_frame_rate("r", frame_rates[norm]);
4087 opt_default("g", norm == PAL ? "15" : "18");
4089 opt_default("b", "2040000");
4090 opt_default("maxrate", "2516000");
4091 opt_default("minrate", "0"); //1145000;
4092 opt_default("bufsize", "1835008"); //224*1024*8;
4093 opt_default("flags", "+scan_offset");
4096 opt_default("ab", "224000");
4097 audio_sample_rate = 44100;
4099 opt_default("packetsize", "2324");
4101 } else if(!strcmp(arg, "dvd")) {
4103 opt_video_codec("vcodec", "mpeg2video");
4104 opt_audio_codec("vcodec", "ac3");
4105 opt_format("f", "dvd");
4107 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4108 opt_frame_rate("r", frame_rates[norm]);
4109 opt_default("g", norm == PAL ? "15" : "18");
4111 opt_default("b", "6000000");
4112 opt_default("maxrate", "9000000");
4113 opt_default("minrate", "0"); //1500000;
4114 opt_default("bufsize", "1835008"); //224*1024*8;
4116 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4117 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4119 opt_default("ab", "448000");
4120 audio_sample_rate = 48000;
4122 } else if(!strncmp(arg, "dv", 2)) {
4124 opt_format("f", "dv");
4126 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4127 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4128 norm == PAL ? "yuv420p" : "yuv411p");
4129 opt_frame_rate("r", frame_rates[norm]);
4131 audio_sample_rate = 48000;
4135 fprintf(stderr, "Unknown target: %s\n", arg);
4136 return AVERROR(EINVAL);
4141 static int opt_vstats_file(const char *opt, const char *arg)
4143 av_free (vstats_filename);
4144 vstats_filename=av_strdup (arg);
4148 static int opt_vstats(const char *opt, const char *arg)
4151 time_t today2 = time(NULL);
4152 struct tm *today = localtime(&today2);
4154 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4156 return opt_vstats_file(opt, filename);
4159 static int opt_bsf(const char *opt, const char *arg)
4161 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4162 AVBitStreamFilterContext **bsfp;
4165 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4169 bsfp= *opt == 'v' ? &video_bitstream_filters :
4170 *opt == 'a' ? &audio_bitstream_filters :
4171 &subtitle_bitstream_filters;
4173 bsfp= &(*bsfp)->next;
4180 static int opt_preset(const char *opt, const char *arg)
4183 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4184 char *codec_name = *opt == 'v' ? video_codec_name :
4185 *opt == 'a' ? audio_codec_name :
4186 subtitle_codec_name;
4188 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4189 fprintf(stderr, "File for preset '%s' not found\n", arg);
4194 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4195 if(line[0] == '#' && !e)
4197 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4199 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4202 if(!strcmp(tmp, "acodec")){
4203 opt_audio_codec(tmp, tmp2);
4204 }else if(!strcmp(tmp, "vcodec")){
4205 opt_video_codec(tmp, tmp2);
4206 }else if(!strcmp(tmp, "scodec")){
4207 opt_subtitle_codec(tmp, tmp2);
4208 }else if(!strcmp(tmp, "dcodec")){
4209 opt_data_codec(tmp, tmp2);
4210 }else if(opt_default(tmp, tmp2) < 0){
4211 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4221 static const OptionDef options[] = {
4223 #include "cmdutils_common_opts.h"
4224 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4225 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4226 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4227 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4228 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4229 "outfile[,metadata]:infile[,metadata]" },
4230 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4231 "outfile[,metadata]:infile[,metadata]" },
4232 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4233 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4234 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4235 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4236 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4237 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4238 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4239 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4240 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4241 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4242 "add timings for benchmarking" },
4243 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4244 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4245 "dump each input packet" },
4246 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4247 "when dumping packets, also dump the payload" },
4248 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4249 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4250 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4251 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4252 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4253 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4254 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4255 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4256 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4257 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4258 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4259 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4260 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4261 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4262 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4263 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4266 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4267 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4268 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4269 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4270 { "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" },
4271 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4272 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4273 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4274 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4275 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4276 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4277 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4278 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4279 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4280 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4281 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4282 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4283 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4284 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4285 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4286 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4287 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4288 "use same quantizer as source (implies VBR)" },
4289 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4290 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4291 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4292 "deinterlace pictures" },
4293 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4294 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4295 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4297 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4299 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4300 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4301 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4302 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4303 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4304 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4305 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4306 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4307 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4308 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4309 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4312 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4313 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4314 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4315 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4316 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4317 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4318 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4319 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4320 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4321 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4322 { "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" },
4324 /* subtitle options */
4325 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4326 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4327 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4328 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4329 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4332 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4333 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4334 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4337 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4338 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4340 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4341 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4342 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4344 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4345 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4346 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4347 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4348 /* data codec support */
4349 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4351 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4355 int main(int argc, char **argv)
4359 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4360 parse_loglevel(argc, argv, options);
4362 avcodec_register_all();
4364 avdevice_register_all();
4367 avfilter_register_all();
4371 avio_set_interrupt_cb(decode_interrupt_cb);
4377 av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
4378 "provided for compatibility. Use avconv instead "
4379 "(see Changelog for the list of incompatible changes).\n");
4382 parse_options(NULL, argc, argv, options, opt_output_file);
4384 if(nb_output_files <= 0 && nb_input_files == 0) {
4386 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4390 /* file converter / grab */
4391 if (nb_output_files <= 0) {
4392 fprintf(stderr, "At least one output file must be specified\n");
4396 if (nb_input_files == 0) {
4397 fprintf(stderr, "At least one input file must be specified\n");
4402 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4403 stream_maps, nb_stream_maps) < 0)
4405 ti = getutime() - ti;
4407 int maxrss = getmaxrss() / 1024;
4408 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);