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
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavutil/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavutil/audioconvert.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/libm.h"
48 #include "libavformat/os_support.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
79 #include "libavutil/avassert.h"
81 const char program_name[] = "ffmpeg";
82 const int program_birth_year = 2000;
84 /* select an input stream for an output stream */
85 typedef struct AVStreamMap {
89 int sync_stream_index;
93 * select an input file for an output file
95 typedef struct AVMetaDataMap {
96 int file; //< file index
97 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
98 int index; //< stream/chapter/program number
101 typedef struct AVChapterMap {
106 static const OptionDef options[];
108 #define MAX_FILES 100
109 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
111 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
113 static const char *last_asked_format = NULL;
114 static AVFormatContext *input_files[MAX_FILES];
115 static int64_t input_files_ts_offset[MAX_FILES];
116 static double *input_files_ts_scale[MAX_FILES] = {NULL};
117 static AVCodec **input_codecs = NULL;
118 static int nb_input_files = 0;
119 static int nb_input_codecs = 0;
120 static int nb_input_files_ts_scale[MAX_FILES] = {0};
122 static AVFormatContext *output_files[MAX_FILES];
123 static AVCodec **output_codecs = NULL;
124 static int nb_output_files = 0;
125 static int nb_output_codecs = 0;
127 static AVStreamMap *stream_maps = NULL;
128 static int nb_stream_maps;
130 /* first item specifies output metadata, second is input */
131 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
132 static int nb_meta_data_maps;
133 static int metadata_global_autocopy = 1;
134 static int metadata_streams_autocopy = 1;
135 static int metadata_chapters_autocopy = 1;
137 static AVChapterMap *chapter_maps = NULL;
138 static int nb_chapter_maps;
140 /* indexed by output file stream index */
141 static int *streamid_map = NULL;
142 static int nb_streamid_map = 0;
144 static int frame_width = 0;
145 static int frame_height = 0;
146 static float frame_aspect_ratio = 0;
147 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
148 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
149 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
150 static AVRational frame_rate;
151 static float video_qscale = 0;
152 static uint16_t *intra_matrix = NULL;
153 static uint16_t *inter_matrix = NULL;
154 static const char *video_rc_override_string=NULL;
155 static int video_disable = 0;
156 static int video_discard = 0;
157 static char *video_codec_name = NULL;
158 static unsigned int video_codec_tag = 0;
159 static char *video_language = NULL;
160 static int same_quality = 0;
161 static int do_deinterlace = 0;
162 static int top_field_first = -1;
163 static int me_threshold = 0;
164 static int intra_dc_precision = 8;
165 static int loop_input = 0;
166 static int loop_output = AVFMT_NOOUTPUTLOOP;
167 static int qp_hist = 0;
169 static char *vfilters = NULL;
170 static AVFilterGraph *graph = NULL;
173 static int intra_only = 0;
174 static int audio_sample_rate = 44100;
175 static int64_t channel_layout = 0;
176 #define QSCALE_NONE -99999
177 static float audio_qscale = QSCALE_NONE;
178 static int audio_disable = 0;
179 static int audio_channels = 1;
180 static char *audio_codec_name = NULL;
181 static unsigned int audio_codec_tag = 0;
182 static char *audio_language = NULL;
184 static int subtitle_disable = 0;
185 static char *subtitle_codec_name = NULL;
186 static char *subtitle_language = NULL;
187 static unsigned int subtitle_codec_tag = 0;
189 static int data_disable = 0;
190 static char *data_codec_name = NULL;
191 static unsigned int data_codec_tag = 0;
193 static float mux_preload= 0.5;
194 static float mux_max_delay= 0.7;
196 static int64_t recording_time = INT64_MAX;
197 static int64_t start_time = 0;
198 static int64_t recording_timestamp = 0;
199 static int64_t input_ts_offset = 0;
200 static int file_overwrite = 0;
201 static AVMetadata *metadata;
202 static int do_benchmark = 0;
203 static int do_hex_dump = 0;
204 static int do_pkt_dump = 0;
205 static int do_psnr = 0;
206 static int do_pass = 0;
207 static char *pass_logfilename_prefix = NULL;
208 static int audio_stream_copy = 0;
209 static int video_stream_copy = 0;
210 static int subtitle_stream_copy = 0;
211 static int data_stream_copy = 0;
212 static int video_sync_method= -1;
213 static int audio_sync_method= 0;
214 static float audio_drift_threshold= 0.1;
215 static int copy_ts= 0;
217 static int opt_shortest = 0;
218 static int video_global_header = 0;
219 static char *vstats_filename;
220 static FILE *vstats_file;
221 static int opt_programid = 0;
222 static int copy_initial_nonkeyframes = 0;
224 static int rate_emu = 0;
226 static int video_channel = 0;
227 static char *video_standard;
229 static int audio_volume = 256;
231 static int exit_on_error = 0;
232 static int using_stdin = 0;
233 static int verbose = 1;
234 static int thread_count= 1;
235 static int q_pressed = 0;
236 static int64_t video_size = 0;
237 static int64_t audio_size = 0;
238 static int64_t extra_size = 0;
239 static int nb_frames_dup = 0;
240 static int nb_frames_drop = 0;
241 static int input_sync;
242 static uint64_t limit_filesize = 0;
243 static int force_fps = 0;
244 static char *forced_key_frames = NULL;
246 static float dts_delta_threshold = 10;
248 static unsigned int sws_flags = SWS_BICUBIC;
250 static int64_t timer_start;
252 static uint8_t *audio_buf;
253 static uint8_t *audio_out;
254 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
256 static short *samples;
258 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
260 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
262 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
264 struct AVInputStream;
266 typedef struct AVOutputStream {
267 int file_index; /* file index */
268 int index; /* stream index in the output file */
269 int source_index; /* AVInputStream index */
270 AVStream *st; /* stream in the output file */
271 int encoding_needed; /* true if encoding needed for this stream */
273 /* input pts and corresponding output pts
275 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
276 struct AVInputStream *sync_ist; /* input stream to sync against */
277 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
278 AVBitStreamFilterContext *bitstream_filters;
281 AVFrame pict_tmp; /* temporary image for resampling */
282 struct SwsContext *img_resample_ctx; /* for image resampling */
285 int resample_pix_fmt;
287 /* full frame size of first frame */
291 /* forced key frames */
292 int64_t *forced_kf_pts;
298 ReSampleContext *resample; /* for audio resampling */
299 int resample_sample_fmt;
300 int resample_channels;
301 int resample_sample_rate;
303 AVAudioConvert *reformat_ctx;
304 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
308 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
311 typedef struct AVInputStream {
315 int discard; /* true if stream data should be discarded */
316 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
317 int64_t sample_index; /* current sample */
319 int64_t start; /* time when read started */
320 int64_t next_pts; /* synthetic pts for cases where pkt.pts
322 int64_t pts; /* current pts */
323 PtsCorrectionContext pts_ctx;
324 int is_start; /* is 1 at the start and after a discontinuity */
325 int showed_multi_packet_warning;
326 int is_past_recording_time;
328 AVFilterContext *output_video_filter;
329 AVFilterContext *input_video_filter;
330 AVFrame *filter_frame;
331 int has_filter_frame;
332 AVFilterBufferRef *picref;
336 typedef struct AVInputFile {
337 int eof_reached; /* true if eof reached */
338 int ist_index; /* index of first stream in ist_table */
339 int buffer_size; /* current total buffer size */
340 int nb_streams; /* nb streams we are aware of */
345 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
347 AVFilterContext *last_filter, *filter;
348 /** filter graph containing all filters including input & output */
349 AVCodecContext *codec = ost->st->codec;
350 AVCodecContext *icodec = ist->st->codec;
351 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
352 AVRational sample_aspect_ratio;
356 graph = avfilter_graph_alloc();
358 if (ist->st->sample_aspect_ratio.num){
359 sample_aspect_ratio = ist->st->sample_aspect_ratio;
361 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
363 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
364 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
365 sample_aspect_ratio.num, sample_aspect_ratio.den);
367 ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
368 "src", args, NULL, graph);
371 ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
372 "out", NULL, &ffsink_ctx, graph);
375 last_filter = ist->input_video_filter;
377 if (codec->width != icodec->width || codec->height != icodec->height) {
378 snprintf(args, 255, "%d:%d:flags=0x%X",
381 (int)av_get_int(sws_opts, "sws_flags", NULL));
382 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
383 NULL, args, NULL, graph)) < 0)
385 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
387 last_filter = filter;
390 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
391 graph->scale_sws_opts = av_strdup(args);
394 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
395 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
397 outputs->name = av_strdup("in");
398 outputs->filter_ctx = last_filter;
399 outputs->pad_idx = 0;
400 outputs->next = NULL;
402 inputs->name = av_strdup("out");
403 inputs->filter_ctx = ist->output_video_filter;
407 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
411 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
415 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
418 codec->width = ist->output_video_filter->inputs[0]->w;
419 codec->height = ist->output_video_filter->inputs[0]->h;
420 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
421 ist->output_video_filter->inputs[0]->sample_aspect_ratio;
425 #endif /* CONFIG_AVFILTER */
427 static void term_exit(void)
429 av_log(NULL, AV_LOG_QUIET, "");
432 static volatile int received_sigterm = 0;
435 sigterm_handler(int sig)
437 received_sigterm = sig;
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 /* read a key without blocking */
451 static int read_key(void)
460 static int decode_interrupt_cb(void)
462 return q_pressed || (q_pressed = read_key() == 'q');
465 static int ffmpeg_exit(int ret)
470 for(i=0;i<nb_output_files;i++) {
471 AVFormatContext *s = output_files[i];
472 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
474 avformat_free_context(s);
475 av_free(output_streams_for_file[i]);
477 for(i=0;i<nb_input_files;i++) {
478 av_close_input_file(input_files[i]);
479 av_free(input_files_ts_scale[i]);
482 av_free(intra_matrix);
483 av_free(inter_matrix);
487 av_free(vstats_filename);
489 av_free(streamid_map);
490 av_free(input_codecs);
491 av_free(output_codecs);
492 av_free(stream_maps);
493 av_free(meta_data_maps);
495 av_free(video_codec_name);
496 av_free(audio_codec_name);
497 av_free(subtitle_codec_name);
498 av_free(data_codec_name);
500 av_free(video_standard);
505 allocated_audio_buf_size= allocated_audio_out_size= 0;
512 if (received_sigterm) {
514 "Received signal %d: terminating.\n",
515 (int) received_sigterm);
519 exit(ret); /* not all OS-es handle main() return value */
523 /* similar to ff_dynarray_add() and av_fast_realloc() */
524 static void *grow_array(void *array, int elem_size, int *size, int new_size)
526 if (new_size >= INT_MAX / elem_size) {
527 fprintf(stderr, "Array too big.\n");
530 if (*size < new_size) {
531 uint8_t *tmp = av_realloc(array, new_size*elem_size);
533 fprintf(stderr, "Could not alloc buffer.\n");
536 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
543 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
545 if(codec && codec->sample_fmts){
546 const enum AVSampleFormat *p= codec->sample_fmts;
548 if(*p == st->codec->sample_fmt)
552 av_log(NULL, AV_LOG_WARNING,
553 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
554 av_get_sample_fmt_name(st->codec->sample_fmt),
556 av_get_sample_fmt_name(codec->sample_fmts[0]));
557 st->codec->sample_fmt = codec->sample_fmts[0];
562 static void choose_sample_rate(AVStream *st, AVCodec *codec)
564 if(codec && codec->supported_samplerates){
565 const int *p= codec->supported_samplerates;
567 int best_dist=INT_MAX;
569 int dist= abs(st->codec->sample_rate - *p);
570 if(dist < best_dist){
576 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
578 st->codec->sample_rate= best;
582 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
584 if(codec && codec->pix_fmts){
585 const enum PixelFormat *p= codec->pix_fmts;
586 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
587 if(st->codec->codec_id==CODEC_ID_MJPEG){
588 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
589 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
590 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};
594 if(*p == st->codec->pix_fmt)
598 st->codec->pix_fmt = codec->pix_fmts[0];
602 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
604 int idx = oc->nb_streams - 1;
607 output_streams_for_file[file_idx] =
608 grow_array(output_streams_for_file[file_idx],
609 sizeof(*output_streams_for_file[file_idx]),
610 &nb_output_streams_for_file[file_idx],
612 ost = output_streams_for_file[file_idx][idx] =
613 av_mallocz(sizeof(AVOutputStream));
615 fprintf(stderr, "Could not alloc output stream\n");
618 ost->file_index = file_idx;
623 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
629 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
632 /* copy stream format */
634 for(i=0;i<ic->nb_streams;i++) {
640 // FIXME: a more elegant solution is needed
641 st = av_mallocz(sizeof(AVStream));
642 memcpy(st, ic->streams[i], sizeof(AVStream));
643 st->codec = avcodec_alloc_context();
645 print_error(filename, AVERROR(ENOMEM));
648 avcodec_copy_context(st->codec, ic->streams[i]->codec);
651 codec = avcodec_find_encoder(st->codec->codec_id);
652 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
653 if (audio_stream_copy) {
656 choose_sample_fmt(st, codec);
657 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
658 if (video_stream_copy) {
661 choose_pixel_fmt(st, codec);
664 if(st->codec->flags & CODEC_FLAG_BITEXACT)
667 new_output_stream(s, nb_output_files);
671 s->timestamp = av_gettime();
673 av_close_input_file(ic);
678 get_sync_ipts(const AVOutputStream *ost)
680 const AVInputStream *ist = ost->sync_ist;
681 return (double)(ist->pts - start_time)/AV_TIME_BASE;
684 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
688 AVPacket new_pkt= *pkt;
689 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
690 &new_pkt.data, &new_pkt.size,
691 pkt->data, pkt->size,
692 pkt->flags & AV_PKT_FLAG_KEY);
695 new_pkt.destruct= av_destruct_packet;
697 fprintf(stderr, "%s failed for stream %d, codec %s",
698 bsfc->filter->name, pkt->stream_index,
699 avctx->codec ? avctx->codec->name : "copy");
709 ret= av_interleaved_write_frame(s, pkt);
711 print_error("av_interleaved_write_frame()", ret);
716 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
718 static void do_audio_out(AVFormatContext *s,
721 unsigned char *buf, int size)
724 int64_t audio_out_size, audio_buf_size;
725 int64_t allocated_for_size= size;
727 int size_out, frame_bytes, ret, resample_changed;
728 AVCodecContext *enc= ost->st->codec;
729 AVCodecContext *dec= ist->st->codec;
730 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
731 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
732 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
735 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
736 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
737 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
738 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
739 audio_buf_size*= osize*enc->channels;
741 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
742 if(coded_bps > 8*osize)
743 audio_out_size= audio_out_size * coded_bps / (8*osize);
744 audio_out_size += FF_MIN_BUFFER_SIZE;
746 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
747 fprintf(stderr, "Buffer sizes too large\n");
751 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
752 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
753 if (!audio_buf || !audio_out){
754 fprintf(stderr, "Out of memory in do_audio_out\n");
758 if (enc->channels != dec->channels)
759 ost->audio_resample = 1;
761 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
762 ost->resample_channels != dec->channels ||
763 ost->resample_sample_rate != dec->sample_rate;
765 if ((ost->audio_resample && !ost->resample) || resample_changed) {
766 if (resample_changed) {
767 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",
768 ist->file_index, ist->index,
769 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
770 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
771 ost->resample_sample_fmt = dec->sample_fmt;
772 ost->resample_channels = dec->channels;
773 ost->resample_sample_rate = dec->sample_rate;
775 audio_resample_close(ost->resample);
777 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
778 if (audio_sync_method <= 1 &&
779 ost->resample_sample_fmt == enc->sample_fmt &&
780 ost->resample_channels == enc->channels &&
781 ost->resample_sample_rate == enc->sample_rate) {
782 ost->resample = NULL;
783 ost->audio_resample = 0;
785 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
786 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
787 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
788 enc->sample_rate, dec->sample_rate,
789 enc->sample_fmt, dec->sample_fmt,
791 if (!ost->resample) {
792 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
793 dec->channels, dec->sample_rate,
794 enc->channels, enc->sample_rate);
800 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
801 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
802 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
803 if (ost->reformat_ctx)
804 av_audio_convert_free(ost->reformat_ctx);
805 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
806 dec->sample_fmt, 1, NULL, 0);
807 if (!ost->reformat_ctx) {
808 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
809 av_get_sample_fmt_name(dec->sample_fmt),
810 av_get_sample_fmt_name(enc->sample_fmt));
813 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
816 if(audio_sync_method){
817 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
818 - av_fifo_size(ost->fifo)/(enc->channels * 2);
819 double idelta= delta*dec->sample_rate / enc->sample_rate;
820 int byte_delta= ((int)idelta)*2*dec->channels;
822 //FIXME resample delay
823 if(fabs(delta) > 50){
824 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
826 byte_delta= FFMAX(byte_delta, -size);
830 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
835 static uint8_t *input_tmp= NULL;
836 input_tmp= av_realloc(input_tmp, byte_delta + size);
838 if(byte_delta > allocated_for_size - size){
839 allocated_for_size= byte_delta + (int64_t)size;
844 memset(input_tmp, 0, byte_delta);
845 memcpy(input_tmp + byte_delta, buf, size);
849 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
851 }else if(audio_sync_method>1){
852 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
853 av_assert0(ost->audio_resample);
855 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
856 // 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));
857 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
861 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
862 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
864 if (ost->audio_resample) {
866 size_out = audio_resample(ost->resample,
867 (short *)buftmp, (short *)buf,
868 size / (dec->channels * isize));
869 size_out = size_out * enc->channels * osize;
875 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
876 const void *ibuf[6]= {buftmp};
877 void *obuf[6]= {audio_buf};
878 int istride[6]= {isize};
879 int ostride[6]= {osize};
880 int len= size_out/istride[0];
881 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
882 printf("av_audio_convert() failed\n");
888 size_out = len*osize;
891 /* now encode as many frames as possible */
892 if (enc->frame_size > 1) {
893 /* output resampled raw samples */
894 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
895 fprintf(stderr, "av_fifo_realloc2() failed\n");
898 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
900 frame_bytes = enc->frame_size * osize * enc->channels;
902 while (av_fifo_size(ost->fifo) >= frame_bytes) {
904 av_init_packet(&pkt);
906 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
908 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
910 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
913 fprintf(stderr, "Audio encoding failed\n");
917 pkt.stream_index= ost->index;
920 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
921 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
922 pkt.flags |= AV_PKT_FLAG_KEY;
923 write_frame(s, &pkt, enc, ost->bitstream_filters);
925 ost->sync_opts += enc->frame_size;
929 av_init_packet(&pkt);
931 ost->sync_opts += size_out / (osize * enc->channels);
933 /* output a pcm frame */
934 /* determine the size of the coded buffer */
937 size_out = size_out*coded_bps/8;
939 if(size_out > audio_out_size){
940 fprintf(stderr, "Internal error, buffer size too small\n");
944 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
945 ret = avcodec_encode_audio(enc, audio_out, size_out,
948 fprintf(stderr, "Audio encoding failed\n");
952 pkt.stream_index= ost->index;
955 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
956 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
957 pkt.flags |= AV_PKT_FLAG_KEY;
958 write_frame(s, &pkt, enc, ost->bitstream_filters);
962 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
966 AVPicture picture_tmp;
969 dec = ist->st->codec;
971 /* deinterlace : must be done before any resize */
972 if (do_deinterlace) {
975 /* create temporary picture */
976 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
977 buf = av_malloc(size);
981 picture2 = &picture_tmp;
982 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
984 if(avpicture_deinterlace(picture2, picture,
985 dec->pix_fmt, dec->width, dec->height) < 0) {
986 /* if error, do not deinterlace */
987 fprintf(stderr, "Deinterlacing failed\n");
996 if (picture != picture2)
997 *picture = *picture2;
1001 /* we begin to correct av delay at this threshold */
1002 #define AV_DELAY_MAX 0.100
1004 static void do_subtitle_out(AVFormatContext *s,
1005 AVOutputStream *ost,
1010 static uint8_t *subtitle_out = NULL;
1011 int subtitle_out_max_size = 1024 * 1024;
1012 int subtitle_out_size, nb, i;
1013 AVCodecContext *enc;
1016 if (pts == AV_NOPTS_VALUE) {
1017 fprintf(stderr, "Subtitle packets must have a pts\n");
1023 enc = ost->st->codec;
1025 if (!subtitle_out) {
1026 subtitle_out = av_malloc(subtitle_out_max_size);
1029 /* Note: DVB subtitle need one packet to draw them and one other
1030 packet to clear them */
1031 /* XXX: signal it in the codec context ? */
1032 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1037 for(i = 0; i < nb; i++) {
1038 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1039 // start_display_time is required to be 0
1040 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1041 sub->end_display_time -= sub->start_display_time;
1042 sub->start_display_time = 0;
1043 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1044 subtitle_out_max_size, sub);
1045 if (subtitle_out_size < 0) {
1046 fprintf(stderr, "Subtitle encoding failed\n");
1050 av_init_packet(&pkt);
1051 pkt.stream_index = ost->index;
1052 pkt.data = subtitle_out;
1053 pkt.size = subtitle_out_size;
1054 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1055 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1056 /* XXX: the pts correction is handled here. Maybe handling
1057 it in the codec would be better */
1059 pkt.pts += 90 * sub->start_display_time;
1061 pkt.pts += 90 * sub->end_display_time;
1063 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1067 static int bit_buffer_size= 1024*256;
1068 static uint8_t *bit_buffer= NULL;
1070 static void do_video_out(AVFormatContext *s,
1071 AVOutputStream *ost,
1073 AVFrame *in_picture,
1076 int nb_frames, i, ret;
1077 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1078 AVCodecContext *enc, *dec;
1081 enc = ost->st->codec;
1082 dec = ist->st->codec;
1084 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1086 /* by default, we output a single frame */
1091 if(video_sync_method){
1092 double vdelta = sync_ipts - ost->sync_opts;
1093 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1096 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1099 }else if(vdelta>0.6)
1100 ost->sync_opts= lrintf(sync_ipts);
1101 }else if (vdelta > 1.1)
1102 nb_frames = lrintf(vdelta);
1103 //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);
1104 if (nb_frames == 0){
1107 fprintf(stderr, "*** drop!\n");
1108 }else if (nb_frames > 1) {
1109 nb_frames_dup += nb_frames - 1;
1111 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1114 ost->sync_opts= lrintf(sync_ipts);
1116 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1120 formatted_picture = in_picture;
1121 final_picture = formatted_picture;
1122 padding_src = formatted_picture;
1123 resampling_dst = &ost->pict_tmp;
1125 if ( ost->resample_height != ist->st->codec->height
1126 || ost->resample_width != ist->st->codec->width
1127 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1129 fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1130 if(!ost->video_resample)
1134 #if !CONFIG_AVFILTER
1135 if (ost->video_resample) {
1137 final_picture = &ost->pict_tmp;
1138 if( ost->resample_height != ist->st->codec->height
1139 || ost->resample_width != ist->st->codec->width
1140 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1142 /* initialize a new scaler context */
1143 sws_freeContext(ost->img_resample_ctx);
1144 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1145 ost->img_resample_ctx = sws_getContext(
1146 ist->st->codec->width,
1147 ist->st->codec->height,
1148 ist->st->codec->pix_fmt,
1149 ost->st->codec->width,
1150 ost->st->codec->height,
1151 ost->st->codec->pix_fmt,
1152 sws_flags, NULL, NULL, NULL);
1153 if (ost->img_resample_ctx == NULL) {
1154 fprintf(stderr, "Cannot get resampling context\n");
1158 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1159 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1163 /* duplicates frame if needed */
1164 for(i=0;i<nb_frames;i++) {
1166 av_init_packet(&pkt);
1167 pkt.stream_index= ost->index;
1169 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1170 /* raw pictures are written as AVPicture structure to
1171 avoid any copies. We support temorarily the older
1173 AVFrame* old_frame = enc->coded_frame;
1174 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1175 pkt.data= (uint8_t *)final_picture;
1176 pkt.size= sizeof(AVPicture);
1177 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1178 pkt.flags |= AV_PKT_FLAG_KEY;
1180 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1181 enc->coded_frame = old_frame;
1183 AVFrame big_picture;
1185 big_picture= *final_picture;
1186 /* better than nothing: use input picture interlaced
1188 big_picture.interlaced_frame = in_picture->interlaced_frame;
1189 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1190 if(top_field_first == -1)
1191 big_picture.top_field_first = in_picture->top_field_first;
1193 big_picture.top_field_first = top_field_first;
1196 /* handles sameq here. This is not correct because it may
1197 not be a global option */
1198 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1200 big_picture.pict_type = 0;
1201 // big_picture.pts = AV_NOPTS_VALUE;
1202 big_picture.pts= ost->sync_opts;
1203 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1204 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1205 if (ost->forced_kf_index < ost->forced_kf_count &&
1206 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1207 big_picture.pict_type = AV_PICTURE_TYPE_I;
1208 ost->forced_kf_index++;
1210 ret = avcodec_encode_video(enc,
1211 bit_buffer, bit_buffer_size,
1214 fprintf(stderr, "Video encoding failed\n");
1219 pkt.data= bit_buffer;
1221 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1222 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1223 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1224 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1225 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1227 if(enc->coded_frame->key_frame)
1228 pkt.flags |= AV_PKT_FLAG_KEY;
1229 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1232 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1233 // enc->frame_number-1, ret, enc->pict_type);
1234 /* if two pass, output log */
1235 if (ost->logfile && enc->stats_out) {
1236 fprintf(ost->logfile, "%s", enc->stats_out);
1241 ost->frame_number++;
1245 static double psnr(double d){
1246 return -10.0*log(d)/log(10.0);
1249 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1252 AVCodecContext *enc;
1254 double ti1, bitrate, avg_bitrate;
1256 /* this is executed just the first time do_video_stats is called */
1258 vstats_file = fopen(vstats_filename, "w");
1265 enc = ost->st->codec;
1266 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1267 frame_number = ost->frame_number;
1268 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1269 if (enc->flags&CODEC_FLAG_PSNR)
1270 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1272 fprintf(vstats_file,"f_size= %6d ", frame_size);
1273 /* compute pts value */
1274 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1278 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1279 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1280 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1281 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1282 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1286 static void print_report(AVFormatContext **output_files,
1287 AVOutputStream **ost_table, int nb_ostreams,
1291 AVOutputStream *ost;
1292 AVFormatContext *oc;
1294 AVCodecContext *enc;
1295 int frame_number, vid, i;
1296 double bitrate, ti1, pts;
1297 static int64_t last_time = -1;
1298 static int qp_histogram[52];
1300 if (!is_last_report) {
1302 /* display the report every 0.5 seconds */
1303 cur_time = av_gettime();
1304 if (last_time == -1) {
1305 last_time = cur_time;
1308 if ((cur_time - last_time) < 500000)
1310 last_time = cur_time;
1314 oc = output_files[0];
1316 total_size = avio_size(oc->pb);
1317 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1318 total_size= avio_tell(oc->pb);
1323 for(i=0;i<nb_ostreams;i++) {
1325 enc = ost->st->codec;
1326 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1327 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1328 !ost->st->stream_copy ?
1329 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1331 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1332 float t = (av_gettime()-timer_start) / 1000000.0;
1334 frame_number = ost->frame_number;
1335 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1336 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1337 !ost->st->stream_copy ?
1338 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1340 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1343 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1344 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1347 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1349 if (enc->flags&CODEC_FLAG_PSNR){
1351 double error, error_sum=0;
1352 double scale, scale_sum=0;
1353 char type[3]= {'Y','U','V'};
1354 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1357 error= enc->error[j];
1358 scale= enc->width*enc->height*255.0*255.0*frame_number;
1360 error= enc->coded_frame->error[j];
1361 scale= enc->width*enc->height*255.0*255.0;
1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1368 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1372 /* compute min output value */
1373 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1374 if ((pts < ti1) && (pts > 0))
1380 if (verbose || is_last_report) {
1381 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1383 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1384 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1385 (double)total_size / 1024, ti1, bitrate);
1387 if (nb_frames_dup || nb_frames_drop)
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1389 nb_frames_dup, nb_frames_drop);
1392 fprintf(stderr, "%s \r", buf);
1397 if (is_last_report && verbose >= 0){
1398 int64_t raw= audio_size + video_size + extra_size;
1399 fprintf(stderr, "\n");
1400 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1404 100.0*(total_size - raw)/raw
1409 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1411 int fill_char = 0x00;
1412 if (sample_fmt == AV_SAMPLE_FMT_U8)
1414 memset(buf, fill_char, size);
1417 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1418 static int output_packet(AVInputStream *ist, int ist_index,
1419 AVOutputStream **ost_table, int nb_ostreams,
1420 const AVPacket *pkt)
1422 AVFormatContext *os;
1423 AVOutputStream *ost;
1427 void *buffer_to_free;
1428 static unsigned int samples_size= 0;
1429 AVSubtitle subtitle, *subtitle_to_free;
1430 int64_t pkt_pts = AV_NOPTS_VALUE;
1432 int frame_available;
1436 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1438 if(ist->next_pts == AV_NOPTS_VALUE)
1439 ist->next_pts= ist->pts;
1443 av_init_packet(&avpkt);
1451 if(pkt->dts != AV_NOPTS_VALUE)
1452 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1453 if(pkt->pts != AV_NOPTS_VALUE)
1454 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1456 //while we have more to decode or while the decoder did output something on EOF
1457 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1458 uint8_t *data_buf, *decoded_data_buf;
1459 int data_size, decoded_data_size;
1461 ist->pts= ist->next_pts;
1463 if(avpkt.size && avpkt.size != pkt->size &&
1464 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1465 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1466 ist->showed_multi_packet_warning=1;
1469 /* decode the packet if needed */
1470 decoded_data_buf = NULL; /* fail safe */
1471 decoded_data_size= 0;
1472 data_buf = avpkt.data;
1473 data_size = avpkt.size;
1474 subtitle_to_free = NULL;
1475 if (ist->decoding_needed) {
1476 switch(ist->st->codec->codec_type) {
1477 case AVMEDIA_TYPE_AUDIO:{
1478 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1479 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1481 samples= av_malloc(samples_size);
1483 decoded_data_size= samples_size;
1484 /* XXX: could avoid copy if PCM 16 bits with same
1485 endianness as CPU */
1486 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1493 /* Some bug in mpeg audio decoder gives */
1494 /* decoded_data_size < 0, it seems they are overflows */
1495 if (decoded_data_size <= 0) {
1496 /* no audio frame */
1499 decoded_data_buf = (uint8_t *)samples;
1500 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1501 (ist->st->codec->sample_rate * ist->st->codec->channels);
1503 case AVMEDIA_TYPE_VIDEO:
1504 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1505 /* XXX: allocate picture correctly */
1506 avcodec_get_frame_defaults(&picture);
1507 avpkt.pts = pkt_pts;
1508 avpkt.dts = ist->pts;
1509 pkt_pts = AV_NOPTS_VALUE;
1511 ret = avcodec_decode_video2(ist->st->codec,
1512 &picture, &got_picture, &avpkt);
1513 ist->st->quality= picture.quality;
1517 /* no picture yet */
1518 goto discard_packet;
1520 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1521 if (ist->st->codec->time_base.num != 0) {
1522 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1523 ist->next_pts += ((int64_t)AV_TIME_BASE *
1524 ist->st->codec->time_base.num * ticks) /
1525 ist->st->codec->time_base.den;
1529 case AVMEDIA_TYPE_SUBTITLE:
1530 ret = avcodec_decode_subtitle2(ist->st->codec,
1531 &subtitle, &got_picture, &avpkt);
1535 goto discard_packet;
1537 subtitle_to_free = &subtitle;
1544 switch(ist->st->codec->codec_type) {
1545 case AVMEDIA_TYPE_AUDIO:
1546 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1547 ist->st->codec->sample_rate;
1549 case AVMEDIA_TYPE_VIDEO:
1550 if (ist->st->codec->time_base.num != 0) {
1551 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1552 ist->next_pts += ((int64_t)AV_TIME_BASE *
1553 ist->st->codec->time_base.num * ticks) /
1554 ist->st->codec->time_base.den;
1562 buffer_to_free = NULL;
1563 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1564 pre_process_video_frame(ist, (AVPicture *)&picture,
1569 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1571 if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1572 else sar = ist->st->codec->sample_aspect_ratio;
1573 // add it to be filtered
1574 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1580 // preprocess audio (volume)
1581 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1582 if (audio_volume != 256) {
1585 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1586 int v = ((*volp) * audio_volume + 128) >> 8;
1587 if (v < -32768) v = -32768;
1588 if (v > 32767) v = 32767;
1594 /* frame rate emulation */
1596 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1597 int64_t now = av_gettime() - ist->start;
1602 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1603 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1605 /* if output time reached then transcode raw format,
1606 encode packets and output them */
1607 if (start_time == 0 || ist->pts >= start_time)
1609 while (frame_available) {
1610 AVRational ist_pts_tb;
1611 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1612 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1614 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1616 for(i=0;i<nb_ostreams;i++) {
1620 if (ost->source_index == ist_index) {
1621 os = output_files[ost->file_index];
1623 /* set the input output pts pairs */
1624 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1626 if (ost->encoding_needed) {
1627 av_assert0(ist->decoding_needed);
1628 switch(ost->st->codec->codec_type) {
1629 case AVMEDIA_TYPE_AUDIO:
1630 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1632 case AVMEDIA_TYPE_VIDEO:
1634 if (ist->picref->video)
1635 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1637 do_video_out(os, ost, ist, &picture, &frame_size);
1638 if (vstats_filename && frame_size)
1639 do_video_stats(os, ost, frame_size);
1641 case AVMEDIA_TYPE_SUBTITLE:
1642 do_subtitle_out(os, ost, ist, &subtitle,
1649 AVFrame avframe; //FIXME/XXX remove this
1651 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1653 av_init_packet(&opkt);
1655 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1658 /* no reencoding needed : output the packet directly */
1659 /* force the input stream PTS */
1661 avcodec_get_frame_defaults(&avframe);
1662 ost->st->codec->coded_frame= &avframe;
1663 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1665 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1666 audio_size += data_size;
1667 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1668 video_size += data_size;
1672 opkt.stream_index= ost->index;
1673 if(pkt->pts != AV_NOPTS_VALUE)
1674 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1676 opkt.pts= AV_NOPTS_VALUE;
1678 if (pkt->dts == AV_NOPTS_VALUE)
1679 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1681 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1682 opkt.dts -= ost_tb_start_time;
1684 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1685 opkt.flags= pkt->flags;
1687 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1688 if( ost->st->codec->codec_id != CODEC_ID_H264
1689 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1690 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1692 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1693 opkt.destruct= av_destruct_packet;
1695 opkt.data = data_buf;
1696 opkt.size = data_size;
1699 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1700 ost->st->codec->frame_number++;
1701 ost->frame_number++;
1702 av_free_packet(&opkt);
1708 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1709 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1711 avfilter_unref_buffer(ist->picref);
1714 av_free(buffer_to_free);
1715 /* XXX: allocate the subtitles in the codec ? */
1716 if (subtitle_to_free) {
1717 avsubtitle_free(subtitle_to_free);
1718 subtitle_to_free = NULL;
1725 for(i=0;i<nb_ostreams;i++) {
1727 if (ost->source_index == ist_index) {
1728 AVCodecContext *enc= ost->st->codec;
1729 os = output_files[ost->file_index];
1731 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1733 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1736 if (ost->encoding_needed) {
1740 av_init_packet(&pkt);
1741 pkt.stream_index= ost->index;
1743 switch(ost->st->codec->codec_type) {
1744 case AVMEDIA_TYPE_AUDIO:
1745 fifo_bytes = av_fifo_size(ost->fifo);
1747 /* encode any samples remaining in fifo */
1748 if (fifo_bytes > 0) {
1749 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1750 int fs_tmp = enc->frame_size;
1752 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1753 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1754 enc->frame_size = fifo_bytes / (osize * enc->channels);
1756 int frame_bytes = enc->frame_size*osize*enc->channels;
1757 if (allocated_audio_buf_size < frame_bytes)
1759 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1762 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1763 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1764 ost->st->time_base.num, enc->sample_rate);
1765 enc->frame_size = fs_tmp;
1768 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1771 fprintf(stderr, "Audio encoding failed\n");
1775 pkt.flags |= AV_PKT_FLAG_KEY;
1777 case AVMEDIA_TYPE_VIDEO:
1778 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1780 fprintf(stderr, "Video encoding failed\n");
1784 if(enc->coded_frame && enc->coded_frame->key_frame)
1785 pkt.flags |= AV_PKT_FLAG_KEY;
1786 if (ost->logfile && enc->stats_out) {
1787 fprintf(ost->logfile, "%s", enc->stats_out);
1796 pkt.data= bit_buffer;
1798 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1799 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1800 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1812 static void print_sdp(AVFormatContext **avc, int n)
1816 av_sdp_create(avc, n, sdp, sizeof(sdp));
1817 printf("SDP:\n%s\n", sdp);
1821 static int copy_chapters(int infile, int outfile)
1823 AVFormatContext *is = input_files[infile];
1824 AVFormatContext *os = output_files[outfile];
1827 for (i = 0; i < is->nb_chapters; i++) {
1828 AVChapter *in_ch = is->chapters[i], *out_ch;
1829 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1830 AV_TIME_BASE_Q, in_ch->time_base);
1831 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1832 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1835 if (in_ch->end < ts_off)
1837 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1840 out_ch = av_mallocz(sizeof(AVChapter));
1842 return AVERROR(ENOMEM);
1844 out_ch->id = in_ch->id;
1845 out_ch->time_base = in_ch->time_base;
1846 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1847 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1849 if (metadata_chapters_autocopy)
1850 av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1853 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1855 return AVERROR(ENOMEM);
1856 os->chapters[os->nb_chapters - 1] = out_ch;
1861 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1862 AVCodecContext *avctx)
1868 for (p = kf; *p; p++)
1871 ost->forced_kf_count = n;
1872 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1873 if (!ost->forced_kf_pts) {
1874 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1877 for (i = 0; i < n; i++) {
1878 p = i ? strchr(p, ',') + 1 : kf;
1879 t = parse_time_or_die("force_key_frames", p, 1);
1880 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1885 * The following code is the main loop of the file converter
1887 static int transcode(AVFormatContext **output_files,
1888 int nb_output_files,
1889 AVFormatContext **input_files,
1891 AVStreamMap *stream_maps, int nb_stream_maps)
1893 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1894 AVFormatContext *is, *os;
1895 AVCodecContext *codec, *icodec;
1896 AVOutputStream *ost, **ost_table = NULL;
1897 AVInputStream *ist, **ist_table = NULL;
1898 AVInputFile *file_table;
1902 uint8_t no_packet[MAX_FILES]={0};
1903 int no_packet_count=0;
1905 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1909 /* input stream init */
1911 for(i=0;i<nb_input_files;i++) {
1912 is = input_files[i];
1913 file_table[i].ist_index = j;
1914 file_table[i].nb_streams = is->nb_streams;
1915 j += is->nb_streams;
1919 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1923 for(i=0;i<nb_istreams;i++) {
1924 ist = av_mallocz(sizeof(AVInputStream));
1930 for(i=0;i<nb_input_files;i++) {
1931 is = input_files[i];
1932 for(k=0;k<is->nb_streams;k++) {
1933 ist = ist_table[j++];
1934 ist->st = is->streams[k];
1935 ist->file_index = i;
1937 ist->discard = 1; /* the stream is discarded by default
1941 ist->start = av_gettime();
1946 /* output stream init */
1948 for(i=0;i<nb_output_files;i++) {
1949 os = output_files[i];
1950 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1951 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1952 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1953 ret = AVERROR(EINVAL);
1956 nb_ostreams += os->nb_streams;
1958 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1959 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1960 ret = AVERROR(EINVAL);
1964 /* Sanity check the mapping args -- do the input files & streams exist? */
1965 for(i=0;i<nb_stream_maps;i++) {
1966 int fi = stream_maps[i].file_index;
1967 int si = stream_maps[i].stream_index;
1969 if (fi < 0 || fi > nb_input_files - 1 ||
1970 si < 0 || si > file_table[fi].nb_streams - 1) {
1971 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1972 ret = AVERROR(EINVAL);
1975 fi = stream_maps[i].sync_file_index;
1976 si = stream_maps[i].sync_stream_index;
1977 if (fi < 0 || fi > nb_input_files - 1 ||
1978 si < 0 || si > file_table[fi].nb_streams - 1) {
1979 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1980 ret = AVERROR(EINVAL);
1985 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1989 for(k=0;k<nb_output_files;k++) {
1990 os = output_files[k];
1991 for(i=0;i<os->nb_streams;i++,n++) {
1993 ost = ost_table[n] = output_streams_for_file[k][i];
1994 ost->st = os->streams[i];
1995 if (nb_stream_maps > 0) {
1996 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1997 stream_maps[n].stream_index;
1999 /* Sanity check that the stream types match */
2000 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2001 int i= ost->file_index;
2002 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2003 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2004 stream_maps[n].file_index, stream_maps[n].stream_index,
2005 ost->file_index, ost->index);
2010 int best_nb_frames=-1;
2011 /* get corresponding input stream index : we select the first one with the right type */
2013 for(j=0;j<nb_istreams;j++) {
2018 AVFormatContext *f= input_files[ ist->file_index ];
2020 for(pi=0; pi<f->nb_programs; pi++){
2021 AVProgram *p= f->programs[pi];
2022 if(p->id == opt_programid)
2023 for(si=0; si<p->nb_stream_indexes; si++){
2024 if(f->streams[ p->stream_index[si] ] == ist->st)
2029 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2030 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2031 if(best_nb_frames < ist->st->codec_info_nb_frames){
2032 best_nb_frames= ist->st->codec_info_nb_frames;
2033 ost->source_index = j;
2040 if(! opt_programid) {
2041 /* try again and reuse existing stream */
2042 for(j=0;j<nb_istreams;j++) {
2044 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2045 && ist->st->discard != AVDISCARD_ALL) {
2046 ost->source_index = j;
2052 int i= ost->file_index;
2053 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2054 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2055 ost->file_index, ost->index);
2060 ist = ist_table[ost->source_index];
2062 ost->sync_ist = (nb_stream_maps > 0) ?
2063 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2064 stream_maps[n].sync_stream_index] : ist;
2068 /* for each output stream, we compute the right encoding parameters */
2069 for(i=0;i<nb_ostreams;i++) {
2071 os = output_files[ost->file_index];
2072 ist = ist_table[ost->source_index];
2074 codec = ost->st->codec;
2075 icodec = ist->st->codec;
2077 if (metadata_streams_autocopy)
2078 av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2079 AV_METADATA_DONT_OVERWRITE);
2081 ost->st->disposition = ist->st->disposition;
2082 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2083 codec->chroma_sample_location = icodec->chroma_sample_location;
2085 if (ost->st->stream_copy) {
2086 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2088 if (extra_size > INT_MAX)
2091 /* if stream_copy is selected, no need to decode or encode */
2092 codec->codec_id = icodec->codec_id;
2093 codec->codec_type = icodec->codec_type;
2095 if(!codec->codec_tag){
2096 if( !os->oformat->codec_tag
2097 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2098 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2099 codec->codec_tag = icodec->codec_tag;
2102 codec->bit_rate = icodec->bit_rate;
2103 codec->rc_max_rate = icodec->rc_max_rate;
2104 codec->rc_buffer_size = icodec->rc_buffer_size;
2105 codec->extradata= av_mallocz(extra_size);
2106 if (!codec->extradata)
2108 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2109 codec->extradata_size= icodec->extradata_size;
2110 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){
2111 codec->time_base = icodec->time_base;
2112 codec->time_base.num *= icodec->ticks_per_frame;
2113 av_reduce(&codec->time_base.num, &codec->time_base.den,
2114 codec->time_base.num, codec->time_base.den, INT_MAX);
2116 codec->time_base = ist->st->time_base;
2117 switch(codec->codec_type) {
2118 case AVMEDIA_TYPE_AUDIO:
2119 if(audio_volume != 256) {
2120 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2123 codec->channel_layout = icodec->channel_layout;
2124 codec->sample_rate = icodec->sample_rate;
2125 codec->channels = icodec->channels;
2126 codec->frame_size = icodec->frame_size;
2127 codec->audio_service_type = icodec->audio_service_type;
2128 codec->block_align= icodec->block_align;
2129 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2130 codec->block_align= 0;
2131 if(codec->codec_id == CODEC_ID_AC3)
2132 codec->block_align= 0;
2134 case AVMEDIA_TYPE_VIDEO:
2135 codec->pix_fmt = icodec->pix_fmt;
2136 codec->width = icodec->width;
2137 codec->height = icodec->height;
2138 codec->has_b_frames = icodec->has_b_frames;
2140 case AVMEDIA_TYPE_SUBTITLE:
2141 codec->width = icodec->width;
2142 codec->height = icodec->height;
2144 case AVMEDIA_TYPE_DATA:
2150 switch(codec->codec_type) {
2151 case AVMEDIA_TYPE_AUDIO:
2152 ost->fifo= av_fifo_alloc(1024);
2155 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2156 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2157 icodec->request_channels = codec->channels;
2158 ist->decoding_needed = 1;
2159 ost->encoding_needed = 1;
2160 ost->resample_sample_fmt = icodec->sample_fmt;
2161 ost->resample_sample_rate = icodec->sample_rate;
2162 ost->resample_channels = icodec->channels;
2164 case AVMEDIA_TYPE_VIDEO:
2165 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2166 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2169 ost->video_resample = (codec->width != icodec->width ||
2170 codec->height != icodec->height ||
2171 (codec->pix_fmt != icodec->pix_fmt));
2172 if (ost->video_resample) {
2173 #if !CONFIG_AVFILTER
2174 avcodec_get_frame_defaults(&ost->pict_tmp);
2175 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2176 codec->width, codec->height)) {
2177 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2180 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2181 ost->img_resample_ctx = sws_getContext(
2188 sws_flags, NULL, NULL, NULL);
2189 if (ost->img_resample_ctx == NULL) {
2190 fprintf(stderr, "Cannot get resampling context\n");
2194 ost->original_height = icodec->height;
2195 ost->original_width = icodec->width;
2197 codec->bits_per_raw_sample= 0;
2199 ost->resample_height = icodec->height;
2200 ost->resample_width = icodec->width;
2201 ost->resample_pix_fmt= icodec->pix_fmt;
2202 ost->encoding_needed = 1;
2203 ist->decoding_needed = 1;
2206 if (configure_filters(ist, ost)) {
2207 fprintf(stderr, "Error opening filters!\n");
2212 case AVMEDIA_TYPE_SUBTITLE:
2213 ost->encoding_needed = 1;
2214 ist->decoding_needed = 1;
2221 if (ost->encoding_needed &&
2222 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2223 char logfilename[1024];
2226 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2227 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2229 if (codec->flags & CODEC_FLAG_PASS1) {
2230 f = fopen(logfilename, "wb");
2232 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2238 size_t logbuffer_size;
2239 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2240 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2243 codec->stats_in = logbuffer;
2247 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2248 int size= codec->width * codec->height;
2249 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2254 bit_buffer = av_malloc(bit_buffer_size);
2256 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2258 ret = AVERROR(ENOMEM);
2262 /* open each encoder */
2263 for(i=0;i<nb_ostreams;i++) {
2265 if (ost->encoding_needed) {
2266 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2267 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2269 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2271 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2272 ost->st->codec->codec_id, ost->file_index, ost->index);
2273 ret = AVERROR(EINVAL);
2276 if (dec->subtitle_header) {
2277 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2278 if (!ost->st->codec->subtitle_header) {
2279 ret = AVERROR(ENOMEM);
2282 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2283 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2285 if (avcodec_open(ost->st->codec, codec) < 0) {
2286 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2287 ost->file_index, ost->index);
2288 ret = AVERROR(EINVAL);
2291 extra_size += ost->st->codec->extradata_size;
2295 /* open each decoder */
2296 for(i=0;i<nb_istreams;i++) {
2298 if (ist->decoding_needed) {
2299 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2301 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2303 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2304 ist->st->codec->codec_id, ist->file_index, ist->index);
2305 ret = AVERROR(EINVAL);
2308 if (avcodec_open(ist->st->codec, codec) < 0) {
2309 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2310 ist->file_index, ist->index);
2311 ret = AVERROR(EINVAL);
2314 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2315 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2320 for(i=0;i<nb_istreams;i++) {
2324 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2325 ist->next_pts = AV_NOPTS_VALUE;
2326 init_pts_correction(&ist->pts_ctx);
2330 /* set meta data information from input file if required */
2331 for (i=0;i<nb_meta_data_maps;i++) {
2332 AVFormatContext *files[2];
2333 AVMetadata **meta[2];
2336 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2337 if ((index) < 0 || (index) >= (nb_elems)) {\
2338 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2340 ret = AVERROR(EINVAL);\
2344 int out_file_index = meta_data_maps[i][0].file;
2345 int in_file_index = meta_data_maps[i][1].file;
2346 if (in_file_index < 0 || out_file_index < 0)
2348 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2349 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2351 files[0] = output_files[out_file_index];
2352 files[1] = input_files[in_file_index];
2354 for (j = 0; j < 2; j++) {
2355 AVMetaDataMap *map = &meta_data_maps[i][j];
2357 switch (map->type) {
2359 meta[j] = &files[j]->metadata;
2362 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2363 meta[j] = &files[j]->streams[map->index]->metadata;
2366 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2367 meta[j] = &files[j]->chapters[map->index]->metadata;
2370 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2371 meta[j] = &files[j]->programs[map->index]->metadata;
2376 av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2379 /* copy global metadata by default */
2380 if (metadata_global_autocopy) {
2382 for (i = 0; i < nb_output_files; i++)
2383 av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2384 AV_METADATA_DONT_OVERWRITE);
2387 /* copy chapters according to chapter maps */
2388 for (i = 0; i < nb_chapter_maps; i++) {
2389 int infile = chapter_maps[i].in_file;
2390 int outfile = chapter_maps[i].out_file;
2392 if (infile < 0 || outfile < 0)
2394 if (infile >= nb_input_files) {
2395 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2396 ret = AVERROR(EINVAL);
2399 if (outfile >= nb_output_files) {
2400 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2401 ret = AVERROR(EINVAL);
2404 copy_chapters(infile, outfile);
2407 /* copy chapters from the first input file that has them*/
2408 if (!nb_chapter_maps)
2409 for (i = 0; i < nb_input_files; i++) {
2410 if (!input_files[i]->nb_chapters)
2413 for (j = 0; j < nb_output_files; j++)
2414 if ((ret = copy_chapters(i, j)) < 0)
2419 /* open files and write file headers */
2420 for(i=0;i<nb_output_files;i++) {
2421 os = output_files[i];
2422 if (av_write_header(os) < 0) {
2423 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2424 ret = AVERROR(EINVAL);
2427 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2433 /* dump the file output parameters - cannot be done before in case
2435 for(i=0;i<nb_output_files;i++) {
2436 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2439 /* dump the stream mapping */
2441 fprintf(stderr, "Stream mapping:\n");
2442 for(i=0;i<nb_ostreams;i++) {
2444 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2445 ist_table[ost->source_index]->file_index,
2446 ist_table[ost->source_index]->index,
2449 if (ost->sync_ist != ist_table[ost->source_index])
2450 fprintf(stderr, " [sync #%d.%d]",
2451 ost->sync_ist->file_index,
2452 ost->sync_ist->index);
2453 fprintf(stderr, "\n");
2458 fprintf(stderr, "%s\n", error);
2463 print_sdp(output_files, nb_output_files);
2466 if (!using_stdin && verbose >= 0) {
2468 fprintf(stderr, "Press [q] to stop encoding\n");
2470 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2472 avio_set_interrupt_cb(decode_interrupt_cb);
2476 timer_start = av_gettime();
2478 for(; received_sigterm == 0;) {
2479 int file_index, ist_index;
2487 /* if 'q' pressed, exits */
2491 /* read_key() returns 0 on EOF */
2497 /* select the stream that we must read now by looking at the
2498 smallest output pts */
2500 for(i=0;i<nb_ostreams;i++) {
2503 os = output_files[ost->file_index];
2504 ist = ist_table[ost->source_index];
2505 if(ist->is_past_recording_time || no_packet[ist->file_index])
2507 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2508 ipts = (double)ist->pts;
2509 if (!file_table[ist->file_index].eof_reached){
2510 if(ipts < ipts_min) {
2512 if(input_sync ) file_index = ist->file_index;
2514 if(opts < opts_min) {
2516 if(!input_sync) file_index = ist->file_index;
2519 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2524 /* if none, if is finished */
2525 if (file_index < 0) {
2526 if(no_packet_count){
2528 memset(no_packet, 0, sizeof(no_packet));
2535 /* finish if limit size exhausted */
2536 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2539 /* read a frame from it and output it in the fifo */
2540 is = input_files[file_index];
2541 ret= av_read_frame(is, &pkt);
2542 if(ret == AVERROR(EAGAIN)){
2543 no_packet[file_index]=1;
2548 file_table[file_index].eof_reached = 1;
2556 memset(no_packet, 0, sizeof(no_packet));
2559 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2560 is->streams[pkt.stream_index]);
2562 /* the following test is needed in case new streams appear
2563 dynamically in stream : we ignore them */
2564 if (pkt.stream_index >= file_table[file_index].nb_streams)
2565 goto discard_packet;
2566 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2567 ist = ist_table[ist_index];
2569 goto discard_packet;
2571 if (pkt.dts != AV_NOPTS_VALUE)
2572 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2573 if (pkt.pts != AV_NOPTS_VALUE)
2574 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2576 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2577 && input_files_ts_scale[file_index][pkt.stream_index]){
2578 if(pkt.pts != AV_NOPTS_VALUE)
2579 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2580 if(pkt.dts != AV_NOPTS_VALUE)
2581 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2584 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2585 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2586 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2587 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2588 int64_t delta= pkt_dts - ist->next_pts;
2589 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2590 input_files_ts_offset[ist->file_index]-= delta;
2592 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2593 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2594 if(pkt.pts != AV_NOPTS_VALUE)
2595 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2599 /* finish if recording time exhausted */
2600 if (recording_time != INT64_MAX &&
2601 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2602 ist->is_past_recording_time = 1;
2603 goto discard_packet;
2606 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2607 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2610 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2611 ist->file_index, ist->index);
2614 av_free_packet(&pkt);
2619 av_free_packet(&pkt);
2621 /* dump report by using the output first video and audio streams */
2622 print_report(output_files, ost_table, nb_ostreams, 0);
2625 /* at the end of stream, we must flush the decoder buffers */
2626 for(i=0;i<nb_istreams;i++) {
2628 if (ist->decoding_needed) {
2629 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2635 /* write the trailer if needed and close file */
2636 for(i=0;i<nb_output_files;i++) {
2637 os = output_files[i];
2638 av_write_trailer(os);
2641 /* dump report by using the first video and audio streams */
2642 print_report(output_files, ost_table, nb_ostreams, 1);
2644 /* close each encoder */
2645 for(i=0;i<nb_ostreams;i++) {
2647 if (ost->encoding_needed) {
2648 av_freep(&ost->st->codec->stats_in);
2649 avcodec_close(ost->st->codec);
2653 /* close each decoder */
2654 for(i=0;i<nb_istreams;i++) {
2656 if (ist->decoding_needed) {
2657 avcodec_close(ist->st->codec);
2661 avfilter_graph_free(&graph);
2668 av_freep(&bit_buffer);
2669 av_free(file_table);
2672 for(i=0;i<nb_istreams;i++) {
2679 for(i=0;i<nb_ostreams;i++) {
2682 if (ost->st->stream_copy)
2683 av_freep(&ost->st->codec->extradata);
2685 fclose(ost->logfile);
2686 ost->logfile = NULL;
2688 av_fifo_free(ost->fifo); /* works even if fifo is not
2689 initialized but set to zero */
2690 av_freep(&ost->st->codec->subtitle_header);
2691 av_free(ost->pict_tmp.data[0]);
2692 av_free(ost->forced_kf_pts);
2693 if (ost->video_resample)
2694 sws_freeContext(ost->img_resample_ctx);
2696 audio_resample_close(ost->resample);
2697 if (ost->reformat_ctx)
2698 av_audio_convert_free(ost->reformat_ctx);
2707 static void opt_format(const char *arg)
2709 last_asked_format = arg;
2712 static void opt_video_rc_override_string(const char *arg)
2714 video_rc_override_string = arg;
2717 static int opt_me_threshold(const char *opt, const char *arg)
2719 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2723 static int opt_verbose(const char *opt, const char *arg)
2725 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2729 static int opt_frame_rate(const char *opt, const char *arg)
2731 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2732 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2738 static int opt_bitrate(const char *opt, const char *arg)
2740 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2742 opt_default(opt, arg);
2744 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2745 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2750 static int opt_frame_crop(const char *opt, const char *arg)
2752 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2753 return AVERROR(EINVAL);
2756 static void opt_frame_size(const char *arg)
2758 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2759 fprintf(stderr, "Incorrect frame size\n");
2764 static int opt_pad(const char *opt, const char *arg) {
2765 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2769 static void opt_frame_pix_fmt(const char *arg)
2771 if (strcmp(arg, "list")) {
2772 frame_pix_fmt = av_get_pix_fmt(arg);
2773 if (frame_pix_fmt == PIX_FMT_NONE) {
2774 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2783 static void opt_frame_aspect_ratio(const char *arg)
2790 p = strchr(arg, ':');
2792 x = strtol(arg, &end, 10);
2794 y = strtol(end+1, &end, 10);
2796 ar = (double)x / (double)y;
2798 ar = strtod(arg, NULL);
2801 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2804 frame_aspect_ratio = ar;
2806 x = vfilters ? strlen(vfilters) : 0;
2807 vfilters = av_realloc(vfilters, x+100);
2808 snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2811 static int opt_metadata(const char *opt, const char *arg)
2813 char *mid= strchr(arg, '=');
2816 fprintf(stderr, "Missing =\n");
2821 av_metadata_set2(&metadata, arg, mid, 0);
2826 static void opt_qscale(const char *arg)
2828 video_qscale = atof(arg);
2829 if (video_qscale <= 0 ||
2830 video_qscale > 255) {
2831 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2836 static void opt_top_field_first(const char *arg)
2838 top_field_first= atoi(arg);
2841 static int opt_thread_count(const char *opt, const char *arg)
2843 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2846 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2851 static void opt_audio_sample_fmt(const char *arg)
2853 if (strcmp(arg, "list")) {
2854 audio_sample_fmt = av_get_sample_fmt(arg);
2855 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2856 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2860 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2865 static int opt_audio_rate(const char *opt, const char *arg)
2867 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2871 static int opt_audio_channels(const char *opt, const char *arg)
2873 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2877 static void opt_video_channel(const char *arg)
2879 video_channel = strtol(arg, NULL, 0);
2882 static void opt_video_standard(const char *arg)
2884 video_standard = av_strdup(arg);
2887 static void opt_codec(int *pstream_copy, char **pcodec_name,
2888 int codec_type, const char *arg)
2890 av_freep(pcodec_name);
2891 if (!strcmp(arg, "copy")) {
2894 *pcodec_name = av_strdup(arg);
2898 static void opt_audio_codec(const char *arg)
2900 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2903 static void opt_video_codec(const char *arg)
2905 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2908 static void opt_subtitle_codec(const char *arg)
2910 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2913 static void opt_data_codec(const char *arg)
2915 opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2918 static int opt_codec_tag(const char *opt, const char *arg)
2921 uint32_t *codec_tag;
2923 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2924 !strcmp(opt, "vtag") ? &video_codec_tag :
2925 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2929 *codec_tag = strtol(arg, &tail, 0);
2931 *codec_tag = AV_RL32(arg);
2936 static void opt_map(const char *arg)
2941 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2942 m = &stream_maps[nb_stream_maps-1];
2944 m->file_index = strtol(arg, &p, 0);
2948 m->stream_index = strtol(p, &p, 0);
2951 m->sync_file_index = strtol(p, &p, 0);
2954 m->sync_stream_index = strtol(p, &p, 0);
2956 m->sync_file_index = m->file_index;
2957 m->sync_stream_index = m->stream_index;
2961 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2972 *index = strtol(++arg, endptr, 0);
2975 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2982 static void opt_map_metadata(const char *arg)
2984 AVMetaDataMap *m, *m1;
2987 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2988 &nb_meta_data_maps, nb_meta_data_maps + 1);
2990 m = &meta_data_maps[nb_meta_data_maps - 1][0];
2991 m->file = strtol(arg, &p, 0);
2992 parse_meta_type(p, &m->type, &m->index, &p);
2996 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2997 m1->file = strtol(p, &p, 0);
2998 parse_meta_type(p, &m1->type, &m1->index, &p);
3000 if (m->type == 'g' || m1->type == 'g')
3001 metadata_global_autocopy = 0;
3002 if (m->type == 's' || m1->type == 's')
3003 metadata_streams_autocopy = 0;
3004 if (m->type == 'c' || m1->type == 'c')
3005 metadata_chapters_autocopy = 0;
3008 static void opt_map_meta_data(const char *arg)
3010 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3011 "Use -map_metadata instead.\n");
3012 opt_map_metadata(arg);
3015 static void opt_map_chapters(const char *arg)
3020 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3021 nb_chapter_maps + 1);
3022 c = &chapter_maps[nb_chapter_maps - 1];
3023 c->out_file = strtol(arg, &p, 0);
3027 c->in_file = strtol(p, &p, 0);
3030 static void opt_input_ts_scale(const char *arg)
3032 unsigned int stream;
3036 stream = strtol(arg, &p, 0);
3039 scale= strtod(p, &p);
3041 if(stream >= MAX_STREAMS)
3044 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);
3045 input_files_ts_scale[nb_input_files][stream]= scale;
3048 static int opt_recording_time(const char *opt, const char *arg)
3050 recording_time = parse_time_or_die(opt, arg, 1);
3054 static int opt_start_time(const char *opt, const char *arg)
3056 start_time = parse_time_or_die(opt, arg, 1);
3060 static int opt_recording_timestamp(const char *opt, const char *arg)
3062 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3066 static int opt_input_ts_offset(const char *opt, const char *arg)
3068 input_ts_offset = parse_time_or_die(opt, arg, 1);
3072 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3074 const char *codec_string = encoder ? "encoder" : "decoder";
3078 return CODEC_ID_NONE;
3080 avcodec_find_encoder_by_name(name) :
3081 avcodec_find_decoder_by_name(name);
3083 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3086 if(codec->type != type) {
3087 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3090 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3091 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3092 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3093 "results.\nAdd '-strict experimental' if you want to use it.\n",
3094 codec_string, codec->name);
3096 avcodec_find_encoder(codec->id) :
3097 avcodec_find_decoder(codec->id);
3098 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3099 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3100 codec_string, codec->name);
3106 static void opt_input_file(const char *filename)
3108 AVFormatContext *ic;
3109 AVFormatParameters params, *ap = ¶ms;
3110 AVInputFormat *file_iformat = NULL;
3111 int err, i, ret, rfps, rfps_base;
3114 if (last_asked_format) {
3115 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3116 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3119 last_asked_format = NULL;
3122 if (!strcmp(filename, "-"))
3125 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3126 !strcmp(filename, "/dev/stdin");
3128 /* get default parameters from command line */
3129 ic = avformat_alloc_context();
3131 print_error(filename, AVERROR(ENOMEM));
3135 memset(ap, 0, sizeof(*ap));
3136 ap->prealloced_context = 1;
3137 ap->sample_rate = audio_sample_rate;
3138 ap->channels = audio_channels;
3139 ap->time_base.den = frame_rate.num;
3140 ap->time_base.num = frame_rate.den;
3141 ap->width = frame_width;
3142 ap->height = frame_height;
3143 ap->pix_fmt = frame_pix_fmt;
3144 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3145 ap->channel = video_channel;
3146 ap->standard = video_standard;
3148 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3150 ic->video_codec_id =
3151 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3152 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3153 ic->audio_codec_id =
3154 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3155 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3156 ic->subtitle_codec_id=
3157 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3158 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3159 ic->flags |= AVFMT_FLAG_NONBLOCK;
3161 /* open the input file with generic libav function */
3162 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3164 print_error(filename, err);
3170 for(i=0; i<ic->nb_streams; i++){
3171 ic->streams[i]->discard= AVDISCARD_ALL;
3173 for(i=0; i<ic->nb_programs; i++){
3174 AVProgram *p= ic->programs[i];
3175 if(p->id != opt_programid){
3176 p->discard = AVDISCARD_ALL;
3179 for(j=0; j<p->nb_stream_indexes; j++){
3180 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3185 fprintf(stderr, "Specified program id not found\n");
3191 ic->loop_input = loop_input;
3193 /* If not enough info to get the stream parameters, we decode the
3194 first frames to get it. (used in mpeg case for example) */
3195 ret = av_find_stream_info(ic);
3196 if (ret < 0 && verbose >= 0) {
3197 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3198 av_close_input_file(ic);
3202 timestamp = start_time;
3203 /* add the stream start time */
3204 if (ic->start_time != AV_NOPTS_VALUE)
3205 timestamp += ic->start_time;
3207 /* if seeking requested, we execute it */
3208 if (start_time != 0) {
3209 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3211 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3212 filename, (double)timestamp / AV_TIME_BASE);
3214 /* reset seek info */
3218 /* update the current parameters so that they match the one of the input stream */
3219 for(i=0;i<ic->nb_streams;i++) {
3220 AVStream *st = ic->streams[i];
3221 AVCodecContext *dec = st->codec;
3222 dec->thread_count = thread_count;
3223 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3224 switch (dec->codec_type) {
3225 case AVMEDIA_TYPE_AUDIO:
3226 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3227 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3228 channel_layout = dec->channel_layout;
3229 audio_channels = dec->channels;
3230 audio_sample_rate = dec->sample_rate;
3231 audio_sample_fmt = dec->sample_fmt;
3233 st->discard= AVDISCARD_ALL;
3234 /* Note that av_find_stream_info can add more streams, and we
3235 * currently have no chance of setting up lowres decoding
3236 * early enough for them. */
3238 audio_sample_rate >>= dec->lowres;
3240 case AVMEDIA_TYPE_VIDEO:
3241 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3242 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3243 frame_height = dec->height;
3244 frame_width = dec->width;
3245 if(ic->streams[i]->sample_aspect_ratio.num)
3246 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3248 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3249 frame_aspect_ratio *= (float) dec->width / dec->height;
3250 frame_pix_fmt = dec->pix_fmt;
3251 rfps = ic->streams[i]->r_frame_rate.num;
3252 rfps_base = ic->streams[i]->r_frame_rate.den;
3254 dec->flags |= CODEC_FLAG_EMU_EDGE;
3255 frame_height >>= dec->lowres;
3256 frame_width >>= dec->lowres;
3257 dec->height = frame_height;
3258 dec->width = frame_width;
3261 dec->debug |= FF_DEBUG_MV;
3263 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3266 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3267 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3269 (float)rfps / rfps_base, rfps, rfps_base);
3271 /* update the current frame rate to match the stream frame rate */
3272 frame_rate.num = rfps;
3273 frame_rate.den = rfps_base;
3276 st->discard= AVDISCARD_ALL;
3277 else if(video_discard)
3278 st->discard= video_discard;
3280 case AVMEDIA_TYPE_DATA:
3282 case AVMEDIA_TYPE_SUBTITLE:
3283 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3284 if(subtitle_disable)
3285 st->discard = AVDISCARD_ALL;
3287 case AVMEDIA_TYPE_ATTACHMENT:
3288 case AVMEDIA_TYPE_UNKNOWN:
3295 input_files[nb_input_files] = ic;
3296 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3297 /* dump the file content */
3299 av_dump_format(ic, nb_input_files, filename, 0);
3305 av_freep(&video_codec_name);
3306 av_freep(&audio_codec_name);
3307 av_freep(&subtitle_codec_name);
3310 static void check_inputs(int *has_video_ptr,
3312 int *has_subtitle_ptr,
3315 int has_video, has_audio, has_subtitle, has_data, i, j;
3316 AVFormatContext *ic;
3323 for(j=0;j<nb_input_files;j++) {
3324 ic = input_files[j];
3325 for(i=0;i<ic->nb_streams;i++) {
3326 AVCodecContext *enc = ic->streams[i]->codec;
3327 switch(enc->codec_type) {
3328 case AVMEDIA_TYPE_AUDIO:
3331 case AVMEDIA_TYPE_VIDEO:
3334 case AVMEDIA_TYPE_SUBTITLE:
3337 case AVMEDIA_TYPE_DATA:
3338 case AVMEDIA_TYPE_ATTACHMENT:
3339 case AVMEDIA_TYPE_UNKNOWN:
3347 *has_video_ptr = has_video;
3348 *has_audio_ptr = has_audio;
3349 *has_subtitle_ptr = has_subtitle;
3350 *has_data_ptr = has_data;
3353 static void new_video_stream(AVFormatContext *oc, int file_idx)
3356 AVOutputStream *ost;
3357 AVCodecContext *video_enc;
3358 enum CodecID codec_id = CODEC_ID_NONE;
3359 AVCodec *codec= NULL;
3361 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3363 fprintf(stderr, "Could not alloc stream\n");
3366 ost = new_output_stream(oc, file_idx);
3368 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3369 if(!video_stream_copy){
3370 if (video_codec_name) {
3371 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3372 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3373 codec = avcodec_find_encoder_by_name(video_codec_name);
3374 output_codecs[nb_output_codecs-1] = codec;
3376 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3377 codec = avcodec_find_encoder(codec_id);
3381 avcodec_get_context_defaults3(st->codec, codec);
3382 ost->bitstream_filters = video_bitstream_filters;
3383 video_bitstream_filters= NULL;
3385 st->codec->thread_count= thread_count;
3387 video_enc = st->codec;
3390 video_enc->codec_tag= video_codec_tag;
3392 if( (video_global_header&1)
3393 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3394 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3395 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3397 if(video_global_header&2){
3398 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3399 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3402 if (video_stream_copy) {
3403 st->stream_copy = 1;
3404 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3405 video_enc->sample_aspect_ratio =
3406 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3410 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3412 video_enc->codec_id = codec_id;
3413 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3415 if (codec && codec->supported_framerates && !force_fps)
3416 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3417 video_enc->time_base.den = fps.num;
3418 video_enc->time_base.num = fps.den;
3420 video_enc->width = frame_width;
3421 video_enc->height = frame_height;
3422 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3423 video_enc->pix_fmt = frame_pix_fmt;
3424 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3426 choose_pixel_fmt(st, codec);
3429 video_enc->gop_size = 0;
3430 if (video_qscale || same_quality) {
3431 video_enc->flags |= CODEC_FLAG_QSCALE;
3432 video_enc->global_quality=
3433 st->quality = FF_QP2LAMBDA * video_qscale;
3437 video_enc->intra_matrix = intra_matrix;
3439 video_enc->inter_matrix = inter_matrix;
3441 p= video_rc_override_string;
3444 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3446 fprintf(stderr, "error parsing rc_override\n");
3449 video_enc->rc_override=
3450 av_realloc(video_enc->rc_override,
3451 sizeof(RcOverride)*(i+1));
3452 video_enc->rc_override[i].start_frame= start;
3453 video_enc->rc_override[i].end_frame = end;
3455 video_enc->rc_override[i].qscale= q;
3456 video_enc->rc_override[i].quality_factor= 1.0;
3459 video_enc->rc_override[i].qscale= 0;
3460 video_enc->rc_override[i].quality_factor= -q/100.0;
3465 video_enc->rc_override_count=i;
3466 if (!video_enc->rc_initial_buffer_occupancy)
3467 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3468 video_enc->me_threshold= me_threshold;
3469 video_enc->intra_dc_precision= intra_dc_precision - 8;
3472 video_enc->flags|= CODEC_FLAG_PSNR;
3477 video_enc->flags |= CODEC_FLAG_PASS1;
3479 video_enc->flags |= CODEC_FLAG_PASS2;
3483 if (forced_key_frames)
3484 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3486 if (video_language) {
3487 av_metadata_set2(&st->metadata, "language", video_language, 0);
3488 av_freep(&video_language);
3491 /* reset some key parameters */
3493 av_freep(&video_codec_name);
3494 av_freep(&forced_key_frames);
3495 video_stream_copy = 0;
3496 frame_pix_fmt = PIX_FMT_NONE;
3499 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3502 AVOutputStream *ost;
3503 AVCodec *codec= NULL;
3504 AVCodecContext *audio_enc;
3505 enum CodecID codec_id = CODEC_ID_NONE;
3507 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3509 fprintf(stderr, "Could not alloc stream\n");
3512 ost = new_output_stream(oc, file_idx);
3514 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3515 if(!audio_stream_copy){
3516 if (audio_codec_name) {
3517 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3518 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3519 codec = avcodec_find_encoder_by_name(audio_codec_name);
3520 output_codecs[nb_output_codecs-1] = codec;
3522 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3523 codec = avcodec_find_encoder(codec_id);
3527 avcodec_get_context_defaults3(st->codec, codec);
3529 ost->bitstream_filters = audio_bitstream_filters;
3530 audio_bitstream_filters= NULL;
3532 st->codec->thread_count= thread_count;
3534 audio_enc = st->codec;
3535 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3538 audio_enc->codec_tag= audio_codec_tag;
3540 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3541 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3542 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3544 if (audio_stream_copy) {
3545 st->stream_copy = 1;
3546 audio_enc->channels = audio_channels;
3547 audio_enc->sample_rate = audio_sample_rate;
3549 audio_enc->codec_id = codec_id;
3550 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3552 if (audio_qscale > QSCALE_NONE) {
3553 audio_enc->flags |= CODEC_FLAG_QSCALE;
3554 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3556 audio_enc->channels = audio_channels;
3557 audio_enc->sample_fmt = audio_sample_fmt;
3558 audio_enc->sample_rate = audio_sample_rate;
3559 audio_enc->channel_layout = channel_layout;
3560 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3561 audio_enc->channel_layout = 0;
3562 choose_sample_fmt(st, codec);
3563 choose_sample_rate(st, codec);
3565 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3566 if (audio_language) {
3567 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3568 av_freep(&audio_language);
3571 /* reset some key parameters */
3573 av_freep(&audio_codec_name);
3574 audio_stream_copy = 0;
3577 static void new_data_stream(AVFormatContext *oc, int file_idx)
3580 AVOutputStream *ost;
3581 AVCodec *codec=NULL;
3582 AVCodecContext *data_enc;
3584 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3586 fprintf(stderr, "Could not alloc stream\n");
3589 ost = new_output_stream(oc, file_idx);
3590 data_enc = st->codec;
3591 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3592 if (!data_stream_copy) {
3593 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3596 avcodec_get_context_defaults3(st->codec, codec);
3598 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3601 data_enc->codec_tag= data_codec_tag;
3603 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3604 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3605 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3607 if (data_stream_copy) {
3608 st->stream_copy = 1;
3612 av_freep(&data_codec_name);
3613 data_stream_copy = 0;
3616 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3619 AVOutputStream *ost;
3620 AVCodec *codec=NULL;
3621 AVCodecContext *subtitle_enc;
3622 enum CodecID codec_id = CODEC_ID_NONE;
3624 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3626 fprintf(stderr, "Could not alloc stream\n");
3629 ost = new_output_stream(oc, file_idx);
3630 subtitle_enc = st->codec;
3631 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3632 if(!subtitle_stream_copy){
3633 if (subtitle_codec_name) {
3634 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3635 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3636 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3638 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3639 codec = avcodec_find_encoder(codec_id);
3642 avcodec_get_context_defaults3(st->codec, codec);
3644 ost->bitstream_filters = subtitle_bitstream_filters;
3645 subtitle_bitstream_filters= NULL;
3647 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3649 if(subtitle_codec_tag)
3650 subtitle_enc->codec_tag= subtitle_codec_tag;
3652 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3653 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3654 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3656 if (subtitle_stream_copy) {
3657 st->stream_copy = 1;
3659 subtitle_enc->codec_id = codec_id;
3660 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3663 if (subtitle_language) {
3664 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3665 av_freep(&subtitle_language);
3668 subtitle_disable = 0;
3669 av_freep(&subtitle_codec_name);
3670 subtitle_stream_copy = 0;
3673 static int opt_new_stream(const char *opt, const char *arg)
3675 AVFormatContext *oc;
3676 int file_idx = nb_output_files - 1;
3677 if (nb_output_files <= 0) {
3678 fprintf(stderr, "At least one output file must be specified\n");
3681 oc = output_files[file_idx];
3683 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3684 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3685 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3686 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3691 /* arg format is "output-stream-index:streamid-value". */
3692 static int opt_streamid(const char *opt, const char *arg)
3698 strncpy(idx_str, arg, sizeof(idx_str));
3699 idx_str[sizeof(idx_str)-1] = '\0';
3700 p = strchr(idx_str, ':');
3703 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3708 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3709 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3710 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3714 static void opt_output_file(const char *filename)
3716 AVFormatContext *oc;
3717 int err, use_video, use_audio, use_subtitle, use_data;
3718 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3719 AVFormatParameters params, *ap = ¶ms;
3720 AVOutputFormat *file_oformat;
3722 if (!strcmp(filename, "-"))
3725 oc = avformat_alloc_context();
3727 print_error(filename, AVERROR(ENOMEM));
3731 if (last_asked_format) {
3732 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3733 if (!file_oformat) {
3734 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3737 last_asked_format = NULL;
3739 file_oformat = av_guess_format(NULL, filename, NULL);
3740 if (!file_oformat) {
3741 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3747 oc->oformat = file_oformat;
3748 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3750 if (!strcmp(file_oformat->name, "ffm") &&
3751 av_strstart(filename, "http:", NULL)) {
3752 /* special case for files sent to ffserver: we get the stream
3753 parameters from ffserver */
3754 int err = read_ffserver_streams(oc, filename);
3756 print_error(filename, err);
3760 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3761 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3762 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3763 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 */
3765 /* disable if no corresponding type found and at least one
3767 if (nb_input_files > 0) {
3768 check_inputs(&input_has_video,
3770 &input_has_subtitle,
3773 if (!input_has_video)
3775 if (!input_has_audio)
3777 if (!input_has_subtitle)
3779 if (!input_has_data)
3783 /* manual disable */
3784 if (audio_disable) use_audio = 0;
3785 if (video_disable) use_video = 0;
3786 if (subtitle_disable) use_subtitle = 0;
3787 if (data_disable) use_data = 0;
3789 if (use_video) new_video_stream(oc, nb_output_files);
3790 if (use_audio) new_audio_stream(oc, nb_output_files);
3791 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3792 if (use_data) new_data_stream(oc, nb_output_files);
3794 oc->timestamp = recording_timestamp;
3796 av_metadata_copy(&oc->metadata, metadata, 0);
3797 av_metadata_free(&metadata);
3800 output_files[nb_output_files++] = oc;
3802 /* check filename in case of an image number is expected */
3803 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3804 if (!av_filename_number_test(oc->filename)) {
3805 print_error(oc->filename, AVERROR(EINVAL));
3810 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3811 /* test if it already exists to avoid loosing precious files */
3812 if (!file_overwrite &&
3813 (strchr(filename, ':') == NULL ||
3814 filename[1] == ':' ||
3815 av_strstart(filename, "file:", NULL))) {
3816 if (avio_check(filename, 0) == 0) {
3818 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3820 if (!read_yesno()) {
3821 fprintf(stderr, "Not overwriting - exiting\n");
3826 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3833 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3834 print_error(filename, err);
3839 memset(ap, 0, sizeof(*ap));
3840 if (av_set_parameters(oc, ap) < 0) {
3841 fprintf(stderr, "%s: Invalid encoding parameters\n",
3846 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3847 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3848 oc->loop_output = loop_output;
3849 oc->flags |= AVFMT_FLAG_NONBLOCK;
3851 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3853 av_freep(&forced_key_frames);
3856 /* same option as mencoder */
3857 static void opt_pass(const char *pass_str)
3860 pass = atoi(pass_str);
3861 if (pass != 1 && pass != 2) {
3862 fprintf(stderr, "pass number can be only 1 or 2\n");
3868 static int64_t getutime(void)
3871 struct rusage rusage;
3873 getrusage(RUSAGE_SELF, &rusage);
3874 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3875 #elif HAVE_GETPROCESSTIMES
3877 FILETIME c, e, k, u;
3878 proc = GetCurrentProcess();
3879 GetProcessTimes(proc, &c, &e, &k, &u);
3880 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3882 return av_gettime();
3886 static int64_t getmaxrss(void)
3888 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3889 struct rusage rusage;
3890 getrusage(RUSAGE_SELF, &rusage);
3891 return (int64_t)rusage.ru_maxrss * 1024;
3892 #elif HAVE_GETPROCESSMEMORYINFO
3894 PROCESS_MEMORY_COUNTERS memcounters;
3895 proc = GetCurrentProcess();
3896 memcounters.cb = sizeof(memcounters);
3897 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3898 return memcounters.PeakPagefileUsage;
3904 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3907 const char *p = str;
3914 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3921 static void opt_inter_matrix(const char *arg)
3923 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3924 parse_matrix_coeffs(inter_matrix, arg);
3927 static void opt_intra_matrix(const char *arg)
3929 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3930 parse_matrix_coeffs(intra_matrix, arg);
3933 static void show_usage(void)
3935 printf("Hyper fast Audio and Video encoder\n");
3936 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3940 static void show_help(void)
3943 AVOutputFormat *oformat = NULL;
3945 av_log_set_callback(log_callback_help);
3947 show_help_options(options, "Main options:\n",
3948 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3949 show_help_options(options, "\nAdvanced options:\n",
3950 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3952 show_help_options(options, "\nVideo options:\n",
3953 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3955 show_help_options(options, "\nAdvanced Video options:\n",
3956 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3957 OPT_VIDEO | OPT_EXPERT);
3958 show_help_options(options, "\nAudio options:\n",
3959 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3961 show_help_options(options, "\nAdvanced Audio options:\n",
3962 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3963 OPT_AUDIO | OPT_EXPERT);
3964 show_help_options(options, "\nSubtitle options:\n",
3965 OPT_SUBTITLE | OPT_GRAB,
3967 show_help_options(options, "\nAudio/Video grab options:\n",
3971 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3974 /* individual codec options */
3976 while ((c = av_codec_next(c))) {
3977 if (c->priv_class) {
3978 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3983 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3986 /* individual muxer options */
3987 while ((oformat = av_oformat_next(oformat))) {
3988 if (oformat->priv_class) {
3989 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3994 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3997 static void opt_target(const char *arg)
3999 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4000 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4002 if(!strncmp(arg, "pal-", 4)) {
4005 } else if(!strncmp(arg, "ntsc-", 5)) {
4008 } else if(!strncmp(arg, "film-", 5)) {
4013 /* Calculate FR via float to avoid int overflow */
4014 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4017 } else if((fr == 29970) || (fr == 23976)) {
4020 /* Try to determine PAL/NTSC by peeking in the input files */
4021 if(nb_input_files) {
4023 for(j = 0; j < nb_input_files; j++) {
4024 for(i = 0; i < input_files[j]->nb_streams; i++) {
4025 AVCodecContext *c = input_files[j]->streams[i]->codec;
4026 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4028 fr = c->time_base.den * 1000 / c->time_base.num;
4032 } else if((fr == 29970) || (fr == 23976)) {
4042 if(verbose && norm != UNKNOWN)
4043 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4046 if(norm == UNKNOWN) {
4047 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4048 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4049 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4053 if(!strcmp(arg, "vcd")) {
4055 opt_video_codec("mpeg1video");
4056 opt_audio_codec("mp2");
4059 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4060 opt_frame_rate(NULL, frame_rates[norm]);
4061 opt_default("g", norm == PAL ? "15" : "18");
4063 opt_default("b", "1150000");
4064 opt_default("maxrate", "1150000");
4065 opt_default("minrate", "1150000");
4066 opt_default("bufsize", "327680"); // 40*1024*8;
4068 opt_default("ab", "224000");
4069 audio_sample_rate = 44100;
4072 opt_default("packetsize", "2324");
4073 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4075 /* We have to offset the PTS, so that it is consistent with the SCR.
4076 SCR starts at 36000, but the first two packs contain only padding
4077 and the first pack from the other stream, respectively, may also have
4078 been written before.
4079 So the real data starts at SCR 36000+3*1200. */
4080 mux_preload= (36000+3*1200) / 90000.0; //0.44
4081 } else if(!strcmp(arg, "svcd")) {
4083 opt_video_codec("mpeg2video");
4084 opt_audio_codec("mp2");
4087 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4088 opt_frame_rate(NULL, frame_rates[norm]);
4089 opt_default("g", norm == PAL ? "15" : "18");
4091 opt_default("b", "2040000");
4092 opt_default("maxrate", "2516000");
4093 opt_default("minrate", "0"); //1145000;
4094 opt_default("bufsize", "1835008"); //224*1024*8;
4095 opt_default("flags", "+scan_offset");
4098 opt_default("ab", "224000");
4099 audio_sample_rate = 44100;
4101 opt_default("packetsize", "2324");
4103 } else if(!strcmp(arg, "dvd")) {
4105 opt_video_codec("mpeg2video");
4106 opt_audio_codec("ac3");
4109 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4110 opt_frame_rate(NULL, frame_rates[norm]);
4111 opt_default("g", norm == PAL ? "15" : "18");
4113 opt_default("b", "6000000");
4114 opt_default("maxrate", "9000000");
4115 opt_default("minrate", "0"); //1500000;
4116 opt_default("bufsize", "1835008"); //224*1024*8;
4118 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4119 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4121 opt_default("ab", "448000");
4122 audio_sample_rate = 48000;
4124 } else if(!strncmp(arg, "dv", 2)) {
4128 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4129 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4130 (norm == PAL ? "yuv420p" : "yuv411p"));
4131 opt_frame_rate(NULL, frame_rates[norm]);
4133 audio_sample_rate = 48000;
4137 fprintf(stderr, "Unknown target: %s\n", arg);
4142 static void opt_vstats_file (const char *arg)
4144 av_free (vstats_filename);
4145 vstats_filename=av_strdup (arg);
4148 static void opt_vstats (void)
4151 time_t today2 = time(NULL);
4152 struct tm *today = localtime(&today2);
4154 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4156 opt_vstats_file(filename);
4159 static int opt_bsf(const char *opt, const char *arg)
4161 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4162 AVBitStreamFilterContext **bsfp;
4165 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4169 bsfp= *opt == 'v' ? &video_bitstream_filters :
4170 *opt == 'a' ? &audio_bitstream_filters :
4171 &subtitle_bitstream_filters;
4173 bsfp= &(*bsfp)->next;
4180 static int opt_preset(const char *opt, const char *arg)
4183 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4184 char *codec_name = *opt == 'v' ? video_codec_name :
4185 *opt == 'a' ? audio_codec_name :
4186 subtitle_codec_name;
4188 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4189 fprintf(stderr, "File for preset '%s' not found\n", arg);
4194 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4195 if(line[0] == '#' && !e)
4197 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4199 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4202 if(!strcmp(tmp, "acodec")){
4203 opt_audio_codec(tmp2);
4204 }else if(!strcmp(tmp, "vcodec")){
4205 opt_video_codec(tmp2);
4206 }else if(!strcmp(tmp, "scodec")){
4207 opt_subtitle_codec(tmp2);
4208 }else if(!strcmp(tmp, "dcodec")){
4209 opt_data_codec(tmp2);
4210 }else if(opt_default(tmp, tmp2) < 0){
4211 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4221 static const OptionDef options[] = {
4223 #include "cmdutils_common_opts.h"
4224 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4225 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4226 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4227 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4228 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4229 "outfile[,metadata]:infile[,metadata]" },
4230 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4231 "outfile[,metadata]:infile[,metadata]" },
4232 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4233 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4234 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4235 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4236 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4237 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4238 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4239 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4240 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4241 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4242 "add timings for benchmarking" },
4243 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4244 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4245 "dump each input packet" },
4246 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4247 "when dumping packets, also dump the payload" },
4248 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4249 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4250 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4251 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4252 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4253 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4254 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4255 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4256 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4257 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4258 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4259 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4260 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4261 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4262 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4263 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4264 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4267 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4268 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4269 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4270 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4271 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4272 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4273 { "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" },
4274 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4275 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4276 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4277 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4278 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4279 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4280 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4281 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4282 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4283 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4284 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4285 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4286 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4287 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4288 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4289 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4290 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4291 "use same quantizer as source (implies VBR)" },
4292 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4293 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4294 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4295 "deinterlace pictures" },
4296 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4297 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4298 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4300 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4302 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4303 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4304 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4305 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4306 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4307 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4308 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4309 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4310 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4311 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4312 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4315 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4316 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4317 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4318 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4319 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4320 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4321 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4322 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4323 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4324 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4325 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4326 { "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" },
4328 /* subtitle options */
4329 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4330 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4331 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4332 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4333 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4336 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4337 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4338 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4341 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4342 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4344 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4345 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4346 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4348 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4349 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4350 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4351 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4352 /* data codec support */
4353 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4355 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4359 int main(int argc, char **argv)
4363 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4365 avcodec_register_all();
4367 avdevice_register_all();
4370 avfilter_register_all();
4375 if(isatty(STDIN_FILENO))
4376 avio_set_interrupt_cb(decode_interrupt_cb);
4384 parse_options(argc, argv, options, opt_output_file);
4386 if(nb_output_files <= 0 && nb_input_files == 0) {
4388 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4392 /* file converter / grab */
4393 if (nb_output_files <= 0) {
4394 fprintf(stderr, "At least one output file must be specified\n");
4398 if (nb_input_files == 0) {
4399 fprintf(stderr, "At least one input file must be specified\n");
4404 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4405 stream_maps, nb_stream_maps) < 0)
4407 ti = getutime() - ti;
4409 int maxrss = getmaxrss() / 1024;
4410 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4413 return ffmpeg_exit(0);