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/pixdesc.h"
44 #include "libavutil/avstring.h"
45 #include "libavutil/libm.h"
46 #include "libavformat/os_support.h"
49 # include "libavfilter/avfilter.h"
50 # include "libavfilter/avfiltergraph.h"
51 # include "libavfilter/vsrc_buffer.h"
54 #if HAVE_SYS_RESOURCE_H
55 #include <sys/types.h>
57 #include <sys/resource.h>
58 #elif HAVE_GETPROCESSTIMES
61 #if HAVE_GETPROCESSMEMORYINFO
67 #include <sys/select.h>
74 #include "libavutil/avassert.h"
76 const char program_name[] = "ffmpeg";
77 const int program_birth_year = 2000;
79 /* select an input stream for an output stream */
80 typedef struct AVStreamMap {
84 int sync_stream_index;
88 * select an input file for an output file
90 typedef struct AVMetaDataMap {
91 int file; //< file index
92 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
93 int index; //< stream/chapter/program number
96 typedef struct AVChapterMap {
101 static const OptionDef options[];
103 #define MAX_FILES 100
104 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
106 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
108 static const char *last_asked_format = NULL;
109 static int64_t input_files_ts_offset[MAX_FILES];
110 static double *input_files_ts_scale[MAX_FILES] = {NULL};
111 static AVCodec **input_codecs = NULL;
112 static int nb_input_codecs = 0;
113 static int nb_input_files_ts_scale[MAX_FILES] = {0};
115 static AVFormatContext *output_files[MAX_FILES];
116 static AVDictionary *output_opts[MAX_FILES];
117 static int nb_output_files = 0;
119 static AVStreamMap *stream_maps = NULL;
120 static int nb_stream_maps;
122 /* first item specifies output metadata, second is input */
123 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
124 static int nb_meta_data_maps;
125 static int metadata_global_autocopy = 1;
126 static int metadata_streams_autocopy = 1;
127 static int metadata_chapters_autocopy = 1;
129 static AVChapterMap *chapter_maps = NULL;
130 static int nb_chapter_maps;
132 /* indexed by output file stream index */
133 static int *streamid_map = NULL;
134 static int nb_streamid_map = 0;
136 static int frame_width = 0;
137 static int frame_height = 0;
138 static float frame_aspect_ratio = 0;
139 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
140 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
141 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
142 static AVRational frame_rate;
143 static float video_qscale = 0;
144 static uint16_t *intra_matrix = NULL;
145 static uint16_t *inter_matrix = NULL;
146 static const char *video_rc_override_string=NULL;
147 static int video_disable = 0;
148 static int video_discard = 0;
149 static char *video_codec_name = NULL;
150 static unsigned int video_codec_tag = 0;
151 static char *video_language = NULL;
152 static int same_quality = 0;
153 static int do_deinterlace = 0;
154 static int top_field_first = -1;
155 static int me_threshold = 0;
156 static int intra_dc_precision = 8;
157 static int loop_input = 0;
158 static int loop_output = AVFMT_NOOUTPUTLOOP;
159 static int qp_hist = 0;
161 static char *vfilters = NULL;
164 static int intra_only = 0;
165 static int audio_sample_rate = 0;
166 static int64_t channel_layout = 0;
167 #define QSCALE_NONE -99999
168 static float audio_qscale = QSCALE_NONE;
169 static int audio_disable = 0;
170 static int audio_channels = 0;
171 static char *audio_codec_name = NULL;
172 static unsigned int audio_codec_tag = 0;
173 static char *audio_language = NULL;
175 static int subtitle_disable = 0;
176 static char *subtitle_codec_name = NULL;
177 static char *subtitle_language = NULL;
178 static unsigned int subtitle_codec_tag = 0;
180 static int data_disable = 0;
181 static char *data_codec_name = NULL;
182 static unsigned int data_codec_tag = 0;
184 static float mux_preload= 0.5;
185 static float mux_max_delay= 0.7;
187 static int64_t recording_time = INT64_MAX;
188 static int64_t start_time = 0;
189 static int64_t recording_timestamp = 0;
190 static int64_t input_ts_offset = 0;
191 static int file_overwrite = 0;
192 static AVDictionary *metadata;
193 static int do_benchmark = 0;
194 static int do_hex_dump = 0;
195 static int do_pkt_dump = 0;
196 static int do_psnr = 0;
197 static int do_pass = 0;
198 static char *pass_logfilename_prefix = NULL;
199 static int audio_stream_copy = 0;
200 static int video_stream_copy = 0;
201 static int subtitle_stream_copy = 0;
202 static int data_stream_copy = 0;
203 static int video_sync_method= -1;
204 static int audio_sync_method= 0;
205 static float audio_drift_threshold= 0.1;
206 static int copy_ts= 0;
208 static int opt_shortest = 0;
209 static char *vstats_filename;
210 static FILE *vstats_file;
211 static int opt_programid = 0;
212 static int copy_initial_nonkeyframes = 0;
214 static int rate_emu = 0;
216 static int audio_volume = 256;
218 static int exit_on_error = 0;
219 static int using_stdin = 0;
220 static int verbose = 1;
221 static int thread_count= 1;
222 static int64_t video_size = 0;
223 static int64_t audio_size = 0;
224 static int64_t extra_size = 0;
225 static int nb_frames_dup = 0;
226 static int nb_frames_drop = 0;
227 static int input_sync;
228 static uint64_t limit_filesize = 0;
229 static int force_fps = 0;
230 static char *forced_key_frames = NULL;
232 static float dts_delta_threshold = 10;
234 static int64_t timer_start;
236 static uint8_t *audio_buf;
237 static uint8_t *audio_out;
238 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
240 static short *samples;
242 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
243 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
244 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
246 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
248 struct AVInputStream;
250 typedef struct AVOutputStream {
251 int file_index; /* file index */
252 int index; /* stream index in the output file */
253 int source_index; /* AVInputStream index */
254 AVStream *st; /* stream in the output file */
255 int encoding_needed; /* true if encoding needed for this stream */
257 /* input pts and corresponding output pts
259 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
260 struct AVInputStream *sync_ist; /* input stream to sync against */
261 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
262 AVBitStreamFilterContext *bitstream_filters;
267 AVFrame pict_tmp; /* temporary image for resampling */
268 struct SwsContext *img_resample_ctx; /* for image resampling */
271 int resample_pix_fmt;
272 AVRational frame_rate;
274 float frame_aspect_ratio;
276 /* forced key frames */
277 int64_t *forced_kf_pts;
283 ReSampleContext *resample; /* for audio resampling */
284 int resample_sample_fmt;
285 int resample_channels;
286 int resample_sample_rate;
288 AVAudioConvert *reformat_ctx;
289 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
293 AVFilterContext *output_video_filter;
294 AVFilterContext *input_video_filter;
295 AVFilterBufferRef *picref;
297 AVFilterGraph *graph;
303 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
304 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
306 typedef struct AVInputStream {
309 int discard; /* true if stream data should be discarded */
310 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
311 int64_t sample_index; /* current sample */
313 int64_t start; /* time when read started */
314 int64_t next_pts; /* synthetic pts for cases where pkt.pts
316 int64_t pts; /* current pts */
317 PtsCorrectionContext pts_ctx;
318 int is_start; /* is 1 at the start and after a discontinuity */
319 int showed_multi_packet_warning;
320 int is_past_recording_time;
322 AVFrame *filter_frame;
323 int has_filter_frame;
327 typedef struct AVInputFile {
328 AVFormatContext *ctx;
329 int eof_reached; /* true if eof reached */
330 int ist_index; /* index of first stream in ist_table */
331 int buffer_size; /* current total buffer size */
334 static AVInputStream *input_streams = NULL;
335 static int nb_input_streams = 0;
336 static AVInputFile *input_files = NULL;
337 static int nb_input_files = 0;
341 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
343 AVFilterContext *last_filter, *filter;
344 /** filter graph containing all filters including input & output */
345 AVCodecContext *codec = ost->st->codec;
346 AVCodecContext *icodec = ist->st->codec;
347 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
348 AVRational sample_aspect_ratio;
352 ost->graph = avfilter_graph_alloc();
354 if (ist->st->sample_aspect_ratio.num){
355 sample_aspect_ratio = ist->st->sample_aspect_ratio;
357 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
359 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
360 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
361 sample_aspect_ratio.num, sample_aspect_ratio.den);
363 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
364 "src", args, NULL, ost->graph);
367 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
368 "out", NULL, &ffsink_ctx, ost->graph);
371 last_filter = ost->input_video_filter;
373 if (codec->width != icodec->width || codec->height != icodec->height) {
374 snprintf(args, 255, "%d:%d:flags=0x%X",
378 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
379 NULL, args, NULL, ost->graph)) < 0)
381 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
383 last_filter = filter;
386 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
387 ost->graph->scale_sws_opts = av_strdup(args);
390 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
391 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
393 outputs->name = av_strdup("in");
394 outputs->filter_ctx = last_filter;
395 outputs->pad_idx = 0;
396 outputs->next = NULL;
398 inputs->name = av_strdup("out");
399 inputs->filter_ctx = ost->output_video_filter;
403 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
405 av_freep(&ost->avfilter);
407 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
411 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
414 codec->width = ost->output_video_filter->inputs[0]->w;
415 codec->height = ost->output_video_filter->inputs[0]->h;
416 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
417 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
418 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
419 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
423 #endif /* CONFIG_AVFILTER */
425 static void term_exit(void)
427 av_log(NULL, AV_LOG_QUIET, "");
430 static volatile int received_sigterm = 0;
431 static volatile int received_nb_signals = 0;
434 sigterm_handler(int sig)
436 received_sigterm = sig;
437 received_nb_signals++;
441 static void term_init(void)
443 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
444 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
446 signal(SIGXCPU, sigterm_handler);
450 static int decode_interrupt_cb(void)
452 return received_nb_signals > 1;
455 static int ffmpeg_exit(int ret)
460 for(i=0;i<nb_output_files;i++) {
461 AVFormatContext *s = output_files[i];
462 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
464 avformat_free_context(s);
465 av_free(output_streams_for_file[i]);
466 av_dict_free(&output_opts[i]);
468 for(i=0;i<nb_input_files;i++) {
469 av_close_input_file(input_files[i].ctx);
470 av_free(input_files_ts_scale[i]);
473 av_free(intra_matrix);
474 av_free(inter_matrix);
478 av_free(vstats_filename);
480 av_free(streamid_map);
481 av_free(input_codecs);
482 av_free(stream_maps);
483 av_free(meta_data_maps);
485 av_freep(&input_streams);
486 av_freep(&input_files);
488 av_free(video_codec_name);
489 av_free(audio_codec_name);
490 av_free(subtitle_codec_name);
491 av_free(data_codec_name);
496 allocated_audio_buf_size= allocated_audio_out_size= 0;
503 if (received_sigterm) {
505 "Received signal %d: terminating.\n",
506 (int) received_sigterm);
510 exit(ret); /* not all OS-es handle main() return value */
514 static void assert_avoptions(AVDictionary *m)
516 AVDictionaryEntry *t;
517 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
518 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
523 /* similar to ff_dynarray_add() and av_fast_realloc() */
524 static void *grow_array(void *array, int elem_size, int *size, int new_size)
526 if (new_size >= INT_MAX / elem_size) {
527 fprintf(stderr, "Array too big.\n");
530 if (*size < new_size) {
531 uint8_t *tmp = av_realloc(array, new_size*elem_size);
533 fprintf(stderr, "Could not alloc buffer.\n");
536 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
543 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
545 if(codec && codec->sample_fmts){
546 const enum AVSampleFormat *p= codec->sample_fmts;
548 if(*p == st->codec->sample_fmt)
552 av_log(NULL, AV_LOG_WARNING,
553 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
554 av_get_sample_fmt_name(st->codec->sample_fmt),
556 av_get_sample_fmt_name(codec->sample_fmts[0]));
557 st->codec->sample_fmt = codec->sample_fmts[0];
563 * Update the requested input sample format based on the output sample format.
564 * This is currently only used to request float output from decoders which
565 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
566 * Ideally this will be removed in the future when decoders do not do format
567 * conversion and only output in their native format.
569 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
572 /* if sample formats match or a decoder sample format has already been
573 requested, just return */
574 if (enc->sample_fmt == dec->sample_fmt ||
575 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
578 /* if decoder supports more than one output format */
579 if (dec_codec && dec_codec->sample_fmts &&
580 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
581 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
582 const enum AVSampleFormat *p;
583 int min_dec = -1, min_inc = -1;
585 /* find a matching sample format in the encoder */
586 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
587 if (*p == enc->sample_fmt) {
588 dec->request_sample_fmt = *p;
590 } else if (*p > enc->sample_fmt) {
591 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
593 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
596 /* if none match, provide the one that matches quality closest */
597 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
598 enc->sample_fmt - min_dec;
602 static void choose_sample_rate(AVStream *st, AVCodec *codec)
604 if(codec && codec->supported_samplerates){
605 const int *p= codec->supported_samplerates;
607 int best_dist=INT_MAX;
609 int dist= abs(st->codec->sample_rate - *p);
610 if(dist < best_dist){
616 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
618 st->codec->sample_rate= best;
622 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
624 if(codec && codec->pix_fmts){
625 const enum PixelFormat *p= codec->pix_fmts;
626 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
627 if(st->codec->codec_id==CODEC_ID_MJPEG){
628 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
629 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
630 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};
634 if(*p == st->codec->pix_fmt)
638 if(st->codec->pix_fmt != PIX_FMT_NONE)
639 av_log(NULL, AV_LOG_WARNING,
640 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
641 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
643 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
644 st->codec->pix_fmt = codec->pix_fmts[0];
649 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
651 int idx = oc->nb_streams - 1;
654 output_streams_for_file[file_idx] =
655 grow_array(output_streams_for_file[file_idx],
656 sizeof(*output_streams_for_file[file_idx]),
657 &nb_output_streams_for_file[file_idx],
659 ost = output_streams_for_file[file_idx][idx] =
660 av_mallocz(sizeof(AVOutputStream));
662 fprintf(stderr, "Could not alloc output stream\n");
665 ost->file_index = file_idx;
668 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
672 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
675 AVFormatContext *ic = NULL;
678 err = avformat_open_input(&ic, filename, NULL, NULL);
681 /* copy stream format */
683 s->streams = av_mallocz(sizeof(AVStream *) * ic->nb_streams);
684 for(i=0;i<ic->nb_streams;i++) {
690 // FIXME: a more elegant solution is needed
691 st = av_mallocz(sizeof(AVStream));
692 memcpy(st, ic->streams[i], sizeof(AVStream));
694 st->codec = avcodec_alloc_context();
696 print_error(filename, AVERROR(ENOMEM));
699 avcodec_copy_context(st->codec, ic->streams[i]->codec);
702 codec = avcodec_find_encoder(st->codec->codec_id);
703 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
704 if (audio_stream_copy) {
707 choose_sample_fmt(st, codec);
708 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
709 if (video_stream_copy) {
712 choose_pixel_fmt(st, codec);
715 if(st->codec->flags & CODEC_FLAG_BITEXACT)
718 new_output_stream(s, nb_output_files);
722 s->timestamp = av_gettime();
724 av_close_input_file(ic);
729 get_sync_ipts(const AVOutputStream *ost)
731 const AVInputStream *ist = ost->sync_ist;
732 return (double)(ist->pts - start_time)/AV_TIME_BASE;
735 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
739 AVPacket new_pkt= *pkt;
740 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
741 &new_pkt.data, &new_pkt.size,
742 pkt->data, pkt->size,
743 pkt->flags & AV_PKT_FLAG_KEY);
746 new_pkt.destruct= av_destruct_packet;
748 fprintf(stderr, "%s failed for stream %d, codec %s",
749 bsfc->filter->name, pkt->stream_index,
750 avctx->codec ? avctx->codec->name : "copy");
760 ret= av_interleaved_write_frame(s, pkt);
762 print_error("av_interleaved_write_frame()", ret);
767 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
769 static void do_audio_out(AVFormatContext *s,
772 unsigned char *buf, int size)
775 int64_t audio_out_size, audio_buf_size;
776 int64_t allocated_for_size= size;
778 int size_out, frame_bytes, ret, resample_changed;
779 AVCodecContext *enc= ost->st->codec;
780 AVCodecContext *dec= ist->st->codec;
781 int osize = av_get_bytes_per_sample(enc->sample_fmt);
782 int isize = av_get_bytes_per_sample(dec->sample_fmt);
783 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
786 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
787 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
788 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
789 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
790 audio_buf_size*= osize*enc->channels;
792 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
793 if(coded_bps > 8*osize)
794 audio_out_size= audio_out_size * coded_bps / (8*osize);
795 audio_out_size += FF_MIN_BUFFER_SIZE;
797 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
798 fprintf(stderr, "Buffer sizes too large\n");
802 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
803 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
804 if (!audio_buf || !audio_out){
805 fprintf(stderr, "Out of memory in do_audio_out\n");
809 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
810 ost->audio_resample = 1;
812 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
813 ost->resample_channels != dec->channels ||
814 ost->resample_sample_rate != dec->sample_rate;
816 if ((ost->audio_resample && !ost->resample) || resample_changed) {
817 if (resample_changed) {
818 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",
819 ist->file_index, ist->st->index,
820 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
821 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
822 ost->resample_sample_fmt = dec->sample_fmt;
823 ost->resample_channels = dec->channels;
824 ost->resample_sample_rate = dec->sample_rate;
826 audio_resample_close(ost->resample);
828 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
829 if (audio_sync_method <= 1 &&
830 ost->resample_sample_fmt == enc->sample_fmt &&
831 ost->resample_channels == enc->channels &&
832 ost->resample_sample_rate == enc->sample_rate) {
833 ost->resample = NULL;
834 ost->audio_resample = 0;
835 } else if (ost->audio_resample) {
836 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
837 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
838 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
839 enc->sample_rate, dec->sample_rate,
840 enc->sample_fmt, dec->sample_fmt,
842 if (!ost->resample) {
843 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
844 dec->channels, dec->sample_rate,
845 enc->channels, enc->sample_rate);
851 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
852 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
853 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
854 if (ost->reformat_ctx)
855 av_audio_convert_free(ost->reformat_ctx);
856 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
857 dec->sample_fmt, 1, NULL, 0);
858 if (!ost->reformat_ctx) {
859 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
860 av_get_sample_fmt_name(dec->sample_fmt),
861 av_get_sample_fmt_name(enc->sample_fmt));
864 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
867 if(audio_sync_method){
868 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
869 - av_fifo_size(ost->fifo)/(enc->channels * 2);
870 double idelta= delta*dec->sample_rate / enc->sample_rate;
871 int byte_delta= ((int)idelta)*2*dec->channels;
873 //FIXME resample delay
874 if(fabs(delta) > 50){
875 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
877 byte_delta= FFMAX(byte_delta, -size);
881 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
886 static uint8_t *input_tmp= NULL;
887 input_tmp= av_realloc(input_tmp, byte_delta + size);
889 if(byte_delta > allocated_for_size - size){
890 allocated_for_size= byte_delta + (int64_t)size;
895 memset(input_tmp, 0, byte_delta);
896 memcpy(input_tmp + byte_delta, buf, size);
900 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
902 }else if(audio_sync_method>1){
903 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
904 av_assert0(ost->audio_resample);
906 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
907 // 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));
908 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
912 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
913 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
915 if (ost->audio_resample) {
917 size_out = audio_resample(ost->resample,
918 (short *)buftmp, (short *)buf,
919 size / (dec->channels * isize));
920 size_out = size_out * enc->channels * osize;
926 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
927 const void *ibuf[6]= {buftmp};
928 void *obuf[6]= {audio_buf};
929 int istride[6]= {isize};
930 int ostride[6]= {osize};
931 int len= size_out/istride[0];
932 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
933 printf("av_audio_convert() failed\n");
939 size_out = len*osize;
942 /* now encode as many frames as possible */
943 if (enc->frame_size > 1) {
944 /* output resampled raw samples */
945 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
946 fprintf(stderr, "av_fifo_realloc2() failed\n");
949 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
951 frame_bytes = enc->frame_size * osize * enc->channels;
953 while (av_fifo_size(ost->fifo) >= frame_bytes) {
955 av_init_packet(&pkt);
957 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
959 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
961 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
964 fprintf(stderr, "Audio encoding failed\n");
968 pkt.stream_index= ost->index;
971 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
972 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
973 pkt.flags |= AV_PKT_FLAG_KEY;
974 write_frame(s, &pkt, enc, ost->bitstream_filters);
976 ost->sync_opts += enc->frame_size;
980 av_init_packet(&pkt);
982 ost->sync_opts += size_out / (osize * enc->channels);
984 /* output a pcm frame */
985 /* determine the size of the coded buffer */
988 size_out = size_out*coded_bps/8;
990 if(size_out > audio_out_size){
991 fprintf(stderr, "Internal error, buffer size too small\n");
995 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
996 ret = avcodec_encode_audio(enc, audio_out, size_out,
999 fprintf(stderr, "Audio encoding failed\n");
1003 pkt.stream_index= ost->index;
1004 pkt.data= audio_out;
1006 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1007 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1008 pkt.flags |= AV_PKT_FLAG_KEY;
1009 write_frame(s, &pkt, enc, ost->bitstream_filters);
1013 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1015 AVCodecContext *dec;
1016 AVPicture *picture2;
1017 AVPicture picture_tmp;
1020 dec = ist->st->codec;
1022 /* deinterlace : must be done before any resize */
1023 if (do_deinterlace) {
1026 /* create temporary picture */
1027 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1028 buf = av_malloc(size);
1032 picture2 = &picture_tmp;
1033 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1035 if(avpicture_deinterlace(picture2, picture,
1036 dec->pix_fmt, dec->width, dec->height) < 0) {
1037 /* if error, do not deinterlace */
1038 fprintf(stderr, "Deinterlacing failed\n");
1047 if (picture != picture2)
1048 *picture = *picture2;
1052 /* we begin to correct av delay at this threshold */
1053 #define AV_DELAY_MAX 0.100
1055 static void do_subtitle_out(AVFormatContext *s,
1056 AVOutputStream *ost,
1061 static uint8_t *subtitle_out = NULL;
1062 int subtitle_out_max_size = 1024 * 1024;
1063 int subtitle_out_size, nb, i;
1064 AVCodecContext *enc;
1067 if (pts == AV_NOPTS_VALUE) {
1068 fprintf(stderr, "Subtitle packets must have a pts\n");
1074 enc = ost->st->codec;
1076 if (!subtitle_out) {
1077 subtitle_out = av_malloc(subtitle_out_max_size);
1080 /* Note: DVB subtitle need one packet to draw them and one other
1081 packet to clear them */
1082 /* XXX: signal it in the codec context ? */
1083 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1088 for(i = 0; i < nb; i++) {
1089 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1090 // start_display_time is required to be 0
1091 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1092 sub->end_display_time -= sub->start_display_time;
1093 sub->start_display_time = 0;
1094 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1095 subtitle_out_max_size, sub);
1096 if (subtitle_out_size < 0) {
1097 fprintf(stderr, "Subtitle encoding failed\n");
1101 av_init_packet(&pkt);
1102 pkt.stream_index = ost->index;
1103 pkt.data = subtitle_out;
1104 pkt.size = subtitle_out_size;
1105 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1106 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1107 /* XXX: the pts correction is handled here. Maybe handling
1108 it in the codec would be better */
1110 pkt.pts += 90 * sub->start_display_time;
1112 pkt.pts += 90 * sub->end_display_time;
1114 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1118 static int bit_buffer_size= 1024*256;
1119 static uint8_t *bit_buffer= NULL;
1121 static void do_video_out(AVFormatContext *s,
1122 AVOutputStream *ost,
1124 AVFrame *in_picture,
1127 int nb_frames, i, ret, resample_changed;
1128 AVFrame *final_picture, *formatted_picture;
1129 AVCodecContext *enc, *dec;
1132 enc = ost->st->codec;
1133 dec = ist->st->codec;
1135 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1137 /* by default, we output a single frame */
1142 if(video_sync_method){
1143 double vdelta = sync_ipts - ost->sync_opts;
1144 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1147 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1150 }else if(vdelta>0.6)
1151 ost->sync_opts= lrintf(sync_ipts);
1152 }else if (vdelta > 1.1)
1153 nb_frames = lrintf(vdelta);
1154 //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);
1155 if (nb_frames == 0){
1158 fprintf(stderr, "*** drop!\n");
1159 }else if (nb_frames > 1) {
1160 nb_frames_dup += nb_frames - 1;
1162 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1165 ost->sync_opts= lrintf(sync_ipts);
1167 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1171 formatted_picture = in_picture;
1172 final_picture = formatted_picture;
1174 resample_changed = ost->resample_width != dec->width ||
1175 ost->resample_height != dec->height ||
1176 ost->resample_pix_fmt != dec->pix_fmt;
1178 if (resample_changed) {
1179 av_log(NULL, AV_LOG_INFO,
1180 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1181 ist->file_index, ist->st->index,
1182 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1183 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1184 if(!ost->video_resample)
1188 #if !CONFIG_AVFILTER
1189 if (ost->video_resample) {
1190 final_picture = &ost->pict_tmp;
1191 if (resample_changed) {
1192 /* initialize a new scaler context */
1193 sws_freeContext(ost->img_resample_ctx);
1194 ost->img_resample_ctx = sws_getContext(
1195 ist->st->codec->width,
1196 ist->st->codec->height,
1197 ist->st->codec->pix_fmt,
1198 ost->st->codec->width,
1199 ost->st->codec->height,
1200 ost->st->codec->pix_fmt,
1201 ost->sws_flags, NULL, NULL, NULL);
1202 if (ost->img_resample_ctx == NULL) {
1203 fprintf(stderr, "Cannot get resampling context\n");
1207 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1208 0, ost->resample_height, final_picture->data, final_picture->linesize);
1212 /* duplicates frame if needed */
1213 for(i=0;i<nb_frames;i++) {
1215 av_init_packet(&pkt);
1216 pkt.stream_index= ost->index;
1218 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1219 /* raw pictures are written as AVPicture structure to
1220 avoid any copies. We support temorarily the older
1222 AVFrame* old_frame = enc->coded_frame;
1223 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1224 pkt.data= (uint8_t *)final_picture;
1225 pkt.size= sizeof(AVPicture);
1226 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1227 pkt.flags |= AV_PKT_FLAG_KEY;
1229 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1230 enc->coded_frame = old_frame;
1232 AVFrame big_picture;
1234 big_picture= *final_picture;
1235 /* better than nothing: use input picture interlaced
1237 big_picture.interlaced_frame = in_picture->interlaced_frame;
1238 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1239 if(top_field_first == -1)
1240 big_picture.top_field_first = in_picture->top_field_first;
1242 big_picture.top_field_first = top_field_first;
1245 /* handles sameq here. This is not correct because it may
1246 not be a global option */
1247 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1249 big_picture.pict_type = 0;
1250 // big_picture.pts = AV_NOPTS_VALUE;
1251 big_picture.pts= ost->sync_opts;
1252 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1253 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1254 if (ost->forced_kf_index < ost->forced_kf_count &&
1255 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1256 big_picture.pict_type = AV_PICTURE_TYPE_I;
1257 ost->forced_kf_index++;
1259 ret = avcodec_encode_video(enc,
1260 bit_buffer, bit_buffer_size,
1263 fprintf(stderr, "Video encoding failed\n");
1268 pkt.data= bit_buffer;
1270 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1271 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1272 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1273 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1274 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1276 if(enc->coded_frame->key_frame)
1277 pkt.flags |= AV_PKT_FLAG_KEY;
1278 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1281 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1282 // enc->frame_number-1, ret, enc->pict_type);
1283 /* if two pass, output log */
1284 if (ost->logfile && enc->stats_out) {
1285 fprintf(ost->logfile, "%s", enc->stats_out);
1290 ost->frame_number++;
1294 static double psnr(double d){
1295 return -10.0*log(d)/log(10.0);
1298 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1301 AVCodecContext *enc;
1303 double ti1, bitrate, avg_bitrate;
1305 /* this is executed just the first time do_video_stats is called */
1307 vstats_file = fopen(vstats_filename, "w");
1314 enc = ost->st->codec;
1315 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1316 frame_number = ost->frame_number;
1317 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1318 if (enc->flags&CODEC_FLAG_PSNR)
1319 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1321 fprintf(vstats_file,"f_size= %6d ", frame_size);
1322 /* compute pts value */
1323 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1327 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1328 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1329 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1330 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1331 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1335 static void print_report(AVFormatContext **output_files,
1336 AVOutputStream **ost_table, int nb_ostreams,
1340 AVOutputStream *ost;
1341 AVFormatContext *oc;
1343 AVCodecContext *enc;
1344 int frame_number, vid, i;
1345 double bitrate, ti1, pts;
1346 static int64_t last_time = -1;
1347 static int qp_histogram[52];
1349 if (!is_last_report) {
1351 /* display the report every 0.5 seconds */
1352 cur_time = av_gettime();
1353 if (last_time == -1) {
1354 last_time = cur_time;
1357 if ((cur_time - last_time) < 500000)
1359 last_time = cur_time;
1363 oc = output_files[0];
1365 total_size = avio_size(oc->pb);
1366 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1367 total_size= avio_tell(oc->pb);
1372 for(i=0;i<nb_ostreams;i++) {
1375 enc = ost->st->codec;
1376 if (!ost->st->stream_copy && enc->coded_frame)
1377 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1378 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1379 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1381 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1382 float t = (av_gettime()-timer_start) / 1000000.0;
1384 frame_number = ost->frame_number;
1385 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1386 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1392 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1395 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1397 if (enc->flags&CODEC_FLAG_PSNR){
1399 double error, error_sum=0;
1400 double scale, scale_sum=0;
1401 char type[3]= {'Y','U','V'};
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1405 error= enc->error[j];
1406 scale= enc->width*enc->height*255.0*255.0*frame_number;
1408 error= enc->coded_frame->error[j];
1409 scale= enc->width*enc->height*255.0*255.0;
1414 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1420 /* compute min output value */
1421 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1422 if ((pts < ti1) && (pts > 0))
1428 if (verbose > 0 || is_last_report) {
1429 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1431 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1432 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1433 (double)total_size / 1024, ti1, bitrate);
1435 if (nb_frames_dup || nb_frames_drop)
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1437 nb_frames_dup, nb_frames_drop);
1440 fprintf(stderr, "%s \r", buf);
1445 if (is_last_report && verbose >= 0){
1446 int64_t raw= audio_size + video_size + extra_size;
1447 fprintf(stderr, "\n");
1448 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1452 100.0*(total_size - raw)/raw
1457 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1459 int fill_char = 0x00;
1460 if (sample_fmt == AV_SAMPLE_FMT_U8)
1462 memset(buf, fill_char, size);
1465 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1466 static int output_packet(AVInputStream *ist, int ist_index,
1467 AVOutputStream **ost_table, int nb_ostreams,
1468 const AVPacket *pkt)
1470 AVFormatContext *os;
1471 AVOutputStream *ost;
1475 void *buffer_to_free = NULL;
1476 static unsigned int samples_size= 0;
1477 AVSubtitle subtitle, *subtitle_to_free;
1478 int64_t pkt_pts = AV_NOPTS_VALUE;
1480 int frame_available;
1484 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1486 if(ist->next_pts == AV_NOPTS_VALUE)
1487 ist->next_pts= ist->pts;
1491 av_init_packet(&avpkt);
1499 if(pkt->dts != AV_NOPTS_VALUE)
1500 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1501 if(pkt->pts != AV_NOPTS_VALUE)
1502 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1504 //while we have more to decode or while the decoder did output something on EOF
1505 while (avpkt.size > 0 || (!pkt && got_output)) {
1506 uint8_t *data_buf, *decoded_data_buf;
1507 int data_size, decoded_data_size;
1509 ist->pts= ist->next_pts;
1511 if(avpkt.size && avpkt.size != pkt->size &&
1512 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1513 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1514 ist->showed_multi_packet_warning=1;
1517 /* decode the packet if needed */
1518 decoded_data_buf = NULL; /* fail safe */
1519 decoded_data_size= 0;
1520 data_buf = avpkt.data;
1521 data_size = avpkt.size;
1522 subtitle_to_free = NULL;
1523 if (ist->decoding_needed) {
1524 switch(ist->st->codec->codec_type) {
1525 case AVMEDIA_TYPE_AUDIO:{
1526 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1527 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1529 samples= av_malloc(samples_size);
1531 decoded_data_size= samples_size;
1532 /* XXX: could avoid copy if PCM 16 bits with same
1533 endianness as CPU */
1534 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1541 got_output = decoded_data_size > 0;
1542 /* Some bug in mpeg audio decoder gives */
1543 /* decoded_data_size < 0, it seems they are overflows */
1545 /* no audio frame */
1548 decoded_data_buf = (uint8_t *)samples;
1549 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1550 (ist->st->codec->sample_rate * ist->st->codec->channels);
1552 case AVMEDIA_TYPE_VIDEO:
1553 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1554 /* XXX: allocate picture correctly */
1555 avcodec_get_frame_defaults(&picture);
1556 avpkt.pts = pkt_pts;
1557 avpkt.dts = ist->pts;
1558 pkt_pts = AV_NOPTS_VALUE;
1560 ret = avcodec_decode_video2(ist->st->codec,
1561 &picture, &got_output, &avpkt);
1562 ist->st->quality= picture.quality;
1566 /* no picture yet */
1567 goto discard_packet;
1569 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1570 if (ist->st->codec->time_base.num != 0) {
1571 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1572 ist->next_pts += ((int64_t)AV_TIME_BASE *
1573 ist->st->codec->time_base.num * ticks) /
1574 ist->st->codec->time_base.den;
1577 buffer_to_free = NULL;
1578 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1580 case AVMEDIA_TYPE_SUBTITLE:
1581 ret = avcodec_decode_subtitle2(ist->st->codec,
1582 &subtitle, &got_output, &avpkt);
1586 goto discard_packet;
1588 subtitle_to_free = &subtitle;
1595 switch(ist->st->codec->codec_type) {
1596 case AVMEDIA_TYPE_AUDIO:
1597 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1598 ist->st->codec->sample_rate;
1600 case AVMEDIA_TYPE_VIDEO:
1601 if (ist->st->codec->time_base.num != 0) {
1602 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1603 ist->next_pts += ((int64_t)AV_TIME_BASE *
1604 ist->st->codec->time_base.num * ticks) /
1605 ist->st->codec->time_base.den;
1614 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1615 for (i = 0; i < nb_ostreams; i++) {
1617 if (ost->input_video_filter && ost->source_index == ist_index) {
1619 if (ist->st->sample_aspect_ratio.num)
1620 sar = ist->st->sample_aspect_ratio;
1622 sar = ist->st->codec->sample_aspect_ratio;
1623 // add it to be filtered
1624 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1632 // preprocess audio (volume)
1633 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1634 if (audio_volume != 256) {
1637 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1638 int v = ((*volp) * audio_volume + 128) >> 8;
1639 if (v < -32768) v = -32768;
1640 if (v > 32767) v = 32767;
1646 /* frame rate emulation */
1648 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1649 int64_t now = av_gettime() - ist->start;
1653 /* if output time reached then transcode raw format,
1654 encode packets and output them */
1655 if (start_time == 0 || ist->pts >= start_time)
1656 for(i=0;i<nb_ostreams;i++) {
1660 if (ost->source_index == ist_index) {
1662 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1663 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1664 while (frame_available) {
1665 AVRational ist_pts_tb;
1666 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1667 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1669 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1671 os = output_files[ost->file_index];
1673 /* set the input output pts pairs */
1674 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1676 if (ost->encoding_needed) {
1677 av_assert0(ist->decoding_needed);
1678 switch(ost->st->codec->codec_type) {
1679 case AVMEDIA_TYPE_AUDIO:
1680 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1682 case AVMEDIA_TYPE_VIDEO:
1684 if (ost->picref->video && !ost->frame_aspect_ratio)
1685 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1687 do_video_out(os, ost, ist, &picture, &frame_size);
1688 if (vstats_filename && frame_size)
1689 do_video_stats(os, ost, frame_size);
1691 case AVMEDIA_TYPE_SUBTITLE:
1692 do_subtitle_out(os, ost, ist, &subtitle,
1699 AVFrame avframe; //FIXME/XXX remove this
1701 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1703 av_init_packet(&opkt);
1705 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1706 #if !CONFIG_AVFILTER
1712 /* no reencoding needed : output the packet directly */
1713 /* force the input stream PTS */
1715 avcodec_get_frame_defaults(&avframe);
1716 ost->st->codec->coded_frame= &avframe;
1717 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1719 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1720 audio_size += data_size;
1721 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1722 video_size += data_size;
1726 opkt.stream_index= ost->index;
1727 if(pkt->pts != AV_NOPTS_VALUE)
1728 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1730 opkt.pts= AV_NOPTS_VALUE;
1732 if (pkt->dts == AV_NOPTS_VALUE)
1733 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1735 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1736 opkt.dts -= ost_tb_start_time;
1738 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1739 opkt.flags= pkt->flags;
1741 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1742 if( ost->st->codec->codec_id != CODEC_ID_H264
1743 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1744 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1746 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1747 opkt.destruct= av_destruct_packet;
1749 opkt.data = data_buf;
1750 opkt.size = data_size;
1753 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1754 ost->st->codec->frame_number++;
1755 ost->frame_number++;
1756 av_free_packet(&opkt);
1760 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1761 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1763 avfilter_unref_buffer(ost->picref);
1769 av_free(buffer_to_free);
1770 /* XXX: allocate the subtitles in the codec ? */
1771 if (subtitle_to_free) {
1772 avsubtitle_free(subtitle_to_free);
1773 subtitle_to_free = NULL;
1780 for(i=0;i<nb_ostreams;i++) {
1782 if (ost->source_index == ist_index) {
1783 AVCodecContext *enc= ost->st->codec;
1784 os = output_files[ost->file_index];
1786 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1788 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1791 if (ost->encoding_needed) {
1795 av_init_packet(&pkt);
1796 pkt.stream_index= ost->index;
1798 switch(ost->st->codec->codec_type) {
1799 case AVMEDIA_TYPE_AUDIO:
1800 fifo_bytes = av_fifo_size(ost->fifo);
1802 /* encode any samples remaining in fifo */
1803 if (fifo_bytes > 0) {
1804 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1805 int fs_tmp = enc->frame_size;
1807 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1808 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1809 enc->frame_size = fifo_bytes / (osize * enc->channels);
1811 int frame_bytes = enc->frame_size*osize*enc->channels;
1812 if (allocated_audio_buf_size < frame_bytes)
1814 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1817 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1818 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1819 ost->st->time_base.num, enc->sample_rate);
1820 enc->frame_size = fs_tmp;
1823 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1826 fprintf(stderr, "Audio encoding failed\n");
1830 pkt.flags |= AV_PKT_FLAG_KEY;
1832 case AVMEDIA_TYPE_VIDEO:
1833 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1835 fprintf(stderr, "Video encoding failed\n");
1839 if(enc->coded_frame && enc->coded_frame->key_frame)
1840 pkt.flags |= AV_PKT_FLAG_KEY;
1841 if (ost->logfile && enc->stats_out) {
1842 fprintf(ost->logfile, "%s", enc->stats_out);
1851 pkt.data= bit_buffer;
1853 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1854 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1855 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1867 static void print_sdp(AVFormatContext **avc, int n)
1871 av_sdp_create(avc, n, sdp, sizeof(sdp));
1872 printf("SDP:\n%s\n", sdp);
1876 static int copy_chapters(int infile, int outfile)
1878 AVFormatContext *is = input_files[infile].ctx;
1879 AVFormatContext *os = output_files[outfile];
1882 for (i = 0; i < is->nb_chapters; i++) {
1883 AVChapter *in_ch = is->chapters[i], *out_ch;
1884 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1885 AV_TIME_BASE_Q, in_ch->time_base);
1886 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1887 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1890 if (in_ch->end < ts_off)
1892 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1895 out_ch = av_mallocz(sizeof(AVChapter));
1897 return AVERROR(ENOMEM);
1899 out_ch->id = in_ch->id;
1900 out_ch->time_base = in_ch->time_base;
1901 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1902 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1904 if (metadata_chapters_autocopy)
1905 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1908 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1910 return AVERROR(ENOMEM);
1911 os->chapters[os->nb_chapters - 1] = out_ch;
1916 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1917 AVCodecContext *avctx)
1923 for (p = kf; *p; p++)
1926 ost->forced_kf_count = n;
1927 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1928 if (!ost->forced_kf_pts) {
1929 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1932 for (i = 0; i < n; i++) {
1933 p = i ? strchr(p, ',') + 1 : kf;
1934 t = parse_time_or_die("force_key_frames", p, 1);
1935 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1940 * The following code is the main loop of the file converter
1942 static int transcode(AVFormatContext **output_files,
1943 int nb_output_files,
1944 AVInputFile *input_files,
1946 AVStreamMap *stream_maps, int nb_stream_maps)
1948 int ret = 0, i, j, k, n, nb_ostreams = 0;
1949 AVFormatContext *is, *os;
1950 AVCodecContext *codec, *icodec;
1951 AVOutputStream *ost, **ost_table = NULL;
1955 uint8_t no_packet[MAX_FILES]={0};
1956 int no_packet_count=0;
1959 for (i = 0; i < nb_input_streams; i++)
1960 input_streams[i].start = av_gettime();
1962 /* output stream init */
1964 for(i=0;i<nb_output_files;i++) {
1965 os = output_files[i];
1966 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1967 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1968 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1969 ret = AVERROR(EINVAL);
1972 nb_ostreams += os->nb_streams;
1974 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1975 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1976 ret = AVERROR(EINVAL);
1980 /* Sanity check the mapping args -- do the input files & streams exist? */
1981 for(i=0;i<nb_stream_maps;i++) {
1982 int fi = stream_maps[i].file_index;
1983 int si = stream_maps[i].stream_index;
1985 if (fi < 0 || fi > nb_input_files - 1 ||
1986 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1987 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1988 ret = AVERROR(EINVAL);
1991 fi = stream_maps[i].sync_file_index;
1992 si = stream_maps[i].sync_stream_index;
1993 if (fi < 0 || fi > nb_input_files - 1 ||
1994 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1995 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1996 ret = AVERROR(EINVAL);
2001 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2005 for(k=0;k<nb_output_files;k++) {
2006 os = output_files[k];
2007 for(i=0;i<os->nb_streams;i++,n++) {
2009 ost = ost_table[n] = output_streams_for_file[k][i];
2010 ost->st = os->streams[i];
2011 if (nb_stream_maps > 0) {
2012 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2013 stream_maps[n].stream_index;
2015 /* Sanity check that the stream types match */
2016 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2017 int i= ost->file_index;
2018 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2019 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2020 stream_maps[n].file_index, stream_maps[n].stream_index,
2021 ost->file_index, ost->index);
2026 int best_nb_frames=-1;
2027 /* get corresponding input stream index : we select the first one with the right type */
2029 for (j = 0; j < nb_input_streams; j++) {
2031 ist = &input_streams[j];
2034 AVFormatContext *f = input_files[ist->file_index].ctx;
2036 for(pi=0; pi<f->nb_programs; pi++){
2037 AVProgram *p= f->programs[pi];
2038 if(p->id == opt_programid)
2039 for(si=0; si<p->nb_stream_indexes; si++){
2040 if(f->streams[ p->stream_index[si] ] == ist->st)
2045 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2046 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2047 if(best_nb_frames < ist->st->codec_info_nb_frames){
2048 best_nb_frames= ist->st->codec_info_nb_frames;
2049 ost->source_index = j;
2056 if(! opt_programid) {
2057 /* try again and reuse existing stream */
2058 for (j = 0; j < nb_input_streams; j++) {
2059 ist = &input_streams[j];
2060 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2061 && ist->st->discard != AVDISCARD_ALL) {
2062 ost->source_index = j;
2068 int i= ost->file_index;
2069 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2070 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2071 ost->file_index, ost->index);
2076 ist = &input_streams[ost->source_index];
2078 ost->sync_ist = (nb_stream_maps > 0) ?
2079 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2080 stream_maps[n].sync_stream_index] : ist;
2084 /* for each output stream, we compute the right encoding parameters */
2085 for(i=0;i<nb_ostreams;i++) {
2087 os = output_files[ost->file_index];
2088 ist = &input_streams[ost->source_index];
2090 codec = ost->st->codec;
2091 icodec = ist->st->codec;
2093 if (metadata_streams_autocopy)
2094 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2095 AV_DICT_DONT_OVERWRITE);
2097 ost->st->disposition = ist->st->disposition;
2098 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2099 codec->chroma_sample_location = icodec->chroma_sample_location;
2101 if (ost->st->stream_copy) {
2102 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2104 if (extra_size > INT_MAX)
2107 /* if stream_copy is selected, no need to decode or encode */
2108 codec->codec_id = icodec->codec_id;
2109 codec->codec_type = icodec->codec_type;
2111 if(!codec->codec_tag){
2112 if( !os->oformat->codec_tag
2113 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2114 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2115 codec->codec_tag = icodec->codec_tag;
2118 codec->bit_rate = icodec->bit_rate;
2119 codec->rc_max_rate = icodec->rc_max_rate;
2120 codec->rc_buffer_size = icodec->rc_buffer_size;
2121 codec->extradata= av_mallocz(extra_size);
2122 if (!codec->extradata)
2124 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2125 codec->extradata_size= icodec->extradata_size;
2126 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){
2127 codec->time_base = icodec->time_base;
2128 codec->time_base.num *= icodec->ticks_per_frame;
2129 av_reduce(&codec->time_base.num, &codec->time_base.den,
2130 codec->time_base.num, codec->time_base.den, INT_MAX);
2132 codec->time_base = ist->st->time_base;
2133 switch(codec->codec_type) {
2134 case AVMEDIA_TYPE_AUDIO:
2135 if(audio_volume != 256) {
2136 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2139 codec->channel_layout = icodec->channel_layout;
2140 codec->sample_rate = icodec->sample_rate;
2141 codec->channels = icodec->channels;
2142 codec->frame_size = icodec->frame_size;
2143 codec->audio_service_type = icodec->audio_service_type;
2144 codec->block_align= icodec->block_align;
2145 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2146 codec->block_align= 0;
2147 if(codec->codec_id == CODEC_ID_AC3)
2148 codec->block_align= 0;
2150 case AVMEDIA_TYPE_VIDEO:
2151 codec->pix_fmt = icodec->pix_fmt;
2152 codec->width = icodec->width;
2153 codec->height = icodec->height;
2154 codec->has_b_frames = icodec->has_b_frames;
2155 if (!codec->sample_aspect_ratio.num) {
2156 codec->sample_aspect_ratio =
2157 ost->st->sample_aspect_ratio =
2158 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2159 ist->st->codec->sample_aspect_ratio.num ?
2160 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2163 case AVMEDIA_TYPE_SUBTITLE:
2164 codec->width = icodec->width;
2165 codec->height = icodec->height;
2167 case AVMEDIA_TYPE_DATA:
2174 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2175 switch(codec->codec_type) {
2176 case AVMEDIA_TYPE_AUDIO:
2177 ost->fifo= av_fifo_alloc(1024);
2180 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2181 if (!codec->sample_rate) {
2182 codec->sample_rate = icodec->sample_rate;
2184 codec->sample_rate >>= icodec->lowres;
2186 choose_sample_rate(ost->st, ost->enc);
2187 codec->time_base = (AVRational){1, codec->sample_rate};
2188 if (!codec->channels)
2189 codec->channels = icodec->channels;
2190 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2191 codec->channel_layout = 0;
2192 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2193 icodec->request_channels = codec->channels;
2194 ist->decoding_needed = 1;
2195 ost->encoding_needed = 1;
2196 ost->resample_sample_fmt = icodec->sample_fmt;
2197 ost->resample_sample_rate = icodec->sample_rate;
2198 ost->resample_channels = icodec->channels;
2200 case AVMEDIA_TYPE_VIDEO:
2201 if (codec->pix_fmt == PIX_FMT_NONE)
2202 codec->pix_fmt = icodec->pix_fmt;
2203 choose_pixel_fmt(ost->st, ost->enc);
2205 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2206 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2209 ost->video_resample = codec->width != icodec->width ||
2210 codec->height != icodec->height ||
2211 codec->pix_fmt != icodec->pix_fmt;
2212 if (ost->video_resample) {
2213 #if !CONFIG_AVFILTER
2214 avcodec_get_frame_defaults(&ost->pict_tmp);
2215 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2216 codec->width, codec->height)) {
2217 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2220 ost->img_resample_ctx = sws_getContext(
2227 ost->sws_flags, NULL, NULL, NULL);
2228 if (ost->img_resample_ctx == NULL) {
2229 fprintf(stderr, "Cannot get resampling context\n");
2233 codec->bits_per_raw_sample= 0;
2235 if (!codec->width || !codec->height) {
2236 codec->width = icodec->width;
2237 codec->height = icodec->height;
2239 ost->resample_height = icodec->height;
2240 ost->resample_width = icodec->width;
2241 ost->resample_pix_fmt= icodec->pix_fmt;
2242 ost->encoding_needed = 1;
2243 ist->decoding_needed = 1;
2245 if (!ost->frame_rate.num)
2246 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2247 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2248 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2249 ost->frame_rate = ost->enc->supported_framerates[idx];
2251 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2254 if (configure_video_filters(ist, ost)) {
2255 fprintf(stderr, "Error opening filters!\n");
2260 case AVMEDIA_TYPE_SUBTITLE:
2261 ost->encoding_needed = 1;
2262 ist->decoding_needed = 1;
2269 if (ost->encoding_needed &&
2270 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2271 char logfilename[1024];
2274 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2275 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2277 if (codec->flags & CODEC_FLAG_PASS1) {
2278 f = fopen(logfilename, "wb");
2280 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2286 size_t logbuffer_size;
2287 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2288 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2291 codec->stats_in = logbuffer;
2295 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2296 int size= codec->width * codec->height;
2297 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2302 bit_buffer = av_malloc(bit_buffer_size);
2304 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2306 ret = AVERROR(ENOMEM);
2310 /* open each encoder */
2311 for(i=0;i<nb_ostreams;i++) {
2313 if (ost->encoding_needed) {
2314 AVCodec *codec = ost->enc;
2315 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2317 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2318 ost->st->codec->codec_id, ost->file_index, ost->index);
2319 ret = AVERROR(EINVAL);
2322 if (dec->subtitle_header) {
2323 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2324 if (!ost->st->codec->subtitle_header) {
2325 ret = AVERROR(ENOMEM);
2328 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2329 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2331 if (avcodec_open(ost->st->codec, codec) < 0) {
2332 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2333 ost->file_index, ost->index);
2334 ret = AVERROR(EINVAL);
2337 extra_size += ost->st->codec->extradata_size;
2341 /* open each decoder */
2342 for (i = 0; i < nb_input_streams; i++) {
2343 ist = &input_streams[i];
2344 if (ist->decoding_needed) {
2345 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2347 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2349 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2350 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2351 ret = AVERROR(EINVAL);
2355 /* update requested sample format for the decoder based on the
2356 corresponding encoder sample format */
2357 for (j = 0; j < nb_ostreams; j++) {
2359 if (ost->source_index == i) {
2360 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2365 if (avcodec_open(ist->st->codec, codec) < 0) {
2366 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2367 ist->file_index, ist->st->index);
2368 ret = AVERROR(EINVAL);
2371 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2372 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2377 for (i = 0; i < nb_input_streams; i++) {
2379 ist = &input_streams[i];
2381 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2382 ist->next_pts = AV_NOPTS_VALUE;
2383 init_pts_correction(&ist->pts_ctx);
2387 /* set meta data information from input file if required */
2388 for (i=0;i<nb_meta_data_maps;i++) {
2389 AVFormatContext *files[2];
2390 AVDictionary **meta[2];
2393 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2394 if ((index) < 0 || (index) >= (nb_elems)) {\
2395 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2397 ret = AVERROR(EINVAL);\
2401 int out_file_index = meta_data_maps[i][0].file;
2402 int in_file_index = meta_data_maps[i][1].file;
2403 if (in_file_index < 0 || out_file_index < 0)
2405 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2406 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2408 files[0] = output_files[out_file_index];
2409 files[1] = input_files[in_file_index].ctx;
2411 for (j = 0; j < 2; j++) {
2412 AVMetaDataMap *map = &meta_data_maps[i][j];
2414 switch (map->type) {
2416 meta[j] = &files[j]->metadata;
2419 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2420 meta[j] = &files[j]->streams[map->index]->metadata;
2423 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2424 meta[j] = &files[j]->chapters[map->index]->metadata;
2427 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2428 meta[j] = &files[j]->programs[map->index]->metadata;
2433 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2436 /* copy global metadata by default */
2437 if (metadata_global_autocopy) {
2439 for (i = 0; i < nb_output_files; i++)
2440 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2441 AV_DICT_DONT_OVERWRITE);
2444 /* copy chapters according to chapter maps */
2445 for (i = 0; i < nb_chapter_maps; i++) {
2446 int infile = chapter_maps[i].in_file;
2447 int outfile = chapter_maps[i].out_file;
2449 if (infile < 0 || outfile < 0)
2451 if (infile >= nb_input_files) {
2452 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2453 ret = AVERROR(EINVAL);
2456 if (outfile >= nb_output_files) {
2457 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2458 ret = AVERROR(EINVAL);
2461 copy_chapters(infile, outfile);
2464 /* copy chapters from the first input file that has them*/
2465 if (!nb_chapter_maps)
2466 for (i = 0; i < nb_input_files; i++) {
2467 if (!input_files[i].ctx->nb_chapters)
2470 for (j = 0; j < nb_output_files; j++)
2471 if ((ret = copy_chapters(i, j)) < 0)
2476 /* open files and write file headers */
2477 for(i=0;i<nb_output_files;i++) {
2478 os = output_files[i];
2479 if (avformat_write_header(os, &output_opts[i]) < 0) {
2480 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2481 ret = AVERROR(EINVAL);
2484 assert_avoptions(output_opts[i]);
2485 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2491 /* dump the file output parameters - cannot be done before in case
2493 for(i=0;i<nb_output_files;i++) {
2494 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2497 /* dump the stream mapping */
2499 fprintf(stderr, "Stream mapping:\n");
2500 for(i=0;i<nb_ostreams;i++) {
2502 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2503 input_streams[ost->source_index].file_index,
2504 input_streams[ost->source_index].st->index,
2507 if (ost->sync_ist != &input_streams[ost->source_index])
2508 fprintf(stderr, " [sync #%d.%d]",
2509 ost->sync_ist->file_index,
2510 ost->sync_ist->st->index);
2511 fprintf(stderr, "\n");
2516 fprintf(stderr, "%s\n", error);
2521 print_sdp(output_files, nb_output_files);
2525 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2528 timer_start = av_gettime();
2530 for(; received_sigterm == 0;) {
2531 int file_index, ist_index;
2540 /* select the stream that we must read now by looking at the
2541 smallest output pts */
2543 for(i=0;i<nb_ostreams;i++) {
2546 os = output_files[ost->file_index];
2547 ist = &input_streams[ost->source_index];
2548 if(ist->is_past_recording_time || no_packet[ist->file_index])
2550 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2551 ipts = (double)ist->pts;
2552 if (!input_files[ist->file_index].eof_reached){
2553 if(ipts < ipts_min) {
2555 if(input_sync ) file_index = ist->file_index;
2557 if(opts < opts_min) {
2559 if(!input_sync) file_index = ist->file_index;
2562 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2567 /* if none, if is finished */
2568 if (file_index < 0) {
2569 if(no_packet_count){
2571 memset(no_packet, 0, sizeof(no_packet));
2578 /* finish if limit size exhausted */
2579 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2582 /* read a frame from it and output it in the fifo */
2583 is = input_files[file_index].ctx;
2584 ret= av_read_frame(is, &pkt);
2585 if(ret == AVERROR(EAGAIN)){
2586 no_packet[file_index]=1;
2591 input_files[file_index].eof_reached = 1;
2599 memset(no_packet, 0, sizeof(no_packet));
2602 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2603 is->streams[pkt.stream_index]);
2605 /* the following test is needed in case new streams appear
2606 dynamically in stream : we ignore them */
2607 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2608 goto discard_packet;
2609 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2610 ist = &input_streams[ist_index];
2612 goto discard_packet;
2614 if (pkt.dts != AV_NOPTS_VALUE)
2615 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2616 if (pkt.pts != AV_NOPTS_VALUE)
2617 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2619 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2620 && input_files_ts_scale[file_index][pkt.stream_index]){
2621 if(pkt.pts != AV_NOPTS_VALUE)
2622 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2623 if(pkt.dts != AV_NOPTS_VALUE)
2624 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2627 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2628 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2629 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2630 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2631 int64_t delta= pkt_dts - ist->next_pts;
2632 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2633 input_files_ts_offset[ist->file_index]-= delta;
2635 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2636 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2637 if(pkt.pts != AV_NOPTS_VALUE)
2638 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2642 /* finish if recording time exhausted */
2643 if (recording_time != INT64_MAX &&
2644 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2645 ist->is_past_recording_time = 1;
2646 goto discard_packet;
2649 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2650 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2653 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2654 ist->file_index, ist->st->index);
2657 av_free_packet(&pkt);
2662 av_free_packet(&pkt);
2664 /* dump report by using the output first video and audio streams */
2665 print_report(output_files, ost_table, nb_ostreams, 0);
2668 /* at the end of stream, we must flush the decoder buffers */
2669 for (i = 0; i < nb_input_streams; i++) {
2670 ist = &input_streams[i];
2671 if (ist->decoding_needed) {
2672 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2678 /* write the trailer if needed and close file */
2679 for(i=0;i<nb_output_files;i++) {
2680 os = output_files[i];
2681 av_write_trailer(os);
2684 /* dump report by using the first video and audio streams */
2685 print_report(output_files, ost_table, nb_ostreams, 1);
2687 /* close each encoder */
2688 for(i=0;i<nb_ostreams;i++) {
2690 if (ost->encoding_needed) {
2691 av_freep(&ost->st->codec->stats_in);
2692 avcodec_close(ost->st->codec);
2695 avfilter_graph_free(&ost->graph);
2699 /* close each decoder */
2700 for (i = 0; i < nb_input_streams; i++) {
2701 ist = &input_streams[i];
2702 if (ist->decoding_needed) {
2703 avcodec_close(ist->st->codec);
2711 av_freep(&bit_buffer);
2714 for(i=0;i<nb_ostreams;i++) {
2717 if (ost->st->stream_copy)
2718 av_freep(&ost->st->codec->extradata);
2720 fclose(ost->logfile);
2721 ost->logfile = NULL;
2723 av_fifo_free(ost->fifo); /* works even if fifo is not
2724 initialized but set to zero */
2725 av_freep(&ost->st->codec->subtitle_header);
2726 av_free(ost->pict_tmp.data[0]);
2727 av_free(ost->forced_kf_pts);
2728 if (ost->video_resample)
2729 sws_freeContext(ost->img_resample_ctx);
2731 audio_resample_close(ost->resample);
2732 if (ost->reformat_ctx)
2733 av_audio_convert_free(ost->reformat_ctx);
2742 static int opt_format(const char *opt, const char *arg)
2744 last_asked_format = arg;
2748 static int opt_video_rc_override_string(const char *opt, const char *arg)
2750 video_rc_override_string = arg;
2754 static int opt_me_threshold(const char *opt, const char *arg)
2756 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2760 static int opt_verbose(const char *opt, const char *arg)
2762 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2766 static int opt_frame_rate(const char *opt, const char *arg)
2768 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2769 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2775 static int opt_bitrate(const char *opt, const char *arg)
2777 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2779 opt_default(opt, arg);
2781 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2782 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2787 static int opt_frame_crop(const char *opt, const char *arg)
2789 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2790 return AVERROR(EINVAL);
2793 static int opt_frame_size(const char *opt, const char *arg)
2795 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2796 fprintf(stderr, "Incorrect frame size\n");
2797 return AVERROR(EINVAL);
2802 static int opt_pad(const char *opt, const char *arg) {
2803 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2807 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2809 if (strcmp(arg, "list")) {
2810 frame_pix_fmt = av_get_pix_fmt(arg);
2811 if (frame_pix_fmt == PIX_FMT_NONE) {
2812 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2813 return AVERROR(EINVAL);
2822 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2829 p = strchr(arg, ':');
2831 x = strtol(arg, &end, 10);
2833 y = strtol(end+1, &end, 10);
2835 ar = (double)x / (double)y;
2837 ar = strtod(arg, NULL);
2840 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2841 return AVERROR(EINVAL);
2843 frame_aspect_ratio = ar;
2847 static int opt_metadata(const char *opt, const char *arg)
2849 char *mid= strchr(arg, '=');
2852 fprintf(stderr, "Missing =\n");
2857 av_dict_set(&metadata, arg, mid, 0);
2862 static int opt_qscale(const char *opt, const char *arg)
2864 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2865 if (video_qscale == 0) {
2866 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2867 return AVERROR(EINVAL);
2872 static int opt_top_field_first(const char *opt, const char *arg)
2874 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2878 static int opt_thread_count(const char *opt, const char *arg)
2880 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2883 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2888 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2890 if (strcmp(arg, "list")) {
2891 audio_sample_fmt = av_get_sample_fmt(arg);
2892 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2893 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2894 return AVERROR(EINVAL);
2899 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2900 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2906 static int opt_audio_rate(const char *opt, const char *arg)
2908 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2912 static int opt_audio_channels(const char *opt, const char *arg)
2914 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2918 static int opt_video_channel(const char *opt, const char *arg)
2920 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2921 opt_default("channel", arg);
2925 static int opt_video_standard(const char *opt, const char *arg)
2927 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2928 opt_default("standard", arg);
2932 static int opt_codec(int *pstream_copy, char **pcodec_name,
2933 int codec_type, const char *arg)
2935 av_freep(pcodec_name);
2936 if (!strcmp(arg, "copy")) {
2939 *pcodec_name = av_strdup(arg);
2944 static int opt_audio_codec(const char *opt, const char *arg)
2946 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2949 static int opt_video_codec(const char *opt, const char *arg)
2951 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2954 static int opt_subtitle_codec(const char *opt, const char *arg)
2956 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2959 static int opt_data_codec(const char *opt, const char *arg)
2961 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2964 static int opt_codec_tag(const char *opt, const char *arg)
2967 uint32_t *codec_tag;
2969 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2970 !strcmp(opt, "vtag") ? &video_codec_tag :
2971 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2975 *codec_tag = strtol(arg, &tail, 0);
2977 *codec_tag = AV_RL32(arg);
2982 static int opt_map(const char *opt, const char *arg)
2987 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2988 m = &stream_maps[nb_stream_maps-1];
2990 m->file_index = strtol(arg, &p, 0);
2994 m->stream_index = strtol(p, &p, 0);
2997 m->sync_file_index = strtol(p, &p, 0);
3000 m->sync_stream_index = strtol(p, &p, 0);
3002 m->sync_file_index = m->file_index;
3003 m->sync_stream_index = m->stream_index;
3008 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3019 *index = strtol(++arg, endptr, 0);
3022 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3029 static int opt_map_metadata(const char *opt, const char *arg)
3031 AVMetaDataMap *m, *m1;
3034 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3035 &nb_meta_data_maps, nb_meta_data_maps + 1);
3037 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3038 m->file = strtol(arg, &p, 0);
3039 parse_meta_type(p, &m->type, &m->index, &p);
3043 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3044 m1->file = strtol(p, &p, 0);
3045 parse_meta_type(p, &m1->type, &m1->index, &p);
3047 if (m->type == 'g' || m1->type == 'g')
3048 metadata_global_autocopy = 0;
3049 if (m->type == 's' || m1->type == 's')
3050 metadata_streams_autocopy = 0;
3051 if (m->type == 'c' || m1->type == 'c')
3052 metadata_chapters_autocopy = 0;
3057 static int opt_map_meta_data(const char *opt, const char *arg)
3059 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3060 "Use -map_metadata instead.\n");
3061 return opt_map_metadata(opt, arg);
3064 static int opt_map_chapters(const char *opt, const char *arg)
3069 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3070 nb_chapter_maps + 1);
3071 c = &chapter_maps[nb_chapter_maps - 1];
3072 c->out_file = strtol(arg, &p, 0);
3076 c->in_file = strtol(p, &p, 0);
3080 static int opt_input_ts_scale(const char *opt, const char *arg)
3082 unsigned int stream;
3086 stream = strtol(arg, &p, 0);
3089 scale= strtod(p, &p);
3091 if(stream >= MAX_STREAMS)
3094 input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3095 input_files_ts_scale[nb_input_files][stream]= scale;
3099 static int opt_recording_time(const char *opt, const char *arg)
3101 recording_time = parse_time_or_die(opt, arg, 1);
3105 static int opt_start_time(const char *opt, const char *arg)
3107 start_time = parse_time_or_die(opt, arg, 1);
3111 static int opt_recording_timestamp(const char *opt, const char *arg)
3113 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3117 static int opt_input_ts_offset(const char *opt, const char *arg)
3119 input_ts_offset = parse_time_or_die(opt, arg, 1);
3123 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3125 const char *codec_string = encoder ? "encoder" : "decoder";
3129 return CODEC_ID_NONE;
3131 avcodec_find_encoder_by_name(name) :
3132 avcodec_find_decoder_by_name(name);
3134 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3137 if(codec->type != type) {
3138 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3141 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3142 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3143 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3144 "results.\nAdd '-strict experimental' if you want to use it.\n",
3145 codec_string, codec->name);
3147 avcodec_find_encoder(codec->id) :
3148 avcodec_find_decoder(codec->id);
3149 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3150 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3151 codec_string, codec->name);
3157 static int opt_input_file(const char *opt, const char *filename)
3159 AVFormatContext *ic;
3160 AVInputFormat *file_iformat = NULL;
3161 int err, i, ret, rfps, rfps_base;
3165 if (last_asked_format) {
3166 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3167 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3170 last_asked_format = NULL;
3173 if (!strcmp(filename, "-"))
3176 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3177 !strcmp(filename, "/dev/stdin");
3179 /* get default parameters from command line */
3180 ic = avformat_alloc_context();
3182 print_error(filename, AVERROR(ENOMEM));
3185 if (audio_sample_rate) {
3186 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3187 av_dict_set(&format_opts, "sample_rate", buf, 0);
3189 if (audio_channels) {
3190 snprintf(buf, sizeof(buf), "%d", audio_channels);
3191 av_dict_set(&format_opts, "channels", buf, 0);
3193 if (frame_rate.num) {
3194 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3195 av_dict_set(&format_opts, "framerate", buf, 0);
3197 if (frame_width && frame_height) {
3198 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3199 av_dict_set(&format_opts, "video_size", buf, 0);
3201 if (frame_pix_fmt != PIX_FMT_NONE)
3202 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3204 ic->video_codec_id =
3205 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3206 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3207 ic->audio_codec_id =
3208 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3209 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3210 ic->subtitle_codec_id=
3211 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3212 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3213 ic->flags |= AVFMT_FLAG_NONBLOCK;
3215 /* open the input file with generic libav function */
3216 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3218 print_error(filename, err);
3221 assert_avoptions(format_opts);
3226 for(i=0; i<ic->nb_streams; i++){
3227 ic->streams[i]->discard= AVDISCARD_ALL;
3229 for(i=0; i<ic->nb_programs; i++){
3230 AVProgram *p= ic->programs[i];
3231 if(p->id != opt_programid){
3232 p->discard = AVDISCARD_ALL;
3235 for(j=0; j<p->nb_stream_indexes; j++){
3236 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3241 fprintf(stderr, "Specified program id not found\n");
3247 ic->loop_input = loop_input;
3249 /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3250 for (i = 0; i < ic->nb_streams; i++) {
3251 AVCodecContext *dec = ic->streams[i]->codec;
3252 switch (dec->codec_type) {
3253 case AVMEDIA_TYPE_AUDIO:
3254 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3255 AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3258 case AVMEDIA_TYPE_VIDEO:
3259 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3260 AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3266 /* If not enough info to get the stream parameters, we decode the
3267 first frames to get it. (used in mpeg case for example) */
3268 ret = av_find_stream_info(ic);
3269 if (ret < 0 && verbose >= 0) {
3270 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3271 av_close_input_file(ic);
3275 timestamp = start_time;
3276 /* add the stream start time */
3277 if (ic->start_time != AV_NOPTS_VALUE)
3278 timestamp += ic->start_time;
3280 /* if seeking requested, we execute it */
3281 if (start_time != 0) {
3282 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3284 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3285 filename, (double)timestamp / AV_TIME_BASE);
3287 /* reset seek info */
3291 /* update the current parameters so that they match the one of the input stream */
3292 for(i=0;i<ic->nb_streams;i++) {
3293 AVStream *st = ic->streams[i];
3294 AVCodecContext *dec = st->codec;
3297 dec->thread_count = thread_count;
3298 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3300 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3301 ist = &input_streams[nb_input_streams - 1];
3303 ist->file_index = nb_input_files;
3306 switch (dec->codec_type) {
3307 case AVMEDIA_TYPE_AUDIO:
3308 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3309 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3310 channel_layout = dec->channel_layout;
3311 audio_sample_fmt = dec->sample_fmt;
3313 st->discard= AVDISCARD_ALL;
3315 case AVMEDIA_TYPE_VIDEO:
3316 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3317 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3318 rfps = ic->streams[i]->r_frame_rate.num;
3319 rfps_base = ic->streams[i]->r_frame_rate.den;
3321 dec->flags |= CODEC_FLAG_EMU_EDGE;
3322 dec->height >>= dec->lowres;
3323 dec->width >>= dec->lowres;
3326 dec->debug |= FF_DEBUG_MV;
3328 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3331 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3332 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3334 (float)rfps / rfps_base, rfps, rfps_base);
3338 st->discard= AVDISCARD_ALL;
3339 else if(video_discard)
3340 st->discard= video_discard;
3342 case AVMEDIA_TYPE_DATA:
3344 case AVMEDIA_TYPE_SUBTITLE:
3345 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3346 if(subtitle_disable)
3347 st->discard = AVDISCARD_ALL;
3349 case AVMEDIA_TYPE_ATTACHMENT:
3350 case AVMEDIA_TYPE_UNKNOWN:
3357 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3358 /* dump the file content */
3360 av_dump_format(ic, nb_input_files, filename, 0);
3362 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3363 input_files[nb_input_files - 1].ctx = ic;
3364 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3366 frame_rate = (AVRational){0, 0};
3367 frame_pix_fmt = PIX_FMT_NONE;
3370 audio_sample_rate = 0;
3373 av_freep(&video_codec_name);
3374 av_freep(&audio_codec_name);
3375 av_freep(&subtitle_codec_name);
3381 static void check_inputs(int *has_video_ptr,
3383 int *has_subtitle_ptr,
3386 int has_video, has_audio, has_subtitle, has_data, i, j;
3387 AVFormatContext *ic;
3394 for(j=0;j<nb_input_files;j++) {
3395 ic = input_files[j].ctx;
3396 for(i=0;i<ic->nb_streams;i++) {
3397 AVCodecContext *enc = ic->streams[i]->codec;
3398 switch(enc->codec_type) {
3399 case AVMEDIA_TYPE_AUDIO:
3402 case AVMEDIA_TYPE_VIDEO:
3405 case AVMEDIA_TYPE_SUBTITLE:
3408 case AVMEDIA_TYPE_DATA:
3409 case AVMEDIA_TYPE_ATTACHMENT:
3410 case AVMEDIA_TYPE_UNKNOWN:
3418 *has_video_ptr = has_video;
3419 *has_audio_ptr = has_audio;
3420 *has_subtitle_ptr = has_subtitle;
3421 *has_data_ptr = has_data;
3424 static void new_video_stream(AVFormatContext *oc, int file_idx)
3427 AVOutputStream *ost;
3428 AVCodecContext *video_enc;
3429 enum CodecID codec_id = CODEC_ID_NONE;
3430 AVCodec *codec= NULL;
3432 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3434 fprintf(stderr, "Could not alloc stream\n");
3437 ost = new_output_stream(oc, file_idx);
3439 if(!video_stream_copy){
3440 if (video_codec_name) {
3441 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3442 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3443 codec = avcodec_find_encoder_by_name(video_codec_name);
3446 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3447 codec = avcodec_find_encoder(codec_id);
3450 ost->frame_aspect_ratio = frame_aspect_ratio;
3451 frame_aspect_ratio = 0;
3453 ost->avfilter= vfilters;
3458 avcodec_get_context_defaults3(st->codec, codec);
3459 ost->bitstream_filters = video_bitstream_filters;
3460 video_bitstream_filters= NULL;
3462 st->codec->thread_count= thread_count;
3464 video_enc = st->codec;
3467 video_enc->codec_tag= video_codec_tag;
3469 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3470 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3471 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3474 if (video_stream_copy) {
3475 st->stream_copy = 1;
3476 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3477 video_enc->sample_aspect_ratio =
3478 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3484 ost->frame_rate = frame_rate;
3485 video_enc->codec_id = codec_id;
3486 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3488 video_enc->width = frame_width;
3489 video_enc->height = frame_height;
3490 video_enc->pix_fmt = frame_pix_fmt;
3491 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3494 video_enc->gop_size = 0;
3495 if (video_qscale || same_quality) {
3496 video_enc->flags |= CODEC_FLAG_QSCALE;
3497 video_enc->global_quality=
3498 st->quality = FF_QP2LAMBDA * video_qscale;
3502 video_enc->intra_matrix = intra_matrix;
3504 video_enc->inter_matrix = inter_matrix;
3506 p= video_rc_override_string;
3509 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3511 fprintf(stderr, "error parsing rc_override\n");
3514 video_enc->rc_override=
3515 av_realloc(video_enc->rc_override,
3516 sizeof(RcOverride)*(i+1));
3517 video_enc->rc_override[i].start_frame= start;
3518 video_enc->rc_override[i].end_frame = end;
3520 video_enc->rc_override[i].qscale= q;
3521 video_enc->rc_override[i].quality_factor= 1.0;
3524 video_enc->rc_override[i].qscale= 0;
3525 video_enc->rc_override[i].quality_factor= -q/100.0;
3530 video_enc->rc_override_count=i;
3531 if (!video_enc->rc_initial_buffer_occupancy)
3532 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3533 video_enc->me_threshold= me_threshold;
3534 video_enc->intra_dc_precision= intra_dc_precision - 8;
3537 video_enc->flags|= CODEC_FLAG_PSNR;
3542 video_enc->flags |= CODEC_FLAG_PASS1;
3544 video_enc->flags |= CODEC_FLAG_PASS2;
3548 if (forced_key_frames)
3549 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3551 if (video_language) {
3552 av_dict_set(&st->metadata, "language", video_language, 0);
3553 av_freep(&video_language);
3556 /* reset some key parameters */
3558 av_freep(&video_codec_name);
3559 av_freep(&forced_key_frames);
3560 video_stream_copy = 0;
3561 frame_pix_fmt = PIX_FMT_NONE;
3564 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3567 AVOutputStream *ost;
3568 AVCodec *codec= NULL;
3569 AVCodecContext *audio_enc;
3570 enum CodecID codec_id = CODEC_ID_NONE;
3572 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3574 fprintf(stderr, "Could not alloc stream\n");
3577 ost = new_output_stream(oc, file_idx);
3579 if(!audio_stream_copy){
3580 if (audio_codec_name) {
3581 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3582 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3583 codec = avcodec_find_encoder_by_name(audio_codec_name);
3586 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3587 codec = avcodec_find_encoder(codec_id);
3591 avcodec_get_context_defaults3(st->codec, codec);
3593 ost->bitstream_filters = audio_bitstream_filters;
3594 audio_bitstream_filters= NULL;
3596 st->codec->thread_count= thread_count;
3598 audio_enc = st->codec;
3599 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3602 audio_enc->codec_tag= audio_codec_tag;
3604 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3605 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3606 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3608 if (audio_stream_copy) {
3609 st->stream_copy = 1;
3611 audio_enc->codec_id = codec_id;
3612 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3614 if (audio_qscale > QSCALE_NONE) {
3615 audio_enc->flags |= CODEC_FLAG_QSCALE;
3616 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3619 audio_enc->channels = audio_channels;
3620 audio_enc->sample_fmt = audio_sample_fmt;
3621 if (audio_sample_rate)
3622 audio_enc->sample_rate = audio_sample_rate;
3623 audio_enc->channel_layout = channel_layout;
3624 choose_sample_fmt(st, codec);
3626 if (audio_language) {
3627 av_dict_set(&st->metadata, "language", audio_language, 0);
3628 av_freep(&audio_language);
3631 /* reset some key parameters */
3633 av_freep(&audio_codec_name);
3634 audio_stream_copy = 0;
3637 static void new_data_stream(AVFormatContext *oc, int file_idx)
3640 AVCodec *codec=NULL;
3641 AVCodecContext *data_enc;
3643 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3645 fprintf(stderr, "Could not alloc stream\n");
3648 new_output_stream(oc, file_idx);
3649 data_enc = st->codec;
3650 if (!data_stream_copy) {
3651 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3654 avcodec_get_context_defaults3(st->codec, codec);
3656 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3659 data_enc->codec_tag= data_codec_tag;
3661 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3662 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3663 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3665 if (data_stream_copy) {
3666 st->stream_copy = 1;
3670 av_freep(&data_codec_name);
3671 data_stream_copy = 0;
3674 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3677 AVOutputStream *ost;
3678 AVCodec *codec=NULL;
3679 AVCodecContext *subtitle_enc;
3680 enum CodecID codec_id = CODEC_ID_NONE;
3682 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3684 fprintf(stderr, "Could not alloc stream\n");
3687 ost = new_output_stream(oc, file_idx);
3688 subtitle_enc = st->codec;
3689 if(!subtitle_stream_copy){
3690 if (subtitle_codec_name) {
3691 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3692 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3693 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3696 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3697 codec = avcodec_find_encoder(codec_id);
3700 avcodec_get_context_defaults3(st->codec, codec);
3702 ost->bitstream_filters = subtitle_bitstream_filters;
3703 subtitle_bitstream_filters= NULL;
3705 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3707 if(subtitle_codec_tag)
3708 subtitle_enc->codec_tag= subtitle_codec_tag;
3710 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3711 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3712 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3714 if (subtitle_stream_copy) {
3715 st->stream_copy = 1;
3717 subtitle_enc->codec_id = codec_id;
3718 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3721 if (subtitle_language) {
3722 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3723 av_freep(&subtitle_language);
3726 subtitle_disable = 0;
3727 av_freep(&subtitle_codec_name);
3728 subtitle_stream_copy = 0;
3731 static int opt_new_stream(const char *opt, const char *arg)
3733 AVFormatContext *oc;
3734 int file_idx = nb_output_files - 1;
3735 if (nb_output_files <= 0) {
3736 fprintf(stderr, "At least one output file must be specified\n");
3739 oc = output_files[file_idx];
3741 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3742 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3743 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3744 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3749 /* arg format is "output-stream-index:streamid-value". */
3750 static int opt_streamid(const char *opt, const char *arg)
3756 av_strlcpy(idx_str, arg, sizeof(idx_str));
3757 p = strchr(idx_str, ':');
3760 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3765 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3766 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3767 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3771 static void opt_output_file(const char *filename)
3773 AVFormatContext *oc;
3774 int err, use_video, use_audio, use_subtitle, use_data;
3775 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3776 AVOutputFormat *file_oformat;
3778 if (!strcmp(filename, "-"))
3781 oc = avformat_alloc_context();
3783 print_error(filename, AVERROR(ENOMEM));
3787 if (last_asked_format) {
3788 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3789 if (!file_oformat) {
3790 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3793 last_asked_format = NULL;
3795 file_oformat = av_guess_format(NULL, filename, NULL);
3796 if (!file_oformat) {
3797 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3803 oc->oformat = file_oformat;
3804 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3806 if (!strcmp(file_oformat->name, "ffm") &&
3807 av_strstart(filename, "http:", NULL)) {
3808 /* special case for files sent to ffserver: we get the stream
3809 parameters from ffserver */
3810 int err = read_ffserver_streams(oc, filename);
3812 print_error(filename, err);
3816 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3817 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3818 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3819 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 */
3821 /* disable if no corresponding type found and at least one
3823 if (nb_input_files > 0) {
3824 check_inputs(&input_has_video,
3826 &input_has_subtitle,
3829 if (!input_has_video)
3831 if (!input_has_audio)
3833 if (!input_has_subtitle)
3835 if (!input_has_data)
3839 /* manual disable */
3840 if (audio_disable) use_audio = 0;
3841 if (video_disable) use_video = 0;
3842 if (subtitle_disable) use_subtitle = 0;
3843 if (data_disable) use_data = 0;
3845 if (use_video) new_video_stream(oc, nb_output_files);
3846 if (use_audio) new_audio_stream(oc, nb_output_files);
3847 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3848 if (use_data) new_data_stream(oc, nb_output_files);
3850 oc->timestamp = recording_timestamp;
3852 av_dict_copy(&oc->metadata, metadata, 0);
3853 av_dict_free(&metadata);
3856 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3857 output_files[nb_output_files++] = oc;
3859 /* check filename in case of an image number is expected */
3860 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3861 if (!av_filename_number_test(oc->filename)) {
3862 print_error(oc->filename, AVERROR(EINVAL));
3867 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3868 /* test if it already exists to avoid loosing precious files */
3869 if (!file_overwrite &&
3870 (strchr(filename, ':') == NULL ||
3871 filename[1] == ':' ||
3872 av_strstart(filename, "file:", NULL))) {
3873 if (avio_check(filename, 0) == 0) {
3875 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3877 if (!read_yesno()) {
3878 fprintf(stderr, "Not overwriting - exiting\n");
3883 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3890 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3891 print_error(filename, err);
3896 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3897 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3898 oc->loop_output = loop_output;
3899 oc->flags |= AVFMT_FLAG_NONBLOCK;
3901 frame_rate = (AVRational){0, 0};
3904 audio_sample_rate = 0;
3907 av_freep(&forced_key_frames);
3912 /* same option as mencoder */
3913 static int opt_pass(const char *opt, const char *arg)
3915 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3919 static int64_t getutime(void)
3922 struct rusage rusage;
3924 getrusage(RUSAGE_SELF, &rusage);
3925 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3926 #elif HAVE_GETPROCESSTIMES
3928 FILETIME c, e, k, u;
3929 proc = GetCurrentProcess();
3930 GetProcessTimes(proc, &c, &e, &k, &u);
3931 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3933 return av_gettime();
3937 static int64_t getmaxrss(void)
3939 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3940 struct rusage rusage;
3941 getrusage(RUSAGE_SELF, &rusage);
3942 return (int64_t)rusage.ru_maxrss * 1024;
3943 #elif HAVE_GETPROCESSMEMORYINFO
3945 PROCESS_MEMORY_COUNTERS memcounters;
3946 proc = GetCurrentProcess();
3947 memcounters.cb = sizeof(memcounters);
3948 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3949 return memcounters.PeakPagefileUsage;
3955 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3958 const char *p = str;
3965 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3972 static void opt_inter_matrix(const char *arg)
3974 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3975 parse_matrix_coeffs(inter_matrix, arg);
3978 static void opt_intra_matrix(const char *arg)
3980 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3981 parse_matrix_coeffs(intra_matrix, arg);
3984 static void show_usage(void)
3986 printf("Hyper fast Audio and Video encoder\n");
3987 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3991 static void show_help(void)
3994 AVOutputFormat *oformat = NULL;
3995 AVInputFormat *iformat = NULL;
3997 av_log_set_callback(log_callback_help);
3999 show_help_options(options, "Main options:\n",
4000 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4001 show_help_options(options, "\nAdvanced options:\n",
4002 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4004 show_help_options(options, "\nVideo options:\n",
4005 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4007 show_help_options(options, "\nAdvanced Video options:\n",
4008 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4009 OPT_VIDEO | OPT_EXPERT);
4010 show_help_options(options, "\nAudio options:\n",
4011 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4013 show_help_options(options, "\nAdvanced Audio options:\n",
4014 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4015 OPT_AUDIO | OPT_EXPERT);
4016 show_help_options(options, "\nSubtitle options:\n",
4017 OPT_SUBTITLE | OPT_GRAB,
4019 show_help_options(options, "\nAudio/Video grab options:\n",
4023 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4026 /* individual codec options */
4028 while ((c = av_codec_next(c))) {
4029 if (c->priv_class) {
4030 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4035 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4038 /* individual muxer options */
4039 while ((oformat = av_oformat_next(oformat))) {
4040 if (oformat->priv_class) {
4041 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4046 /* individual demuxer options */
4047 while ((iformat = av_iformat_next(iformat))) {
4048 if (iformat->priv_class) {
4049 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4054 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4057 static int opt_target(const char *opt, const char *arg)
4059 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4060 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4062 if(!strncmp(arg, "pal-", 4)) {
4065 } else if(!strncmp(arg, "ntsc-", 5)) {
4068 } else if(!strncmp(arg, "film-", 5)) {
4073 /* Calculate FR via float to avoid int overflow */
4074 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4077 } else if((fr == 29970) || (fr == 23976)) {
4080 /* Try to determine PAL/NTSC by peeking in the input files */
4081 if(nb_input_files) {
4083 for (j = 0; j < nb_input_files; j++) {
4084 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4085 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4086 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4088 fr = c->time_base.den * 1000 / c->time_base.num;
4092 } else if((fr == 29970) || (fr == 23976)) {
4102 if(verbose > 0 && norm != UNKNOWN)
4103 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4106 if(norm == UNKNOWN) {
4107 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4108 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4109 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4113 if(!strcmp(arg, "vcd")) {
4114 opt_video_codec("vcodec", "mpeg1video");
4115 opt_audio_codec("vcodec", "mp2");
4116 opt_format("f", "vcd");
4118 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4119 opt_frame_rate("r", frame_rates[norm]);
4120 opt_default("g", norm == PAL ? "15" : "18");
4122 opt_default("b", "1150000");
4123 opt_default("maxrate", "1150000");
4124 opt_default("minrate", "1150000");
4125 opt_default("bufsize", "327680"); // 40*1024*8;
4127 opt_default("ab", "224000");
4128 audio_sample_rate = 44100;
4131 opt_default("packetsize", "2324");
4132 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4134 /* We have to offset the PTS, so that it is consistent with the SCR.
4135 SCR starts at 36000, but the first two packs contain only padding
4136 and the first pack from the other stream, respectively, may also have
4137 been written before.
4138 So the real data starts at SCR 36000+3*1200. */
4139 mux_preload= (36000+3*1200) / 90000.0; //0.44
4140 } else if(!strcmp(arg, "svcd")) {
4142 opt_video_codec("vcodec", "mpeg2video");
4143 opt_audio_codec("acodec", "mp2");
4144 opt_format("f", "svcd");
4146 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4147 opt_frame_rate("r", frame_rates[norm]);
4148 opt_default("g", norm == PAL ? "15" : "18");
4150 opt_default("b", "2040000");
4151 opt_default("maxrate", "2516000");
4152 opt_default("minrate", "0"); //1145000;
4153 opt_default("bufsize", "1835008"); //224*1024*8;
4154 opt_default("flags", "+scan_offset");
4157 opt_default("ab", "224000");
4158 audio_sample_rate = 44100;
4160 opt_default("packetsize", "2324");
4162 } else if(!strcmp(arg, "dvd")) {
4164 opt_video_codec("vcodec", "mpeg2video");
4165 opt_audio_codec("vcodec", "ac3");
4166 opt_format("f", "dvd");
4168 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4169 opt_frame_rate("r", frame_rates[norm]);
4170 opt_default("g", norm == PAL ? "15" : "18");
4172 opt_default("b", "6000000");
4173 opt_default("maxrate", "9000000");
4174 opt_default("minrate", "0"); //1500000;
4175 opt_default("bufsize", "1835008"); //224*1024*8;
4177 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4178 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4180 opt_default("ab", "448000");
4181 audio_sample_rate = 48000;
4183 } else if(!strncmp(arg, "dv", 2)) {
4185 opt_format("f", "dv");
4187 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4188 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4189 norm == PAL ? "yuv420p" : "yuv411p");
4190 opt_frame_rate("r", frame_rates[norm]);
4192 audio_sample_rate = 48000;
4196 fprintf(stderr, "Unknown target: %s\n", arg);
4197 return AVERROR(EINVAL);
4202 static int opt_vstats_file(const char *opt, const char *arg)
4204 av_free (vstats_filename);
4205 vstats_filename=av_strdup (arg);
4209 static int opt_vstats(const char *opt, const char *arg)
4212 time_t today2 = time(NULL);
4213 struct tm *today = localtime(&today2);
4215 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4217 return opt_vstats_file(opt, filename);
4220 static int opt_bsf(const char *opt, const char *arg)
4222 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4223 AVBitStreamFilterContext **bsfp;
4226 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4230 bsfp= *opt == 'v' ? &video_bitstream_filters :
4231 *opt == 'a' ? &audio_bitstream_filters :
4232 &subtitle_bitstream_filters;
4234 bsfp= &(*bsfp)->next;
4241 static int opt_preset(const char *opt, const char *arg)
4244 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4245 char *codec_name = *opt == 'v' ? video_codec_name :
4246 *opt == 'a' ? audio_codec_name :
4247 subtitle_codec_name;
4249 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4250 fprintf(stderr, "File for preset '%s' not found\n", arg);
4255 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4256 if(line[0] == '#' && !e)
4258 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4260 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4263 if(!strcmp(tmp, "acodec")){
4264 opt_audio_codec(tmp, tmp2);
4265 }else if(!strcmp(tmp, "vcodec")){
4266 opt_video_codec(tmp, tmp2);
4267 }else if(!strcmp(tmp, "scodec")){
4268 opt_subtitle_codec(tmp, tmp2);
4269 }else if(!strcmp(tmp, "dcodec")){
4270 opt_data_codec(tmp, tmp2);
4271 }else if(opt_default(tmp, tmp2) < 0){
4272 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4282 static const OptionDef options[] = {
4284 #include "cmdutils_common_opts.h"
4285 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4286 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4287 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4288 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4289 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4290 "outfile[,metadata]:infile[,metadata]" },
4291 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4292 "outfile[,metadata]:infile[,metadata]" },
4293 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4294 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4295 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4296 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4297 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4298 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4299 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4300 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4301 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4302 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4303 "add timings for benchmarking" },
4304 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4305 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4306 "dump each input packet" },
4307 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4308 "when dumping packets, also dump the payload" },
4309 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4310 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4311 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4312 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4313 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4314 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4315 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4316 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4317 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4318 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4319 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4320 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4321 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4322 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4323 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4324 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4327 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4328 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4329 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4330 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4331 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4332 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4333 { "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" },
4334 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4335 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4336 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4337 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4338 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4339 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4340 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4341 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4342 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4343 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4344 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4345 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4346 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4347 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4348 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4349 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4350 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4351 "use same quantizer as source (implies VBR)" },
4352 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4353 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4354 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4355 "deinterlace pictures" },
4356 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4357 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4358 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4360 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4362 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4363 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4364 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4365 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4366 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4367 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4368 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4369 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4370 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4371 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4372 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4375 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4376 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4377 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4378 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4379 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4380 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4381 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4382 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4383 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4384 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4385 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4386 { "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" },
4388 /* subtitle options */
4389 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4390 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4391 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4392 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4393 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4396 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4397 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4398 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4401 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4402 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4404 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4405 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4406 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4408 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4409 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4410 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4411 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4412 /* data codec support */
4413 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4415 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4419 int main(int argc, char **argv)
4423 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4425 avcodec_register_all();
4427 avdevice_register_all();
4430 avfilter_register_all();
4434 avio_set_interrupt_cb(decode_interrupt_cb);
4441 parse_options(argc, argv, options, opt_output_file);
4443 if(nb_output_files <= 0 && nb_input_files == 0) {
4445 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4449 /* file converter / grab */
4450 if (nb_output_files <= 0) {
4451 fprintf(stderr, "At least one output file must be specified\n");
4455 if (nb_input_files == 0) {
4456 fprintf(stderr, "At least one input file must be specified\n");
4461 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4462 stream_maps, nb_stream_maps) < 0)
4464 ti = getutime() - ti;
4466 int maxrss = getmaxrss() / 1024;
4467 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4470 return ffmpeg_exit(0);