3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "ffmpeg";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
85 int sync_stream_index;
89 * select an input file for an output file
91 typedef struct MetadataMap {
92 int file; //< file index
93 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
94 int index; //< stream/chapter/program number
97 typedef struct ChapterMap {
102 static const OptionDef options[];
104 #define MAX_FILES 100
106 static const char *last_asked_format = NULL;
107 static double *ts_scale;
108 static int nb_ts_scale;
110 static AVFormatContext *output_files[MAX_FILES];
111 static AVDictionary *output_opts[MAX_FILES];
112 static int nb_output_files = 0;
114 static StreamMap *stream_maps = NULL;
115 static int nb_stream_maps;
117 /* first item specifies output metadata, second is input */
118 static MetadataMap (*meta_data_maps)[2] = NULL;
119 static int nb_meta_data_maps;
120 static int metadata_global_autocopy = 1;
121 static int metadata_streams_autocopy = 1;
122 static int metadata_chapters_autocopy = 1;
124 static ChapterMap *chapter_maps = NULL;
125 static int nb_chapter_maps;
127 /* indexed by output file stream index */
128 static int *streamid_map = NULL;
129 static int nb_streamid_map = 0;
131 static int frame_width = 0;
132 static int frame_height = 0;
133 static float frame_aspect_ratio = 0;
134 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
135 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
136 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
137 static AVRational frame_rate;
138 static float video_qscale = 0;
139 static uint16_t *intra_matrix = NULL;
140 static uint16_t *inter_matrix = NULL;
141 static const char *video_rc_override_string=NULL;
142 static int video_disable = 0;
143 static int video_discard = 0;
144 static char *video_codec_name = NULL;
145 static unsigned int video_codec_tag = 0;
146 static char *video_language = NULL;
147 static int same_quality = 0;
148 static int do_deinterlace = 0;
149 static int top_field_first = -1;
150 static int me_threshold = 0;
151 static int intra_dc_precision = 8;
152 static int loop_input = 0;
153 static int loop_output = AVFMT_NOOUTPUTLOOP;
154 static int qp_hist = 0;
156 static char *vfilters = NULL;
159 static int intra_only = 0;
160 static int audio_sample_rate = 0;
161 #define QSCALE_NONE -99999
162 static float audio_qscale = QSCALE_NONE;
163 static int audio_disable = 0;
164 static int audio_channels = 0;
165 static char *audio_codec_name = NULL;
166 static unsigned int audio_codec_tag = 0;
167 static char *audio_language = NULL;
169 static int subtitle_disable = 0;
170 static char *subtitle_codec_name = NULL;
171 static char *subtitle_language = NULL;
172 static unsigned int subtitle_codec_tag = 0;
174 static int data_disable = 0;
175 static char *data_codec_name = NULL;
176 static unsigned int data_codec_tag = 0;
178 static float mux_preload= 0.5;
179 static float mux_max_delay= 0.7;
181 static int64_t recording_time = INT64_MAX;
182 static int64_t start_time = 0;
183 static int64_t input_ts_offset = 0;
184 static int file_overwrite = 0;
185 static AVDictionary *metadata;
186 static int do_benchmark = 0;
187 static int do_hex_dump = 0;
188 static int do_pkt_dump = 0;
189 static int do_psnr = 0;
190 static int do_pass = 0;
191 static char *pass_logfilename_prefix = NULL;
192 static int audio_stream_copy = 0;
193 static int video_stream_copy = 0;
194 static int subtitle_stream_copy = 0;
195 static int data_stream_copy = 0;
196 static int video_sync_method= -1;
197 static int audio_sync_method= 0;
198 static float audio_drift_threshold= 0.1;
199 static int copy_ts= 0;
201 static int opt_shortest = 0;
202 static char *vstats_filename;
203 static FILE *vstats_file;
204 static int opt_programid = 0;
205 static int copy_initial_nonkeyframes = 0;
207 static int rate_emu = 0;
209 static int audio_volume = 256;
211 static int exit_on_error = 0;
212 static int using_stdin = 0;
213 static int verbose = 1;
214 static int thread_count= 1;
215 static int64_t video_size = 0;
216 static int64_t audio_size = 0;
217 static int64_t extra_size = 0;
218 static int nb_frames_dup = 0;
219 static int nb_frames_drop = 0;
220 static int input_sync;
221 static uint64_t limit_filesize = 0;
222 static int force_fps = 0;
223 static char *forced_key_frames = NULL;
225 static float dts_delta_threshold = 10;
227 static int64_t timer_start;
229 static uint8_t *audio_buf;
230 static uint8_t *audio_out;
231 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
233 static short *samples;
235 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
236 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
237 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
239 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
243 typedef struct OutputStream {
244 int file_index; /* file index */
245 int index; /* stream index in the output file */
246 int source_index; /* InputStream index */
247 AVStream *st; /* stream in the output file */
248 int encoding_needed; /* true if encoding needed for this stream */
250 /* input pts and corresponding output pts
252 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
253 struct InputStream *sync_ist; /* input stream to sync against */
254 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
255 AVBitStreamFilterContext *bitstream_filters;
260 AVFrame pict_tmp; /* temporary image for resampling */
261 struct SwsContext *img_resample_ctx; /* for image resampling */
264 int resample_pix_fmt;
265 AVRational frame_rate;
267 float frame_aspect_ratio;
269 /* forced key frames */
270 int64_t *forced_kf_pts;
276 ReSampleContext *resample; /* for audio resampling */
277 int resample_sample_fmt;
278 int resample_channels;
279 int resample_sample_rate;
281 AVAudioConvert *reformat_ctx;
282 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
286 AVFilterContext *output_video_filter;
287 AVFilterContext *input_video_filter;
288 AVFilterBufferRef *picref;
290 AVFilterGraph *graph;
297 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
298 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
300 typedef struct InputStream {
303 int discard; /* true if stream data should be discarded */
304 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
307 int64_t start; /* time when read started */
308 int64_t next_pts; /* synthetic pts for cases where pkt.pts
310 int64_t pts; /* current pts */
311 PtsCorrectionContext pts_ctx;
313 int is_start; /* is 1 at the start and after a discontinuity */
314 int showed_multi_packet_warning;
315 int is_past_recording_time;
319 typedef struct InputFile {
320 AVFormatContext *ctx;
321 int eof_reached; /* true if eof reached */
322 int ist_index; /* index of first stream in ist_table */
323 int buffer_size; /* current total buffer size */
327 static InputStream *input_streams = NULL;
328 static int nb_input_streams = 0;
329 static InputFile *input_files = NULL;
330 static int nb_input_files = 0;
334 static int configure_video_filters(InputStream *ist, OutputStream *ost)
336 AVFilterContext *last_filter, *filter;
337 /** filter graph containing all filters including input & output */
338 AVCodecContext *codec = ost->st->codec;
339 AVCodecContext *icodec = ist->st->codec;
340 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
341 AVRational sample_aspect_ratio;
345 ost->graph = avfilter_graph_alloc();
347 if (ist->st->sample_aspect_ratio.num){
348 sample_aspect_ratio = ist->st->sample_aspect_ratio;
350 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
352 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
353 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
354 sample_aspect_ratio.num, sample_aspect_ratio.den);
356 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
357 "src", args, NULL, ost->graph);
360 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
361 "out", NULL, &ffsink_ctx, ost->graph);
364 last_filter = ost->input_video_filter;
366 if (codec->width != icodec->width || codec->height != icodec->height) {
367 snprintf(args, 255, "%d:%d:flags=0x%X",
371 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
372 NULL, args, NULL, ost->graph)) < 0)
374 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
376 last_filter = filter;
379 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
380 ost->graph->scale_sws_opts = av_strdup(args);
383 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
384 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
386 outputs->name = av_strdup("in");
387 outputs->filter_ctx = last_filter;
388 outputs->pad_idx = 0;
389 outputs->next = NULL;
391 inputs->name = av_strdup("out");
392 inputs->filter_ctx = ost->output_video_filter;
396 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
398 av_freep(&ost->avfilter);
400 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
404 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
407 codec->width = ost->output_video_filter->inputs[0]->w;
408 codec->height = ost->output_video_filter->inputs[0]->h;
409 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
410 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
411 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
412 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
416 #endif /* CONFIG_AVFILTER */
418 static void term_exit(void)
420 av_log(NULL, AV_LOG_QUIET, "");
423 static volatile int received_sigterm = 0;
424 static volatile int received_nb_signals = 0;
427 sigterm_handler(int sig)
429 received_sigterm = sig;
430 received_nb_signals++;
434 static void term_init(void)
436 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
437 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
439 signal(SIGXCPU, sigterm_handler);
443 static int decode_interrupt_cb(void)
445 return received_nb_signals > 1;
448 static int ffmpeg_exit(int ret)
453 for(i=0;i<nb_output_files;i++) {
454 AVFormatContext *s = output_files[i];
455 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
457 avformat_free_context(s);
458 av_free(output_streams_for_file[i]);
459 av_dict_free(&output_opts[i]);
461 for(i=0;i<nb_input_files;i++) {
462 av_close_input_file(input_files[i].ctx);
464 for (i = 0; i < nb_input_streams; i++)
465 av_dict_free(&input_streams[i].opts);
467 av_free(intra_matrix);
468 av_free(inter_matrix);
472 av_free(vstats_filename);
474 av_free(streamid_map);
475 av_free(stream_maps);
476 av_free(meta_data_maps);
478 av_freep(&input_streams);
479 av_freep(&input_files);
481 av_free(video_codec_name);
482 av_free(audio_codec_name);
483 av_free(subtitle_codec_name);
484 av_free(data_codec_name);
489 allocated_audio_buf_size= allocated_audio_out_size= 0;
496 if (received_sigterm) {
498 "Received signal %d: terminating.\n",
499 (int) received_sigterm);
503 exit(ret); /* not all OS-es handle main() return value */
507 static void assert_avoptions(AVDictionary *m)
509 AVDictionaryEntry *t;
510 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
511 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
516 static void assert_codec_experimental(AVCodecContext *c, int encoder)
518 const char *codec_string = encoder ? "encoder" : "decoder";
520 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
521 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
522 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
523 "results.\nAdd '-strict experimental' if you want to use it.\n",
524 codec_string, c->codec->name);
525 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
526 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
527 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
528 codec_string, codec->name);
533 /* similar to ff_dynarray_add() and av_fast_realloc() */
534 static void *grow_array(void *array, int elem_size, int *size, int new_size)
536 if (new_size >= INT_MAX / elem_size) {
537 fprintf(stderr, "Array too big.\n");
540 if (*size < new_size) {
541 uint8_t *tmp = av_realloc(array, new_size*elem_size);
543 fprintf(stderr, "Could not alloc buffer.\n");
546 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
553 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
555 if(codec && codec->sample_fmts){
556 const enum AVSampleFormat *p= codec->sample_fmts;
558 if(*p == st->codec->sample_fmt)
562 av_log(NULL, AV_LOG_WARNING,
563 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
564 av_get_sample_fmt_name(st->codec->sample_fmt),
566 av_get_sample_fmt_name(codec->sample_fmts[0]));
567 st->codec->sample_fmt = codec->sample_fmts[0];
573 * Update the requested input sample format based on the output sample format.
574 * This is currently only used to request float output from decoders which
575 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
576 * Ideally this will be removed in the future when decoders do not do format
577 * conversion and only output in their native format.
579 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
582 /* if sample formats match or a decoder sample format has already been
583 requested, just return */
584 if (enc->sample_fmt == dec->sample_fmt ||
585 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
588 /* if decoder supports more than one output format */
589 if (dec_codec && dec_codec->sample_fmts &&
590 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
591 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
592 const enum AVSampleFormat *p;
593 int min_dec = -1, min_inc = -1;
595 /* find a matching sample format in the encoder */
596 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
597 if (*p == enc->sample_fmt) {
598 dec->request_sample_fmt = *p;
600 } else if (*p > enc->sample_fmt) {
601 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
603 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
606 /* if none match, provide the one that matches quality closest */
607 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
608 enc->sample_fmt - min_dec;
612 static void choose_sample_rate(AVStream *st, AVCodec *codec)
614 if(codec && codec->supported_samplerates){
615 const int *p= codec->supported_samplerates;
617 int best_dist=INT_MAX;
619 int dist= abs(st->codec->sample_rate - *p);
620 if(dist < best_dist){
626 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
628 st->codec->sample_rate= best;
632 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
634 if(codec && codec->pix_fmts){
635 const enum PixelFormat *p= codec->pix_fmts;
636 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
637 if(st->codec->codec_id==CODEC_ID_MJPEG){
638 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
639 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
640 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};
644 if(*p == st->codec->pix_fmt)
648 if(st->codec->pix_fmt != PIX_FMT_NONE)
649 av_log(NULL, AV_LOG_WARNING,
650 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
651 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
653 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
654 st->codec->pix_fmt = codec->pix_fmts[0];
659 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
662 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
663 int idx = oc->nb_streams - 1;
666 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
670 output_streams_for_file[file_idx] =
671 grow_array(output_streams_for_file[file_idx],
672 sizeof(*output_streams_for_file[file_idx]),
673 &nb_output_streams_for_file[file_idx],
675 ost = output_streams_for_file[file_idx][idx] =
676 av_mallocz(sizeof(OutputStream));
678 fprintf(stderr, "Could not alloc output stream\n");
681 ost->file_index = file_idx;
686 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
688 avcodec_get_context_defaults3(st->codec, codec);
690 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
694 static int read_avserver_streams(AVFormatContext *s, const char *filename)
697 AVFormatContext *ic = NULL;
700 err = avformat_open_input(&ic, filename, NULL, NULL);
703 /* copy stream format */
704 for(i=0;i<ic->nb_streams;i++) {
709 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
710 ost = new_output_stream(s, nb_output_files, codec);
713 // FIXME: a more elegant solution is needed
714 memcpy(st, ic->streams[i], sizeof(AVStream));
716 avcodec_copy_context(st->codec, ic->streams[i]->codec);
718 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
719 if (audio_stream_copy) {
722 choose_sample_fmt(st, codec);
723 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
724 if (video_stream_copy) {
727 choose_pixel_fmt(st, codec);
730 if(st->codec->flags & CODEC_FLAG_BITEXACT)
734 av_close_input_file(ic);
739 get_sync_ipts(const OutputStream *ost)
741 const InputStream *ist = ost->sync_ist;
742 return (double)(ist->pts - start_time)/AV_TIME_BASE;
745 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
749 AVPacket new_pkt= *pkt;
750 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
751 &new_pkt.data, &new_pkt.size,
752 pkt->data, pkt->size,
753 pkt->flags & AV_PKT_FLAG_KEY);
756 new_pkt.destruct= av_destruct_packet;
758 fprintf(stderr, "%s failed for stream %d, codec %s",
759 bsfc->filter->name, pkt->stream_index,
760 avctx->codec ? avctx->codec->name : "copy");
770 ret= av_interleaved_write_frame(s, pkt);
772 print_error("av_interleaved_write_frame()", ret);
777 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
779 static void do_audio_out(AVFormatContext *s,
782 unsigned char *buf, int size)
785 int64_t audio_out_size, audio_buf_size;
786 int64_t allocated_for_size= size;
788 int size_out, frame_bytes, ret, resample_changed;
789 AVCodecContext *enc= ost->st->codec;
790 AVCodecContext *dec= ist->st->codec;
791 int osize = av_get_bytes_per_sample(enc->sample_fmt);
792 int isize = av_get_bytes_per_sample(dec->sample_fmt);
793 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
796 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
797 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
798 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
799 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
800 audio_buf_size*= osize*enc->channels;
802 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
803 if(coded_bps > 8*osize)
804 audio_out_size= audio_out_size * coded_bps / (8*osize);
805 audio_out_size += FF_MIN_BUFFER_SIZE;
807 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
808 fprintf(stderr, "Buffer sizes too large\n");
812 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
813 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
814 if (!audio_buf || !audio_out){
815 fprintf(stderr, "Out of memory in do_audio_out\n");
819 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
820 ost->audio_resample = 1;
822 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
823 ost->resample_channels != dec->channels ||
824 ost->resample_sample_rate != dec->sample_rate;
826 if ((ost->audio_resample && !ost->resample) || resample_changed) {
827 if (resample_changed) {
828 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",
829 ist->file_index, ist->st->index,
830 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
831 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
832 ost->resample_sample_fmt = dec->sample_fmt;
833 ost->resample_channels = dec->channels;
834 ost->resample_sample_rate = dec->sample_rate;
836 audio_resample_close(ost->resample);
838 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
839 if (audio_sync_method <= 1 &&
840 ost->resample_sample_fmt == enc->sample_fmt &&
841 ost->resample_channels == enc->channels &&
842 ost->resample_sample_rate == enc->sample_rate) {
843 ost->resample = NULL;
844 ost->audio_resample = 0;
845 } else if (ost->audio_resample) {
846 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
847 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
848 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
849 enc->sample_rate, dec->sample_rate,
850 enc->sample_fmt, dec->sample_fmt,
852 if (!ost->resample) {
853 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
854 dec->channels, dec->sample_rate,
855 enc->channels, enc->sample_rate);
861 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
862 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
863 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
864 if (ost->reformat_ctx)
865 av_audio_convert_free(ost->reformat_ctx);
866 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
867 dec->sample_fmt, 1, NULL, 0);
868 if (!ost->reformat_ctx) {
869 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
870 av_get_sample_fmt_name(dec->sample_fmt),
871 av_get_sample_fmt_name(enc->sample_fmt));
874 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
877 if(audio_sync_method){
878 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
879 - av_fifo_size(ost->fifo)/(enc->channels * 2);
880 double idelta= delta*dec->sample_rate / enc->sample_rate;
881 int byte_delta= ((int)idelta)*2*dec->channels;
883 //FIXME resample delay
884 if(fabs(delta) > 50){
885 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
887 byte_delta= FFMAX(byte_delta, -size);
891 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
896 static uint8_t *input_tmp= NULL;
897 input_tmp= av_realloc(input_tmp, byte_delta + size);
899 if(byte_delta > allocated_for_size - size){
900 allocated_for_size= byte_delta + (int64_t)size;
905 memset(input_tmp, 0, byte_delta);
906 memcpy(input_tmp + byte_delta, buf, size);
910 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
912 }else if(audio_sync_method>1){
913 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
914 av_assert0(ost->audio_resample);
916 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
917 // 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));
918 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
922 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
923 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
925 if (ost->audio_resample) {
927 size_out = audio_resample(ost->resample,
928 (short *)buftmp, (short *)buf,
929 size / (dec->channels * isize));
930 size_out = size_out * enc->channels * osize;
936 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
937 const void *ibuf[6]= {buftmp};
938 void *obuf[6]= {audio_buf};
939 int istride[6]= {isize};
940 int ostride[6]= {osize};
941 int len= size_out/istride[0];
942 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
943 printf("av_audio_convert() failed\n");
949 size_out = len*osize;
952 /* now encode as many frames as possible */
953 if (enc->frame_size > 1) {
954 /* output resampled raw samples */
955 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
956 fprintf(stderr, "av_fifo_realloc2() failed\n");
959 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
961 frame_bytes = enc->frame_size * osize * enc->channels;
963 while (av_fifo_size(ost->fifo) >= frame_bytes) {
965 av_init_packet(&pkt);
967 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
969 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
971 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
974 fprintf(stderr, "Audio encoding failed\n");
978 pkt.stream_index= ost->index;
981 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
982 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
983 pkt.flags |= AV_PKT_FLAG_KEY;
984 write_frame(s, &pkt, enc, ost->bitstream_filters);
986 ost->sync_opts += enc->frame_size;
990 av_init_packet(&pkt);
992 ost->sync_opts += size_out / (osize * enc->channels);
994 /* output a pcm frame */
995 /* determine the size of the coded buffer */
998 size_out = size_out*coded_bps/8;
1000 if(size_out > audio_out_size){
1001 fprintf(stderr, "Internal error, buffer size too small\n");
1005 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1006 ret = avcodec_encode_audio(enc, audio_out, size_out,
1009 fprintf(stderr, "Audio encoding failed\n");
1013 pkt.stream_index= ost->index;
1014 pkt.data= audio_out;
1016 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1017 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1018 pkt.flags |= AV_PKT_FLAG_KEY;
1019 write_frame(s, &pkt, enc, ost->bitstream_filters);
1023 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1025 AVCodecContext *dec;
1026 AVPicture *picture2;
1027 AVPicture picture_tmp;
1030 dec = ist->st->codec;
1032 /* deinterlace : must be done before any resize */
1033 if (do_deinterlace) {
1036 /* create temporary picture */
1037 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1038 buf = av_malloc(size);
1042 picture2 = &picture_tmp;
1043 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1045 if(avpicture_deinterlace(picture2, picture,
1046 dec->pix_fmt, dec->width, dec->height) < 0) {
1047 /* if error, do not deinterlace */
1048 fprintf(stderr, "Deinterlacing failed\n");
1057 if (picture != picture2)
1058 *picture = *picture2;
1062 /* we begin to correct av delay at this threshold */
1063 #define AV_DELAY_MAX 0.100
1065 static void do_subtitle_out(AVFormatContext *s,
1071 static uint8_t *subtitle_out = NULL;
1072 int subtitle_out_max_size = 1024 * 1024;
1073 int subtitle_out_size, nb, i;
1074 AVCodecContext *enc;
1077 if (pts == AV_NOPTS_VALUE) {
1078 fprintf(stderr, "Subtitle packets must have a pts\n");
1084 enc = ost->st->codec;
1086 if (!subtitle_out) {
1087 subtitle_out = av_malloc(subtitle_out_max_size);
1090 /* Note: DVB subtitle need one packet to draw them and one other
1091 packet to clear them */
1092 /* XXX: signal it in the codec context ? */
1093 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1098 for(i = 0; i < nb; i++) {
1099 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1100 // start_display_time is required to be 0
1101 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1102 sub->end_display_time -= sub->start_display_time;
1103 sub->start_display_time = 0;
1104 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1105 subtitle_out_max_size, sub);
1106 if (subtitle_out_size < 0) {
1107 fprintf(stderr, "Subtitle encoding failed\n");
1111 av_init_packet(&pkt);
1112 pkt.stream_index = ost->index;
1113 pkt.data = subtitle_out;
1114 pkt.size = subtitle_out_size;
1115 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1116 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1117 /* XXX: the pts correction is handled here. Maybe handling
1118 it in the codec would be better */
1120 pkt.pts += 90 * sub->start_display_time;
1122 pkt.pts += 90 * sub->end_display_time;
1124 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1128 static int bit_buffer_size= 1024*256;
1129 static uint8_t *bit_buffer= NULL;
1131 static void do_video_out(AVFormatContext *s,
1134 AVFrame *in_picture,
1135 int *frame_size, float quality)
1137 int nb_frames, i, ret, resample_changed;
1138 AVFrame *final_picture, *formatted_picture;
1139 AVCodecContext *enc, *dec;
1142 enc = ost->st->codec;
1143 dec = ist->st->codec;
1145 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1147 /* by default, we output a single frame */
1152 if(video_sync_method){
1153 double vdelta = sync_ipts - ost->sync_opts;
1154 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1157 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1160 }else if(vdelta>0.6)
1161 ost->sync_opts= lrintf(sync_ipts);
1162 }else if (vdelta > 1.1)
1163 nb_frames = lrintf(vdelta);
1164 //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);
1165 if (nb_frames == 0){
1168 fprintf(stderr, "*** drop!\n");
1169 }else if (nb_frames > 1) {
1170 nb_frames_dup += nb_frames - 1;
1172 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1175 ost->sync_opts= lrintf(sync_ipts);
1177 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1181 formatted_picture = in_picture;
1182 final_picture = formatted_picture;
1184 resample_changed = ost->resample_width != dec->width ||
1185 ost->resample_height != dec->height ||
1186 ost->resample_pix_fmt != dec->pix_fmt;
1188 if (resample_changed) {
1189 av_log(NULL, AV_LOG_INFO,
1190 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1191 ist->file_index, ist->st->index,
1192 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1193 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1194 if(!ost->video_resample)
1198 #if !CONFIG_AVFILTER
1199 if (ost->video_resample) {
1200 final_picture = &ost->pict_tmp;
1201 if (resample_changed) {
1202 /* initialize a new scaler context */
1203 sws_freeContext(ost->img_resample_ctx);
1204 ost->img_resample_ctx = sws_getContext(
1205 ist->st->codec->width,
1206 ist->st->codec->height,
1207 ist->st->codec->pix_fmt,
1208 ost->st->codec->width,
1209 ost->st->codec->height,
1210 ost->st->codec->pix_fmt,
1211 ost->sws_flags, NULL, NULL, NULL);
1212 if (ost->img_resample_ctx == NULL) {
1213 fprintf(stderr, "Cannot get resampling context\n");
1217 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1218 0, ost->resample_height, final_picture->data, final_picture->linesize);
1222 /* duplicates frame if needed */
1223 for(i=0;i<nb_frames;i++) {
1225 av_init_packet(&pkt);
1226 pkt.stream_index= ost->index;
1228 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1229 /* raw pictures are written as AVPicture structure to
1230 avoid any copies. We support temorarily the older
1232 AVFrame* old_frame = enc->coded_frame;
1233 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1234 pkt.data= (uint8_t *)final_picture;
1235 pkt.size= sizeof(AVPicture);
1236 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1237 pkt.flags |= AV_PKT_FLAG_KEY;
1239 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1240 enc->coded_frame = old_frame;
1242 AVFrame big_picture;
1244 big_picture= *final_picture;
1245 /* better than nothing: use input picture interlaced
1247 big_picture.interlaced_frame = in_picture->interlaced_frame;
1248 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1249 if(top_field_first == -1)
1250 big_picture.top_field_first = in_picture->top_field_first;
1252 big_picture.top_field_first = top_field_first;
1255 /* handles sameq here. This is not correct because it may
1256 not be a global option */
1257 big_picture.quality = quality;
1259 big_picture.pict_type = 0;
1260 // big_picture.pts = AV_NOPTS_VALUE;
1261 big_picture.pts= ost->sync_opts;
1262 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1263 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1264 if (ost->forced_kf_index < ost->forced_kf_count &&
1265 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1266 big_picture.pict_type = AV_PICTURE_TYPE_I;
1267 ost->forced_kf_index++;
1269 ret = avcodec_encode_video(enc,
1270 bit_buffer, bit_buffer_size,
1273 fprintf(stderr, "Video encoding failed\n");
1278 pkt.data= bit_buffer;
1280 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1281 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1282 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1283 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1284 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1286 if(enc->coded_frame->key_frame)
1287 pkt.flags |= AV_PKT_FLAG_KEY;
1288 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1291 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1292 // enc->frame_number-1, ret, enc->pict_type);
1293 /* if two pass, output log */
1294 if (ost->logfile && enc->stats_out) {
1295 fprintf(ost->logfile, "%s", enc->stats_out);
1300 ost->frame_number++;
1304 static double psnr(double d){
1305 return -10.0*log(d)/log(10.0);
1308 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1311 AVCodecContext *enc;
1313 double ti1, bitrate, avg_bitrate;
1315 /* this is executed just the first time do_video_stats is called */
1317 vstats_file = fopen(vstats_filename, "w");
1324 enc = ost->st->codec;
1325 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1326 frame_number = ost->frame_number;
1327 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1328 if (enc->flags&CODEC_FLAG_PSNR)
1329 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1331 fprintf(vstats_file,"f_size= %6d ", frame_size);
1332 /* compute pts value */
1333 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1337 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1338 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1339 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1340 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1341 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1345 static void print_report(AVFormatContext **output_files,
1346 OutputStream **ost_table, int nb_ostreams,
1351 AVFormatContext *oc;
1353 AVCodecContext *enc;
1354 int frame_number, vid, i;
1355 double bitrate, ti1, pts;
1356 static int64_t last_time = -1;
1357 static int qp_histogram[52];
1359 if (!is_last_report) {
1361 /* display the report every 0.5 seconds */
1362 cur_time = av_gettime();
1363 if (last_time == -1) {
1364 last_time = cur_time;
1367 if ((cur_time - last_time) < 500000)
1369 last_time = cur_time;
1373 oc = output_files[0];
1375 total_size = avio_size(oc->pb);
1376 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1377 total_size= avio_tell(oc->pb);
1382 for(i=0;i<nb_ostreams;i++) {
1385 enc = ost->st->codec;
1386 if (!ost->st->stream_copy && enc->coded_frame)
1387 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1388 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1391 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1392 float t = (av_gettime()-timer_start) / 1000000.0;
1394 frame_number = ost->frame_number;
1395 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1396 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1398 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1402 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1405 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1407 if (enc->flags&CODEC_FLAG_PSNR){
1409 double error, error_sum=0;
1410 double scale, scale_sum=0;
1411 char type[3]= {'Y','U','V'};
1412 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1415 error= enc->error[j];
1416 scale= enc->width*enc->height*255.0*255.0*frame_number;
1418 error= enc->coded_frame->error[j];
1419 scale= enc->width*enc->height*255.0*255.0;
1424 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1426 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1430 /* compute min output value */
1431 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1432 if ((pts < ti1) && (pts > 0))
1438 if (verbose > 0 || is_last_report) {
1439 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1441 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1442 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1443 (double)total_size / 1024, ti1, bitrate);
1445 if (nb_frames_dup || nb_frames_drop)
1446 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1447 nb_frames_dup, nb_frames_drop);
1450 fprintf(stderr, "%s \r", buf);
1455 if (is_last_report && verbose >= 0){
1456 int64_t raw= audio_size + video_size + extra_size;
1457 fprintf(stderr, "\n");
1458 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1462 100.0*(total_size - raw)/raw
1467 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1469 int fill_char = 0x00;
1470 if (sample_fmt == AV_SAMPLE_FMT_U8)
1472 memset(buf, fill_char, size);
1475 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1476 static int output_packet(InputStream *ist, int ist_index,
1477 OutputStream **ost_table, int nb_ostreams,
1478 const AVPacket *pkt)
1480 AVFormatContext *os;
1485 void *buffer_to_free = NULL;
1486 static unsigned int samples_size= 0;
1487 AVSubtitle subtitle, *subtitle_to_free;
1488 int64_t pkt_pts = AV_NOPTS_VALUE;
1490 int frame_available;
1495 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1497 if(ist->next_pts == AV_NOPTS_VALUE)
1498 ist->next_pts= ist->pts;
1502 av_init_packet(&avpkt);
1510 if(pkt->dts != AV_NOPTS_VALUE)
1511 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1512 if(pkt->pts != AV_NOPTS_VALUE)
1513 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1515 //while we have more to decode or while the decoder did output something on EOF
1516 while (avpkt.size > 0 || (!pkt && got_output)) {
1517 uint8_t *data_buf, *decoded_data_buf;
1518 int data_size, decoded_data_size;
1520 ist->pts= ist->next_pts;
1522 if(avpkt.size && avpkt.size != pkt->size &&
1523 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1524 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1525 ist->showed_multi_packet_warning=1;
1528 /* decode the packet if needed */
1529 decoded_data_buf = NULL; /* fail safe */
1530 decoded_data_size= 0;
1531 data_buf = avpkt.data;
1532 data_size = avpkt.size;
1533 subtitle_to_free = NULL;
1534 if (ist->decoding_needed) {
1535 switch(ist->st->codec->codec_type) {
1536 case AVMEDIA_TYPE_AUDIO:{
1537 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1538 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1540 samples= av_malloc(samples_size);
1542 decoded_data_size= samples_size;
1543 /* XXX: could avoid copy if PCM 16 bits with same
1544 endianness as CPU */
1545 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1552 got_output = decoded_data_size > 0;
1553 /* Some bug in mpeg audio decoder gives */
1554 /* decoded_data_size < 0, it seems they are overflows */
1556 /* no audio frame */
1559 decoded_data_buf = (uint8_t *)samples;
1560 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1561 (ist->st->codec->sample_rate * ist->st->codec->channels);
1563 case AVMEDIA_TYPE_VIDEO:
1564 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1565 /* XXX: allocate picture correctly */
1566 avcodec_get_frame_defaults(&picture);
1567 avpkt.pts = pkt_pts;
1568 avpkt.dts = ist->pts;
1569 pkt_pts = AV_NOPTS_VALUE;
1571 ret = avcodec_decode_video2(ist->st->codec,
1572 &picture, &got_output, &avpkt);
1573 quality = same_quality ? picture.quality : 0;
1577 /* no picture yet */
1578 goto discard_packet;
1580 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1581 if (ist->st->codec->time_base.num != 0) {
1582 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1583 ist->next_pts += ((int64_t)AV_TIME_BASE *
1584 ist->st->codec->time_base.num * ticks) /
1585 ist->st->codec->time_base.den;
1588 buffer_to_free = NULL;
1589 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1591 case AVMEDIA_TYPE_SUBTITLE:
1592 ret = avcodec_decode_subtitle2(ist->st->codec,
1593 &subtitle, &got_output, &avpkt);
1597 goto discard_packet;
1599 subtitle_to_free = &subtitle;
1606 switch(ist->st->codec->codec_type) {
1607 case AVMEDIA_TYPE_AUDIO:
1608 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1609 ist->st->codec->sample_rate;
1611 case AVMEDIA_TYPE_VIDEO:
1612 if (ist->st->codec->time_base.num != 0) {
1613 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1614 ist->next_pts += ((int64_t)AV_TIME_BASE *
1615 ist->st->codec->time_base.num * ticks) /
1616 ist->st->codec->time_base.den;
1625 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1626 for (i = 0; i < nb_ostreams; i++) {
1628 if (ost->input_video_filter && ost->source_index == ist_index) {
1630 if (ist->st->sample_aspect_ratio.num)
1631 sar = ist->st->sample_aspect_ratio;
1633 sar = ist->st->codec->sample_aspect_ratio;
1634 // add it to be filtered
1635 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1643 // preprocess audio (volume)
1644 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1645 if (audio_volume != 256) {
1648 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1649 int v = ((*volp) * audio_volume + 128) >> 8;
1650 if (v < -32768) v = -32768;
1651 if (v > 32767) v = 32767;
1657 /* frame rate emulation */
1659 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1660 int64_t now = av_gettime() - ist->start;
1664 /* if output time reached then transcode raw format,
1665 encode packets and output them */
1666 if (start_time == 0 || ist->pts >= start_time)
1667 for(i=0;i<nb_ostreams;i++) {
1671 if (ost->source_index == ist_index) {
1673 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1674 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1675 while (frame_available) {
1676 AVRational ist_pts_tb;
1677 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1678 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1680 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1682 os = output_files[ost->file_index];
1684 /* set the input output pts pairs */
1685 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1687 if (ost->encoding_needed) {
1688 av_assert0(ist->decoding_needed);
1689 switch(ost->st->codec->codec_type) {
1690 case AVMEDIA_TYPE_AUDIO:
1691 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1693 case AVMEDIA_TYPE_VIDEO:
1695 if (ost->picref->video && !ost->frame_aspect_ratio)
1696 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1698 do_video_out(os, ost, ist, &picture, &frame_size,
1699 same_quality ? quality : ost->st->codec->global_quality);
1700 if (vstats_filename && frame_size)
1701 do_video_stats(os, ost, frame_size);
1703 case AVMEDIA_TYPE_SUBTITLE:
1704 do_subtitle_out(os, ost, ist, &subtitle,
1711 AVFrame avframe; //FIXME/XXX remove this
1713 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1715 av_init_packet(&opkt);
1717 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1718 #if !CONFIG_AVFILTER
1724 /* no reencoding needed : output the packet directly */
1725 /* force the input stream PTS */
1727 avcodec_get_frame_defaults(&avframe);
1728 ost->st->codec->coded_frame= &avframe;
1729 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1731 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1732 audio_size += data_size;
1733 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1734 video_size += data_size;
1738 opkt.stream_index= ost->index;
1739 if(pkt->pts != AV_NOPTS_VALUE)
1740 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1742 opkt.pts= AV_NOPTS_VALUE;
1744 if (pkt->dts == AV_NOPTS_VALUE)
1745 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1747 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1748 opkt.dts -= ost_tb_start_time;
1750 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1751 opkt.flags= pkt->flags;
1753 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1754 if( ost->st->codec->codec_id != CODEC_ID_H264
1755 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1756 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1758 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1759 opkt.destruct= av_destruct_packet;
1761 opkt.data = data_buf;
1762 opkt.size = data_size;
1765 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1766 ost->st->codec->frame_number++;
1767 ost->frame_number++;
1768 av_free_packet(&opkt);
1772 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1773 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1775 avfilter_unref_buffer(ost->picref);
1781 av_free(buffer_to_free);
1782 /* XXX: allocate the subtitles in the codec ? */
1783 if (subtitle_to_free) {
1784 avsubtitle_free(subtitle_to_free);
1785 subtitle_to_free = NULL;
1792 for(i=0;i<nb_ostreams;i++) {
1794 if (ost->source_index == ist_index) {
1795 AVCodecContext *enc= ost->st->codec;
1796 os = output_files[ost->file_index];
1798 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1800 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1803 if (ost->encoding_needed) {
1807 av_init_packet(&pkt);
1808 pkt.stream_index= ost->index;
1810 switch(ost->st->codec->codec_type) {
1811 case AVMEDIA_TYPE_AUDIO:
1812 fifo_bytes = av_fifo_size(ost->fifo);
1814 /* encode any samples remaining in fifo */
1815 if (fifo_bytes > 0) {
1816 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1817 int fs_tmp = enc->frame_size;
1819 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1820 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1821 enc->frame_size = fifo_bytes / (osize * enc->channels);
1823 int frame_bytes = enc->frame_size*osize*enc->channels;
1824 if (allocated_audio_buf_size < frame_bytes)
1826 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1829 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1830 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1831 ost->st->time_base.num, enc->sample_rate);
1832 enc->frame_size = fs_tmp;
1835 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1838 fprintf(stderr, "Audio encoding failed\n");
1842 pkt.flags |= AV_PKT_FLAG_KEY;
1844 case AVMEDIA_TYPE_VIDEO:
1845 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1847 fprintf(stderr, "Video encoding failed\n");
1851 if(enc->coded_frame && enc->coded_frame->key_frame)
1852 pkt.flags |= AV_PKT_FLAG_KEY;
1853 if (ost->logfile && enc->stats_out) {
1854 fprintf(ost->logfile, "%s", enc->stats_out);
1863 pkt.data= bit_buffer;
1865 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1866 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1867 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1877 static void print_sdp(AVFormatContext **avc, int n)
1881 av_sdp_create(avc, n, sdp, sizeof(sdp));
1882 printf("SDP:\n%s\n", sdp);
1886 static int copy_chapters(int infile, int outfile)
1888 AVFormatContext *is = input_files[infile].ctx;
1889 AVFormatContext *os = output_files[outfile];
1892 for (i = 0; i < is->nb_chapters; i++) {
1893 AVChapter *in_ch = is->chapters[i], *out_ch;
1894 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1895 AV_TIME_BASE_Q, in_ch->time_base);
1896 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1897 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1900 if (in_ch->end < ts_off)
1902 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1905 out_ch = av_mallocz(sizeof(AVChapter));
1907 return AVERROR(ENOMEM);
1909 out_ch->id = in_ch->id;
1910 out_ch->time_base = in_ch->time_base;
1911 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1912 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1914 if (metadata_chapters_autocopy)
1915 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1918 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1920 return AVERROR(ENOMEM);
1921 os->chapters[os->nb_chapters - 1] = out_ch;
1926 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1927 AVCodecContext *avctx)
1933 for (p = kf; *p; p++)
1936 ost->forced_kf_count = n;
1937 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1938 if (!ost->forced_kf_pts) {
1939 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1942 for (i = 0; i < n; i++) {
1943 p = i ? strchr(p, ',') + 1 : kf;
1944 t = parse_time_or_die("force_key_frames", p, 1);
1945 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1950 * The following code is the main loop of the file converter
1952 static int transcode(AVFormatContext **output_files,
1953 int nb_output_files,
1954 InputFile *input_files,
1956 StreamMap *stream_maps, int nb_stream_maps)
1958 int ret = 0, i, j, k, n, nb_ostreams = 0;
1959 AVFormatContext *is, *os;
1960 AVCodecContext *codec, *icodec;
1961 OutputStream *ost, **ost_table = NULL;
1965 uint8_t no_packet[MAX_FILES]={0};
1966 int no_packet_count=0;
1969 for (i = 0; i < nb_input_streams; i++)
1970 input_streams[i].start = av_gettime();
1972 /* output stream init */
1974 for(i=0;i<nb_output_files;i++) {
1975 os = output_files[i];
1976 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1977 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1978 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1979 ret = AVERROR(EINVAL);
1982 nb_ostreams += os->nb_streams;
1984 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1985 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1986 ret = AVERROR(EINVAL);
1990 /* Sanity check the mapping args -- do the input files & streams exist? */
1991 for(i=0;i<nb_stream_maps;i++) {
1992 int fi = stream_maps[i].file_index;
1993 int si = stream_maps[i].stream_index;
1995 if (fi < 0 || fi > nb_input_files - 1 ||
1996 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1997 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1998 ret = AVERROR(EINVAL);
2001 fi = stream_maps[i].sync_file_index;
2002 si = stream_maps[i].sync_stream_index;
2003 if (fi < 0 || fi > nb_input_files - 1 ||
2004 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2005 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2006 ret = AVERROR(EINVAL);
2011 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2015 for(k=0;k<nb_output_files;k++) {
2016 os = output_files[k];
2017 for(i=0;i<os->nb_streams;i++,n++) {
2019 ost = ost_table[n] = output_streams_for_file[k][i];
2020 if (nb_stream_maps > 0) {
2021 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2022 stream_maps[n].stream_index;
2024 /* Sanity check that the stream types match */
2025 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2026 int i= ost->file_index;
2027 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2028 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2029 stream_maps[n].file_index, stream_maps[n].stream_index,
2030 ost->file_index, ost->index);
2035 int best_nb_frames=-1;
2036 /* get corresponding input stream index : we select the first one with the right type */
2038 for (j = 0; j < nb_input_streams; j++) {
2040 ist = &input_streams[j];
2043 AVFormatContext *f = input_files[ist->file_index].ctx;
2045 for(pi=0; pi<f->nb_programs; pi++){
2046 AVProgram *p= f->programs[pi];
2047 if(p->id == opt_programid)
2048 for(si=0; si<p->nb_stream_indexes; si++){
2049 if(f->streams[ p->stream_index[si] ] == ist->st)
2054 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2055 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2056 if(best_nb_frames < ist->st->codec_info_nb_frames){
2057 best_nb_frames= ist->st->codec_info_nb_frames;
2058 ost->source_index = j;
2065 if(! opt_programid) {
2066 /* try again and reuse existing stream */
2067 for (j = 0; j < nb_input_streams; j++) {
2068 ist = &input_streams[j];
2069 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2070 && ist->st->discard != AVDISCARD_ALL) {
2071 ost->source_index = j;
2077 int i= ost->file_index;
2078 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2079 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2080 ost->file_index, ost->index);
2085 ist = &input_streams[ost->source_index];
2087 ost->sync_ist = (nb_stream_maps > 0) ?
2088 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2089 stream_maps[n].sync_stream_index] : ist;
2093 /* for each output stream, we compute the right encoding parameters */
2094 for(i=0;i<nb_ostreams;i++) {
2096 os = output_files[ost->file_index];
2097 ist = &input_streams[ost->source_index];
2099 codec = ost->st->codec;
2100 icodec = ist->st->codec;
2102 if (metadata_streams_autocopy)
2103 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2104 AV_DICT_DONT_OVERWRITE);
2106 ost->st->disposition = ist->st->disposition;
2107 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2108 codec->chroma_sample_location = icodec->chroma_sample_location;
2110 if (ost->st->stream_copy) {
2111 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2113 if (extra_size > INT_MAX)
2116 /* if stream_copy is selected, no need to decode or encode */
2117 codec->codec_id = icodec->codec_id;
2118 codec->codec_type = icodec->codec_type;
2120 if(!codec->codec_tag){
2121 if( !os->oformat->codec_tag
2122 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2123 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2124 codec->codec_tag = icodec->codec_tag;
2127 codec->bit_rate = icodec->bit_rate;
2128 codec->rc_max_rate = icodec->rc_max_rate;
2129 codec->rc_buffer_size = icodec->rc_buffer_size;
2130 codec->extradata= av_mallocz(extra_size);
2131 if (!codec->extradata)
2133 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2134 codec->extradata_size= icodec->extradata_size;
2135 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){
2136 codec->time_base = icodec->time_base;
2137 codec->time_base.num *= icodec->ticks_per_frame;
2138 av_reduce(&codec->time_base.num, &codec->time_base.den,
2139 codec->time_base.num, codec->time_base.den, INT_MAX);
2141 codec->time_base = ist->st->time_base;
2142 switch(codec->codec_type) {
2143 case AVMEDIA_TYPE_AUDIO:
2144 if(audio_volume != 256) {
2145 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2148 codec->channel_layout = icodec->channel_layout;
2149 codec->sample_rate = icodec->sample_rate;
2150 codec->channels = icodec->channels;
2151 codec->frame_size = icodec->frame_size;
2152 codec->audio_service_type = icodec->audio_service_type;
2153 codec->block_align= icodec->block_align;
2154 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2155 codec->block_align= 0;
2156 if(codec->codec_id == CODEC_ID_AC3)
2157 codec->block_align= 0;
2159 case AVMEDIA_TYPE_VIDEO:
2160 codec->pix_fmt = icodec->pix_fmt;
2161 codec->width = icodec->width;
2162 codec->height = icodec->height;
2163 codec->has_b_frames = icodec->has_b_frames;
2164 if (!codec->sample_aspect_ratio.num) {
2165 codec->sample_aspect_ratio =
2166 ost->st->sample_aspect_ratio =
2167 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2168 ist->st->codec->sample_aspect_ratio.num ?
2169 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2172 case AVMEDIA_TYPE_SUBTITLE:
2173 codec->width = icodec->width;
2174 codec->height = icodec->height;
2176 case AVMEDIA_TYPE_DATA:
2183 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2184 switch(codec->codec_type) {
2185 case AVMEDIA_TYPE_AUDIO:
2186 ost->fifo= av_fifo_alloc(1024);
2189 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2190 if (!codec->sample_rate) {
2191 codec->sample_rate = icodec->sample_rate;
2193 codec->sample_rate >>= icodec->lowres;
2195 choose_sample_rate(ost->st, ost->enc);
2196 codec->time_base = (AVRational){1, codec->sample_rate};
2197 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2198 codec->sample_fmt = icodec->sample_fmt;
2199 choose_sample_fmt(ost->st, ost->enc);
2200 if (!codec->channels)
2201 codec->channels = icodec->channels;
2202 codec->channel_layout = icodec->channel_layout;
2203 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2204 codec->channel_layout = 0;
2205 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2206 icodec->request_channels = codec->channels;
2207 ist->decoding_needed = 1;
2208 ost->encoding_needed = 1;
2209 ost->resample_sample_fmt = icodec->sample_fmt;
2210 ost->resample_sample_rate = icodec->sample_rate;
2211 ost->resample_channels = icodec->channels;
2213 case AVMEDIA_TYPE_VIDEO:
2214 if (codec->pix_fmt == PIX_FMT_NONE)
2215 codec->pix_fmt = icodec->pix_fmt;
2216 choose_pixel_fmt(ost->st, ost->enc);
2218 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2219 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2223 if (!codec->width || !codec->height) {
2224 codec->width = icodec->width;
2225 codec->height = icodec->height;
2228 ost->video_resample = codec->width != icodec->width ||
2229 codec->height != icodec->height ||
2230 codec->pix_fmt != icodec->pix_fmt;
2231 if (ost->video_resample) {
2232 #if !CONFIG_AVFILTER
2233 avcodec_get_frame_defaults(&ost->pict_tmp);
2234 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2235 codec->width, codec->height)) {
2236 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2239 ost->img_resample_ctx = sws_getContext(
2246 ost->sws_flags, NULL, NULL, NULL);
2247 if (ost->img_resample_ctx == NULL) {
2248 fprintf(stderr, "Cannot get resampling context\n");
2252 codec->bits_per_raw_sample= 0;
2255 ost->resample_height = icodec->height;
2256 ost->resample_width = icodec->width;
2257 ost->resample_pix_fmt= icodec->pix_fmt;
2258 ost->encoding_needed = 1;
2259 ist->decoding_needed = 1;
2261 if (!ost->frame_rate.num)
2262 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2263 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2264 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2265 ost->frame_rate = ost->enc->supported_framerates[idx];
2267 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2270 if (configure_video_filters(ist, ost)) {
2271 fprintf(stderr, "Error opening filters!\n");
2276 case AVMEDIA_TYPE_SUBTITLE:
2277 ost->encoding_needed = 1;
2278 ist->decoding_needed = 1;
2285 if (ost->encoding_needed &&
2286 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2287 char logfilename[1024];
2290 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2291 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2293 if (codec->flags & CODEC_FLAG_PASS1) {
2294 f = fopen(logfilename, "wb");
2296 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2302 size_t logbuffer_size;
2303 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2304 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2307 codec->stats_in = logbuffer;
2311 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2312 int size= codec->width * codec->height;
2313 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2318 bit_buffer = av_malloc(bit_buffer_size);
2320 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2322 ret = AVERROR(ENOMEM);
2326 /* open each encoder */
2327 for(i=0;i<nb_ostreams;i++) {
2329 if (ost->encoding_needed) {
2330 AVCodec *codec = ost->enc;
2331 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2333 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2334 ost->st->codec->codec_id, ost->file_index, ost->index);
2335 ret = AVERROR(EINVAL);
2338 if (dec->subtitle_header) {
2339 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2340 if (!ost->st->codec->subtitle_header) {
2341 ret = AVERROR(ENOMEM);
2344 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2345 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2347 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2348 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2349 ost->file_index, ost->index);
2350 ret = AVERROR(EINVAL);
2353 assert_codec_experimental(ost->st->codec, 1);
2354 assert_avoptions(ost->opts);
2355 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2356 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2357 "It takes bits/s as argument, not kbits/s\n");
2358 extra_size += ost->st->codec->extradata_size;
2362 /* open each decoder */
2363 for (i = 0; i < nb_input_streams; i++) {
2364 ist = &input_streams[i];
2365 if (ist->decoding_needed) {
2366 AVCodec *codec = ist->dec;
2368 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2370 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2371 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2372 ret = AVERROR(EINVAL);
2376 /* update requested sample format for the decoder based on the
2377 corresponding encoder sample format */
2378 for (j = 0; j < nb_ostreams; j++) {
2380 if (ost->source_index == i) {
2381 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2386 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2387 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2388 ist->file_index, ist->st->index);
2389 ret = AVERROR(EINVAL);
2392 assert_codec_experimental(ist->st->codec, 0);
2393 assert_avoptions(ost->opts);
2398 for (i = 0; i < nb_input_streams; i++) {
2400 ist = &input_streams[i];
2402 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2403 ist->next_pts = AV_NOPTS_VALUE;
2404 init_pts_correction(&ist->pts_ctx);
2408 /* set meta data information from input file if required */
2409 for (i=0;i<nb_meta_data_maps;i++) {
2410 AVFormatContext *files[2];
2411 AVDictionary **meta[2];
2414 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2415 if ((index) < 0 || (index) >= (nb_elems)) {\
2416 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2418 ret = AVERROR(EINVAL);\
2422 int out_file_index = meta_data_maps[i][0].file;
2423 int in_file_index = meta_data_maps[i][1].file;
2424 if (in_file_index < 0 || out_file_index < 0)
2426 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2427 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2429 files[0] = output_files[out_file_index];
2430 files[1] = input_files[in_file_index].ctx;
2432 for (j = 0; j < 2; j++) {
2433 MetadataMap *map = &meta_data_maps[i][j];
2435 switch (map->type) {
2437 meta[j] = &files[j]->metadata;
2440 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2441 meta[j] = &files[j]->streams[map->index]->metadata;
2444 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2445 meta[j] = &files[j]->chapters[map->index]->metadata;
2448 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2449 meta[j] = &files[j]->programs[map->index]->metadata;
2454 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2457 /* copy global metadata by default */
2458 if (metadata_global_autocopy) {
2460 for (i = 0; i < nb_output_files; i++)
2461 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2462 AV_DICT_DONT_OVERWRITE);
2465 /* copy chapters according to chapter maps */
2466 for (i = 0; i < nb_chapter_maps; i++) {
2467 int infile = chapter_maps[i].in_file;
2468 int outfile = chapter_maps[i].out_file;
2470 if (infile < 0 || outfile < 0)
2472 if (infile >= nb_input_files) {
2473 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2474 ret = AVERROR(EINVAL);
2477 if (outfile >= nb_output_files) {
2478 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2479 ret = AVERROR(EINVAL);
2482 copy_chapters(infile, outfile);
2485 /* copy chapters from the first input file that has them*/
2486 if (!nb_chapter_maps)
2487 for (i = 0; i < nb_input_files; i++) {
2488 if (!input_files[i].ctx->nb_chapters)
2491 for (j = 0; j < nb_output_files; j++)
2492 if ((ret = copy_chapters(i, j)) < 0)
2497 /* open files and write file headers */
2498 for(i=0;i<nb_output_files;i++) {
2499 os = output_files[i];
2500 if (avformat_write_header(os, &output_opts[i]) < 0) {
2501 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2502 ret = AVERROR(EINVAL);
2505 assert_avoptions(output_opts[i]);
2506 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2512 /* dump the file output parameters - cannot be done before in case
2514 for(i=0;i<nb_output_files;i++) {
2515 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2518 /* dump the stream mapping */
2520 fprintf(stderr, "Stream mapping:\n");
2521 for(i=0;i<nb_ostreams;i++) {
2523 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2524 input_streams[ost->source_index].file_index,
2525 input_streams[ost->source_index].st->index,
2528 if (ost->sync_ist != &input_streams[ost->source_index])
2529 fprintf(stderr, " [sync #%d.%d]",
2530 ost->sync_ist->file_index,
2531 ost->sync_ist->st->index);
2532 fprintf(stderr, "\n");
2537 fprintf(stderr, "%s\n", error);
2542 print_sdp(output_files, nb_output_files);
2546 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2549 timer_start = av_gettime();
2551 for(; received_sigterm == 0;) {
2552 int file_index, ist_index;
2561 /* select the stream that we must read now by looking at the
2562 smallest output pts */
2564 for(i=0;i<nb_ostreams;i++) {
2567 os = output_files[ost->file_index];
2568 ist = &input_streams[ost->source_index];
2569 if(ist->is_past_recording_time || no_packet[ist->file_index])
2571 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2572 ipts = (double)ist->pts;
2573 if (!input_files[ist->file_index].eof_reached){
2574 if(ipts < ipts_min) {
2576 if(input_sync ) file_index = ist->file_index;
2578 if(opts < opts_min) {
2580 if(!input_sync) file_index = ist->file_index;
2583 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2588 /* if none, if is finished */
2589 if (file_index < 0) {
2590 if(no_packet_count){
2592 memset(no_packet, 0, sizeof(no_packet));
2599 /* finish if limit size exhausted */
2600 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2603 /* read a frame from it and output it in the fifo */
2604 is = input_files[file_index].ctx;
2605 ret= av_read_frame(is, &pkt);
2606 if(ret == AVERROR(EAGAIN)){
2607 no_packet[file_index]=1;
2612 input_files[file_index].eof_reached = 1;
2620 memset(no_packet, 0, sizeof(no_packet));
2623 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2624 is->streams[pkt.stream_index]);
2626 /* the following test is needed in case new streams appear
2627 dynamically in stream : we ignore them */
2628 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2629 goto discard_packet;
2630 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2631 ist = &input_streams[ist_index];
2633 goto discard_packet;
2635 if (pkt.dts != AV_NOPTS_VALUE)
2636 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2637 if (pkt.pts != AV_NOPTS_VALUE)
2638 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2640 if (ist->ts_scale) {
2641 if(pkt.pts != AV_NOPTS_VALUE)
2642 pkt.pts *= ist->ts_scale;
2643 if(pkt.dts != AV_NOPTS_VALUE)
2644 pkt.dts *= ist->ts_scale;
2647 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2648 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2649 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2650 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2651 int64_t delta= pkt_dts - ist->next_pts;
2652 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2653 input_files[ist->file_index].ts_offset -= delta;
2655 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2656 delta, input_files[ist->file_index].ts_offset);
2657 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2658 if(pkt.pts != AV_NOPTS_VALUE)
2659 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2663 /* finish if recording time exhausted */
2664 if (recording_time != INT64_MAX &&
2665 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2666 ist->is_past_recording_time = 1;
2667 goto discard_packet;
2670 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2671 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2674 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2675 ist->file_index, ist->st->index);
2678 av_free_packet(&pkt);
2683 av_free_packet(&pkt);
2685 /* dump report by using the output first video and audio streams */
2686 print_report(output_files, ost_table, nb_ostreams, 0);
2689 /* at the end of stream, we must flush the decoder buffers */
2690 for (i = 0; i < nb_input_streams; i++) {
2691 ist = &input_streams[i];
2692 if (ist->decoding_needed) {
2693 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2699 /* write the trailer if needed and close file */
2700 for(i=0;i<nb_output_files;i++) {
2701 os = output_files[i];
2702 av_write_trailer(os);
2705 /* dump report by using the first video and audio streams */
2706 print_report(output_files, ost_table, nb_ostreams, 1);
2708 /* close each encoder */
2709 for(i=0;i<nb_ostreams;i++) {
2711 if (ost->encoding_needed) {
2712 av_freep(&ost->st->codec->stats_in);
2713 avcodec_close(ost->st->codec);
2716 avfilter_graph_free(&ost->graph);
2720 /* close each decoder */
2721 for (i = 0; i < nb_input_streams; i++) {
2722 ist = &input_streams[i];
2723 if (ist->decoding_needed) {
2724 avcodec_close(ist->st->codec);
2732 av_freep(&bit_buffer);
2735 for(i=0;i<nb_ostreams;i++) {
2738 if (ost->st->stream_copy)
2739 av_freep(&ost->st->codec->extradata);
2741 fclose(ost->logfile);
2742 ost->logfile = NULL;
2744 av_fifo_free(ost->fifo); /* works even if fifo is not
2745 initialized but set to zero */
2746 av_freep(&ost->st->codec->subtitle_header);
2747 av_free(ost->pict_tmp.data[0]);
2748 av_free(ost->forced_kf_pts);
2749 if (ost->video_resample)
2750 sws_freeContext(ost->img_resample_ctx);
2752 audio_resample_close(ost->resample);
2753 if (ost->reformat_ctx)
2754 av_audio_convert_free(ost->reformat_ctx);
2755 av_dict_free(&ost->opts);
2764 static int opt_format(const char *opt, const char *arg)
2766 last_asked_format = arg;
2770 static int opt_video_rc_override_string(const char *opt, const char *arg)
2772 video_rc_override_string = arg;
2776 static int opt_me_threshold(const char *opt, const char *arg)
2778 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2782 static int opt_verbose(const char *opt, const char *arg)
2784 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2788 static int opt_frame_rate(const char *opt, const char *arg)
2790 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2791 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2797 static int opt_frame_crop(const char *opt, const char *arg)
2799 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2800 return AVERROR(EINVAL);
2803 static int opt_frame_size(const char *opt, const char *arg)
2805 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2806 fprintf(stderr, "Incorrect frame size\n");
2807 return AVERROR(EINVAL);
2812 static int opt_pad(const char *opt, const char *arg) {
2813 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2817 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2819 if (strcmp(arg, "list")) {
2820 frame_pix_fmt = av_get_pix_fmt(arg);
2821 if (frame_pix_fmt == PIX_FMT_NONE) {
2822 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2823 return AVERROR(EINVAL);
2832 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2839 p = strchr(arg, ':');
2841 x = strtol(arg, &end, 10);
2843 y = strtol(end+1, &end, 10);
2845 ar = (double)x / (double)y;
2847 ar = strtod(arg, NULL);
2850 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2851 return AVERROR(EINVAL);
2853 frame_aspect_ratio = ar;
2857 static int opt_metadata(const char *opt, const char *arg)
2859 char *mid= strchr(arg, '=');
2862 fprintf(stderr, "Missing =\n");
2867 av_dict_set(&metadata, arg, mid, 0);
2872 static int opt_qscale(const char *opt, const char *arg)
2874 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2875 if (video_qscale == 0) {
2876 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2877 return AVERROR(EINVAL);
2882 static int opt_top_field_first(const char *opt, const char *arg)
2884 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2888 static int opt_thread_count(const char *opt, const char *arg)
2890 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2893 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2898 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2900 if (strcmp(arg, "list")) {
2901 audio_sample_fmt = av_get_sample_fmt(arg);
2902 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2903 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2904 return AVERROR(EINVAL);
2909 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2910 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2916 static int opt_audio_rate(const char *opt, const char *arg)
2918 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2922 static int opt_audio_channels(const char *opt, const char *arg)
2924 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2928 static int opt_video_channel(const char *opt, const char *arg)
2930 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2931 opt_default("channel", arg);
2935 static int opt_video_standard(const char *opt, const char *arg)
2937 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2938 opt_default("standard", arg);
2942 static int opt_codec(int *pstream_copy, char **pcodec_name,
2943 int codec_type, const char *arg)
2945 av_freep(pcodec_name);
2946 if (!strcmp(arg, "copy")) {
2949 *pcodec_name = av_strdup(arg);
2954 static int opt_audio_codec(const char *opt, const char *arg)
2956 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2959 static int opt_video_codec(const char *opt, const char *arg)
2961 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2964 static int opt_subtitle_codec(const char *opt, const char *arg)
2966 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2969 static int opt_data_codec(const char *opt, const char *arg)
2971 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2974 static int opt_codec_tag(const char *opt, const char *arg)
2977 uint32_t *codec_tag;
2979 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2980 !strcmp(opt, "vtag") ? &video_codec_tag :
2981 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2985 *codec_tag = strtol(arg, &tail, 0);
2987 *codec_tag = AV_RL32(arg);
2992 static int opt_map(const char *opt, const char *arg)
2997 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2998 m = &stream_maps[nb_stream_maps-1];
3000 m->file_index = strtol(arg, &p, 0);
3004 m->stream_index = strtol(p, &p, 0);
3007 m->sync_file_index = strtol(p, &p, 0);
3010 m->sync_stream_index = strtol(p, &p, 0);
3012 m->sync_file_index = m->file_index;
3013 m->sync_stream_index = m->stream_index;
3018 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3029 *index = strtol(++arg, endptr, 0);
3032 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3039 static int opt_map_metadata(const char *opt, const char *arg)
3041 MetadataMap *m, *m1;
3044 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3045 &nb_meta_data_maps, nb_meta_data_maps + 1);
3047 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3048 m->file = strtol(arg, &p, 0);
3049 parse_meta_type(p, &m->type, &m->index, &p);
3053 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3054 m1->file = strtol(p, &p, 0);
3055 parse_meta_type(p, &m1->type, &m1->index, &p);
3057 if (m->type == 'g' || m1->type == 'g')
3058 metadata_global_autocopy = 0;
3059 if (m->type == 's' || m1->type == 's')
3060 metadata_streams_autocopy = 0;
3061 if (m->type == 'c' || m1->type == 'c')
3062 metadata_chapters_autocopy = 0;
3067 static int opt_map_meta_data(const char *opt, const char *arg)
3069 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3070 "Use -map_metadata instead.\n");
3071 return opt_map_metadata(opt, arg);
3074 static int opt_map_chapters(const char *opt, const char *arg)
3079 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3080 nb_chapter_maps + 1);
3081 c = &chapter_maps[nb_chapter_maps - 1];
3082 c->out_file = strtol(arg, &p, 0);
3086 c->in_file = strtol(p, &p, 0);
3090 static int opt_input_ts_scale(const char *opt, const char *arg)
3092 unsigned int stream;
3096 stream = strtol(arg, &p, 0);
3099 scale= strtod(p, &p);
3101 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3102 ts_scale[stream] = scale;
3106 static int opt_recording_time(const char *opt, const char *arg)
3108 recording_time = parse_time_or_die(opt, arg, 1);
3112 static int opt_start_time(const char *opt, const char *arg)
3114 start_time = parse_time_or_die(opt, arg, 1);
3118 static int opt_recording_timestamp(const char *opt, const char *arg)
3121 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3122 struct tm time = *gmtime((time_t*)&recording_timestamp);
3123 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3124 opt_metadata("metadata", buf);
3126 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3127 "tag instead.\n", opt);
3131 static int opt_input_ts_offset(const char *opt, const char *arg)
3133 input_ts_offset = parse_time_or_die(opt, arg, 1);
3137 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3139 const char *codec_string = encoder ? "encoder" : "decoder";
3143 return CODEC_ID_NONE;
3145 avcodec_find_encoder_by_name(name) :
3146 avcodec_find_decoder_by_name(name);
3148 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3151 if(codec->type != type) {
3152 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3158 static int opt_input_file(const char *opt, const char *filename)
3160 AVFormatContext *ic;
3161 AVInputFormat *file_iformat = NULL;
3162 int err, i, ret, rfps, rfps_base;
3165 AVDictionary **opts;
3166 int orig_nb_streams; // number of streams before avformat_find_stream_info
3168 if (last_asked_format) {
3169 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3170 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3173 last_asked_format = NULL;
3176 if (!strcmp(filename, "-"))
3179 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3180 !strcmp(filename, "/dev/stdin");
3182 /* get default parameters from command line */
3183 ic = avformat_alloc_context();
3185 print_error(filename, AVERROR(ENOMEM));
3188 if (audio_sample_rate) {
3189 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3190 av_dict_set(&format_opts, "sample_rate", buf, 0);
3192 if (audio_channels) {
3193 snprintf(buf, sizeof(buf), "%d", audio_channels);
3194 av_dict_set(&format_opts, "channels", buf, 0);
3196 if (frame_rate.num) {
3197 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3198 av_dict_set(&format_opts, "framerate", buf, 0);
3200 if (frame_width && frame_height) {
3201 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3202 av_dict_set(&format_opts, "video_size", buf, 0);
3204 if (frame_pix_fmt != PIX_FMT_NONE)
3205 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3207 ic->video_codec_id =
3208 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3209 ic->audio_codec_id =
3210 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3211 ic->subtitle_codec_id=
3212 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3213 ic->flags |= AVFMT_FLAG_NONBLOCK;
3215 /* open the input file with generic libav function */
3216 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3218 print_error(filename, err);
3221 assert_avoptions(format_opts);
3226 for(i=0; i<ic->nb_streams; i++){
3227 ic->streams[i]->discard= AVDISCARD_ALL;
3229 for(i=0; i<ic->nb_programs; i++){
3230 AVProgram *p= ic->programs[i];
3231 if(p->id != opt_programid){
3232 p->discard = AVDISCARD_ALL;
3235 for(j=0; j<p->nb_stream_indexes; j++){
3236 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3241 fprintf(stderr, "Specified program id not found\n");
3248 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3249 ic->loop_input = loop_input;
3252 /* Set AVCodecContext options for avformat_find_stream_info */
3253 opts = setup_find_stream_info_opts(ic, codec_opts);
3254 orig_nb_streams = ic->nb_streams;
3256 /* If not enough info to get the stream parameters, we decode the
3257 first frames to get it. (used in mpeg case for example) */
3258 ret = avformat_find_stream_info(ic, opts);
3259 if (ret < 0 && verbose >= 0) {
3260 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3261 av_close_input_file(ic);
3265 timestamp = start_time;
3266 /* add the stream start time */
3267 if (ic->start_time != AV_NOPTS_VALUE)
3268 timestamp += ic->start_time;
3270 /* if seeking requested, we execute it */
3271 if (start_time != 0) {
3272 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3274 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3275 filename, (double)timestamp / AV_TIME_BASE);
3277 /* reset seek info */
3281 /* update the current parameters so that they match the one of the input stream */
3282 for(i=0;i<ic->nb_streams;i++) {
3283 AVStream *st = ic->streams[i];
3284 AVCodecContext *dec = st->codec;
3287 dec->thread_count = thread_count;
3289 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3290 ist = &input_streams[nb_input_streams - 1];
3292 ist->file_index = nb_input_files;
3294 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3296 if (i < nb_ts_scale)
3297 ist->ts_scale = ts_scale[i];
3299 switch (dec->codec_type) {
3300 case AVMEDIA_TYPE_AUDIO:
3301 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3303 st->discard= AVDISCARD_ALL;
3305 case AVMEDIA_TYPE_VIDEO:
3306 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3307 rfps = ic->streams[i]->r_frame_rate.num;
3308 rfps_base = ic->streams[i]->r_frame_rate.den;
3310 dec->flags |= CODEC_FLAG_EMU_EDGE;
3311 dec->height >>= dec->lowres;
3312 dec->width >>= dec->lowres;
3315 dec->debug |= FF_DEBUG_MV;
3317 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3320 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3321 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3323 (float)rfps / rfps_base, rfps, rfps_base);
3327 st->discard= AVDISCARD_ALL;
3328 else if(video_discard)
3329 st->discard= video_discard;
3331 case AVMEDIA_TYPE_DATA:
3333 case AVMEDIA_TYPE_SUBTITLE:
3334 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3335 if(subtitle_disable)
3336 st->discard = AVDISCARD_ALL;
3338 case AVMEDIA_TYPE_ATTACHMENT:
3339 case AVMEDIA_TYPE_UNKNOWN:
3346 /* dump the file content */
3348 av_dump_format(ic, nb_input_files, filename, 0);
3350 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3351 input_files[nb_input_files - 1].ctx = ic;
3352 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3353 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3355 frame_rate = (AVRational){0, 0};
3356 frame_pix_fmt = PIX_FMT_NONE;
3359 audio_sample_rate = 0;
3361 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3362 av_freep(&ts_scale);
3365 for (i = 0; i < orig_nb_streams; i++)
3366 av_dict_free(&opts[i]);
3368 av_freep(&video_codec_name);
3369 av_freep(&audio_codec_name);
3370 av_freep(&subtitle_codec_name);
3376 static void check_inputs(int *has_video_ptr,
3378 int *has_subtitle_ptr,
3381 int has_video, has_audio, has_subtitle, has_data, i, j;
3382 AVFormatContext *ic;
3389 for(j=0;j<nb_input_files;j++) {
3390 ic = input_files[j].ctx;
3391 for(i=0;i<ic->nb_streams;i++) {
3392 AVCodecContext *enc = ic->streams[i]->codec;
3393 switch(enc->codec_type) {
3394 case AVMEDIA_TYPE_AUDIO:
3397 case AVMEDIA_TYPE_VIDEO:
3400 case AVMEDIA_TYPE_SUBTITLE:
3403 case AVMEDIA_TYPE_DATA:
3404 case AVMEDIA_TYPE_ATTACHMENT:
3405 case AVMEDIA_TYPE_UNKNOWN:
3413 *has_video_ptr = has_video;
3414 *has_audio_ptr = has_audio;
3415 *has_subtitle_ptr = has_subtitle;
3416 *has_data_ptr = has_data;
3419 static void new_video_stream(AVFormatContext *oc, int file_idx)
3423 AVCodecContext *video_enc;
3424 enum CodecID codec_id = CODEC_ID_NONE;
3425 AVCodec *codec= NULL;
3427 if(!video_stream_copy){
3428 if (video_codec_name) {
3429 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3430 codec = avcodec_find_encoder_by_name(video_codec_name);
3432 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3433 codec = avcodec_find_encoder(codec_id);
3437 ost = new_output_stream(oc, file_idx, codec);
3439 if (!video_stream_copy) {
3440 ost->frame_aspect_ratio = frame_aspect_ratio;
3441 frame_aspect_ratio = 0;
3443 ost->avfilter= vfilters;
3448 ost->bitstream_filters = video_bitstream_filters;
3449 video_bitstream_filters= NULL;
3451 st->codec->thread_count= thread_count;
3453 video_enc = st->codec;
3456 video_enc->codec_tag= video_codec_tag;
3458 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3459 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3462 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3463 if (video_stream_copy) {
3464 st->stream_copy = 1;
3465 video_enc->sample_aspect_ratio =
3466 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3472 ost->frame_rate = frame_rate;
3473 video_enc->codec_id = codec_id;
3475 video_enc->width = frame_width;
3476 video_enc->height = frame_height;
3477 video_enc->pix_fmt = frame_pix_fmt;
3478 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3481 video_enc->gop_size = 0;
3482 if (video_qscale || same_quality) {
3483 video_enc->flags |= CODEC_FLAG_QSCALE;
3484 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3488 video_enc->intra_matrix = intra_matrix;
3490 video_enc->inter_matrix = inter_matrix;
3492 p= video_rc_override_string;
3495 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3497 fprintf(stderr, "error parsing rc_override\n");
3500 video_enc->rc_override=
3501 av_realloc(video_enc->rc_override,
3502 sizeof(RcOverride)*(i+1));
3503 video_enc->rc_override[i].start_frame= start;
3504 video_enc->rc_override[i].end_frame = end;
3506 video_enc->rc_override[i].qscale= q;
3507 video_enc->rc_override[i].quality_factor= 1.0;
3510 video_enc->rc_override[i].qscale= 0;
3511 video_enc->rc_override[i].quality_factor= -q/100.0;
3516 video_enc->rc_override_count=i;
3517 if (!video_enc->rc_initial_buffer_occupancy)
3518 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3519 video_enc->me_threshold= me_threshold;
3520 video_enc->intra_dc_precision= intra_dc_precision - 8;
3523 video_enc->flags|= CODEC_FLAG_PSNR;
3528 video_enc->flags |= CODEC_FLAG_PASS1;
3530 video_enc->flags |= CODEC_FLAG_PASS2;
3534 if (forced_key_frames)
3535 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3537 if (video_language) {
3538 av_dict_set(&st->metadata, "language", video_language, 0);
3539 av_freep(&video_language);
3542 /* reset some key parameters */
3544 av_freep(&video_codec_name);
3545 av_freep(&forced_key_frames);
3546 video_stream_copy = 0;
3547 frame_pix_fmt = PIX_FMT_NONE;
3550 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3554 AVCodec *codec= NULL;
3555 AVCodecContext *audio_enc;
3556 enum CodecID codec_id = CODEC_ID_NONE;
3558 if(!audio_stream_copy){
3559 if (audio_codec_name) {
3560 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3561 codec = avcodec_find_encoder_by_name(audio_codec_name);
3563 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3564 codec = avcodec_find_encoder(codec_id);
3567 ost = new_output_stream(oc, file_idx, codec);
3570 ost->bitstream_filters = audio_bitstream_filters;
3571 audio_bitstream_filters= NULL;
3573 st->codec->thread_count= thread_count;
3575 audio_enc = st->codec;
3576 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3579 audio_enc->codec_tag= audio_codec_tag;
3581 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3582 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3584 if (audio_stream_copy) {
3585 st->stream_copy = 1;
3587 audio_enc->codec_id = codec_id;
3589 if (audio_qscale > QSCALE_NONE) {
3590 audio_enc->flags |= CODEC_FLAG_QSCALE;
3591 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3594 audio_enc->channels = audio_channels;
3595 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3596 audio_enc->sample_fmt = audio_sample_fmt;
3597 if (audio_sample_rate)
3598 audio_enc->sample_rate = audio_sample_rate;
3600 if (audio_language) {
3601 av_dict_set(&st->metadata, "language", audio_language, 0);
3602 av_freep(&audio_language);
3605 /* reset some key parameters */
3607 av_freep(&audio_codec_name);
3608 audio_stream_copy = 0;
3611 static void new_data_stream(AVFormatContext *oc, int file_idx)
3615 AVCodecContext *data_enc;
3617 ost = new_output_stream(oc, file_idx, NULL);
3619 data_enc = st->codec;
3620 if (!data_stream_copy) {
3621 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3625 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3628 data_enc->codec_tag= data_codec_tag;
3630 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3631 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3633 if (data_stream_copy) {
3634 st->stream_copy = 1;
3638 av_freep(&data_codec_name);
3639 data_stream_copy = 0;
3642 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3646 AVCodec *codec=NULL;
3647 AVCodecContext *subtitle_enc;
3648 enum CodecID codec_id = CODEC_ID_NONE;
3650 if(!subtitle_stream_copy){
3651 if (subtitle_codec_name) {
3652 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3653 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3655 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3656 codec = avcodec_find_encoder(codec_id);
3659 ost = new_output_stream(oc, file_idx, codec);
3661 subtitle_enc = st->codec;
3663 ost->bitstream_filters = subtitle_bitstream_filters;
3664 subtitle_bitstream_filters= NULL;
3666 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3668 if(subtitle_codec_tag)
3669 subtitle_enc->codec_tag= subtitle_codec_tag;
3671 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3672 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3674 if (subtitle_stream_copy) {
3675 st->stream_copy = 1;
3677 subtitle_enc->codec_id = codec_id;
3680 if (subtitle_language) {
3681 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3682 av_freep(&subtitle_language);
3685 subtitle_disable = 0;
3686 av_freep(&subtitle_codec_name);
3687 subtitle_stream_copy = 0;
3690 static int opt_new_stream(const char *opt, const char *arg)
3692 AVFormatContext *oc;
3693 int file_idx = nb_output_files - 1;
3694 if (nb_output_files <= 0) {
3695 fprintf(stderr, "At least one output file must be specified\n");
3698 oc = output_files[file_idx];
3700 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3701 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3702 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3703 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3708 /* arg format is "output-stream-index:streamid-value". */
3709 static int opt_streamid(const char *opt, const char *arg)
3715 av_strlcpy(idx_str, arg, sizeof(idx_str));
3716 p = strchr(idx_str, ':');
3719 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3724 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3725 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3726 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3730 static void opt_output_file(const char *filename)
3732 AVFormatContext *oc;
3733 int err, use_video, use_audio, use_subtitle, use_data;
3734 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3735 AVOutputFormat *file_oformat;
3737 if (!strcmp(filename, "-"))
3740 oc = avformat_alloc_context();
3742 print_error(filename, AVERROR(ENOMEM));
3746 if (last_asked_format) {
3747 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3748 if (!file_oformat) {
3749 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3752 last_asked_format = NULL;
3754 file_oformat = av_guess_format(NULL, filename, NULL);
3755 if (!file_oformat) {
3756 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3762 oc->oformat = file_oformat;
3763 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3765 if (!strcmp(file_oformat->name, "ffm") &&
3766 av_strstart(filename, "http:", NULL)) {
3767 /* special case for files sent to avserver: we get the stream
3768 parameters from avserver */
3769 int err = read_avserver_streams(oc, filename);
3771 print_error(filename, err);
3775 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3776 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3777 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3778 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 */
3780 /* disable if no corresponding type found */
3781 check_inputs(&input_has_video,
3783 &input_has_subtitle,
3786 if (!input_has_video)
3788 if (!input_has_audio)
3790 if (!input_has_subtitle)
3792 if (!input_has_data)
3795 /* manual disable */
3796 if (audio_disable) use_audio = 0;
3797 if (video_disable) use_video = 0;
3798 if (subtitle_disable) use_subtitle = 0;
3799 if (data_disable) use_data = 0;
3801 if (use_video) new_video_stream(oc, nb_output_files);
3802 if (use_audio) new_audio_stream(oc, nb_output_files);
3803 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3804 if (use_data) new_data_stream(oc, nb_output_files);
3806 av_dict_copy(&oc->metadata, metadata, 0);
3807 av_dict_free(&metadata);
3810 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3811 output_files[nb_output_files++] = oc;
3813 /* check filename in case of an image number is expected */
3814 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3815 if (!av_filename_number_test(oc->filename)) {
3816 print_error(oc->filename, AVERROR(EINVAL));
3821 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3822 /* test if it already exists to avoid loosing precious files */
3823 if (!file_overwrite &&
3824 (strchr(filename, ':') == NULL ||
3825 filename[1] == ':' ||
3826 av_strstart(filename, "file:", NULL))) {
3827 if (avio_check(filename, 0) == 0) {
3829 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3831 if (!read_yesno()) {
3832 fprintf(stderr, "Not overwriting - exiting\n");
3837 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3844 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3845 print_error(filename, err);
3850 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3851 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3852 if (loop_output >= 0) {
3853 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3854 oc->loop_output = loop_output;
3856 oc->flags |= AVFMT_FLAG_NONBLOCK;
3858 frame_rate = (AVRational){0, 0};
3861 audio_sample_rate = 0;
3863 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3865 av_freep(&forced_key_frames);
3870 /* same option as mencoder */
3871 static int opt_pass(const char *opt, const char *arg)
3873 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3877 static int64_t getutime(void)
3880 struct rusage rusage;
3882 getrusage(RUSAGE_SELF, &rusage);
3883 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3884 #elif HAVE_GETPROCESSTIMES
3886 FILETIME c, e, k, u;
3887 proc = GetCurrentProcess();
3888 GetProcessTimes(proc, &c, &e, &k, &u);
3889 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3891 return av_gettime();
3895 static int64_t getmaxrss(void)
3897 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3898 struct rusage rusage;
3899 getrusage(RUSAGE_SELF, &rusage);
3900 return (int64_t)rusage.ru_maxrss * 1024;
3901 #elif HAVE_GETPROCESSMEMORYINFO
3903 PROCESS_MEMORY_COUNTERS memcounters;
3904 proc = GetCurrentProcess();
3905 memcounters.cb = sizeof(memcounters);
3906 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3907 return memcounters.PeakPagefileUsage;
3913 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3916 const char *p = str;
3923 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3930 static void opt_inter_matrix(const char *arg)
3932 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3933 parse_matrix_coeffs(inter_matrix, arg);
3936 static void opt_intra_matrix(const char *arg)
3938 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3939 parse_matrix_coeffs(intra_matrix, arg);
3942 static void show_usage(void)
3944 printf("Hyper fast Audio and Video encoder\n");
3945 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3949 static void show_help(void)
3952 AVOutputFormat *oformat = NULL;
3953 AVInputFormat *iformat = NULL;
3955 av_log_set_callback(log_callback_help);
3957 show_help_options(options, "Main options:\n",
3958 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3959 show_help_options(options, "\nAdvanced options:\n",
3960 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3962 show_help_options(options, "\nVideo options:\n",
3963 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3965 show_help_options(options, "\nAdvanced Video options:\n",
3966 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3967 OPT_VIDEO | OPT_EXPERT);
3968 show_help_options(options, "\nAudio options:\n",
3969 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3971 show_help_options(options, "\nAdvanced Audio options:\n",
3972 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3973 OPT_AUDIO | OPT_EXPERT);
3974 show_help_options(options, "\nSubtitle options:\n",
3975 OPT_SUBTITLE | OPT_GRAB,
3977 show_help_options(options, "\nAudio/Video grab options:\n",
3981 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3984 /* individual codec options */
3986 while ((c = av_codec_next(c))) {
3987 if (c->priv_class) {
3988 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3993 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3996 /* individual muxer options */
3997 while ((oformat = av_oformat_next(oformat))) {
3998 if (oformat->priv_class) {
3999 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4004 /* individual demuxer options */
4005 while ((iformat = av_iformat_next(iformat))) {
4006 if (iformat->priv_class) {
4007 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4012 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4015 static int opt_target(const char *opt, const char *arg)
4017 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4018 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4020 if(!strncmp(arg, "pal-", 4)) {
4023 } else if(!strncmp(arg, "ntsc-", 5)) {
4026 } else if(!strncmp(arg, "film-", 5)) {
4031 /* Calculate FR via float to avoid int overflow */
4032 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4035 } else if((fr == 29970) || (fr == 23976)) {
4038 /* Try to determine PAL/NTSC by peeking in the input files */
4039 if(nb_input_files) {
4041 for (j = 0; j < nb_input_files; j++) {
4042 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4043 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4044 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4046 fr = c->time_base.den * 1000 / c->time_base.num;
4050 } else if((fr == 29970) || (fr == 23976)) {
4060 if(verbose > 0 && norm != UNKNOWN)
4061 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4064 if(norm == UNKNOWN) {
4065 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4066 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4067 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4071 if(!strcmp(arg, "vcd")) {
4072 opt_video_codec("vcodec", "mpeg1video");
4073 opt_audio_codec("vcodec", "mp2");
4074 opt_format("f", "vcd");
4076 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4077 opt_frame_rate("r", frame_rates[norm]);
4078 opt_default("g", norm == PAL ? "15" : "18");
4080 opt_default("b", "1150000");
4081 opt_default("maxrate", "1150000");
4082 opt_default("minrate", "1150000");
4083 opt_default("bufsize", "327680"); // 40*1024*8;
4085 opt_default("ab", "224000");
4086 audio_sample_rate = 44100;
4089 opt_default("packetsize", "2324");
4090 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4092 /* We have to offset the PTS, so that it is consistent with the SCR.
4093 SCR starts at 36000, but the first two packs contain only padding
4094 and the first pack from the other stream, respectively, may also have
4095 been written before.
4096 So the real data starts at SCR 36000+3*1200. */
4097 mux_preload= (36000+3*1200) / 90000.0; //0.44
4098 } else if(!strcmp(arg, "svcd")) {
4100 opt_video_codec("vcodec", "mpeg2video");
4101 opt_audio_codec("acodec", "mp2");
4102 opt_format("f", "svcd");
4104 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4105 opt_frame_rate("r", frame_rates[norm]);
4106 opt_default("g", norm == PAL ? "15" : "18");
4108 opt_default("b", "2040000");
4109 opt_default("maxrate", "2516000");
4110 opt_default("minrate", "0"); //1145000;
4111 opt_default("bufsize", "1835008"); //224*1024*8;
4112 opt_default("flags", "+scan_offset");
4115 opt_default("ab", "224000");
4116 audio_sample_rate = 44100;
4118 opt_default("packetsize", "2324");
4120 } else if(!strcmp(arg, "dvd")) {
4122 opt_video_codec("vcodec", "mpeg2video");
4123 opt_audio_codec("vcodec", "ac3");
4124 opt_format("f", "dvd");
4126 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4127 opt_frame_rate("r", frame_rates[norm]);
4128 opt_default("g", norm == PAL ? "15" : "18");
4130 opt_default("b", "6000000");
4131 opt_default("maxrate", "9000000");
4132 opt_default("minrate", "0"); //1500000;
4133 opt_default("bufsize", "1835008"); //224*1024*8;
4135 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4136 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4138 opt_default("ab", "448000");
4139 audio_sample_rate = 48000;
4141 } else if(!strncmp(arg, "dv", 2)) {
4143 opt_format("f", "dv");
4145 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4146 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4147 norm == PAL ? "yuv420p" : "yuv411p");
4148 opt_frame_rate("r", frame_rates[norm]);
4150 audio_sample_rate = 48000;
4154 fprintf(stderr, "Unknown target: %s\n", arg);
4155 return AVERROR(EINVAL);
4160 static int opt_vstats_file(const char *opt, const char *arg)
4162 av_free (vstats_filename);
4163 vstats_filename=av_strdup (arg);
4167 static int opt_vstats(const char *opt, const char *arg)
4170 time_t today2 = time(NULL);
4171 struct tm *today = localtime(&today2);
4173 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4175 return opt_vstats_file(opt, filename);
4178 static int opt_bsf(const char *opt, const char *arg)
4180 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4181 AVBitStreamFilterContext **bsfp;
4184 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4188 bsfp= *opt == 'v' ? &video_bitstream_filters :
4189 *opt == 'a' ? &audio_bitstream_filters :
4190 &subtitle_bitstream_filters;
4192 bsfp= &(*bsfp)->next;
4199 static int opt_preset(const char *opt, const char *arg)
4202 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4203 char *codec_name = *opt == 'v' ? video_codec_name :
4204 *opt == 'a' ? audio_codec_name :
4205 subtitle_codec_name;
4207 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4208 fprintf(stderr, "File for preset '%s' not found\n", arg);
4213 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4214 if(line[0] == '#' && !e)
4216 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4218 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4221 if(!strcmp(tmp, "acodec")){
4222 opt_audio_codec(tmp, tmp2);
4223 }else if(!strcmp(tmp, "vcodec")){
4224 opt_video_codec(tmp, tmp2);
4225 }else if(!strcmp(tmp, "scodec")){
4226 opt_subtitle_codec(tmp, tmp2);
4227 }else if(!strcmp(tmp, "dcodec")){
4228 opt_data_codec(tmp, tmp2);
4229 }else if(opt_default(tmp, tmp2) < 0){
4230 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4240 static const OptionDef options[] = {
4242 #include "cmdutils_common_opts.h"
4243 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4244 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4245 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4246 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4247 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4248 "outfile[,metadata]:infile[,metadata]" },
4249 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4250 "outfile[,metadata]:infile[,metadata]" },
4251 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4252 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4253 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4254 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4255 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4256 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4257 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4258 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4259 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4260 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4261 "add timings for benchmarking" },
4262 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4263 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4264 "dump each input packet" },
4265 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4266 "when dumping packets, also dump the payload" },
4267 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4268 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4269 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4270 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4271 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4272 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4273 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4274 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4275 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4276 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4277 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4278 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4279 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4280 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4281 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4282 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4285 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4286 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4287 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4288 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4289 { "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" },
4290 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4291 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4292 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4293 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4294 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4295 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4296 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4297 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4298 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4299 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4300 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4301 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4302 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4303 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4304 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4305 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4306 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4307 "use same quantizer as source (implies VBR)" },
4308 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4309 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4310 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4311 "deinterlace pictures" },
4312 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4313 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4314 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4316 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4318 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4319 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4320 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4321 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4322 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4323 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4324 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4325 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4326 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4327 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4328 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4331 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4332 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4333 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4334 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4335 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4336 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4337 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4338 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4339 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4340 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4341 { "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" },
4343 /* subtitle options */
4344 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4345 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4346 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4347 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4348 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4351 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4352 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4353 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4356 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4357 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4359 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4360 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4361 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4363 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4364 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4365 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4366 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4367 /* data codec support */
4368 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4370 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4374 int main(int argc, char **argv)
4378 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4380 avcodec_register_all();
4382 avdevice_register_all();
4385 avfilter_register_all();
4389 avio_set_interrupt_cb(decode_interrupt_cb);
4395 av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
4396 "provided for compatibility. Use avconv instead "
4397 "(see Changelog for the list of incompatible changes).\n");
4400 parse_options(argc, argv, options, opt_output_file);
4402 if(nb_output_files <= 0 && nb_input_files == 0) {
4404 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4408 /* file converter / grab */
4409 if (nb_output_files <= 0) {
4410 fprintf(stderr, "At least one output file must be specified\n");
4414 if (nb_input_files == 0) {
4415 fprintf(stderr, "At least one input file must be specified\n");
4420 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4421 stream_maps, nb_stream_maps) < 0)
4423 ti = getutime() - ti;
4425 int maxrss = getmaxrss() / 1024;
4426 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4429 return ffmpeg_exit(0);