3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "ffmpeg";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
85 int sync_stream_index;
89 * select an input file for an output file
91 typedef struct MetadataMap {
92 int file; //< file index
93 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
94 int index; //< stream/chapter/program number
97 typedef struct ChapterMap {
102 static const OptionDef options[];
104 #define MAX_FILES 100
105 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
107 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
109 static const char *last_asked_format = NULL;
110 static double *input_files_ts_scale[MAX_FILES] = {NULL};
111 static int nb_input_files_ts_scale[MAX_FILES] = {0};
113 static AVFormatContext *output_files[MAX_FILES];
114 static AVDictionary *output_opts[MAX_FILES];
115 static int nb_output_files = 0;
117 static StreamMap *stream_maps = NULL;
118 static int nb_stream_maps;
120 /* first item specifies output metadata, second is input */
121 static MetadataMap (*meta_data_maps)[2] = NULL;
122 static int nb_meta_data_maps;
123 static int metadata_global_autocopy = 1;
124 static int metadata_streams_autocopy = 1;
125 static int metadata_chapters_autocopy = 1;
127 static ChapterMap *chapter_maps = NULL;
128 static int nb_chapter_maps;
130 /* indexed by output file stream index */
131 static int *streamid_map = NULL;
132 static int nb_streamid_map = 0;
134 static int frame_width = 0;
135 static int frame_height = 0;
136 static float frame_aspect_ratio = 0;
137 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
138 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
139 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
140 static AVRational frame_rate;
141 static float video_qscale = 0;
142 static uint16_t *intra_matrix = NULL;
143 static uint16_t *inter_matrix = NULL;
144 static const char *video_rc_override_string=NULL;
145 static int video_disable = 0;
146 static int video_discard = 0;
147 static char *video_codec_name = NULL;
148 static unsigned int video_codec_tag = 0;
149 static char *video_language = NULL;
150 static int same_quality = 0;
151 static int do_deinterlace = 0;
152 static int top_field_first = -1;
153 static int me_threshold = 0;
154 static int intra_dc_precision = 8;
155 static int loop_input = 0;
156 static int loop_output = AVFMT_NOOUTPUTLOOP;
157 static int qp_hist = 0;
159 static char *vfilters = NULL;
162 static int intra_only = 0;
163 static int audio_sample_rate = 0;
164 static int64_t channel_layout = 0;
165 #define QSCALE_NONE -99999
166 static float audio_qscale = QSCALE_NONE;
167 static int audio_disable = 0;
168 static int audio_channels = 0;
169 static char *audio_codec_name = NULL;
170 static unsigned int audio_codec_tag = 0;
171 static char *audio_language = NULL;
173 static int subtitle_disable = 0;
174 static char *subtitle_codec_name = NULL;
175 static char *subtitle_language = NULL;
176 static unsigned int subtitle_codec_tag = 0;
178 static int data_disable = 0;
179 static char *data_codec_name = NULL;
180 static unsigned int data_codec_tag = 0;
182 static float mux_preload= 0.5;
183 static float mux_max_delay= 0.7;
185 static int64_t recording_time = INT64_MAX;
186 static int64_t start_time = 0;
187 static int64_t recording_timestamp = 0;
188 static int64_t input_ts_offset = 0;
189 static int file_overwrite = 0;
190 static AVDictionary *metadata;
191 static int do_benchmark = 0;
192 static int do_hex_dump = 0;
193 static int do_pkt_dump = 0;
194 static int do_psnr = 0;
195 static int do_pass = 0;
196 static char *pass_logfilename_prefix = NULL;
197 static int audio_stream_copy = 0;
198 static int video_stream_copy = 0;
199 static int subtitle_stream_copy = 0;
200 static int data_stream_copy = 0;
201 static int video_sync_method= -1;
202 static int audio_sync_method= 0;
203 static float audio_drift_threshold= 0.1;
204 static int copy_ts= 0;
206 static int opt_shortest = 0;
207 static char *vstats_filename;
208 static FILE *vstats_file;
209 static int opt_programid = 0;
210 static int copy_initial_nonkeyframes = 0;
212 static int rate_emu = 0;
214 static int audio_volume = 256;
216 static int exit_on_error = 0;
217 static int using_stdin = 0;
218 static int verbose = 1;
219 static int thread_count= 1;
220 static int64_t video_size = 0;
221 static int64_t audio_size = 0;
222 static int64_t extra_size = 0;
223 static int nb_frames_dup = 0;
224 static int nb_frames_drop = 0;
225 static int input_sync;
226 static uint64_t limit_filesize = 0;
227 static int force_fps = 0;
228 static char *forced_key_frames = NULL;
230 static float dts_delta_threshold = 10;
232 static int64_t timer_start;
234 static uint8_t *audio_buf;
235 static uint8_t *audio_out;
236 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
238 static short *samples;
240 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
241 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
242 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
244 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
248 typedef struct OutputStream {
249 int file_index; /* file index */
250 int index; /* stream index in the output file */
251 int source_index; /* InputStream index */
252 AVStream *st; /* stream in the output file */
253 int encoding_needed; /* true if encoding needed for this stream */
255 /* input pts and corresponding output pts
257 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
258 struct InputStream *sync_ist; /* input stream to sync against */
259 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
260 AVBitStreamFilterContext *bitstream_filters;
265 AVFrame pict_tmp; /* temporary image for resampling */
266 struct SwsContext *img_resample_ctx; /* for image resampling */
269 int resample_pix_fmt;
270 AVRational frame_rate;
272 float frame_aspect_ratio;
274 /* forced key frames */
275 int64_t *forced_kf_pts;
281 ReSampleContext *resample; /* for audio resampling */
282 int resample_sample_fmt;
283 int resample_channels;
284 int resample_sample_rate;
286 AVAudioConvert *reformat_ctx;
287 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
291 AVFilterContext *output_video_filter;
292 AVFilterContext *input_video_filter;
293 AVFilterBufferRef *picref;
295 AVFilterGraph *graph;
301 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
302 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
304 typedef struct InputStream {
307 int discard; /* true if stream data should be discarded */
308 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
309 int64_t sample_index; /* current sample */
312 int64_t start; /* time when read started */
313 int64_t next_pts; /* synthetic pts for cases where pkt.pts
315 int64_t pts; /* current pts */
316 PtsCorrectionContext pts_ctx;
317 int is_start; /* is 1 at the start and after a discontinuity */
318 int showed_multi_packet_warning;
319 int is_past_recording_time;
321 AVFrame *filter_frame;
322 int has_filter_frame;
326 typedef struct InputFile {
327 AVFormatContext *ctx;
328 int eof_reached; /* true if eof reached */
329 int ist_index; /* index of first stream in ist_table */
330 int buffer_size; /* current total buffer size */
334 static InputStream *input_streams = NULL;
335 static int nb_input_streams = 0;
336 static InputFile *input_files = NULL;
337 static int nb_input_files = 0;
341 static int configure_video_filters(InputStream *ist, OutputStream *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(stream_maps);
482 av_free(meta_data_maps);
484 av_freep(&input_streams);
485 av_freep(&input_files);
487 av_free(video_codec_name);
488 av_free(audio_codec_name);
489 av_free(subtitle_codec_name);
490 av_free(data_codec_name);
495 allocated_audio_buf_size= allocated_audio_out_size= 0;
502 if (received_sigterm) {
504 "Received signal %d: terminating.\n",
505 (int) received_sigterm);
509 exit(ret); /* not all OS-es handle main() return value */
513 static void assert_avoptions(AVDictionary *m)
515 AVDictionaryEntry *t;
516 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
517 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
522 /* similar to ff_dynarray_add() and av_fast_realloc() */
523 static void *grow_array(void *array, int elem_size, int *size, int new_size)
525 if (new_size >= INT_MAX / elem_size) {
526 fprintf(stderr, "Array too big.\n");
529 if (*size < new_size) {
530 uint8_t *tmp = av_realloc(array, new_size*elem_size);
532 fprintf(stderr, "Could not alloc buffer.\n");
535 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
542 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
544 if(codec && codec->sample_fmts){
545 const enum AVSampleFormat *p= codec->sample_fmts;
547 if(*p == st->codec->sample_fmt)
551 av_log(NULL, AV_LOG_WARNING,
552 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
553 av_get_sample_fmt_name(st->codec->sample_fmt),
555 av_get_sample_fmt_name(codec->sample_fmts[0]));
556 st->codec->sample_fmt = codec->sample_fmts[0];
562 * Update the requested input sample format based on the output sample format.
563 * This is currently only used to request float output from decoders which
564 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
565 * Ideally this will be removed in the future when decoders do not do format
566 * conversion and only output in their native format.
568 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
571 /* if sample formats match or a decoder sample format has already been
572 requested, just return */
573 if (enc->sample_fmt == dec->sample_fmt ||
574 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
577 /* if decoder supports more than one output format */
578 if (dec_codec && dec_codec->sample_fmts &&
579 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
580 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
581 const enum AVSampleFormat *p;
582 int min_dec = -1, min_inc = -1;
584 /* find a matching sample format in the encoder */
585 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
586 if (*p == enc->sample_fmt) {
587 dec->request_sample_fmt = *p;
589 } else if (*p > enc->sample_fmt) {
590 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
592 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
595 /* if none match, provide the one that matches quality closest */
596 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
597 enc->sample_fmt - min_dec;
601 static void choose_sample_rate(AVStream *st, AVCodec *codec)
603 if(codec && codec->supported_samplerates){
604 const int *p= codec->supported_samplerates;
606 int best_dist=INT_MAX;
608 int dist= abs(st->codec->sample_rate - *p);
609 if(dist < best_dist){
615 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
617 st->codec->sample_rate= best;
621 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
623 if(codec && codec->pix_fmts){
624 const enum PixelFormat *p= codec->pix_fmts;
625 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
626 if(st->codec->codec_id==CODEC_ID_MJPEG){
627 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
628 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
629 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};
633 if(*p == st->codec->pix_fmt)
637 if(st->codec->pix_fmt != PIX_FMT_NONE)
638 av_log(NULL, AV_LOG_WARNING,
639 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
640 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
642 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
643 st->codec->pix_fmt = codec->pix_fmts[0];
648 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
650 int idx = oc->nb_streams - 1;
653 output_streams_for_file[file_idx] =
654 grow_array(output_streams_for_file[file_idx],
655 sizeof(*output_streams_for_file[file_idx]),
656 &nb_output_streams_for_file[file_idx],
658 ost = output_streams_for_file[file_idx][idx] =
659 av_mallocz(sizeof(OutputStream));
661 fprintf(stderr, "Could not alloc output stream\n");
664 ost->file_index = file_idx;
667 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
671 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
674 AVFormatContext *ic = NULL;
677 err = avformat_open_input(&ic, filename, NULL, NULL);
680 /* copy stream format */
682 s->streams = av_mallocz(sizeof(AVStream *) * ic->nb_streams);
683 for(i=0;i<ic->nb_streams;i++) {
689 // FIXME: a more elegant solution is needed
690 st = av_mallocz(sizeof(AVStream));
691 memcpy(st, ic->streams[i], sizeof(AVStream));
693 st->codec = avcodec_alloc_context();
695 print_error(filename, AVERROR(ENOMEM));
698 avcodec_copy_context(st->codec, ic->streams[i]->codec);
701 codec = avcodec_find_encoder(st->codec->codec_id);
702 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
703 if (audio_stream_copy) {
706 choose_sample_fmt(st, codec);
707 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
708 if (video_stream_copy) {
711 choose_pixel_fmt(st, codec);
714 if(st->codec->flags & CODEC_FLAG_BITEXACT)
717 new_output_stream(s, nb_output_files);
721 s->timestamp = av_gettime();
723 av_close_input_file(ic);
728 get_sync_ipts(const OutputStream *ost)
730 const InputStream *ist = ost->sync_ist;
731 return (double)(ist->pts - start_time)/AV_TIME_BASE;
734 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
738 AVPacket new_pkt= *pkt;
739 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
740 &new_pkt.data, &new_pkt.size,
741 pkt->data, pkt->size,
742 pkt->flags & AV_PKT_FLAG_KEY);
745 new_pkt.destruct= av_destruct_packet;
747 fprintf(stderr, "%s failed for stream %d, codec %s",
748 bsfc->filter->name, pkt->stream_index,
749 avctx->codec ? avctx->codec->name : "copy");
759 ret= av_interleaved_write_frame(s, pkt);
761 print_error("av_interleaved_write_frame()", ret);
766 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
768 static void do_audio_out(AVFormatContext *s,
771 unsigned char *buf, int size)
774 int64_t audio_out_size, audio_buf_size;
775 int64_t allocated_for_size= size;
777 int size_out, frame_bytes, ret, resample_changed;
778 AVCodecContext *enc= ost->st->codec;
779 AVCodecContext *dec= ist->st->codec;
780 int osize = av_get_bytes_per_sample(enc->sample_fmt);
781 int isize = av_get_bytes_per_sample(dec->sample_fmt);
782 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
785 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
786 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
787 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
788 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
789 audio_buf_size*= osize*enc->channels;
791 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
792 if(coded_bps > 8*osize)
793 audio_out_size= audio_out_size * coded_bps / (8*osize);
794 audio_out_size += FF_MIN_BUFFER_SIZE;
796 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
797 fprintf(stderr, "Buffer sizes too large\n");
801 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
802 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
803 if (!audio_buf || !audio_out){
804 fprintf(stderr, "Out of memory in do_audio_out\n");
808 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
809 ost->audio_resample = 1;
811 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
812 ost->resample_channels != dec->channels ||
813 ost->resample_sample_rate != dec->sample_rate;
815 if ((ost->audio_resample && !ost->resample) || resample_changed) {
816 if (resample_changed) {
817 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",
818 ist->file_index, ist->st->index,
819 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
820 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
821 ost->resample_sample_fmt = dec->sample_fmt;
822 ost->resample_channels = dec->channels;
823 ost->resample_sample_rate = dec->sample_rate;
825 audio_resample_close(ost->resample);
827 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
828 if (audio_sync_method <= 1 &&
829 ost->resample_sample_fmt == enc->sample_fmt &&
830 ost->resample_channels == enc->channels &&
831 ost->resample_sample_rate == enc->sample_rate) {
832 ost->resample = NULL;
833 ost->audio_resample = 0;
834 } else if (ost->audio_resample) {
835 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
836 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
837 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
838 enc->sample_rate, dec->sample_rate,
839 enc->sample_fmt, dec->sample_fmt,
841 if (!ost->resample) {
842 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
843 dec->channels, dec->sample_rate,
844 enc->channels, enc->sample_rate);
850 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
851 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
852 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
853 if (ost->reformat_ctx)
854 av_audio_convert_free(ost->reformat_ctx);
855 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
856 dec->sample_fmt, 1, NULL, 0);
857 if (!ost->reformat_ctx) {
858 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
859 av_get_sample_fmt_name(dec->sample_fmt),
860 av_get_sample_fmt_name(enc->sample_fmt));
863 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
866 if(audio_sync_method){
867 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
868 - av_fifo_size(ost->fifo)/(enc->channels * 2);
869 double idelta= delta*dec->sample_rate / enc->sample_rate;
870 int byte_delta= ((int)idelta)*2*dec->channels;
872 //FIXME resample delay
873 if(fabs(delta) > 50){
874 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
876 byte_delta= FFMAX(byte_delta, -size);
880 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
885 static uint8_t *input_tmp= NULL;
886 input_tmp= av_realloc(input_tmp, byte_delta + size);
888 if(byte_delta > allocated_for_size - size){
889 allocated_for_size= byte_delta + (int64_t)size;
894 memset(input_tmp, 0, byte_delta);
895 memcpy(input_tmp + byte_delta, buf, size);
899 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
901 }else if(audio_sync_method>1){
902 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
903 av_assert0(ost->audio_resample);
905 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
906 // 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));
907 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
911 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
912 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
914 if (ost->audio_resample) {
916 size_out = audio_resample(ost->resample,
917 (short *)buftmp, (short *)buf,
918 size / (dec->channels * isize));
919 size_out = size_out * enc->channels * osize;
925 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
926 const void *ibuf[6]= {buftmp};
927 void *obuf[6]= {audio_buf};
928 int istride[6]= {isize};
929 int ostride[6]= {osize};
930 int len= size_out/istride[0];
931 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
932 printf("av_audio_convert() failed\n");
938 size_out = len*osize;
941 /* now encode as many frames as possible */
942 if (enc->frame_size > 1) {
943 /* output resampled raw samples */
944 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
945 fprintf(stderr, "av_fifo_realloc2() failed\n");
948 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
950 frame_bytes = enc->frame_size * osize * enc->channels;
952 while (av_fifo_size(ost->fifo) >= frame_bytes) {
954 av_init_packet(&pkt);
956 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
958 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
960 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
963 fprintf(stderr, "Audio encoding failed\n");
967 pkt.stream_index= ost->index;
970 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
971 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
972 pkt.flags |= AV_PKT_FLAG_KEY;
973 write_frame(s, &pkt, enc, ost->bitstream_filters);
975 ost->sync_opts += enc->frame_size;
979 av_init_packet(&pkt);
981 ost->sync_opts += size_out / (osize * enc->channels);
983 /* output a pcm frame */
984 /* determine the size of the coded buffer */
987 size_out = size_out*coded_bps/8;
989 if(size_out > audio_out_size){
990 fprintf(stderr, "Internal error, buffer size too small\n");
994 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
995 ret = avcodec_encode_audio(enc, audio_out, size_out,
998 fprintf(stderr, "Audio encoding failed\n");
1002 pkt.stream_index= ost->index;
1003 pkt.data= audio_out;
1005 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1006 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1007 pkt.flags |= AV_PKT_FLAG_KEY;
1008 write_frame(s, &pkt, enc, ost->bitstream_filters);
1012 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1014 AVCodecContext *dec;
1015 AVPicture *picture2;
1016 AVPicture picture_tmp;
1019 dec = ist->st->codec;
1021 /* deinterlace : must be done before any resize */
1022 if (do_deinterlace) {
1025 /* create temporary picture */
1026 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1027 buf = av_malloc(size);
1031 picture2 = &picture_tmp;
1032 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1034 if(avpicture_deinterlace(picture2, picture,
1035 dec->pix_fmt, dec->width, dec->height) < 0) {
1036 /* if error, do not deinterlace */
1037 fprintf(stderr, "Deinterlacing failed\n");
1046 if (picture != picture2)
1047 *picture = *picture2;
1051 /* we begin to correct av delay at this threshold */
1052 #define AV_DELAY_MAX 0.100
1054 static void do_subtitle_out(AVFormatContext *s,
1060 static uint8_t *subtitle_out = NULL;
1061 int subtitle_out_max_size = 1024 * 1024;
1062 int subtitle_out_size, nb, i;
1063 AVCodecContext *enc;
1066 if (pts == AV_NOPTS_VALUE) {
1067 fprintf(stderr, "Subtitle packets must have a pts\n");
1073 enc = ost->st->codec;
1075 if (!subtitle_out) {
1076 subtitle_out = av_malloc(subtitle_out_max_size);
1079 /* Note: DVB subtitle need one packet to draw them and one other
1080 packet to clear them */
1081 /* XXX: signal it in the codec context ? */
1082 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1087 for(i = 0; i < nb; i++) {
1088 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1089 // start_display_time is required to be 0
1090 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1091 sub->end_display_time -= sub->start_display_time;
1092 sub->start_display_time = 0;
1093 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1094 subtitle_out_max_size, sub);
1095 if (subtitle_out_size < 0) {
1096 fprintf(stderr, "Subtitle encoding failed\n");
1100 av_init_packet(&pkt);
1101 pkt.stream_index = ost->index;
1102 pkt.data = subtitle_out;
1103 pkt.size = subtitle_out_size;
1104 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1105 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1106 /* XXX: the pts correction is handled here. Maybe handling
1107 it in the codec would be better */
1109 pkt.pts += 90 * sub->start_display_time;
1111 pkt.pts += 90 * sub->end_display_time;
1113 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1117 static int bit_buffer_size= 1024*256;
1118 static uint8_t *bit_buffer= NULL;
1120 static void do_video_out(AVFormatContext *s,
1123 AVFrame *in_picture,
1124 int *frame_size, float quality)
1126 int nb_frames, i, ret, resample_changed;
1127 AVFrame *final_picture, *formatted_picture;
1128 AVCodecContext *enc, *dec;
1131 enc = ost->st->codec;
1132 dec = ist->st->codec;
1134 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1136 /* by default, we output a single frame */
1141 if(video_sync_method){
1142 double vdelta = sync_ipts - ost->sync_opts;
1143 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1146 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1149 }else if(vdelta>0.6)
1150 ost->sync_opts= lrintf(sync_ipts);
1151 }else if (vdelta > 1.1)
1152 nb_frames = lrintf(vdelta);
1153 //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);
1154 if (nb_frames == 0){
1157 fprintf(stderr, "*** drop!\n");
1158 }else if (nb_frames > 1) {
1159 nb_frames_dup += nb_frames - 1;
1161 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1164 ost->sync_opts= lrintf(sync_ipts);
1166 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1170 formatted_picture = in_picture;
1171 final_picture = formatted_picture;
1173 resample_changed = ost->resample_width != dec->width ||
1174 ost->resample_height != dec->height ||
1175 ost->resample_pix_fmt != dec->pix_fmt;
1177 if (resample_changed) {
1178 av_log(NULL, AV_LOG_INFO,
1179 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1180 ist->file_index, ist->st->index,
1181 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1182 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1183 if(!ost->video_resample)
1187 #if !CONFIG_AVFILTER
1188 if (ost->video_resample) {
1189 final_picture = &ost->pict_tmp;
1190 if (resample_changed) {
1191 /* initialize a new scaler context */
1192 sws_freeContext(ost->img_resample_ctx);
1193 ost->img_resample_ctx = sws_getContext(
1194 ist->st->codec->width,
1195 ist->st->codec->height,
1196 ist->st->codec->pix_fmt,
1197 ost->st->codec->width,
1198 ost->st->codec->height,
1199 ost->st->codec->pix_fmt,
1200 ost->sws_flags, NULL, NULL, NULL);
1201 if (ost->img_resample_ctx == NULL) {
1202 fprintf(stderr, "Cannot get resampling context\n");
1206 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1207 0, ost->resample_height, final_picture->data, final_picture->linesize);
1211 /* duplicates frame if needed */
1212 for(i=0;i<nb_frames;i++) {
1214 av_init_packet(&pkt);
1215 pkt.stream_index= ost->index;
1217 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1218 /* raw pictures are written as AVPicture structure to
1219 avoid any copies. We support temorarily the older
1221 AVFrame* old_frame = enc->coded_frame;
1222 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1223 pkt.data= (uint8_t *)final_picture;
1224 pkt.size= sizeof(AVPicture);
1225 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1226 pkt.flags |= AV_PKT_FLAG_KEY;
1228 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1229 enc->coded_frame = old_frame;
1231 AVFrame big_picture;
1233 big_picture= *final_picture;
1234 /* better than nothing: use input picture interlaced
1236 big_picture.interlaced_frame = in_picture->interlaced_frame;
1237 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1238 if(top_field_first == -1)
1239 big_picture.top_field_first = in_picture->top_field_first;
1241 big_picture.top_field_first = top_field_first;
1244 /* handles sameq here. This is not correct because it may
1245 not be a global option */
1246 big_picture.quality = quality;
1248 big_picture.pict_type = 0;
1249 // big_picture.pts = AV_NOPTS_VALUE;
1250 big_picture.pts= ost->sync_opts;
1251 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1252 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1253 if (ost->forced_kf_index < ost->forced_kf_count &&
1254 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1255 big_picture.pict_type = AV_PICTURE_TYPE_I;
1256 ost->forced_kf_index++;
1258 ret = avcodec_encode_video(enc,
1259 bit_buffer, bit_buffer_size,
1262 fprintf(stderr, "Video encoding failed\n");
1267 pkt.data= bit_buffer;
1269 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1270 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1271 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1272 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1273 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1275 if(enc->coded_frame->key_frame)
1276 pkt.flags |= AV_PKT_FLAG_KEY;
1277 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1280 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1281 // enc->frame_number-1, ret, enc->pict_type);
1282 /* if two pass, output log */
1283 if (ost->logfile && enc->stats_out) {
1284 fprintf(ost->logfile, "%s", enc->stats_out);
1289 ost->frame_number++;
1293 static double psnr(double d){
1294 return -10.0*log(d)/log(10.0);
1297 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1300 AVCodecContext *enc;
1302 double ti1, bitrate, avg_bitrate;
1304 /* this is executed just the first time do_video_stats is called */
1306 vstats_file = fopen(vstats_filename, "w");
1313 enc = ost->st->codec;
1314 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1315 frame_number = ost->frame_number;
1316 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1317 if (enc->flags&CODEC_FLAG_PSNR)
1318 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1320 fprintf(vstats_file,"f_size= %6d ", frame_size);
1321 /* compute pts value */
1322 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1326 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1327 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1328 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1329 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1330 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1334 static void print_report(AVFormatContext **output_files,
1335 OutputStream **ost_table, int nb_ostreams,
1340 AVFormatContext *oc;
1342 AVCodecContext *enc;
1343 int frame_number, vid, i;
1344 double bitrate, ti1, pts;
1345 static int64_t last_time = -1;
1346 static int qp_histogram[52];
1348 if (!is_last_report) {
1350 /* display the report every 0.5 seconds */
1351 cur_time = av_gettime();
1352 if (last_time == -1) {
1353 last_time = cur_time;
1356 if ((cur_time - last_time) < 500000)
1358 last_time = cur_time;
1362 oc = output_files[0];
1364 total_size = avio_size(oc->pb);
1365 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1366 total_size= avio_tell(oc->pb);
1371 for(i=0;i<nb_ostreams;i++) {
1374 enc = ost->st->codec;
1375 if (!ost->st->stream_copy && enc->coded_frame)
1376 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1377 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1378 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1380 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1381 float t = (av_gettime()-timer_start) / 1000000.0;
1383 frame_number = ost->frame_number;
1384 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1385 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1391 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1394 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1396 if (enc->flags&CODEC_FLAG_PSNR){
1398 double error, error_sum=0;
1399 double scale, scale_sum=0;
1400 char type[3]= {'Y','U','V'};
1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1404 error= enc->error[j];
1405 scale= enc->width*enc->height*255.0*255.0*frame_number;
1407 error= enc->coded_frame->error[j];
1408 scale= enc->width*enc->height*255.0*255.0;
1413 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1415 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1419 /* compute min output value */
1420 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1421 if ((pts < ti1) && (pts > 0))
1427 if (verbose > 0 || is_last_report) {
1428 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1430 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1431 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1432 (double)total_size / 1024, ti1, bitrate);
1434 if (nb_frames_dup || nb_frames_drop)
1435 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1436 nb_frames_dup, nb_frames_drop);
1439 fprintf(stderr, "%s \r", buf);
1444 if (is_last_report && verbose >= 0){
1445 int64_t raw= audio_size + video_size + extra_size;
1446 fprintf(stderr, "\n");
1447 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1451 100.0*(total_size - raw)/raw
1456 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1458 int fill_char = 0x00;
1459 if (sample_fmt == AV_SAMPLE_FMT_U8)
1461 memset(buf, fill_char, size);
1464 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1465 static int output_packet(InputStream *ist, int ist_index,
1466 OutputStream **ost_table, int nb_ostreams,
1467 const AVPacket *pkt)
1469 AVFormatContext *os;
1474 void *buffer_to_free = NULL;
1475 static unsigned int samples_size= 0;
1476 AVSubtitle subtitle, *subtitle_to_free;
1477 int64_t pkt_pts = AV_NOPTS_VALUE;
1479 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 quality = same_quality ? picture.quality : 0;
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[ist->file_index].ts_offset - 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 same_quality ? quality : ost->st->codec->global_quality);
1689 if (vstats_filename && frame_size)
1690 do_video_stats(os, ost, frame_size);
1692 case AVMEDIA_TYPE_SUBTITLE:
1693 do_subtitle_out(os, ost, ist, &subtitle,
1700 AVFrame avframe; //FIXME/XXX remove this
1702 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1704 av_init_packet(&opkt);
1706 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1707 #if !CONFIG_AVFILTER
1713 /* no reencoding needed : output the packet directly */
1714 /* force the input stream PTS */
1716 avcodec_get_frame_defaults(&avframe);
1717 ost->st->codec->coded_frame= &avframe;
1718 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1720 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1721 audio_size += data_size;
1722 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1723 video_size += data_size;
1727 opkt.stream_index= ost->index;
1728 if(pkt->pts != AV_NOPTS_VALUE)
1729 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1731 opkt.pts= AV_NOPTS_VALUE;
1733 if (pkt->dts == AV_NOPTS_VALUE)
1734 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1736 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1737 opkt.dts -= ost_tb_start_time;
1739 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1740 opkt.flags= pkt->flags;
1742 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1743 if( ost->st->codec->codec_id != CODEC_ID_H264
1744 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1745 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1747 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1748 opkt.destruct= av_destruct_packet;
1750 opkt.data = data_buf;
1751 opkt.size = data_size;
1754 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1755 ost->st->codec->frame_number++;
1756 ost->frame_number++;
1757 av_free_packet(&opkt);
1761 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1762 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1764 avfilter_unref_buffer(ost->picref);
1770 av_free(buffer_to_free);
1771 /* XXX: allocate the subtitles in the codec ? */
1772 if (subtitle_to_free) {
1773 avsubtitle_free(subtitle_to_free);
1774 subtitle_to_free = NULL;
1781 for(i=0;i<nb_ostreams;i++) {
1783 if (ost->source_index == ist_index) {
1784 AVCodecContext *enc= ost->st->codec;
1785 os = output_files[ost->file_index];
1787 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1789 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1792 if (ost->encoding_needed) {
1796 av_init_packet(&pkt);
1797 pkt.stream_index= ost->index;
1799 switch(ost->st->codec->codec_type) {
1800 case AVMEDIA_TYPE_AUDIO:
1801 fifo_bytes = av_fifo_size(ost->fifo);
1803 /* encode any samples remaining in fifo */
1804 if (fifo_bytes > 0) {
1805 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1806 int fs_tmp = enc->frame_size;
1808 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1809 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1810 enc->frame_size = fifo_bytes / (osize * enc->channels);
1812 int frame_bytes = enc->frame_size*osize*enc->channels;
1813 if (allocated_audio_buf_size < frame_bytes)
1815 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1818 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1819 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1820 ost->st->time_base.num, enc->sample_rate);
1821 enc->frame_size = fs_tmp;
1824 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1827 fprintf(stderr, "Audio encoding failed\n");
1831 pkt.flags |= AV_PKT_FLAG_KEY;
1833 case AVMEDIA_TYPE_VIDEO:
1834 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1836 fprintf(stderr, "Video encoding failed\n");
1840 if(enc->coded_frame && enc->coded_frame->key_frame)
1841 pkt.flags |= AV_PKT_FLAG_KEY;
1842 if (ost->logfile && enc->stats_out) {
1843 fprintf(ost->logfile, "%s", enc->stats_out);
1852 pkt.data= bit_buffer;
1854 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1855 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1856 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1868 static void print_sdp(AVFormatContext **avc, int n)
1872 av_sdp_create(avc, n, sdp, sizeof(sdp));
1873 printf("SDP:\n%s\n", sdp);
1877 static int copy_chapters(int infile, int outfile)
1879 AVFormatContext *is = input_files[infile].ctx;
1880 AVFormatContext *os = output_files[outfile];
1883 for (i = 0; i < is->nb_chapters; i++) {
1884 AVChapter *in_ch = is->chapters[i], *out_ch;
1885 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1886 AV_TIME_BASE_Q, in_ch->time_base);
1887 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1888 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1891 if (in_ch->end < ts_off)
1893 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1896 out_ch = av_mallocz(sizeof(AVChapter));
1898 return AVERROR(ENOMEM);
1900 out_ch->id = in_ch->id;
1901 out_ch->time_base = in_ch->time_base;
1902 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1903 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1905 if (metadata_chapters_autocopy)
1906 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1909 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1911 return AVERROR(ENOMEM);
1912 os->chapters[os->nb_chapters - 1] = out_ch;
1917 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1918 AVCodecContext *avctx)
1924 for (p = kf; *p; p++)
1927 ost->forced_kf_count = n;
1928 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1929 if (!ost->forced_kf_pts) {
1930 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1933 for (i = 0; i < n; i++) {
1934 p = i ? strchr(p, ',') + 1 : kf;
1935 t = parse_time_or_die("force_key_frames", p, 1);
1936 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1941 * The following code is the main loop of the file converter
1943 static int transcode(AVFormatContext **output_files,
1944 int nb_output_files,
1945 InputFile *input_files,
1947 StreamMap *stream_maps, int nb_stream_maps)
1949 int ret = 0, i, j, k, n, nb_ostreams = 0;
1950 AVFormatContext *is, *os;
1951 AVCodecContext *codec, *icodec;
1952 OutputStream *ost, **ost_table = NULL;
1956 uint8_t no_packet[MAX_FILES]={0};
1957 int no_packet_count=0;
1960 for (i = 0; i < nb_input_streams; i++)
1961 input_streams[i].start = av_gettime();
1963 /* output stream init */
1965 for(i=0;i<nb_output_files;i++) {
1966 os = output_files[i];
1967 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1968 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1969 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1970 ret = AVERROR(EINVAL);
1973 nb_ostreams += os->nb_streams;
1975 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1976 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1977 ret = AVERROR(EINVAL);
1981 /* Sanity check the mapping args -- do the input files & streams exist? */
1982 for(i=0;i<nb_stream_maps;i++) {
1983 int fi = stream_maps[i].file_index;
1984 int si = stream_maps[i].stream_index;
1986 if (fi < 0 || fi > nb_input_files - 1 ||
1987 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1988 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1989 ret = AVERROR(EINVAL);
1992 fi = stream_maps[i].sync_file_index;
1993 si = stream_maps[i].sync_stream_index;
1994 if (fi < 0 || fi > nb_input_files - 1 ||
1995 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1996 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1997 ret = AVERROR(EINVAL);
2002 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2006 for(k=0;k<nb_output_files;k++) {
2007 os = output_files[k];
2008 for(i=0;i<os->nb_streams;i++,n++) {
2010 ost = ost_table[n] = output_streams_for_file[k][i];
2011 ost->st = os->streams[i];
2012 if (nb_stream_maps > 0) {
2013 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2014 stream_maps[n].stream_index;
2016 /* Sanity check that the stream types match */
2017 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2018 int i= ost->file_index;
2019 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2020 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2021 stream_maps[n].file_index, stream_maps[n].stream_index,
2022 ost->file_index, ost->index);
2027 int best_nb_frames=-1;
2028 /* get corresponding input stream index : we select the first one with the right type */
2030 for (j = 0; j < nb_input_streams; j++) {
2032 ist = &input_streams[j];
2035 AVFormatContext *f = input_files[ist->file_index].ctx;
2037 for(pi=0; pi<f->nb_programs; pi++){
2038 AVProgram *p= f->programs[pi];
2039 if(p->id == opt_programid)
2040 for(si=0; si<p->nb_stream_indexes; si++){
2041 if(f->streams[ p->stream_index[si] ] == ist->st)
2046 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2047 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2048 if(best_nb_frames < ist->st->codec_info_nb_frames){
2049 best_nb_frames= ist->st->codec_info_nb_frames;
2050 ost->source_index = j;
2057 if(! opt_programid) {
2058 /* try again and reuse existing stream */
2059 for (j = 0; j < nb_input_streams; j++) {
2060 ist = &input_streams[j];
2061 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2062 && ist->st->discard != AVDISCARD_ALL) {
2063 ost->source_index = j;
2069 int i= ost->file_index;
2070 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2071 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2072 ost->file_index, ost->index);
2077 ist = &input_streams[ost->source_index];
2079 ost->sync_ist = (nb_stream_maps > 0) ?
2080 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2081 stream_maps[n].sync_stream_index] : ist;
2085 /* for each output stream, we compute the right encoding parameters */
2086 for(i=0;i<nb_ostreams;i++) {
2088 os = output_files[ost->file_index];
2089 ist = &input_streams[ost->source_index];
2091 codec = ost->st->codec;
2092 icodec = ist->st->codec;
2094 if (metadata_streams_autocopy)
2095 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2096 AV_DICT_DONT_OVERWRITE);
2098 ost->st->disposition = ist->st->disposition;
2099 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2100 codec->chroma_sample_location = icodec->chroma_sample_location;
2102 if (ost->st->stream_copy) {
2103 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2105 if (extra_size > INT_MAX)
2108 /* if stream_copy is selected, no need to decode or encode */
2109 codec->codec_id = icodec->codec_id;
2110 codec->codec_type = icodec->codec_type;
2112 if(!codec->codec_tag){
2113 if( !os->oformat->codec_tag
2114 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2115 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2116 codec->codec_tag = icodec->codec_tag;
2119 codec->bit_rate = icodec->bit_rate;
2120 codec->rc_max_rate = icodec->rc_max_rate;
2121 codec->rc_buffer_size = icodec->rc_buffer_size;
2122 codec->extradata= av_mallocz(extra_size);
2123 if (!codec->extradata)
2125 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2126 codec->extradata_size= icodec->extradata_size;
2127 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){
2128 codec->time_base = icodec->time_base;
2129 codec->time_base.num *= icodec->ticks_per_frame;
2130 av_reduce(&codec->time_base.num, &codec->time_base.den,
2131 codec->time_base.num, codec->time_base.den, INT_MAX);
2133 codec->time_base = ist->st->time_base;
2134 switch(codec->codec_type) {
2135 case AVMEDIA_TYPE_AUDIO:
2136 if(audio_volume != 256) {
2137 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2140 codec->channel_layout = icodec->channel_layout;
2141 codec->sample_rate = icodec->sample_rate;
2142 codec->channels = icodec->channels;
2143 codec->frame_size = icodec->frame_size;
2144 codec->audio_service_type = icodec->audio_service_type;
2145 codec->block_align= icodec->block_align;
2146 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2147 codec->block_align= 0;
2148 if(codec->codec_id == CODEC_ID_AC3)
2149 codec->block_align= 0;
2151 case AVMEDIA_TYPE_VIDEO:
2152 codec->pix_fmt = icodec->pix_fmt;
2153 codec->width = icodec->width;
2154 codec->height = icodec->height;
2155 codec->has_b_frames = icodec->has_b_frames;
2156 if (!codec->sample_aspect_ratio.num) {
2157 codec->sample_aspect_ratio =
2158 ost->st->sample_aspect_ratio =
2159 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2160 ist->st->codec->sample_aspect_ratio.num ?
2161 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2164 case AVMEDIA_TYPE_SUBTITLE:
2165 codec->width = icodec->width;
2166 codec->height = icodec->height;
2168 case AVMEDIA_TYPE_DATA:
2175 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2176 switch(codec->codec_type) {
2177 case AVMEDIA_TYPE_AUDIO:
2178 ost->fifo= av_fifo_alloc(1024);
2181 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2182 if (!codec->sample_rate) {
2183 codec->sample_rate = icodec->sample_rate;
2185 codec->sample_rate >>= icodec->lowres;
2187 choose_sample_rate(ost->st, ost->enc);
2188 codec->time_base = (AVRational){1, codec->sample_rate};
2189 if (!codec->channels)
2190 codec->channels = icodec->channels;
2191 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2192 codec->channel_layout = 0;
2193 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2194 icodec->request_channels = codec->channels;
2195 ist->decoding_needed = 1;
2196 ost->encoding_needed = 1;
2197 ost->resample_sample_fmt = icodec->sample_fmt;
2198 ost->resample_sample_rate = icodec->sample_rate;
2199 ost->resample_channels = icodec->channels;
2201 case AVMEDIA_TYPE_VIDEO:
2202 if (codec->pix_fmt == PIX_FMT_NONE)
2203 codec->pix_fmt = icodec->pix_fmt;
2204 choose_pixel_fmt(ost->st, ost->enc);
2206 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2207 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2210 ost->video_resample = codec->width != icodec->width ||
2211 codec->height != icodec->height ||
2212 codec->pix_fmt != icodec->pix_fmt;
2213 if (ost->video_resample) {
2214 #if !CONFIG_AVFILTER
2215 avcodec_get_frame_defaults(&ost->pict_tmp);
2216 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2217 codec->width, codec->height)) {
2218 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2221 ost->img_resample_ctx = sws_getContext(
2228 ost->sws_flags, NULL, NULL, NULL);
2229 if (ost->img_resample_ctx == NULL) {
2230 fprintf(stderr, "Cannot get resampling context\n");
2234 codec->bits_per_raw_sample= 0;
2236 if (!codec->width || !codec->height) {
2237 codec->width = icodec->width;
2238 codec->height = icodec->height;
2240 ost->resample_height = icodec->height;
2241 ost->resample_width = icodec->width;
2242 ost->resample_pix_fmt= icodec->pix_fmt;
2243 ost->encoding_needed = 1;
2244 ist->decoding_needed = 1;
2246 if (!ost->frame_rate.num)
2247 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2248 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2249 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2250 ost->frame_rate = ost->enc->supported_framerates[idx];
2252 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2255 if (configure_video_filters(ist, ost)) {
2256 fprintf(stderr, "Error opening filters!\n");
2261 case AVMEDIA_TYPE_SUBTITLE:
2262 ost->encoding_needed = 1;
2263 ist->decoding_needed = 1;
2270 if (ost->encoding_needed &&
2271 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2272 char logfilename[1024];
2275 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2276 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2278 if (codec->flags & CODEC_FLAG_PASS1) {
2279 f = fopen(logfilename, "wb");
2281 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2287 size_t logbuffer_size;
2288 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2289 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2292 codec->stats_in = logbuffer;
2296 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2297 int size= codec->width * codec->height;
2298 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2303 bit_buffer = av_malloc(bit_buffer_size);
2305 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2307 ret = AVERROR(ENOMEM);
2311 /* open each encoder */
2312 for(i=0;i<nb_ostreams;i++) {
2314 if (ost->encoding_needed) {
2315 AVCodec *codec = ost->enc;
2316 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2318 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2319 ost->st->codec->codec_id, ost->file_index, ost->index);
2320 ret = AVERROR(EINVAL);
2323 if (dec->subtitle_header) {
2324 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2325 if (!ost->st->codec->subtitle_header) {
2326 ret = AVERROR(ENOMEM);
2329 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2330 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2332 if (avcodec_open(ost->st->codec, codec) < 0) {
2333 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2334 ost->file_index, ost->index);
2335 ret = AVERROR(EINVAL);
2338 extra_size += ost->st->codec->extradata_size;
2342 /* open each decoder */
2343 for (i = 0; i < nb_input_streams; i++) {
2344 ist = &input_streams[i];
2345 if (ist->decoding_needed) {
2346 AVCodec *codec = ist->dec;
2348 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2350 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2351 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2352 ret = AVERROR(EINVAL);
2356 /* update requested sample format for the decoder based on the
2357 corresponding encoder sample format */
2358 for (j = 0; j < nb_ostreams; j++) {
2360 if (ost->source_index == i) {
2361 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2366 if (avcodec_open(ist->st->codec, codec) < 0) {
2367 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2368 ist->file_index, ist->st->index);
2369 ret = AVERROR(EINVAL);
2372 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2373 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2378 for (i = 0; i < nb_input_streams; i++) {
2380 ist = &input_streams[i];
2382 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2383 ist->next_pts = AV_NOPTS_VALUE;
2384 init_pts_correction(&ist->pts_ctx);
2388 /* set meta data information from input file if required */
2389 for (i=0;i<nb_meta_data_maps;i++) {
2390 AVFormatContext *files[2];
2391 AVDictionary **meta[2];
2394 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2395 if ((index) < 0 || (index) >= (nb_elems)) {\
2396 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2398 ret = AVERROR(EINVAL);\
2402 int out_file_index = meta_data_maps[i][0].file;
2403 int in_file_index = meta_data_maps[i][1].file;
2404 if (in_file_index < 0 || out_file_index < 0)
2406 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2407 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2409 files[0] = output_files[out_file_index];
2410 files[1] = input_files[in_file_index].ctx;
2412 for (j = 0; j < 2; j++) {
2413 MetadataMap *map = &meta_data_maps[i][j];
2415 switch (map->type) {
2417 meta[j] = &files[j]->metadata;
2420 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2421 meta[j] = &files[j]->streams[map->index]->metadata;
2424 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2425 meta[j] = &files[j]->chapters[map->index]->metadata;
2428 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2429 meta[j] = &files[j]->programs[map->index]->metadata;
2434 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2437 /* copy global metadata by default */
2438 if (metadata_global_autocopy) {
2440 for (i = 0; i < nb_output_files; i++)
2441 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2442 AV_DICT_DONT_OVERWRITE);
2445 /* copy chapters according to chapter maps */
2446 for (i = 0; i < nb_chapter_maps; i++) {
2447 int infile = chapter_maps[i].in_file;
2448 int outfile = chapter_maps[i].out_file;
2450 if (infile < 0 || outfile < 0)
2452 if (infile >= nb_input_files) {
2453 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2454 ret = AVERROR(EINVAL);
2457 if (outfile >= nb_output_files) {
2458 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2459 ret = AVERROR(EINVAL);
2462 copy_chapters(infile, outfile);
2465 /* copy chapters from the first input file that has them*/
2466 if (!nb_chapter_maps)
2467 for (i = 0; i < nb_input_files; i++) {
2468 if (!input_files[i].ctx->nb_chapters)
2471 for (j = 0; j < nb_output_files; j++)
2472 if ((ret = copy_chapters(i, j)) < 0)
2477 /* open files and write file headers */
2478 for(i=0;i<nb_output_files;i++) {
2479 os = output_files[i];
2480 if (avformat_write_header(os, &output_opts[i]) < 0) {
2481 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2482 ret = AVERROR(EINVAL);
2485 assert_avoptions(output_opts[i]);
2486 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2492 /* dump the file output parameters - cannot be done before in case
2494 for(i=0;i<nb_output_files;i++) {
2495 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2498 /* dump the stream mapping */
2500 fprintf(stderr, "Stream mapping:\n");
2501 for(i=0;i<nb_ostreams;i++) {
2503 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2504 input_streams[ost->source_index].file_index,
2505 input_streams[ost->source_index].st->index,
2508 if (ost->sync_ist != &input_streams[ost->source_index])
2509 fprintf(stderr, " [sync #%d.%d]",
2510 ost->sync_ist->file_index,
2511 ost->sync_ist->st->index);
2512 fprintf(stderr, "\n");
2517 fprintf(stderr, "%s\n", error);
2522 print_sdp(output_files, nb_output_files);
2526 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2529 timer_start = av_gettime();
2531 for(; received_sigterm == 0;) {
2532 int file_index, ist_index;
2541 /* select the stream that we must read now by looking at the
2542 smallest output pts */
2544 for(i=0;i<nb_ostreams;i++) {
2547 os = output_files[ost->file_index];
2548 ist = &input_streams[ost->source_index];
2549 if(ist->is_past_recording_time || no_packet[ist->file_index])
2551 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2552 ipts = (double)ist->pts;
2553 if (!input_files[ist->file_index].eof_reached){
2554 if(ipts < ipts_min) {
2556 if(input_sync ) file_index = ist->file_index;
2558 if(opts < opts_min) {
2560 if(!input_sync) file_index = ist->file_index;
2563 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2568 /* if none, if is finished */
2569 if (file_index < 0) {
2570 if(no_packet_count){
2572 memset(no_packet, 0, sizeof(no_packet));
2579 /* finish if limit size exhausted */
2580 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2583 /* read a frame from it and output it in the fifo */
2584 is = input_files[file_index].ctx;
2585 ret= av_read_frame(is, &pkt);
2586 if(ret == AVERROR(EAGAIN)){
2587 no_packet[file_index]=1;
2592 input_files[file_index].eof_reached = 1;
2600 memset(no_packet, 0, sizeof(no_packet));
2603 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2604 is->streams[pkt.stream_index]);
2606 /* the following test is needed in case new streams appear
2607 dynamically in stream : we ignore them */
2608 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2609 goto discard_packet;
2610 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2611 ist = &input_streams[ist_index];
2613 goto discard_packet;
2615 if (pkt.dts != AV_NOPTS_VALUE)
2616 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2617 if (pkt.pts != AV_NOPTS_VALUE)
2618 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2620 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2621 && input_files_ts_scale[file_index][pkt.stream_index]){
2622 if(pkt.pts != AV_NOPTS_VALUE)
2623 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2624 if(pkt.dts != AV_NOPTS_VALUE)
2625 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2628 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2629 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2630 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2631 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2632 int64_t delta= pkt_dts - ist->next_pts;
2633 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2634 input_files[ist->file_index].ts_offset -= delta;
2636 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2637 delta, input_files[ist->file_index].ts_offset);
2638 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2639 if(pkt.pts != AV_NOPTS_VALUE)
2640 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2644 /* finish if recording time exhausted */
2645 if (recording_time != INT64_MAX &&
2646 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2647 ist->is_past_recording_time = 1;
2648 goto discard_packet;
2651 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2652 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2655 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2656 ist->file_index, ist->st->index);
2659 av_free_packet(&pkt);
2664 av_free_packet(&pkt);
2666 /* dump report by using the output first video and audio streams */
2667 print_report(output_files, ost_table, nb_ostreams, 0);
2670 /* at the end of stream, we must flush the decoder buffers */
2671 for (i = 0; i < nb_input_streams; i++) {
2672 ist = &input_streams[i];
2673 if (ist->decoding_needed) {
2674 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2680 /* write the trailer if needed and close file */
2681 for(i=0;i<nb_output_files;i++) {
2682 os = output_files[i];
2683 av_write_trailer(os);
2686 /* dump report by using the first video and audio streams */
2687 print_report(output_files, ost_table, nb_ostreams, 1);
2689 /* close each encoder */
2690 for(i=0;i<nb_ostreams;i++) {
2692 if (ost->encoding_needed) {
2693 av_freep(&ost->st->codec->stats_in);
2694 avcodec_close(ost->st->codec);
2697 avfilter_graph_free(&ost->graph);
2701 /* close each decoder */
2702 for (i = 0; i < nb_input_streams; i++) {
2703 ist = &input_streams[i];
2704 if (ist->decoding_needed) {
2705 avcodec_close(ist->st->codec);
2713 av_freep(&bit_buffer);
2716 for(i=0;i<nb_ostreams;i++) {
2719 if (ost->st->stream_copy)
2720 av_freep(&ost->st->codec->extradata);
2722 fclose(ost->logfile);
2723 ost->logfile = NULL;
2725 av_fifo_free(ost->fifo); /* works even if fifo is not
2726 initialized but set to zero */
2727 av_freep(&ost->st->codec->subtitle_header);
2728 av_free(ost->pict_tmp.data[0]);
2729 av_free(ost->forced_kf_pts);
2730 if (ost->video_resample)
2731 sws_freeContext(ost->img_resample_ctx);
2733 audio_resample_close(ost->resample);
2734 if (ost->reformat_ctx)
2735 av_audio_convert_free(ost->reformat_ctx);
2744 static int opt_format(const char *opt, const char *arg)
2746 last_asked_format = arg;
2750 static int opt_video_rc_override_string(const char *opt, const char *arg)
2752 video_rc_override_string = arg;
2756 static int opt_me_threshold(const char *opt, const char *arg)
2758 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2762 static int opt_verbose(const char *opt, const char *arg)
2764 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2768 static int opt_frame_rate(const char *opt, const char *arg)
2770 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2771 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2777 static int opt_bitrate(const char *opt, const char *arg)
2779 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2781 opt_default(opt, arg);
2783 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2784 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2789 static int opt_frame_crop(const char *opt, const char *arg)
2791 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2792 return AVERROR(EINVAL);
2795 static int opt_frame_size(const char *opt, const char *arg)
2797 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2798 fprintf(stderr, "Incorrect frame size\n");
2799 return AVERROR(EINVAL);
2804 static int opt_pad(const char *opt, const char *arg) {
2805 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2809 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2811 if (strcmp(arg, "list")) {
2812 frame_pix_fmt = av_get_pix_fmt(arg);
2813 if (frame_pix_fmt == PIX_FMT_NONE) {
2814 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2815 return AVERROR(EINVAL);
2824 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2831 p = strchr(arg, ':');
2833 x = strtol(arg, &end, 10);
2835 y = strtol(end+1, &end, 10);
2837 ar = (double)x / (double)y;
2839 ar = strtod(arg, NULL);
2842 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2843 return AVERROR(EINVAL);
2845 frame_aspect_ratio = ar;
2849 static int opt_metadata(const char *opt, const char *arg)
2851 char *mid= strchr(arg, '=');
2854 fprintf(stderr, "Missing =\n");
2859 av_dict_set(&metadata, arg, mid, 0);
2864 static int opt_qscale(const char *opt, const char *arg)
2866 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2867 if (video_qscale == 0) {
2868 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2869 return AVERROR(EINVAL);
2874 static int opt_top_field_first(const char *opt, const char *arg)
2876 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2880 static int opt_thread_count(const char *opt, const char *arg)
2882 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2885 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2890 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2892 if (strcmp(arg, "list")) {
2893 audio_sample_fmt = av_get_sample_fmt(arg);
2894 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2895 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2896 return AVERROR(EINVAL);
2901 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2902 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2908 static int opt_audio_rate(const char *opt, const char *arg)
2910 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2914 static int opt_audio_channels(const char *opt, const char *arg)
2916 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2920 static int opt_video_channel(const char *opt, const char *arg)
2922 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2923 opt_default("channel", arg);
2927 static int opt_video_standard(const char *opt, const char *arg)
2929 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2930 opt_default("standard", arg);
2934 static int opt_codec(int *pstream_copy, char **pcodec_name,
2935 int codec_type, const char *arg)
2937 av_freep(pcodec_name);
2938 if (!strcmp(arg, "copy")) {
2941 *pcodec_name = av_strdup(arg);
2946 static int opt_audio_codec(const char *opt, const char *arg)
2948 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2951 static int opt_video_codec(const char *opt, const char *arg)
2953 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2956 static int opt_subtitle_codec(const char *opt, const char *arg)
2958 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2961 static int opt_data_codec(const char *opt, const char *arg)
2963 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2966 static int opt_codec_tag(const char *opt, const char *arg)
2969 uint32_t *codec_tag;
2971 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2972 !strcmp(opt, "vtag") ? &video_codec_tag :
2973 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2977 *codec_tag = strtol(arg, &tail, 0);
2979 *codec_tag = AV_RL32(arg);
2984 static int opt_map(const char *opt, const char *arg)
2989 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2990 m = &stream_maps[nb_stream_maps-1];
2992 m->file_index = strtol(arg, &p, 0);
2996 m->stream_index = strtol(p, &p, 0);
2999 m->sync_file_index = strtol(p, &p, 0);
3002 m->sync_stream_index = strtol(p, &p, 0);
3004 m->sync_file_index = m->file_index;
3005 m->sync_stream_index = m->stream_index;
3010 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3021 *index = strtol(++arg, endptr, 0);
3024 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3031 static int opt_map_metadata(const char *opt, const char *arg)
3033 MetadataMap *m, *m1;
3036 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3037 &nb_meta_data_maps, nb_meta_data_maps + 1);
3039 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3040 m->file = strtol(arg, &p, 0);
3041 parse_meta_type(p, &m->type, &m->index, &p);
3045 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3046 m1->file = strtol(p, &p, 0);
3047 parse_meta_type(p, &m1->type, &m1->index, &p);
3049 if (m->type == 'g' || m1->type == 'g')
3050 metadata_global_autocopy = 0;
3051 if (m->type == 's' || m1->type == 's')
3052 metadata_streams_autocopy = 0;
3053 if (m->type == 'c' || m1->type == 'c')
3054 metadata_chapters_autocopy = 0;
3059 static int opt_map_meta_data(const char *opt, const char *arg)
3061 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3062 "Use -map_metadata instead.\n");
3063 return opt_map_metadata(opt, arg);
3066 static int opt_map_chapters(const char *opt, const char *arg)
3071 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3072 nb_chapter_maps + 1);
3073 c = &chapter_maps[nb_chapter_maps - 1];
3074 c->out_file = strtol(arg, &p, 0);
3078 c->in_file = strtol(p, &p, 0);
3082 static int opt_input_ts_scale(const char *opt, const char *arg)
3084 unsigned int stream;
3088 stream = strtol(arg, &p, 0);
3091 scale= strtod(p, &p);
3093 if(stream >= MAX_STREAMS)
3096 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);
3097 input_files_ts_scale[nb_input_files][stream]= scale;
3101 static int opt_recording_time(const char *opt, const char *arg)
3103 recording_time = parse_time_or_die(opt, arg, 1);
3107 static int opt_start_time(const char *opt, const char *arg)
3109 start_time = parse_time_or_die(opt, arg, 1);
3113 static int opt_recording_timestamp(const char *opt, const char *arg)
3115 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3119 static int opt_input_ts_offset(const char *opt, const char *arg)
3121 input_ts_offset = parse_time_or_die(opt, arg, 1);
3125 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3127 const char *codec_string = encoder ? "encoder" : "decoder";
3131 return CODEC_ID_NONE;
3133 avcodec_find_encoder_by_name(name) :
3134 avcodec_find_decoder_by_name(name);
3136 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3139 if(codec->type != type) {
3140 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3143 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3144 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3145 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3146 "results.\nAdd '-strict experimental' if you want to use it.\n",
3147 codec_string, codec->name);
3149 avcodec_find_encoder(codec->id) :
3150 avcodec_find_decoder(codec->id);
3151 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3152 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3153 codec_string, codec->name);
3159 static int opt_input_file(const char *opt, const char *filename)
3161 AVFormatContext *ic;
3162 AVInputFormat *file_iformat = NULL;
3163 int err, i, ret, rfps, rfps_base;
3167 if (last_asked_format) {
3168 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3169 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3172 last_asked_format = NULL;
3175 if (!strcmp(filename, "-"))
3178 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3179 !strcmp(filename, "/dev/stdin");
3181 /* get default parameters from command line */
3182 ic = avformat_alloc_context();
3184 print_error(filename, AVERROR(ENOMEM));
3187 if (audio_sample_rate) {
3188 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3189 av_dict_set(&format_opts, "sample_rate", buf, 0);
3191 if (audio_channels) {
3192 snprintf(buf, sizeof(buf), "%d", audio_channels);
3193 av_dict_set(&format_opts, "channels", buf, 0);
3195 if (frame_rate.num) {
3196 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3197 av_dict_set(&format_opts, "framerate", buf, 0);
3199 if (frame_width && frame_height) {
3200 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3201 av_dict_set(&format_opts, "video_size", buf, 0);
3203 if (frame_pix_fmt != PIX_FMT_NONE)
3204 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3206 ic->video_codec_id =
3207 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3208 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3209 ic->audio_codec_id =
3210 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3211 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3212 ic->subtitle_codec_id=
3213 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3214 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3215 ic->flags |= AVFMT_FLAG_NONBLOCK;
3217 /* open the input file with generic libav function */
3218 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3220 print_error(filename, err);
3223 assert_avoptions(format_opts);
3228 for(i=0; i<ic->nb_streams; i++){
3229 ic->streams[i]->discard= AVDISCARD_ALL;
3231 for(i=0; i<ic->nb_programs; i++){
3232 AVProgram *p= ic->programs[i];
3233 if(p->id != opt_programid){
3234 p->discard = AVDISCARD_ALL;
3237 for(j=0; j<p->nb_stream_indexes; j++){
3238 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3243 fprintf(stderr, "Specified program id not found\n");
3250 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3251 ic->loop_input = loop_input;
3254 /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3255 for (i = 0; i < ic->nb_streams; i++) {
3256 AVCodecContext *dec = ic->streams[i]->codec;
3257 switch (dec->codec_type) {
3258 case AVMEDIA_TYPE_AUDIO:
3259 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3260 AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3263 case AVMEDIA_TYPE_VIDEO:
3264 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3265 AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3271 /* If not enough info to get the stream parameters, we decode the
3272 first frames to get it. (used in mpeg case for example) */
3273 ret = av_find_stream_info(ic);
3274 if (ret < 0 && verbose >= 0) {
3275 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3276 av_close_input_file(ic);
3280 timestamp = start_time;
3281 /* add the stream start time */
3282 if (ic->start_time != AV_NOPTS_VALUE)
3283 timestamp += ic->start_time;
3285 /* if seeking requested, we execute it */
3286 if (start_time != 0) {
3287 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3289 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3290 filename, (double)timestamp / AV_TIME_BASE);
3292 /* reset seek info */
3296 /* update the current parameters so that they match the one of the input stream */
3297 for(i=0;i<ic->nb_streams;i++) {
3298 AVStream *st = ic->streams[i];
3299 AVCodecContext *dec = st->codec;
3302 dec->thread_count = thread_count;
3304 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3305 ist = &input_streams[nb_input_streams - 1];
3307 ist->file_index = nb_input_files;
3310 switch (dec->codec_type) {
3311 case AVMEDIA_TYPE_AUDIO:
3312 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3313 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3314 channel_layout = dec->channel_layout;
3315 audio_sample_fmt = dec->sample_fmt;
3317 st->discard= AVDISCARD_ALL;
3319 case AVMEDIA_TYPE_VIDEO:
3320 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3321 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3322 rfps = ic->streams[i]->r_frame_rate.num;
3323 rfps_base = ic->streams[i]->r_frame_rate.den;
3325 dec->flags |= CODEC_FLAG_EMU_EDGE;
3326 dec->height >>= dec->lowres;
3327 dec->width >>= dec->lowres;
3330 dec->debug |= FF_DEBUG_MV;
3332 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3335 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3336 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3338 (float)rfps / rfps_base, rfps, rfps_base);
3342 st->discard= AVDISCARD_ALL;
3343 else if(video_discard)
3344 st->discard= video_discard;
3346 case AVMEDIA_TYPE_DATA:
3348 case AVMEDIA_TYPE_SUBTITLE:
3349 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3350 if(subtitle_disable)
3351 st->discard = AVDISCARD_ALL;
3353 case AVMEDIA_TYPE_ATTACHMENT:
3354 case AVMEDIA_TYPE_UNKNOWN:
3361 /* dump the file content */
3363 av_dump_format(ic, nb_input_files, filename, 0);
3365 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3366 input_files[nb_input_files - 1].ctx = ic;
3367 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3368 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3370 frame_rate = (AVRational){0, 0};
3371 frame_pix_fmt = PIX_FMT_NONE;
3374 audio_sample_rate = 0;
3377 av_freep(&video_codec_name);
3378 av_freep(&audio_codec_name);
3379 av_freep(&subtitle_codec_name);
3385 static void check_inputs(int *has_video_ptr,
3387 int *has_subtitle_ptr,
3390 int has_video, has_audio, has_subtitle, has_data, i, j;
3391 AVFormatContext *ic;
3398 for(j=0;j<nb_input_files;j++) {
3399 ic = input_files[j].ctx;
3400 for(i=0;i<ic->nb_streams;i++) {
3401 AVCodecContext *enc = ic->streams[i]->codec;
3402 switch(enc->codec_type) {
3403 case AVMEDIA_TYPE_AUDIO:
3406 case AVMEDIA_TYPE_VIDEO:
3409 case AVMEDIA_TYPE_SUBTITLE:
3412 case AVMEDIA_TYPE_DATA:
3413 case AVMEDIA_TYPE_ATTACHMENT:
3414 case AVMEDIA_TYPE_UNKNOWN:
3422 *has_video_ptr = has_video;
3423 *has_audio_ptr = has_audio;
3424 *has_subtitle_ptr = has_subtitle;
3425 *has_data_ptr = has_data;
3428 static void new_video_stream(AVFormatContext *oc, int file_idx)
3432 AVCodecContext *video_enc;
3433 enum CodecID codec_id = CODEC_ID_NONE;
3434 AVCodec *codec= NULL;
3436 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3438 fprintf(stderr, "Could not alloc stream\n");
3441 ost = new_output_stream(oc, file_idx);
3443 if(!video_stream_copy){
3444 if (video_codec_name) {
3445 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3446 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3447 codec = avcodec_find_encoder_by_name(video_codec_name);
3450 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3451 codec = avcodec_find_encoder(codec_id);
3454 ost->frame_aspect_ratio = frame_aspect_ratio;
3455 frame_aspect_ratio = 0;
3457 ost->avfilter= vfilters;
3462 avcodec_get_context_defaults3(st->codec, codec);
3463 ost->bitstream_filters = video_bitstream_filters;
3464 video_bitstream_filters= NULL;
3466 st->codec->thread_count= thread_count;
3468 video_enc = st->codec;
3471 video_enc->codec_tag= video_codec_tag;
3473 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3474 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3475 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3478 if (video_stream_copy) {
3479 st->stream_copy = 1;
3480 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3481 video_enc->sample_aspect_ratio =
3482 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3488 ost->frame_rate = frame_rate;
3489 video_enc->codec_id = codec_id;
3490 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3492 video_enc->width = frame_width;
3493 video_enc->height = frame_height;
3494 video_enc->pix_fmt = frame_pix_fmt;
3495 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3498 video_enc->gop_size = 0;
3499 if (video_qscale || same_quality) {
3500 video_enc->flags |= CODEC_FLAG_QSCALE;
3501 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3505 video_enc->intra_matrix = intra_matrix;
3507 video_enc->inter_matrix = inter_matrix;
3509 p= video_rc_override_string;
3512 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3514 fprintf(stderr, "error parsing rc_override\n");
3517 video_enc->rc_override=
3518 av_realloc(video_enc->rc_override,
3519 sizeof(RcOverride)*(i+1));
3520 video_enc->rc_override[i].start_frame= start;
3521 video_enc->rc_override[i].end_frame = end;
3523 video_enc->rc_override[i].qscale= q;
3524 video_enc->rc_override[i].quality_factor= 1.0;
3527 video_enc->rc_override[i].qscale= 0;
3528 video_enc->rc_override[i].quality_factor= -q/100.0;
3533 video_enc->rc_override_count=i;
3534 if (!video_enc->rc_initial_buffer_occupancy)
3535 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3536 video_enc->me_threshold= me_threshold;
3537 video_enc->intra_dc_precision= intra_dc_precision - 8;
3540 video_enc->flags|= CODEC_FLAG_PSNR;
3545 video_enc->flags |= CODEC_FLAG_PASS1;
3547 video_enc->flags |= CODEC_FLAG_PASS2;
3551 if (forced_key_frames)
3552 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3554 if (video_language) {
3555 av_dict_set(&st->metadata, "language", video_language, 0);
3556 av_freep(&video_language);
3559 /* reset some key parameters */
3561 av_freep(&video_codec_name);
3562 av_freep(&forced_key_frames);
3563 video_stream_copy = 0;
3564 frame_pix_fmt = PIX_FMT_NONE;
3567 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3571 AVCodec *codec= NULL;
3572 AVCodecContext *audio_enc;
3573 enum CodecID codec_id = CODEC_ID_NONE;
3575 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3577 fprintf(stderr, "Could not alloc stream\n");
3580 ost = new_output_stream(oc, file_idx);
3582 if(!audio_stream_copy){
3583 if (audio_codec_name) {
3584 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3585 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3586 codec = avcodec_find_encoder_by_name(audio_codec_name);
3589 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3590 codec = avcodec_find_encoder(codec_id);
3594 avcodec_get_context_defaults3(st->codec, codec);
3596 ost->bitstream_filters = audio_bitstream_filters;
3597 audio_bitstream_filters= NULL;
3599 st->codec->thread_count= thread_count;
3601 audio_enc = st->codec;
3602 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3605 audio_enc->codec_tag= audio_codec_tag;
3607 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3608 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3609 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3611 if (audio_stream_copy) {
3612 st->stream_copy = 1;
3614 audio_enc->codec_id = codec_id;
3615 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3617 if (audio_qscale > QSCALE_NONE) {
3618 audio_enc->flags |= CODEC_FLAG_QSCALE;
3619 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3622 audio_enc->channels = audio_channels;
3623 audio_enc->sample_fmt = audio_sample_fmt;
3624 if (audio_sample_rate)
3625 audio_enc->sample_rate = audio_sample_rate;
3626 audio_enc->channel_layout = channel_layout;
3627 choose_sample_fmt(st, codec);
3629 if (audio_language) {
3630 av_dict_set(&st->metadata, "language", audio_language, 0);
3631 av_freep(&audio_language);
3634 /* reset some key parameters */
3636 av_freep(&audio_codec_name);
3637 audio_stream_copy = 0;
3640 static void new_data_stream(AVFormatContext *oc, int file_idx)
3643 AVCodec *codec=NULL;
3644 AVCodecContext *data_enc;
3646 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3648 fprintf(stderr, "Could not alloc stream\n");
3651 new_output_stream(oc, file_idx);
3652 data_enc = st->codec;
3653 if (!data_stream_copy) {
3654 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3657 avcodec_get_context_defaults3(st->codec, codec);
3659 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3662 data_enc->codec_tag= data_codec_tag;
3664 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3665 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3666 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3668 if (data_stream_copy) {
3669 st->stream_copy = 1;
3673 av_freep(&data_codec_name);
3674 data_stream_copy = 0;
3677 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3681 AVCodec *codec=NULL;
3682 AVCodecContext *subtitle_enc;
3683 enum CodecID codec_id = CODEC_ID_NONE;
3685 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3687 fprintf(stderr, "Could not alloc stream\n");
3690 ost = new_output_stream(oc, file_idx);
3691 subtitle_enc = st->codec;
3692 if(!subtitle_stream_copy){
3693 if (subtitle_codec_name) {
3694 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3695 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3696 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3699 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3700 codec = avcodec_find_encoder(codec_id);
3703 avcodec_get_context_defaults3(st->codec, codec);
3705 ost->bitstream_filters = subtitle_bitstream_filters;
3706 subtitle_bitstream_filters= NULL;
3708 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3710 if(subtitle_codec_tag)
3711 subtitle_enc->codec_tag= subtitle_codec_tag;
3713 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3714 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3715 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3717 if (subtitle_stream_copy) {
3718 st->stream_copy = 1;
3720 subtitle_enc->codec_id = codec_id;
3721 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3724 if (subtitle_language) {
3725 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3726 av_freep(&subtitle_language);
3729 subtitle_disable = 0;
3730 av_freep(&subtitle_codec_name);
3731 subtitle_stream_copy = 0;
3734 static int opt_new_stream(const char *opt, const char *arg)
3736 AVFormatContext *oc;
3737 int file_idx = nb_output_files - 1;
3738 if (nb_output_files <= 0) {
3739 fprintf(stderr, "At least one output file must be specified\n");
3742 oc = output_files[file_idx];
3744 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3745 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3746 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3747 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3752 /* arg format is "output-stream-index:streamid-value". */
3753 static int opt_streamid(const char *opt, const char *arg)
3759 av_strlcpy(idx_str, arg, sizeof(idx_str));
3760 p = strchr(idx_str, ':');
3763 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3768 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3769 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3770 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3774 static void opt_output_file(const char *filename)
3776 AVFormatContext *oc;
3777 int err, use_video, use_audio, use_subtitle, use_data;
3778 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3779 AVOutputFormat *file_oformat;
3781 if (!strcmp(filename, "-"))
3784 oc = avformat_alloc_context();
3786 print_error(filename, AVERROR(ENOMEM));
3790 if (last_asked_format) {
3791 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3792 if (!file_oformat) {
3793 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3796 last_asked_format = NULL;
3798 file_oformat = av_guess_format(NULL, filename, NULL);
3799 if (!file_oformat) {
3800 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3806 oc->oformat = file_oformat;
3807 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3809 if (!strcmp(file_oformat->name, "ffm") &&
3810 av_strstart(filename, "http:", NULL)) {
3811 /* special case for files sent to ffserver: we get the stream
3812 parameters from ffserver */
3813 int err = read_ffserver_streams(oc, filename);
3815 print_error(filename, err);
3819 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3820 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3821 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3822 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 */
3824 /* disable if no corresponding type found and at least one
3826 if (nb_input_files > 0) {
3827 check_inputs(&input_has_video,
3829 &input_has_subtitle,
3832 if (!input_has_video)
3834 if (!input_has_audio)
3836 if (!input_has_subtitle)
3838 if (!input_has_data)
3842 /* manual disable */
3843 if (audio_disable) use_audio = 0;
3844 if (video_disable) use_video = 0;
3845 if (subtitle_disable) use_subtitle = 0;
3846 if (data_disable) use_data = 0;
3848 if (use_video) new_video_stream(oc, nb_output_files);
3849 if (use_audio) new_audio_stream(oc, nb_output_files);
3850 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3851 if (use_data) new_data_stream(oc, nb_output_files);
3853 oc->timestamp = recording_timestamp;
3855 av_dict_copy(&oc->metadata, metadata, 0);
3856 av_dict_free(&metadata);
3859 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3860 output_files[nb_output_files++] = oc;
3862 /* check filename in case of an image number is expected */
3863 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3864 if (!av_filename_number_test(oc->filename)) {
3865 print_error(oc->filename, AVERROR(EINVAL));
3870 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3871 /* test if it already exists to avoid loosing precious files */
3872 if (!file_overwrite &&
3873 (strchr(filename, ':') == NULL ||
3874 filename[1] == ':' ||
3875 av_strstart(filename, "file:", NULL))) {
3876 if (avio_check(filename, 0) == 0) {
3878 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3880 if (!read_yesno()) {
3881 fprintf(stderr, "Not overwriting - exiting\n");
3886 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3893 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3894 print_error(filename, err);
3899 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3900 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3901 if (loop_output >= 0) {
3902 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3903 oc->loop_output = loop_output;
3905 oc->flags |= AVFMT_FLAG_NONBLOCK;
3907 frame_rate = (AVRational){0, 0};
3910 audio_sample_rate = 0;
3913 av_freep(&forced_key_frames);
3918 /* same option as mencoder */
3919 static int opt_pass(const char *opt, const char *arg)
3921 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3925 static int64_t getutime(void)
3928 struct rusage rusage;
3930 getrusage(RUSAGE_SELF, &rusage);
3931 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3932 #elif HAVE_GETPROCESSTIMES
3934 FILETIME c, e, k, u;
3935 proc = GetCurrentProcess();
3936 GetProcessTimes(proc, &c, &e, &k, &u);
3937 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3939 return av_gettime();
3943 static int64_t getmaxrss(void)
3945 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3946 struct rusage rusage;
3947 getrusage(RUSAGE_SELF, &rusage);
3948 return (int64_t)rusage.ru_maxrss * 1024;
3949 #elif HAVE_GETPROCESSMEMORYINFO
3951 PROCESS_MEMORY_COUNTERS memcounters;
3952 proc = GetCurrentProcess();
3953 memcounters.cb = sizeof(memcounters);
3954 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3955 return memcounters.PeakPagefileUsage;
3961 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3964 const char *p = str;
3971 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3978 static void opt_inter_matrix(const char *arg)
3980 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3981 parse_matrix_coeffs(inter_matrix, arg);
3984 static void opt_intra_matrix(const char *arg)
3986 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3987 parse_matrix_coeffs(intra_matrix, arg);
3990 static void show_usage(void)
3992 printf("Hyper fast Audio and Video encoder\n");
3993 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3997 static void show_help(void)
4000 AVOutputFormat *oformat = NULL;
4001 AVInputFormat *iformat = NULL;
4003 av_log_set_callback(log_callback_help);
4005 show_help_options(options, "Main options:\n",
4006 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4007 show_help_options(options, "\nAdvanced options:\n",
4008 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4010 show_help_options(options, "\nVideo options:\n",
4011 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4013 show_help_options(options, "\nAdvanced Video options:\n",
4014 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4015 OPT_VIDEO | OPT_EXPERT);
4016 show_help_options(options, "\nAudio options:\n",
4017 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4019 show_help_options(options, "\nAdvanced Audio options:\n",
4020 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4021 OPT_AUDIO | OPT_EXPERT);
4022 show_help_options(options, "\nSubtitle options:\n",
4023 OPT_SUBTITLE | OPT_GRAB,
4025 show_help_options(options, "\nAudio/Video grab options:\n",
4029 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4032 /* individual codec options */
4034 while ((c = av_codec_next(c))) {
4035 if (c->priv_class) {
4036 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4041 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4044 /* individual muxer options */
4045 while ((oformat = av_oformat_next(oformat))) {
4046 if (oformat->priv_class) {
4047 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4052 /* individual demuxer options */
4053 while ((iformat = av_iformat_next(iformat))) {
4054 if (iformat->priv_class) {
4055 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4060 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4063 static int opt_target(const char *opt, const char *arg)
4065 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4066 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4068 if(!strncmp(arg, "pal-", 4)) {
4071 } else if(!strncmp(arg, "ntsc-", 5)) {
4074 } else if(!strncmp(arg, "film-", 5)) {
4079 /* Calculate FR via float to avoid int overflow */
4080 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4083 } else if((fr == 29970) || (fr == 23976)) {
4086 /* Try to determine PAL/NTSC by peeking in the input files */
4087 if(nb_input_files) {
4089 for (j = 0; j < nb_input_files; j++) {
4090 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4091 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4092 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4094 fr = c->time_base.den * 1000 / c->time_base.num;
4098 } else if((fr == 29970) || (fr == 23976)) {
4108 if(verbose > 0 && norm != UNKNOWN)
4109 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4112 if(norm == UNKNOWN) {
4113 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4114 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4115 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4119 if(!strcmp(arg, "vcd")) {
4120 opt_video_codec("vcodec", "mpeg1video");
4121 opt_audio_codec("vcodec", "mp2");
4122 opt_format("f", "vcd");
4124 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4125 opt_frame_rate("r", frame_rates[norm]);
4126 opt_default("g", norm == PAL ? "15" : "18");
4128 opt_default("b", "1150000");
4129 opt_default("maxrate", "1150000");
4130 opt_default("minrate", "1150000");
4131 opt_default("bufsize", "327680"); // 40*1024*8;
4133 opt_default("ab", "224000");
4134 audio_sample_rate = 44100;
4137 opt_default("packetsize", "2324");
4138 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4140 /* We have to offset the PTS, so that it is consistent with the SCR.
4141 SCR starts at 36000, but the first two packs contain only padding
4142 and the first pack from the other stream, respectively, may also have
4143 been written before.
4144 So the real data starts at SCR 36000+3*1200. */
4145 mux_preload= (36000+3*1200) / 90000.0; //0.44
4146 } else if(!strcmp(arg, "svcd")) {
4148 opt_video_codec("vcodec", "mpeg2video");
4149 opt_audio_codec("acodec", "mp2");
4150 opt_format("f", "svcd");
4152 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4153 opt_frame_rate("r", frame_rates[norm]);
4154 opt_default("g", norm == PAL ? "15" : "18");
4156 opt_default("b", "2040000");
4157 opt_default("maxrate", "2516000");
4158 opt_default("minrate", "0"); //1145000;
4159 opt_default("bufsize", "1835008"); //224*1024*8;
4160 opt_default("flags", "+scan_offset");
4163 opt_default("ab", "224000");
4164 audio_sample_rate = 44100;
4166 opt_default("packetsize", "2324");
4168 } else if(!strcmp(arg, "dvd")) {
4170 opt_video_codec("vcodec", "mpeg2video");
4171 opt_audio_codec("vcodec", "ac3");
4172 opt_format("f", "dvd");
4174 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4175 opt_frame_rate("r", frame_rates[norm]);
4176 opt_default("g", norm == PAL ? "15" : "18");
4178 opt_default("b", "6000000");
4179 opt_default("maxrate", "9000000");
4180 opt_default("minrate", "0"); //1500000;
4181 opt_default("bufsize", "1835008"); //224*1024*8;
4183 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4184 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4186 opt_default("ab", "448000");
4187 audio_sample_rate = 48000;
4189 } else if(!strncmp(arg, "dv", 2)) {
4191 opt_format("f", "dv");
4193 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4194 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4195 norm == PAL ? "yuv420p" : "yuv411p");
4196 opt_frame_rate("r", frame_rates[norm]);
4198 audio_sample_rate = 48000;
4202 fprintf(stderr, "Unknown target: %s\n", arg);
4203 return AVERROR(EINVAL);
4208 static int opt_vstats_file(const char *opt, const char *arg)
4210 av_free (vstats_filename);
4211 vstats_filename=av_strdup (arg);
4215 static int opt_vstats(const char *opt, const char *arg)
4218 time_t today2 = time(NULL);
4219 struct tm *today = localtime(&today2);
4221 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4223 return opt_vstats_file(opt, filename);
4226 static int opt_bsf(const char *opt, const char *arg)
4228 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4229 AVBitStreamFilterContext **bsfp;
4232 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4236 bsfp= *opt == 'v' ? &video_bitstream_filters :
4237 *opt == 'a' ? &audio_bitstream_filters :
4238 &subtitle_bitstream_filters;
4240 bsfp= &(*bsfp)->next;
4247 static int opt_preset(const char *opt, const char *arg)
4250 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4251 char *codec_name = *opt == 'v' ? video_codec_name :
4252 *opt == 'a' ? audio_codec_name :
4253 subtitle_codec_name;
4255 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4256 fprintf(stderr, "File for preset '%s' not found\n", arg);
4261 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4262 if(line[0] == '#' && !e)
4264 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4266 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4269 if(!strcmp(tmp, "acodec")){
4270 opt_audio_codec(tmp, tmp2);
4271 }else if(!strcmp(tmp, "vcodec")){
4272 opt_video_codec(tmp, tmp2);
4273 }else if(!strcmp(tmp, "scodec")){
4274 opt_subtitle_codec(tmp, tmp2);
4275 }else if(!strcmp(tmp, "dcodec")){
4276 opt_data_codec(tmp, tmp2);
4277 }else if(opt_default(tmp, tmp2) < 0){
4278 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4288 static const OptionDef options[] = {
4290 #include "cmdutils_common_opts.h"
4291 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4292 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4293 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4294 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4295 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4296 "outfile[,metadata]:infile[,metadata]" },
4297 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4298 "outfile[,metadata]:infile[,metadata]" },
4299 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4300 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4301 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4302 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4303 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4304 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4305 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4306 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4307 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4308 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4309 "add timings for benchmarking" },
4310 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4311 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4312 "dump each input packet" },
4313 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4314 "when dumping packets, also dump the payload" },
4315 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4316 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4317 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4318 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4319 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4320 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4321 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4322 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4323 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4324 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4325 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4326 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4327 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4328 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4329 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4330 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4333 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4334 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4335 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4336 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4337 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4338 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4339 { "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" },
4340 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4341 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4342 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4343 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4344 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4345 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4346 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4347 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4348 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4349 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4350 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4351 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4352 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4353 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4354 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4355 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4356 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4357 "use same quantizer as source (implies VBR)" },
4358 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4359 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4360 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4361 "deinterlace pictures" },
4362 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4363 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4364 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4366 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4368 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4369 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4370 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4371 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4372 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4373 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4374 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4375 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4376 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4377 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4378 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4381 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4382 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4383 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4384 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4385 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4386 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4387 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4388 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4389 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4390 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4391 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4392 { "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" },
4394 /* subtitle options */
4395 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4396 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4397 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4398 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4399 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4402 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4403 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4404 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4407 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4408 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4410 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4411 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4412 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4414 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4415 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4416 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4417 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4418 /* data codec support */
4419 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4421 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4425 int main(int argc, char **argv)
4429 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4431 avcodec_register_all();
4433 avdevice_register_all();
4436 avfilter_register_all();
4440 avio_set_interrupt_cb(decode_interrupt_cb);
4447 parse_options(argc, argv, options, opt_output_file);
4449 if(nb_output_files <= 0 && nb_input_files == 0) {
4451 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4455 /* file converter / grab */
4456 if (nb_output_files <= 0) {
4457 fprintf(stderr, "At least one output file must be specified\n");
4461 if (nb_input_files == 0) {
4462 fprintf(stderr, "At least one input file must be specified\n");
4467 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4468 stream_maps, nb_stream_maps) < 0)
4470 ti = getutime() - ti;
4472 int maxrss = getmaxrss() / 1024;
4473 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4476 return ffmpeg_exit(0);