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 void exit_program(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 */
506 static void assert_avoptions(AVDictionary *m)
508 AVDictionaryEntry *t;
509 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
510 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
515 static void assert_codec_experimental(AVCodecContext *c, int encoder)
517 const char *codec_string = encoder ? "encoder" : "decoder";
519 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
520 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
521 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
522 "results.\nAdd '-strict experimental' if you want to use it.\n",
523 codec_string, c->codec->name);
524 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
525 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
526 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
527 codec_string, codec->name);
532 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
534 if(codec && codec->sample_fmts){
535 const enum AVSampleFormat *p= codec->sample_fmts;
537 if(*p == st->codec->sample_fmt)
541 av_log(NULL, AV_LOG_WARNING,
542 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
543 av_get_sample_fmt_name(st->codec->sample_fmt),
545 av_get_sample_fmt_name(codec->sample_fmts[0]));
546 st->codec->sample_fmt = codec->sample_fmts[0];
552 * Update the requested input sample format based on the output sample format.
553 * This is currently only used to request float output from decoders which
554 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
555 * Ideally this will be removed in the future when decoders do not do format
556 * conversion and only output in their native format.
558 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
561 /* if sample formats match or a decoder sample format has already been
562 requested, just return */
563 if (enc->sample_fmt == dec->sample_fmt ||
564 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
567 /* if decoder supports more than one output format */
568 if (dec_codec && dec_codec->sample_fmts &&
569 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
570 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
571 const enum AVSampleFormat *p;
572 int min_dec = -1, min_inc = -1;
574 /* find a matching sample format in the encoder */
575 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
576 if (*p == enc->sample_fmt) {
577 dec->request_sample_fmt = *p;
579 } else if (*p > enc->sample_fmt) {
580 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
582 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
585 /* if none match, provide the one that matches quality closest */
586 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
587 enc->sample_fmt - min_dec;
591 static void choose_sample_rate(AVStream *st, AVCodec *codec)
593 if(codec && codec->supported_samplerates){
594 const int *p= codec->supported_samplerates;
596 int best_dist=INT_MAX;
598 int dist= abs(st->codec->sample_rate - *p);
599 if(dist < best_dist){
605 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
607 st->codec->sample_rate= best;
611 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
613 if(codec && codec->pix_fmts){
614 const enum PixelFormat *p= codec->pix_fmts;
615 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
616 if(st->codec->codec_id==CODEC_ID_MJPEG){
617 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
618 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
619 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};
623 if(*p == st->codec->pix_fmt)
627 if(st->codec->pix_fmt != PIX_FMT_NONE)
628 av_log(NULL, AV_LOG_WARNING,
629 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
630 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
632 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
633 st->codec->pix_fmt = codec->pix_fmts[0];
638 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
641 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
642 int idx = oc->nb_streams - 1;
645 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
649 output_streams_for_file[file_idx] =
650 grow_array(output_streams_for_file[file_idx],
651 sizeof(*output_streams_for_file[file_idx]),
652 &nb_output_streams_for_file[file_idx],
654 ost = output_streams_for_file[file_idx][idx] =
655 av_mallocz(sizeof(OutputStream));
657 fprintf(stderr, "Could not alloc output stream\n");
660 ost->file_index = file_idx;
665 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
667 avcodec_get_context_defaults3(st->codec, codec);
669 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
673 static int read_avserver_streams(AVFormatContext *s, const char *filename)
676 AVFormatContext *ic = NULL;
678 err = avformat_open_input(&ic, filename, NULL, NULL);
681 /* copy stream format */
682 for(i=0;i<ic->nb_streams;i++) {
687 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
688 ost = new_output_stream(s, nb_output_files, codec);
691 // FIXME: a more elegant solution is needed
692 memcpy(st, ic->streams[i], sizeof(AVStream));
694 avcodec_copy_context(st->codec, ic->streams[i]->codec);
696 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
697 if (audio_stream_copy) {
700 choose_sample_fmt(st, codec);
701 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
702 if (video_stream_copy) {
705 choose_pixel_fmt(st, codec);
709 av_close_input_file(ic);
714 get_sync_ipts(const OutputStream *ost)
716 const InputStream *ist = ost->sync_ist;
717 return (double)(ist->pts - start_time)/AV_TIME_BASE;
720 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
724 AVPacket new_pkt= *pkt;
725 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
726 &new_pkt.data, &new_pkt.size,
727 pkt->data, pkt->size,
728 pkt->flags & AV_PKT_FLAG_KEY);
731 new_pkt.destruct= av_destruct_packet;
733 fprintf(stderr, "%s failed for stream %d, codec %s",
734 bsfc->filter->name, pkt->stream_index,
735 avctx->codec ? avctx->codec->name : "copy");
745 ret= av_interleaved_write_frame(s, pkt);
747 print_error("av_interleaved_write_frame()", ret);
752 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
754 static void do_audio_out(AVFormatContext *s,
757 unsigned char *buf, int size)
760 int64_t audio_out_size, audio_buf_size;
761 int64_t allocated_for_size= size;
763 int size_out, frame_bytes, ret, resample_changed;
764 AVCodecContext *enc= ost->st->codec;
765 AVCodecContext *dec= ist->st->codec;
766 int osize = av_get_bytes_per_sample(enc->sample_fmt);
767 int isize = av_get_bytes_per_sample(dec->sample_fmt);
768 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
771 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
772 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
773 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
774 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
775 audio_buf_size*= osize*enc->channels;
777 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
778 if(coded_bps > 8*osize)
779 audio_out_size= audio_out_size * coded_bps / (8*osize);
780 audio_out_size += FF_MIN_BUFFER_SIZE;
782 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
783 fprintf(stderr, "Buffer sizes too large\n");
787 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
788 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
789 if (!audio_buf || !audio_out){
790 fprintf(stderr, "Out of memory in do_audio_out\n");
794 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
795 ost->audio_resample = 1;
797 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
798 ost->resample_channels != dec->channels ||
799 ost->resample_sample_rate != dec->sample_rate;
801 if ((ost->audio_resample && !ost->resample) || resample_changed) {
802 if (resample_changed) {
803 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",
804 ist->file_index, ist->st->index,
805 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
806 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
807 ost->resample_sample_fmt = dec->sample_fmt;
808 ost->resample_channels = dec->channels;
809 ost->resample_sample_rate = dec->sample_rate;
811 audio_resample_close(ost->resample);
813 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
814 if (audio_sync_method <= 1 &&
815 ost->resample_sample_fmt == enc->sample_fmt &&
816 ost->resample_channels == enc->channels &&
817 ost->resample_sample_rate == enc->sample_rate) {
818 ost->resample = NULL;
819 ost->audio_resample = 0;
820 } else if (ost->audio_resample) {
821 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
822 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
823 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
824 enc->sample_rate, dec->sample_rate,
825 enc->sample_fmt, dec->sample_fmt,
827 if (!ost->resample) {
828 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
829 dec->channels, dec->sample_rate,
830 enc->channels, enc->sample_rate);
836 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
837 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
838 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
839 if (ost->reformat_ctx)
840 av_audio_convert_free(ost->reformat_ctx);
841 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
842 dec->sample_fmt, 1, NULL, 0);
843 if (!ost->reformat_ctx) {
844 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
845 av_get_sample_fmt_name(dec->sample_fmt),
846 av_get_sample_fmt_name(enc->sample_fmt));
849 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
852 if(audio_sync_method){
853 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
854 - av_fifo_size(ost->fifo)/(enc->channels * 2);
855 double idelta= delta*dec->sample_rate / enc->sample_rate;
856 int byte_delta= ((int)idelta)*2*dec->channels;
858 //FIXME resample delay
859 if(fabs(delta) > 50){
860 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
862 byte_delta= FFMAX(byte_delta, -size);
866 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
871 static uint8_t *input_tmp= NULL;
872 input_tmp= av_realloc(input_tmp, byte_delta + size);
874 if(byte_delta > allocated_for_size - size){
875 allocated_for_size= byte_delta + (int64_t)size;
880 memset(input_tmp, 0, byte_delta);
881 memcpy(input_tmp + byte_delta, buf, size);
885 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
887 }else if(audio_sync_method>1){
888 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
889 av_assert0(ost->audio_resample);
891 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
892 // 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));
893 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
897 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
898 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
900 if (ost->audio_resample) {
902 size_out = audio_resample(ost->resample,
903 (short *)buftmp, (short *)buf,
904 size / (dec->channels * isize));
905 size_out = size_out * enc->channels * osize;
911 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
912 const void *ibuf[6]= {buftmp};
913 void *obuf[6]= {audio_buf};
914 int istride[6]= {isize};
915 int ostride[6]= {osize};
916 int len= size_out/istride[0];
917 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
918 printf("av_audio_convert() failed\n");
924 size_out = len*osize;
927 /* now encode as many frames as possible */
928 if (enc->frame_size > 1) {
929 /* output resampled raw samples */
930 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
931 fprintf(stderr, "av_fifo_realloc2() failed\n");
934 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
936 frame_bytes = enc->frame_size * osize * enc->channels;
938 while (av_fifo_size(ost->fifo) >= frame_bytes) {
940 av_init_packet(&pkt);
942 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
944 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
946 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
949 fprintf(stderr, "Audio encoding failed\n");
953 pkt.stream_index= ost->index;
956 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
957 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
958 pkt.flags |= AV_PKT_FLAG_KEY;
959 write_frame(s, &pkt, enc, ost->bitstream_filters);
961 ost->sync_opts += enc->frame_size;
965 av_init_packet(&pkt);
967 ost->sync_opts += size_out / (osize * enc->channels);
969 /* output a pcm frame */
970 /* determine the size of the coded buffer */
973 size_out = size_out*coded_bps/8;
975 if(size_out > audio_out_size){
976 fprintf(stderr, "Internal error, buffer size too small\n");
980 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
981 ret = avcodec_encode_audio(enc, audio_out, size_out,
984 fprintf(stderr, "Audio encoding failed\n");
988 pkt.stream_index= ost->index;
991 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
992 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
993 pkt.flags |= AV_PKT_FLAG_KEY;
994 write_frame(s, &pkt, enc, ost->bitstream_filters);
998 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1000 AVCodecContext *dec;
1001 AVPicture *picture2;
1002 AVPicture picture_tmp;
1005 dec = ist->st->codec;
1007 /* deinterlace : must be done before any resize */
1008 if (do_deinterlace) {
1011 /* create temporary picture */
1012 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1013 buf = av_malloc(size);
1017 picture2 = &picture_tmp;
1018 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1020 if(avpicture_deinterlace(picture2, picture,
1021 dec->pix_fmt, dec->width, dec->height) < 0) {
1022 /* if error, do not deinterlace */
1023 fprintf(stderr, "Deinterlacing failed\n");
1032 if (picture != picture2)
1033 *picture = *picture2;
1037 /* we begin to correct av delay at this threshold */
1038 #define AV_DELAY_MAX 0.100
1040 static void do_subtitle_out(AVFormatContext *s,
1046 static uint8_t *subtitle_out = NULL;
1047 int subtitle_out_max_size = 1024 * 1024;
1048 int subtitle_out_size, nb, i;
1049 AVCodecContext *enc;
1052 if (pts == AV_NOPTS_VALUE) {
1053 fprintf(stderr, "Subtitle packets must have a pts\n");
1059 enc = ost->st->codec;
1061 if (!subtitle_out) {
1062 subtitle_out = av_malloc(subtitle_out_max_size);
1065 /* Note: DVB subtitle need one packet to draw them and one other
1066 packet to clear them */
1067 /* XXX: signal it in the codec context ? */
1068 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1073 for(i = 0; i < nb; i++) {
1074 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1075 // start_display_time is required to be 0
1076 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1077 sub->end_display_time -= sub->start_display_time;
1078 sub->start_display_time = 0;
1079 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1080 subtitle_out_max_size, sub);
1081 if (subtitle_out_size < 0) {
1082 fprintf(stderr, "Subtitle encoding failed\n");
1086 av_init_packet(&pkt);
1087 pkt.stream_index = ost->index;
1088 pkt.data = subtitle_out;
1089 pkt.size = subtitle_out_size;
1090 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1091 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1092 /* XXX: the pts correction is handled here. Maybe handling
1093 it in the codec would be better */
1095 pkt.pts += 90 * sub->start_display_time;
1097 pkt.pts += 90 * sub->end_display_time;
1099 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1103 static int bit_buffer_size= 1024*256;
1104 static uint8_t *bit_buffer= NULL;
1106 static void do_video_out(AVFormatContext *s,
1109 AVFrame *in_picture,
1110 int *frame_size, float quality)
1112 int nb_frames, i, ret, resample_changed;
1113 AVFrame *final_picture, *formatted_picture;
1114 AVCodecContext *enc, *dec;
1117 enc = ost->st->codec;
1118 dec = ist->st->codec;
1120 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1122 /* by default, we output a single frame */
1127 if(video_sync_method){
1128 double vdelta = sync_ipts - ost->sync_opts;
1129 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1132 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1135 }else if(vdelta>0.6)
1136 ost->sync_opts= lrintf(sync_ipts);
1137 }else if (vdelta > 1.1)
1138 nb_frames = lrintf(vdelta);
1139 //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);
1140 if (nb_frames == 0){
1143 fprintf(stderr, "*** drop!\n");
1144 }else if (nb_frames > 1) {
1145 nb_frames_dup += nb_frames - 1;
1147 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1150 ost->sync_opts= lrintf(sync_ipts);
1152 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1156 formatted_picture = in_picture;
1157 final_picture = formatted_picture;
1159 resample_changed = ost->resample_width != dec->width ||
1160 ost->resample_height != dec->height ||
1161 ost->resample_pix_fmt != dec->pix_fmt;
1163 if (resample_changed) {
1164 av_log(NULL, AV_LOG_INFO,
1165 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1166 ist->file_index, ist->st->index,
1167 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1168 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1169 if(!ost->video_resample)
1173 #if !CONFIG_AVFILTER
1174 if (ost->video_resample) {
1175 final_picture = &ost->pict_tmp;
1176 if (resample_changed) {
1177 /* initialize a new scaler context */
1178 sws_freeContext(ost->img_resample_ctx);
1179 ost->img_resample_ctx = sws_getContext(
1180 ist->st->codec->width,
1181 ist->st->codec->height,
1182 ist->st->codec->pix_fmt,
1183 ost->st->codec->width,
1184 ost->st->codec->height,
1185 ost->st->codec->pix_fmt,
1186 ost->sws_flags, NULL, NULL, NULL);
1187 if (ost->img_resample_ctx == NULL) {
1188 fprintf(stderr, "Cannot get resampling context\n");
1192 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1193 0, ost->resample_height, final_picture->data, final_picture->linesize);
1197 /* duplicates frame if needed */
1198 for(i=0;i<nb_frames;i++) {
1200 av_init_packet(&pkt);
1201 pkt.stream_index= ost->index;
1203 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1204 /* raw pictures are written as AVPicture structure to
1205 avoid any copies. We support temorarily the older
1207 AVFrame* old_frame = enc->coded_frame;
1208 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1209 pkt.data= (uint8_t *)final_picture;
1210 pkt.size= sizeof(AVPicture);
1211 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1212 pkt.flags |= AV_PKT_FLAG_KEY;
1214 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1215 enc->coded_frame = old_frame;
1217 AVFrame big_picture;
1219 big_picture= *final_picture;
1220 /* better than nothing: use input picture interlaced
1222 big_picture.interlaced_frame = in_picture->interlaced_frame;
1223 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1224 if(top_field_first == -1)
1225 big_picture.top_field_first = in_picture->top_field_first;
1227 big_picture.top_field_first = top_field_first;
1230 /* handles sameq here. This is not correct because it may
1231 not be a global option */
1232 big_picture.quality = quality;
1234 big_picture.pict_type = 0;
1235 // big_picture.pts = AV_NOPTS_VALUE;
1236 big_picture.pts= ost->sync_opts;
1237 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1238 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1239 if (ost->forced_kf_index < ost->forced_kf_count &&
1240 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1241 big_picture.pict_type = AV_PICTURE_TYPE_I;
1242 ost->forced_kf_index++;
1244 ret = avcodec_encode_video(enc,
1245 bit_buffer, bit_buffer_size,
1248 fprintf(stderr, "Video encoding failed\n");
1253 pkt.data= bit_buffer;
1255 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1256 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1257 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1258 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1259 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1261 if(enc->coded_frame->key_frame)
1262 pkt.flags |= AV_PKT_FLAG_KEY;
1263 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1266 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1267 // enc->frame_number-1, ret, enc->pict_type);
1268 /* if two pass, output log */
1269 if (ost->logfile && enc->stats_out) {
1270 fprintf(ost->logfile, "%s", enc->stats_out);
1275 ost->frame_number++;
1279 static double psnr(double d){
1280 return -10.0*log(d)/log(10.0);
1283 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1286 AVCodecContext *enc;
1288 double ti1, bitrate, avg_bitrate;
1290 /* this is executed just the first time do_video_stats is called */
1292 vstats_file = fopen(vstats_filename, "w");
1299 enc = ost->st->codec;
1300 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1301 frame_number = ost->frame_number;
1302 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1303 if (enc->flags&CODEC_FLAG_PSNR)
1304 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1306 fprintf(vstats_file,"f_size= %6d ", frame_size);
1307 /* compute pts value */
1308 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1312 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1313 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1314 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1315 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1316 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1320 static void print_report(AVFormatContext **output_files,
1321 OutputStream **ost_table, int nb_ostreams,
1326 AVFormatContext *oc;
1328 AVCodecContext *enc;
1329 int frame_number, vid, i;
1330 double bitrate, ti1, pts;
1331 static int64_t last_time = -1;
1332 static int qp_histogram[52];
1334 if (!is_last_report) {
1336 /* display the report every 0.5 seconds */
1337 cur_time = av_gettime();
1338 if (last_time == -1) {
1339 last_time = cur_time;
1342 if ((cur_time - last_time) < 500000)
1344 last_time = cur_time;
1348 oc = output_files[0];
1350 total_size = avio_size(oc->pb);
1351 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1352 total_size= avio_tell(oc->pb);
1357 for(i=0;i<nb_ostreams;i++) {
1360 enc = ost->st->codec;
1361 if (!ost->st->stream_copy && enc->coded_frame)
1362 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1363 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1364 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1366 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1367 float t = (av_gettime()-timer_start) / 1000000.0;
1369 frame_number = ost->frame_number;
1370 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1371 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1373 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1377 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1380 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1382 if (enc->flags&CODEC_FLAG_PSNR){
1384 double error, error_sum=0;
1385 double scale, scale_sum=0;
1386 char type[3]= {'Y','U','V'};
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1390 error= enc->error[j];
1391 scale= enc->width*enc->height*255.0*255.0*frame_number;
1393 error= enc->coded_frame->error[j];
1394 scale= enc->width*enc->height*255.0*255.0;
1399 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1405 /* compute min output value */
1406 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1407 if ((pts < ti1) && (pts > 0))
1413 if (verbose > 0 || is_last_report) {
1414 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1417 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1418 (double)total_size / 1024, ti1, bitrate);
1420 if (nb_frames_dup || nb_frames_drop)
1421 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1422 nb_frames_dup, nb_frames_drop);
1425 fprintf(stderr, "%s \r", buf);
1430 if (is_last_report && verbose >= 0){
1431 int64_t raw= audio_size + video_size + extra_size;
1432 fprintf(stderr, "\n");
1433 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1437 100.0*(total_size - raw)/raw
1442 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1444 int fill_char = 0x00;
1445 if (sample_fmt == AV_SAMPLE_FMT_U8)
1447 memset(buf, fill_char, size);
1450 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1451 static int output_packet(InputStream *ist, int ist_index,
1452 OutputStream **ost_table, int nb_ostreams,
1453 const AVPacket *pkt)
1455 AVFormatContext *os;
1460 void *buffer_to_free = NULL;
1461 static unsigned int samples_size= 0;
1462 AVSubtitle subtitle, *subtitle_to_free;
1463 int64_t pkt_pts = AV_NOPTS_VALUE;
1465 int frame_available;
1470 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1472 if(ist->next_pts == AV_NOPTS_VALUE)
1473 ist->next_pts= ist->pts;
1477 av_init_packet(&avpkt);
1485 if(pkt->dts != AV_NOPTS_VALUE)
1486 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1487 if(pkt->pts != AV_NOPTS_VALUE)
1488 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1490 //while we have more to decode or while the decoder did output something on EOF
1491 while (avpkt.size > 0 || (!pkt && got_output)) {
1492 uint8_t *data_buf, *decoded_data_buf;
1493 int data_size, decoded_data_size;
1495 ist->pts= ist->next_pts;
1497 if(avpkt.size && avpkt.size != pkt->size &&
1498 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1499 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1500 ist->showed_multi_packet_warning=1;
1503 /* decode the packet if needed */
1504 decoded_data_buf = NULL; /* fail safe */
1505 decoded_data_size= 0;
1506 data_buf = avpkt.data;
1507 data_size = avpkt.size;
1508 subtitle_to_free = NULL;
1509 if (ist->decoding_needed) {
1510 switch(ist->st->codec->codec_type) {
1511 case AVMEDIA_TYPE_AUDIO:{
1512 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1513 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1515 samples= av_malloc(samples_size);
1517 decoded_data_size= samples_size;
1518 /* XXX: could avoid copy if PCM 16 bits with same
1519 endianness as CPU */
1520 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1527 got_output = decoded_data_size > 0;
1528 /* Some bug in mpeg audio decoder gives */
1529 /* decoded_data_size < 0, it seems they are overflows */
1531 /* no audio frame */
1534 decoded_data_buf = (uint8_t *)samples;
1535 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1536 (ist->st->codec->sample_rate * ist->st->codec->channels);
1538 case AVMEDIA_TYPE_VIDEO:
1539 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1540 /* XXX: allocate picture correctly */
1541 avcodec_get_frame_defaults(&picture);
1542 avpkt.pts = pkt_pts;
1543 avpkt.dts = ist->pts;
1544 pkt_pts = AV_NOPTS_VALUE;
1546 ret = avcodec_decode_video2(ist->st->codec,
1547 &picture, &got_output, &avpkt);
1548 quality = same_quality ? picture.quality : 0;
1552 /* no picture yet */
1553 goto discard_packet;
1555 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1556 if (ist->st->codec->time_base.num != 0) {
1557 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1558 ist->next_pts += ((int64_t)AV_TIME_BASE *
1559 ist->st->codec->time_base.num * ticks) /
1560 ist->st->codec->time_base.den;
1563 buffer_to_free = NULL;
1564 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1566 case AVMEDIA_TYPE_SUBTITLE:
1567 ret = avcodec_decode_subtitle2(ist->st->codec,
1568 &subtitle, &got_output, &avpkt);
1572 goto discard_packet;
1574 subtitle_to_free = &subtitle;
1581 switch(ist->st->codec->codec_type) {
1582 case AVMEDIA_TYPE_AUDIO:
1583 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1584 ist->st->codec->sample_rate;
1586 case AVMEDIA_TYPE_VIDEO:
1587 if (ist->st->codec->time_base.num != 0) {
1588 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1589 ist->next_pts += ((int64_t)AV_TIME_BASE *
1590 ist->st->codec->time_base.num * ticks) /
1591 ist->st->codec->time_base.den;
1600 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1601 for (i = 0; i < nb_ostreams; i++) {
1603 if (ost->input_video_filter && ost->source_index == ist_index) {
1605 if (ist->st->sample_aspect_ratio.num)
1606 sar = ist->st->sample_aspect_ratio;
1608 sar = ist->st->codec->sample_aspect_ratio;
1609 // add it to be filtered
1610 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1618 // preprocess audio (volume)
1619 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1620 if (audio_volume != 256) {
1623 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1624 int v = ((*volp) * audio_volume + 128) >> 8;
1625 if (v < -32768) v = -32768;
1626 if (v > 32767) v = 32767;
1632 /* frame rate emulation */
1634 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1635 int64_t now = av_gettime() - ist->start;
1639 /* if output time reached then transcode raw format,
1640 encode packets and output them */
1641 if (start_time == 0 || ist->pts >= start_time)
1642 for(i=0;i<nb_ostreams;i++) {
1646 if (ost->source_index == ist_index) {
1648 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1649 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1650 while (frame_available) {
1651 AVRational ist_pts_tb;
1652 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1653 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1655 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1657 os = output_files[ost->file_index];
1659 /* set the input output pts pairs */
1660 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1662 if (ost->encoding_needed) {
1663 av_assert0(ist->decoding_needed);
1664 switch(ost->st->codec->codec_type) {
1665 case AVMEDIA_TYPE_AUDIO:
1666 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1668 case AVMEDIA_TYPE_VIDEO:
1670 if (ost->picref->video && !ost->frame_aspect_ratio)
1671 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1673 do_video_out(os, ost, ist, &picture, &frame_size,
1674 same_quality ? quality : ost->st->codec->global_quality);
1675 if (vstats_filename && frame_size)
1676 do_video_stats(os, ost, frame_size);
1678 case AVMEDIA_TYPE_SUBTITLE:
1679 do_subtitle_out(os, ost, ist, &subtitle,
1686 AVFrame avframe; //FIXME/XXX remove this
1688 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1690 av_init_packet(&opkt);
1692 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1693 #if !CONFIG_AVFILTER
1699 /* no reencoding needed : output the packet directly */
1700 /* force the input stream PTS */
1702 avcodec_get_frame_defaults(&avframe);
1703 ost->st->codec->coded_frame= &avframe;
1704 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1706 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1707 audio_size += data_size;
1708 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1709 video_size += data_size;
1713 opkt.stream_index= ost->index;
1714 if(pkt->pts != AV_NOPTS_VALUE)
1715 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1717 opkt.pts= AV_NOPTS_VALUE;
1719 if (pkt->dts == AV_NOPTS_VALUE)
1720 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1722 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1723 opkt.dts -= ost_tb_start_time;
1725 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1726 opkt.flags= pkt->flags;
1728 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1729 if( ost->st->codec->codec_id != CODEC_ID_H264
1730 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1731 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1733 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1734 opkt.destruct= av_destruct_packet;
1736 opkt.data = data_buf;
1737 opkt.size = data_size;
1740 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1741 ost->st->codec->frame_number++;
1742 ost->frame_number++;
1743 av_free_packet(&opkt);
1747 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1748 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1750 avfilter_unref_buffer(ost->picref);
1756 av_free(buffer_to_free);
1757 /* XXX: allocate the subtitles in the codec ? */
1758 if (subtitle_to_free) {
1759 avsubtitle_free(subtitle_to_free);
1760 subtitle_to_free = NULL;
1767 for(i=0;i<nb_ostreams;i++) {
1769 if (ost->source_index == ist_index) {
1770 AVCodecContext *enc= ost->st->codec;
1771 os = output_files[ost->file_index];
1773 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1775 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1778 if (ost->encoding_needed) {
1782 av_init_packet(&pkt);
1783 pkt.stream_index= ost->index;
1785 switch(ost->st->codec->codec_type) {
1786 case AVMEDIA_TYPE_AUDIO:
1787 fifo_bytes = av_fifo_size(ost->fifo);
1789 /* encode any samples remaining in fifo */
1790 if (fifo_bytes > 0) {
1791 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1792 int fs_tmp = enc->frame_size;
1794 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1795 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1796 enc->frame_size = fifo_bytes / (osize * enc->channels);
1798 int frame_bytes = enc->frame_size*osize*enc->channels;
1799 if (allocated_audio_buf_size < frame_bytes)
1801 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1804 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1805 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1806 ost->st->time_base.num, enc->sample_rate);
1807 enc->frame_size = fs_tmp;
1810 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1813 fprintf(stderr, "Audio encoding failed\n");
1817 pkt.flags |= AV_PKT_FLAG_KEY;
1819 case AVMEDIA_TYPE_VIDEO:
1820 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1822 fprintf(stderr, "Video encoding failed\n");
1826 if(enc->coded_frame && enc->coded_frame->key_frame)
1827 pkt.flags |= AV_PKT_FLAG_KEY;
1828 if (ost->logfile && enc->stats_out) {
1829 fprintf(ost->logfile, "%s", enc->stats_out);
1838 pkt.data= bit_buffer;
1840 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1841 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1842 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1852 static void print_sdp(AVFormatContext **avc, int n)
1856 av_sdp_create(avc, n, sdp, sizeof(sdp));
1857 printf("SDP:\n%s\n", sdp);
1861 static int copy_chapters(int infile, int outfile)
1863 AVFormatContext *is = input_files[infile].ctx;
1864 AVFormatContext *os = output_files[outfile];
1867 for (i = 0; i < is->nb_chapters; i++) {
1868 AVChapter *in_ch = is->chapters[i], *out_ch;
1869 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1870 AV_TIME_BASE_Q, in_ch->time_base);
1871 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1872 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1875 if (in_ch->end < ts_off)
1877 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1880 out_ch = av_mallocz(sizeof(AVChapter));
1882 return AVERROR(ENOMEM);
1884 out_ch->id = in_ch->id;
1885 out_ch->time_base = in_ch->time_base;
1886 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1887 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1889 if (metadata_chapters_autocopy)
1890 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1893 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1895 return AVERROR(ENOMEM);
1896 os->chapters[os->nb_chapters - 1] = out_ch;
1901 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1902 AVCodecContext *avctx)
1908 for (p = kf; *p; p++)
1911 ost->forced_kf_count = n;
1912 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1913 if (!ost->forced_kf_pts) {
1914 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1917 for (i = 0; i < n; i++) {
1918 p = i ? strchr(p, ',') + 1 : kf;
1919 t = parse_time_or_die("force_key_frames", p, 1);
1920 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1925 * The following code is the main loop of the file converter
1927 static int transcode(AVFormatContext **output_files,
1928 int nb_output_files,
1929 InputFile *input_files,
1931 StreamMap *stream_maps, int nb_stream_maps)
1933 int ret = 0, i, j, k, n, nb_ostreams = 0;
1934 AVFormatContext *is, *os;
1935 AVCodecContext *codec, *icodec;
1936 OutputStream *ost, **ost_table = NULL;
1940 uint8_t no_packet[MAX_FILES]={0};
1941 int no_packet_count=0;
1944 for (i = 0; i < nb_input_streams; i++)
1945 input_streams[i].start = av_gettime();
1947 /* output stream init */
1949 for(i=0;i<nb_output_files;i++) {
1950 os = output_files[i];
1951 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1952 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1953 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1954 ret = AVERROR(EINVAL);
1957 nb_ostreams += os->nb_streams;
1959 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1960 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1961 ret = AVERROR(EINVAL);
1965 /* Sanity check the mapping args -- do the input files & streams exist? */
1966 for(i=0;i<nb_stream_maps;i++) {
1967 int fi = stream_maps[i].file_index;
1968 int si = stream_maps[i].stream_index;
1970 if (fi < 0 || fi > nb_input_files - 1 ||
1971 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1972 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1973 ret = AVERROR(EINVAL);
1976 fi = stream_maps[i].sync_file_index;
1977 si = stream_maps[i].sync_stream_index;
1978 if (fi < 0 || fi > nb_input_files - 1 ||
1979 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1980 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1981 ret = AVERROR(EINVAL);
1986 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1990 for(k=0;k<nb_output_files;k++) {
1991 os = output_files[k];
1992 for(i=0;i<os->nb_streams;i++,n++) {
1994 ost = ost_table[n] = output_streams_for_file[k][i];
1995 if (nb_stream_maps > 0) {
1996 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
1997 stream_maps[n].stream_index;
1999 /* Sanity check that the stream types match */
2000 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2001 int i= ost->file_index;
2002 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2003 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2004 stream_maps[n].file_index, stream_maps[n].stream_index,
2005 ost->file_index, ost->index);
2010 int best_nb_frames=-1;
2011 /* get corresponding input stream index : we select the first one with the right type */
2013 for (j = 0; j < nb_input_streams; j++) {
2015 ist = &input_streams[j];
2018 AVFormatContext *f = input_files[ist->file_index].ctx;
2020 for(pi=0; pi<f->nb_programs; pi++){
2021 AVProgram *p= f->programs[pi];
2022 if(p->id == opt_programid)
2023 for(si=0; si<p->nb_stream_indexes; si++){
2024 if(f->streams[ p->stream_index[si] ] == ist->st)
2029 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2030 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2031 if(best_nb_frames < ist->st->codec_info_nb_frames){
2032 best_nb_frames= ist->st->codec_info_nb_frames;
2033 ost->source_index = j;
2040 if(! opt_programid) {
2041 /* try again and reuse existing stream */
2042 for (j = 0; j < nb_input_streams; j++) {
2043 ist = &input_streams[j];
2044 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2045 && ist->st->discard != AVDISCARD_ALL) {
2046 ost->source_index = j;
2052 int i= ost->file_index;
2053 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2054 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2055 ost->file_index, ost->index);
2060 ist = &input_streams[ost->source_index];
2062 ost->sync_ist = (nb_stream_maps > 0) ?
2063 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2064 stream_maps[n].sync_stream_index] : ist;
2068 /* for each output stream, we compute the right encoding parameters */
2069 for(i=0;i<nb_ostreams;i++) {
2071 os = output_files[ost->file_index];
2072 ist = &input_streams[ost->source_index];
2074 codec = ost->st->codec;
2075 icodec = ist->st->codec;
2077 if (metadata_streams_autocopy)
2078 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2079 AV_DICT_DONT_OVERWRITE);
2081 ost->st->disposition = ist->st->disposition;
2082 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2083 codec->chroma_sample_location = icodec->chroma_sample_location;
2085 if (ost->st->stream_copy) {
2086 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2088 if (extra_size > INT_MAX)
2091 /* if stream_copy is selected, no need to decode or encode */
2092 codec->codec_id = icodec->codec_id;
2093 codec->codec_type = icodec->codec_type;
2095 if(!codec->codec_tag){
2096 if( !os->oformat->codec_tag
2097 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2098 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2099 codec->codec_tag = icodec->codec_tag;
2102 codec->bit_rate = icodec->bit_rate;
2103 codec->rc_max_rate = icodec->rc_max_rate;
2104 codec->rc_buffer_size = icodec->rc_buffer_size;
2105 codec->extradata= av_mallocz(extra_size);
2106 if (!codec->extradata)
2108 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2109 codec->extradata_size= icodec->extradata_size;
2110 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2111 codec->time_base = icodec->time_base;
2112 codec->time_base.num *= icodec->ticks_per_frame;
2113 av_reduce(&codec->time_base.num, &codec->time_base.den,
2114 codec->time_base.num, codec->time_base.den, INT_MAX);
2116 codec->time_base = ist->st->time_base;
2117 switch(codec->codec_type) {
2118 case AVMEDIA_TYPE_AUDIO:
2119 if(audio_volume != 256) {
2120 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2123 codec->channel_layout = icodec->channel_layout;
2124 codec->sample_rate = icodec->sample_rate;
2125 codec->channels = icodec->channels;
2126 codec->frame_size = icodec->frame_size;
2127 codec->audio_service_type = icodec->audio_service_type;
2128 codec->block_align= icodec->block_align;
2129 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2130 codec->block_align= 0;
2131 if(codec->codec_id == CODEC_ID_AC3)
2132 codec->block_align= 0;
2134 case AVMEDIA_TYPE_VIDEO:
2135 codec->pix_fmt = icodec->pix_fmt;
2136 codec->width = icodec->width;
2137 codec->height = icodec->height;
2138 codec->has_b_frames = icodec->has_b_frames;
2139 if (!codec->sample_aspect_ratio.num) {
2140 codec->sample_aspect_ratio =
2141 ost->st->sample_aspect_ratio =
2142 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2143 ist->st->codec->sample_aspect_ratio.num ?
2144 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2147 case AVMEDIA_TYPE_SUBTITLE:
2148 codec->width = icodec->width;
2149 codec->height = icodec->height;
2151 case AVMEDIA_TYPE_DATA:
2158 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2159 switch(codec->codec_type) {
2160 case AVMEDIA_TYPE_AUDIO:
2161 ost->fifo= av_fifo_alloc(1024);
2164 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2165 if (!codec->sample_rate) {
2166 codec->sample_rate = icodec->sample_rate;
2168 codec->sample_rate >>= icodec->lowres;
2170 choose_sample_rate(ost->st, ost->enc);
2171 codec->time_base = (AVRational){1, codec->sample_rate};
2172 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2173 codec->sample_fmt = icodec->sample_fmt;
2174 choose_sample_fmt(ost->st, ost->enc);
2175 if (!codec->channels)
2176 codec->channels = icodec->channels;
2177 codec->channel_layout = icodec->channel_layout;
2178 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2179 codec->channel_layout = 0;
2180 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2181 icodec->request_channels = codec->channels;
2182 ist->decoding_needed = 1;
2183 ost->encoding_needed = 1;
2184 ost->resample_sample_fmt = icodec->sample_fmt;
2185 ost->resample_sample_rate = icodec->sample_rate;
2186 ost->resample_channels = icodec->channels;
2188 case AVMEDIA_TYPE_VIDEO:
2189 if (codec->pix_fmt == PIX_FMT_NONE)
2190 codec->pix_fmt = icodec->pix_fmt;
2191 choose_pixel_fmt(ost->st, ost->enc);
2193 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2194 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2198 if (!codec->width || !codec->height) {
2199 codec->width = icodec->width;
2200 codec->height = icodec->height;
2203 ost->video_resample = codec->width != icodec->width ||
2204 codec->height != icodec->height ||
2205 codec->pix_fmt != icodec->pix_fmt;
2206 if (ost->video_resample) {
2207 #if !CONFIG_AVFILTER
2208 avcodec_get_frame_defaults(&ost->pict_tmp);
2209 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2210 codec->width, codec->height)) {
2211 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2214 ost->img_resample_ctx = sws_getContext(
2221 ost->sws_flags, NULL, NULL, NULL);
2222 if (ost->img_resample_ctx == NULL) {
2223 fprintf(stderr, "Cannot get resampling context\n");
2227 codec->bits_per_raw_sample= 0;
2230 ost->resample_height = icodec->height;
2231 ost->resample_width = icodec->width;
2232 ost->resample_pix_fmt= icodec->pix_fmt;
2233 ost->encoding_needed = 1;
2234 ist->decoding_needed = 1;
2236 if (!ost->frame_rate.num)
2237 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2238 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2239 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2240 ost->frame_rate = ost->enc->supported_framerates[idx];
2242 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2245 if (configure_video_filters(ist, ost)) {
2246 fprintf(stderr, "Error opening filters!\n");
2251 case AVMEDIA_TYPE_SUBTITLE:
2252 ost->encoding_needed = 1;
2253 ist->decoding_needed = 1;
2260 if (ost->encoding_needed &&
2261 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2262 char logfilename[1024];
2265 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2266 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2268 if (codec->flags & CODEC_FLAG_PASS1) {
2269 f = fopen(logfilename, "wb");
2271 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2277 size_t logbuffer_size;
2278 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2279 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2282 codec->stats_in = logbuffer;
2286 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2287 int size= codec->width * codec->height;
2288 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2293 bit_buffer = av_malloc(bit_buffer_size);
2295 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2297 ret = AVERROR(ENOMEM);
2301 /* open each encoder */
2302 for(i=0;i<nb_ostreams;i++) {
2304 if (ost->encoding_needed) {
2305 AVCodec *codec = ost->enc;
2306 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2308 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2309 ost->st->codec->codec_id, ost->file_index, ost->index);
2310 ret = AVERROR(EINVAL);
2313 if (dec->subtitle_header) {
2314 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2315 if (!ost->st->codec->subtitle_header) {
2316 ret = AVERROR(ENOMEM);
2319 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2320 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2322 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2323 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2324 ost->file_index, ost->index);
2325 ret = AVERROR(EINVAL);
2328 assert_codec_experimental(ost->st->codec, 1);
2329 assert_avoptions(ost->opts);
2330 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2331 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2332 "It takes bits/s as argument, not kbits/s\n");
2333 extra_size += ost->st->codec->extradata_size;
2337 /* open each decoder */
2338 for (i = 0; i < nb_input_streams; i++) {
2339 ist = &input_streams[i];
2340 if (ist->decoding_needed) {
2341 AVCodec *codec = ist->dec;
2343 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2345 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2346 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2347 ret = AVERROR(EINVAL);
2351 /* update requested sample format for the decoder based on the
2352 corresponding encoder sample format */
2353 for (j = 0; j < nb_ostreams; j++) {
2355 if (ost->source_index == i) {
2356 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2361 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2362 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2363 ist->file_index, ist->st->index);
2364 ret = AVERROR(EINVAL);
2367 assert_codec_experimental(ist->st->codec, 0);
2368 assert_avoptions(ost->opts);
2373 for (i = 0; i < nb_input_streams; i++) {
2375 ist = &input_streams[i];
2377 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2378 ist->next_pts = AV_NOPTS_VALUE;
2379 init_pts_correction(&ist->pts_ctx);
2383 /* set meta data information from input file if required */
2384 for (i=0;i<nb_meta_data_maps;i++) {
2385 AVFormatContext *files[2];
2386 AVDictionary **meta[2];
2389 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2390 if ((index) < 0 || (index) >= (nb_elems)) {\
2391 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2393 ret = AVERROR(EINVAL);\
2397 int out_file_index = meta_data_maps[i][0].file;
2398 int in_file_index = meta_data_maps[i][1].file;
2399 if (in_file_index < 0 || out_file_index < 0)
2401 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2402 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2404 files[0] = output_files[out_file_index];
2405 files[1] = input_files[in_file_index].ctx;
2407 for (j = 0; j < 2; j++) {
2408 MetadataMap *map = &meta_data_maps[i][j];
2410 switch (map->type) {
2412 meta[j] = &files[j]->metadata;
2415 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2416 meta[j] = &files[j]->streams[map->index]->metadata;
2419 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2420 meta[j] = &files[j]->chapters[map->index]->metadata;
2423 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2424 meta[j] = &files[j]->programs[map->index]->metadata;
2429 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2432 /* copy global metadata by default */
2433 if (metadata_global_autocopy) {
2435 for (i = 0; i < nb_output_files; i++)
2436 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2437 AV_DICT_DONT_OVERWRITE);
2440 /* copy chapters according to chapter maps */
2441 for (i = 0; i < nb_chapter_maps; i++) {
2442 int infile = chapter_maps[i].in_file;
2443 int outfile = chapter_maps[i].out_file;
2445 if (infile < 0 || outfile < 0)
2447 if (infile >= nb_input_files) {
2448 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2449 ret = AVERROR(EINVAL);
2452 if (outfile >= nb_output_files) {
2453 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2454 ret = AVERROR(EINVAL);
2457 copy_chapters(infile, outfile);
2460 /* copy chapters from the first input file that has them*/
2461 if (!nb_chapter_maps)
2462 for (i = 0; i < nb_input_files; i++) {
2463 if (!input_files[i].ctx->nb_chapters)
2466 for (j = 0; j < nb_output_files; j++)
2467 if ((ret = copy_chapters(i, j)) < 0)
2472 /* open files and write file headers */
2473 for(i=0;i<nb_output_files;i++) {
2474 os = output_files[i];
2475 if (avformat_write_header(os, &output_opts[i]) < 0) {
2476 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2477 ret = AVERROR(EINVAL);
2480 assert_avoptions(output_opts[i]);
2481 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2487 /* dump the file output parameters - cannot be done before in case
2489 for(i=0;i<nb_output_files;i++) {
2490 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2493 /* dump the stream mapping */
2495 fprintf(stderr, "Stream mapping:\n");
2496 for(i=0;i<nb_ostreams;i++) {
2498 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2499 input_streams[ost->source_index].file_index,
2500 input_streams[ost->source_index].st->index,
2503 if (ost->sync_ist != &input_streams[ost->source_index])
2504 fprintf(stderr, " [sync #%d.%d]",
2505 ost->sync_ist->file_index,
2506 ost->sync_ist->st->index);
2507 fprintf(stderr, "\n");
2512 fprintf(stderr, "%s\n", error);
2517 print_sdp(output_files, nb_output_files);
2521 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2524 timer_start = av_gettime();
2526 for(; received_sigterm == 0;) {
2527 int file_index, ist_index;
2536 /* select the stream that we must read now by looking at the
2537 smallest output pts */
2539 for(i=0;i<nb_ostreams;i++) {
2542 os = output_files[ost->file_index];
2543 ist = &input_streams[ost->source_index];
2544 if(ist->is_past_recording_time || no_packet[ist->file_index])
2546 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2547 ipts = (double)ist->pts;
2548 if (!input_files[ist->file_index].eof_reached){
2549 if(ipts < ipts_min) {
2551 if(input_sync ) file_index = ist->file_index;
2553 if(opts < opts_min) {
2555 if(!input_sync) file_index = ist->file_index;
2558 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2563 /* if none, if is finished */
2564 if (file_index < 0) {
2565 if(no_packet_count){
2567 memset(no_packet, 0, sizeof(no_packet));
2574 /* finish if limit size exhausted */
2575 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2578 /* read a frame from it and output it in the fifo */
2579 is = input_files[file_index].ctx;
2580 ret= av_read_frame(is, &pkt);
2581 if(ret == AVERROR(EAGAIN)){
2582 no_packet[file_index]=1;
2587 input_files[file_index].eof_reached = 1;
2595 memset(no_packet, 0, sizeof(no_packet));
2598 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2599 is->streams[pkt.stream_index]);
2601 /* the following test is needed in case new streams appear
2602 dynamically in stream : we ignore them */
2603 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2604 goto discard_packet;
2605 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2606 ist = &input_streams[ist_index];
2608 goto discard_packet;
2610 if (pkt.dts != AV_NOPTS_VALUE)
2611 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2612 if (pkt.pts != AV_NOPTS_VALUE)
2613 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2615 if (ist->ts_scale) {
2616 if(pkt.pts != AV_NOPTS_VALUE)
2617 pkt.pts *= ist->ts_scale;
2618 if(pkt.dts != AV_NOPTS_VALUE)
2619 pkt.dts *= ist->ts_scale;
2622 // 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);
2623 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2624 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2625 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2626 int64_t delta= pkt_dts - ist->next_pts;
2627 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2628 input_files[ist->file_index].ts_offset -= delta;
2630 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2631 delta, input_files[ist->file_index].ts_offset);
2632 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2633 if(pkt.pts != AV_NOPTS_VALUE)
2634 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2638 /* finish if recording time exhausted */
2639 if (recording_time != INT64_MAX &&
2640 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2641 ist->is_past_recording_time = 1;
2642 goto discard_packet;
2645 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2646 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2649 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2650 ist->file_index, ist->st->index);
2653 av_free_packet(&pkt);
2658 av_free_packet(&pkt);
2660 /* dump report by using the output first video and audio streams */
2661 print_report(output_files, ost_table, nb_ostreams, 0);
2664 /* at the end of stream, we must flush the decoder buffers */
2665 for (i = 0; i < nb_input_streams; i++) {
2666 ist = &input_streams[i];
2667 if (ist->decoding_needed) {
2668 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2674 /* write the trailer if needed and close file */
2675 for(i=0;i<nb_output_files;i++) {
2676 os = output_files[i];
2677 av_write_trailer(os);
2680 /* dump report by using the first video and audio streams */
2681 print_report(output_files, ost_table, nb_ostreams, 1);
2683 /* close each encoder */
2684 for(i=0;i<nb_ostreams;i++) {
2686 if (ost->encoding_needed) {
2687 av_freep(&ost->st->codec->stats_in);
2688 avcodec_close(ost->st->codec);
2691 avfilter_graph_free(&ost->graph);
2695 /* close each decoder */
2696 for (i = 0; i < nb_input_streams; i++) {
2697 ist = &input_streams[i];
2698 if (ist->decoding_needed) {
2699 avcodec_close(ist->st->codec);
2707 av_freep(&bit_buffer);
2710 for(i=0;i<nb_ostreams;i++) {
2713 if (ost->st->stream_copy)
2714 av_freep(&ost->st->codec->extradata);
2716 fclose(ost->logfile);
2717 ost->logfile = NULL;
2719 av_fifo_free(ost->fifo); /* works even if fifo is not
2720 initialized but set to zero */
2721 av_freep(&ost->st->codec->subtitle_header);
2722 av_free(ost->pict_tmp.data[0]);
2723 av_free(ost->forced_kf_pts);
2724 if (ost->video_resample)
2725 sws_freeContext(ost->img_resample_ctx);
2727 audio_resample_close(ost->resample);
2728 if (ost->reformat_ctx)
2729 av_audio_convert_free(ost->reformat_ctx);
2730 av_dict_free(&ost->opts);
2739 static int opt_format(const char *opt, const char *arg)
2741 last_asked_format = arg;
2745 static int opt_video_rc_override_string(const char *opt, const char *arg)
2747 video_rc_override_string = arg;
2751 static int opt_me_threshold(const char *opt, const char *arg)
2753 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2757 static int opt_verbose(const char *opt, const char *arg)
2759 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2763 static int opt_frame_rate(const char *opt, const char *arg)
2765 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2766 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2772 static int opt_frame_crop(const char *opt, const char *arg)
2774 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2775 return AVERROR(EINVAL);
2778 static int opt_frame_size(const char *opt, const char *arg)
2780 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2781 fprintf(stderr, "Incorrect frame size\n");
2782 return AVERROR(EINVAL);
2787 static int opt_pad(const char *opt, const char *arg) {
2788 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2792 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2794 if (strcmp(arg, "list")) {
2795 frame_pix_fmt = av_get_pix_fmt(arg);
2796 if (frame_pix_fmt == PIX_FMT_NONE) {
2797 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2798 return AVERROR(EINVAL);
2807 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2814 p = strchr(arg, ':');
2816 x = strtol(arg, &end, 10);
2818 y = strtol(end+1, &end, 10);
2820 ar = (double)x / (double)y;
2822 ar = strtod(arg, NULL);
2825 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2826 return AVERROR(EINVAL);
2828 frame_aspect_ratio = ar;
2832 static int opt_metadata(const char *opt, const char *arg)
2834 char *mid= strchr(arg, '=');
2837 fprintf(stderr, "Missing =\n");
2842 av_dict_set(&metadata, arg, mid, 0);
2847 static int opt_qscale(const char *opt, const char *arg)
2849 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2850 if (video_qscale == 0) {
2851 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2852 return AVERROR(EINVAL);
2857 static int opt_top_field_first(const char *opt, const char *arg)
2859 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2863 static int opt_thread_count(const char *opt, const char *arg)
2865 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2868 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2873 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2875 if (strcmp(arg, "list")) {
2876 audio_sample_fmt = av_get_sample_fmt(arg);
2877 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2878 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2879 return AVERROR(EINVAL);
2884 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2885 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2891 static int opt_audio_rate(const char *opt, const char *arg)
2893 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2897 static int opt_audio_channels(const char *opt, const char *arg)
2899 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2903 static int opt_video_channel(const char *opt, const char *arg)
2905 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2906 opt_default("channel", arg);
2910 static int opt_video_standard(const char *opt, const char *arg)
2912 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2913 opt_default("standard", arg);
2917 static int opt_codec(int *pstream_copy, char **pcodec_name,
2918 int codec_type, const char *arg)
2920 av_freep(pcodec_name);
2921 if (!strcmp(arg, "copy")) {
2924 *pcodec_name = av_strdup(arg);
2929 static int opt_audio_codec(const char *opt, const char *arg)
2931 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2934 static int opt_video_codec(const char *opt, const char *arg)
2936 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2939 static int opt_subtitle_codec(const char *opt, const char *arg)
2941 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2944 static int opt_data_codec(const char *opt, const char *arg)
2946 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2949 static int opt_codec_tag(const char *opt, const char *arg)
2952 uint32_t *codec_tag;
2954 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2955 !strcmp(opt, "vtag") ? &video_codec_tag :
2956 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2960 *codec_tag = strtol(arg, &tail, 0);
2962 *codec_tag = AV_RL32(arg);
2967 static int opt_map(const char *opt, const char *arg)
2972 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2973 m = &stream_maps[nb_stream_maps-1];
2975 m->file_index = strtol(arg, &p, 0);
2979 m->stream_index = strtol(p, &p, 0);
2982 m->sync_file_index = strtol(p, &p, 0);
2985 m->sync_stream_index = strtol(p, &p, 0);
2987 m->sync_file_index = m->file_index;
2988 m->sync_stream_index = m->stream_index;
2993 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3004 *index = strtol(++arg, endptr, 0);
3007 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3014 static int opt_map_metadata(const char *opt, const char *arg)
3016 MetadataMap *m, *m1;
3019 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3020 &nb_meta_data_maps, nb_meta_data_maps + 1);
3022 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3023 m->file = strtol(arg, &p, 0);
3024 parse_meta_type(p, &m->type, &m->index, &p);
3028 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3029 m1->file = strtol(p, &p, 0);
3030 parse_meta_type(p, &m1->type, &m1->index, &p);
3032 if (m->type == 'g' || m1->type == 'g')
3033 metadata_global_autocopy = 0;
3034 if (m->type == 's' || m1->type == 's')
3035 metadata_streams_autocopy = 0;
3036 if (m->type == 'c' || m1->type == 'c')
3037 metadata_chapters_autocopy = 0;
3042 static int opt_map_meta_data(const char *opt, const char *arg)
3044 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3045 "Use -map_metadata instead.\n");
3046 return opt_map_metadata(opt, arg);
3049 static int opt_map_chapters(const char *opt, const char *arg)
3054 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3055 nb_chapter_maps + 1);
3056 c = &chapter_maps[nb_chapter_maps - 1];
3057 c->out_file = strtol(arg, &p, 0);
3061 c->in_file = strtol(p, &p, 0);
3065 static int opt_input_ts_scale(const char *opt, const char *arg)
3067 unsigned int stream;
3071 stream = strtol(arg, &p, 0);
3074 scale= strtod(p, &p);
3076 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3077 ts_scale[stream] = scale;
3081 static int opt_recording_time(const char *opt, const char *arg)
3083 recording_time = parse_time_or_die(opt, arg, 1);
3087 static int opt_start_time(const char *opt, const char *arg)
3089 start_time = parse_time_or_die(opt, arg, 1);
3093 static int opt_recording_timestamp(const char *opt, const char *arg)
3096 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3097 struct tm time = *gmtime((time_t*)&recording_timestamp);
3098 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3099 opt_metadata("metadata", buf);
3101 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3102 "tag instead.\n", opt);
3106 static int opt_input_ts_offset(const char *opt, const char *arg)
3108 input_ts_offset = parse_time_or_die(opt, arg, 1);
3112 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3114 const char *codec_string = encoder ? "encoder" : "decoder";
3118 return CODEC_ID_NONE;
3120 avcodec_find_encoder_by_name(name) :
3121 avcodec_find_decoder_by_name(name);
3123 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3126 if(codec->type != type) {
3127 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3133 static int opt_input_file(const char *opt, const char *filename)
3135 AVFormatContext *ic;
3136 AVInputFormat *file_iformat = NULL;
3137 int err, i, ret, rfps, rfps_base;
3140 AVDictionary **opts;
3141 int orig_nb_streams; // number of streams before avformat_find_stream_info
3143 if (last_asked_format) {
3144 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3145 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3148 last_asked_format = NULL;
3151 if (!strcmp(filename, "-"))
3154 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3155 !strcmp(filename, "/dev/stdin");
3157 /* get default parameters from command line */
3158 ic = avformat_alloc_context();
3160 print_error(filename, AVERROR(ENOMEM));
3163 if (audio_sample_rate) {
3164 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3165 av_dict_set(&format_opts, "sample_rate", buf, 0);
3167 if (audio_channels) {
3168 snprintf(buf, sizeof(buf), "%d", audio_channels);
3169 av_dict_set(&format_opts, "channels", buf, 0);
3171 if (frame_rate.num) {
3172 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3173 av_dict_set(&format_opts, "framerate", buf, 0);
3175 if (frame_width && frame_height) {
3176 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3177 av_dict_set(&format_opts, "video_size", buf, 0);
3179 if (frame_pix_fmt != PIX_FMT_NONE)
3180 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3182 ic->video_codec_id =
3183 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3184 ic->audio_codec_id =
3185 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3186 ic->subtitle_codec_id=
3187 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3188 ic->flags |= AVFMT_FLAG_NONBLOCK;
3190 /* open the input file with generic libav function */
3191 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3193 print_error(filename, err);
3196 assert_avoptions(format_opts);
3201 for(i=0; i<ic->nb_streams; i++){
3202 ic->streams[i]->discard= AVDISCARD_ALL;
3204 for(i=0; i<ic->nb_programs; i++){
3205 AVProgram *p= ic->programs[i];
3206 if(p->id != opt_programid){
3207 p->discard = AVDISCARD_ALL;
3210 for(j=0; j<p->nb_stream_indexes; j++){
3211 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3216 fprintf(stderr, "Specified program id not found\n");
3223 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3224 ic->loop_input = loop_input;
3227 /* Set AVCodecContext options for avformat_find_stream_info */
3228 opts = setup_find_stream_info_opts(ic, codec_opts);
3229 orig_nb_streams = ic->nb_streams;
3231 /* If not enough info to get the stream parameters, we decode the
3232 first frames to get it. (used in mpeg case for example) */
3233 ret = avformat_find_stream_info(ic, opts);
3234 if (ret < 0 && verbose >= 0) {
3235 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3236 av_close_input_file(ic);
3240 timestamp = start_time;
3241 /* add the stream start time */
3242 if (ic->start_time != AV_NOPTS_VALUE)
3243 timestamp += ic->start_time;
3245 /* if seeking requested, we execute it */
3246 if (start_time != 0) {
3247 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3249 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3250 filename, (double)timestamp / AV_TIME_BASE);
3252 /* reset seek info */
3256 /* update the current parameters so that they match the one of the input stream */
3257 for(i=0;i<ic->nb_streams;i++) {
3258 AVStream *st = ic->streams[i];
3259 AVCodecContext *dec = st->codec;
3262 dec->thread_count = thread_count;
3264 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3265 ist = &input_streams[nb_input_streams - 1];
3267 ist->file_index = nb_input_files;
3269 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3271 if (i < nb_ts_scale)
3272 ist->ts_scale = ts_scale[i];
3274 switch (dec->codec_type) {
3275 case AVMEDIA_TYPE_AUDIO:
3276 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3278 st->discard= AVDISCARD_ALL;
3280 case AVMEDIA_TYPE_VIDEO:
3281 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3282 rfps = ic->streams[i]->r_frame_rate.num;
3283 rfps_base = ic->streams[i]->r_frame_rate.den;
3285 dec->flags |= CODEC_FLAG_EMU_EDGE;
3286 dec->height >>= dec->lowres;
3287 dec->width >>= dec->lowres;
3290 dec->debug |= FF_DEBUG_MV;
3292 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3295 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3296 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3298 (float)rfps / rfps_base, rfps, rfps_base);
3302 st->discard= AVDISCARD_ALL;
3303 else if(video_discard)
3304 st->discard= video_discard;
3306 case AVMEDIA_TYPE_DATA:
3308 case AVMEDIA_TYPE_SUBTITLE:
3309 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3310 if(subtitle_disable)
3311 st->discard = AVDISCARD_ALL;
3313 case AVMEDIA_TYPE_ATTACHMENT:
3314 case AVMEDIA_TYPE_UNKNOWN:
3321 /* dump the file content */
3323 av_dump_format(ic, nb_input_files, filename, 0);
3325 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3326 input_files[nb_input_files - 1].ctx = ic;
3327 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3328 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3330 frame_rate = (AVRational){0, 0};
3331 frame_pix_fmt = PIX_FMT_NONE;
3334 audio_sample_rate = 0;
3336 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3337 av_freep(&ts_scale);
3340 for (i = 0; i < orig_nb_streams; i++)
3341 av_dict_free(&opts[i]);
3343 av_freep(&video_codec_name);
3344 av_freep(&audio_codec_name);
3345 av_freep(&subtitle_codec_name);
3351 static void check_inputs(int *has_video_ptr,
3353 int *has_subtitle_ptr,
3356 int has_video, has_audio, has_subtitle, has_data, i, j;
3357 AVFormatContext *ic;
3364 for(j=0;j<nb_input_files;j++) {
3365 ic = input_files[j].ctx;
3366 for(i=0;i<ic->nb_streams;i++) {
3367 AVCodecContext *enc = ic->streams[i]->codec;
3368 switch(enc->codec_type) {
3369 case AVMEDIA_TYPE_AUDIO:
3372 case AVMEDIA_TYPE_VIDEO:
3375 case AVMEDIA_TYPE_SUBTITLE:
3378 case AVMEDIA_TYPE_DATA:
3379 case AVMEDIA_TYPE_ATTACHMENT:
3380 case AVMEDIA_TYPE_UNKNOWN:
3388 *has_video_ptr = has_video;
3389 *has_audio_ptr = has_audio;
3390 *has_subtitle_ptr = has_subtitle;
3391 *has_data_ptr = has_data;
3394 static void new_video_stream(AVFormatContext *oc, int file_idx)
3398 AVCodecContext *video_enc;
3399 enum CodecID codec_id = CODEC_ID_NONE;
3400 AVCodec *codec= NULL;
3402 if(!video_stream_copy){
3403 if (video_codec_name) {
3404 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3405 codec = avcodec_find_encoder_by_name(video_codec_name);
3407 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3408 codec = avcodec_find_encoder(codec_id);
3412 ost = new_output_stream(oc, file_idx, codec);
3414 if (!video_stream_copy) {
3415 ost->frame_aspect_ratio = frame_aspect_ratio;
3416 frame_aspect_ratio = 0;
3418 ost->avfilter= vfilters;
3423 ost->bitstream_filters = video_bitstream_filters;
3424 video_bitstream_filters= NULL;
3426 st->codec->thread_count= thread_count;
3428 video_enc = st->codec;
3431 video_enc->codec_tag= video_codec_tag;
3433 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3434 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3437 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3438 if (video_stream_copy) {
3439 st->stream_copy = 1;
3440 video_enc->sample_aspect_ratio =
3441 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3447 ost->frame_rate = frame_rate;
3448 video_enc->codec_id = codec_id;
3450 video_enc->width = frame_width;
3451 video_enc->height = frame_height;
3452 video_enc->pix_fmt = frame_pix_fmt;
3453 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3456 video_enc->gop_size = 0;
3457 if (video_qscale || same_quality) {
3458 video_enc->flags |= CODEC_FLAG_QSCALE;
3459 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3463 video_enc->intra_matrix = intra_matrix;
3465 video_enc->inter_matrix = inter_matrix;
3467 p= video_rc_override_string;
3470 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3472 fprintf(stderr, "error parsing rc_override\n");
3475 video_enc->rc_override=
3476 av_realloc(video_enc->rc_override,
3477 sizeof(RcOverride)*(i+1));
3478 video_enc->rc_override[i].start_frame= start;
3479 video_enc->rc_override[i].end_frame = end;
3481 video_enc->rc_override[i].qscale= q;
3482 video_enc->rc_override[i].quality_factor= 1.0;
3485 video_enc->rc_override[i].qscale= 0;
3486 video_enc->rc_override[i].quality_factor= -q/100.0;
3491 video_enc->rc_override_count=i;
3492 if (!video_enc->rc_initial_buffer_occupancy)
3493 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3494 video_enc->me_threshold= me_threshold;
3495 video_enc->intra_dc_precision= intra_dc_precision - 8;
3498 video_enc->flags|= CODEC_FLAG_PSNR;
3503 video_enc->flags |= CODEC_FLAG_PASS1;
3505 video_enc->flags |= CODEC_FLAG_PASS2;
3509 if (forced_key_frames)
3510 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3512 if (video_language) {
3513 av_dict_set(&st->metadata, "language", video_language, 0);
3514 av_freep(&video_language);
3517 /* reset some key parameters */
3519 av_freep(&video_codec_name);
3520 av_freep(&forced_key_frames);
3521 video_stream_copy = 0;
3522 frame_pix_fmt = PIX_FMT_NONE;
3525 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3529 AVCodec *codec= NULL;
3530 AVCodecContext *audio_enc;
3531 enum CodecID codec_id = CODEC_ID_NONE;
3533 if(!audio_stream_copy){
3534 if (audio_codec_name) {
3535 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3536 codec = avcodec_find_encoder_by_name(audio_codec_name);
3538 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3539 codec = avcodec_find_encoder(codec_id);
3542 ost = new_output_stream(oc, file_idx, codec);
3545 ost->bitstream_filters = audio_bitstream_filters;
3546 audio_bitstream_filters= NULL;
3548 st->codec->thread_count= thread_count;
3550 audio_enc = st->codec;
3551 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3554 audio_enc->codec_tag= audio_codec_tag;
3556 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3557 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3559 if (audio_stream_copy) {
3560 st->stream_copy = 1;
3562 audio_enc->codec_id = codec_id;
3564 if (audio_qscale > QSCALE_NONE) {
3565 audio_enc->flags |= CODEC_FLAG_QSCALE;
3566 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3569 audio_enc->channels = audio_channels;
3570 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3571 audio_enc->sample_fmt = audio_sample_fmt;
3572 if (audio_sample_rate)
3573 audio_enc->sample_rate = audio_sample_rate;
3575 if (audio_language) {
3576 av_dict_set(&st->metadata, "language", audio_language, 0);
3577 av_freep(&audio_language);
3580 /* reset some key parameters */
3582 av_freep(&audio_codec_name);
3583 audio_stream_copy = 0;
3586 static void new_data_stream(AVFormatContext *oc, int file_idx)
3590 AVCodecContext *data_enc;
3592 ost = new_output_stream(oc, file_idx, NULL);
3594 data_enc = st->codec;
3595 if (!data_stream_copy) {
3596 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3600 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3603 data_enc->codec_tag= data_codec_tag;
3605 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3606 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3608 if (data_stream_copy) {
3609 st->stream_copy = 1;
3613 av_freep(&data_codec_name);
3614 data_stream_copy = 0;
3617 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3621 AVCodec *codec=NULL;
3622 AVCodecContext *subtitle_enc;
3623 enum CodecID codec_id = CODEC_ID_NONE;
3625 if(!subtitle_stream_copy){
3626 if (subtitle_codec_name) {
3627 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3628 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3630 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3631 codec = avcodec_find_encoder(codec_id);
3634 ost = new_output_stream(oc, file_idx, codec);
3636 subtitle_enc = st->codec;
3638 ost->bitstream_filters = subtitle_bitstream_filters;
3639 subtitle_bitstream_filters= NULL;
3641 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3643 if(subtitle_codec_tag)
3644 subtitle_enc->codec_tag= subtitle_codec_tag;
3646 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3647 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3649 if (subtitle_stream_copy) {
3650 st->stream_copy = 1;
3652 subtitle_enc->codec_id = codec_id;
3655 if (subtitle_language) {
3656 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3657 av_freep(&subtitle_language);
3660 subtitle_disable = 0;
3661 av_freep(&subtitle_codec_name);
3662 subtitle_stream_copy = 0;
3665 static int opt_new_stream(const char *opt, const char *arg)
3667 AVFormatContext *oc;
3668 int file_idx = nb_output_files - 1;
3669 if (nb_output_files <= 0) {
3670 fprintf(stderr, "At least one output file must be specified\n");
3673 oc = output_files[file_idx];
3675 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3676 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3677 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3678 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3683 /* arg format is "output-stream-index:streamid-value". */
3684 static int opt_streamid(const char *opt, const char *arg)
3690 av_strlcpy(idx_str, arg, sizeof(idx_str));
3691 p = strchr(idx_str, ':');
3694 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3699 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3700 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3701 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3705 static void opt_output_file(void *optctx, const char *filename)
3707 AVFormatContext *oc;
3708 int err, use_video, use_audio, use_subtitle, use_data;
3709 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3710 AVOutputFormat *file_oformat;
3712 if (!strcmp(filename, "-"))
3715 oc = avformat_alloc_context();
3717 print_error(filename, AVERROR(ENOMEM));
3721 if (last_asked_format) {
3722 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3723 if (!file_oformat) {
3724 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3727 last_asked_format = NULL;
3729 file_oformat = av_guess_format(NULL, filename, NULL);
3730 if (!file_oformat) {
3731 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3737 oc->oformat = file_oformat;
3738 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3740 if (!strcmp(file_oformat->name, "ffm") &&
3741 av_strstart(filename, "http:", NULL)) {
3742 /* special case for files sent to avserver: we get the stream
3743 parameters from avserver */
3744 int err = read_avserver_streams(oc, filename);
3746 print_error(filename, err);
3750 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3751 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3752 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3753 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 */
3755 /* disable if no corresponding type found */
3756 check_inputs(&input_has_video,
3758 &input_has_subtitle,
3761 if (!input_has_video)
3763 if (!input_has_audio)
3765 if (!input_has_subtitle)
3767 if (!input_has_data)
3770 /* manual disable */
3771 if (audio_disable) use_audio = 0;
3772 if (video_disable) use_video = 0;
3773 if (subtitle_disable) use_subtitle = 0;
3774 if (data_disable) use_data = 0;
3776 if (use_video) new_video_stream(oc, nb_output_files);
3777 if (use_audio) new_audio_stream(oc, nb_output_files);
3778 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3779 if (use_data) new_data_stream(oc, nb_output_files);
3781 av_dict_copy(&oc->metadata, metadata, 0);
3782 av_dict_free(&metadata);
3785 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3786 output_files[nb_output_files++] = oc;
3788 /* check filename in case of an image number is expected */
3789 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3790 if (!av_filename_number_test(oc->filename)) {
3791 print_error(oc->filename, AVERROR(EINVAL));
3796 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3797 /* test if it already exists to avoid loosing precious files */
3798 if (!file_overwrite &&
3799 (strchr(filename, ':') == NULL ||
3800 filename[1] == ':' ||
3801 av_strstart(filename, "file:", NULL))) {
3802 if (avio_check(filename, 0) == 0) {
3804 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3806 if (!read_yesno()) {
3807 fprintf(stderr, "Not overwriting - exiting\n");
3812 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3819 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3820 print_error(filename, err);
3825 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3826 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3827 if (loop_output >= 0) {
3828 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3829 oc->loop_output = loop_output;
3831 oc->flags |= AVFMT_FLAG_NONBLOCK;
3833 frame_rate = (AVRational){0, 0};
3836 audio_sample_rate = 0;
3838 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3840 av_freep(&forced_key_frames);
3845 /* same option as mencoder */
3846 static int opt_pass(const char *opt, const char *arg)
3848 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3852 static int64_t getutime(void)
3855 struct rusage rusage;
3857 getrusage(RUSAGE_SELF, &rusage);
3858 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3859 #elif HAVE_GETPROCESSTIMES
3861 FILETIME c, e, k, u;
3862 proc = GetCurrentProcess();
3863 GetProcessTimes(proc, &c, &e, &k, &u);
3864 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3866 return av_gettime();
3870 static int64_t getmaxrss(void)
3872 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3873 struct rusage rusage;
3874 getrusage(RUSAGE_SELF, &rusage);
3875 return (int64_t)rusage.ru_maxrss * 1024;
3876 #elif HAVE_GETPROCESSMEMORYINFO
3878 PROCESS_MEMORY_COUNTERS memcounters;
3879 proc = GetCurrentProcess();
3880 memcounters.cb = sizeof(memcounters);
3881 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3882 return memcounters.PeakPagefileUsage;
3888 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3891 const char *p = str;
3898 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3905 static void opt_inter_matrix(const char *arg)
3907 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3908 parse_matrix_coeffs(inter_matrix, arg);
3911 static void opt_intra_matrix(const char *arg)
3913 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3914 parse_matrix_coeffs(intra_matrix, arg);
3917 static void show_usage(void)
3919 printf("Hyper fast Audio and Video encoder\n");
3920 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3924 static void show_help(void)
3927 AVOutputFormat *oformat = NULL;
3928 AVInputFormat *iformat = NULL;
3929 const AVClass *class;
3931 av_log_set_callback(log_callback_help);
3933 show_help_options(options, "Main options:\n",
3934 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3935 show_help_options(options, "\nAdvanced options:\n",
3936 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3938 show_help_options(options, "\nVideo options:\n",
3939 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3941 show_help_options(options, "\nAdvanced Video options:\n",
3942 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3943 OPT_VIDEO | OPT_EXPERT);
3944 show_help_options(options, "\nAudio options:\n",
3945 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3947 show_help_options(options, "\nAdvanced Audio options:\n",
3948 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3949 OPT_AUDIO | OPT_EXPERT);
3950 show_help_options(options, "\nSubtitle options:\n",
3951 OPT_SUBTITLE | OPT_GRAB,
3953 show_help_options(options, "\nAudio/Video grab options:\n",
3957 class = avcodec_get_class();
3958 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3961 /* individual codec options */
3963 while ((c = av_codec_next(c))) {
3964 if (c->priv_class) {
3965 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3970 class = avformat_get_class();
3971 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3974 /* individual muxer options */
3975 while ((oformat = av_oformat_next(oformat))) {
3976 if (oformat->priv_class) {
3977 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3982 /* individual demuxer options */
3983 while ((iformat = av_iformat_next(iformat))) {
3984 if (iformat->priv_class) {
3985 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3990 class = sws_get_class();
3991 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3994 static int opt_target(const char *opt, const char *arg)
3996 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3997 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3999 if(!strncmp(arg, "pal-", 4)) {
4002 } else if(!strncmp(arg, "ntsc-", 5)) {
4005 } else if(!strncmp(arg, "film-", 5)) {
4010 /* Calculate FR via float to avoid int overflow */
4011 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4014 } else if((fr == 29970) || (fr == 23976)) {
4017 /* Try to determine PAL/NTSC by peeking in the input files */
4018 if(nb_input_files) {
4020 for (j = 0; j < nb_input_files; j++) {
4021 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4022 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4023 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4025 fr = c->time_base.den * 1000 / c->time_base.num;
4029 } else if((fr == 29970) || (fr == 23976)) {
4039 if(verbose > 0 && norm != UNKNOWN)
4040 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4043 if(norm == UNKNOWN) {
4044 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4045 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4046 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4050 if(!strcmp(arg, "vcd")) {
4051 opt_video_codec("vcodec", "mpeg1video");
4052 opt_audio_codec("vcodec", "mp2");
4053 opt_format("f", "vcd");
4055 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4056 opt_frame_rate("r", frame_rates[norm]);
4057 opt_default("g", norm == PAL ? "15" : "18");
4059 opt_default("b", "1150000");
4060 opt_default("maxrate", "1150000");
4061 opt_default("minrate", "1150000");
4062 opt_default("bufsize", "327680"); // 40*1024*8;
4064 opt_default("ab", "224000");
4065 audio_sample_rate = 44100;
4068 opt_default("packetsize", "2324");
4069 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4071 /* We have to offset the PTS, so that it is consistent with the SCR.
4072 SCR starts at 36000, but the first two packs contain only padding
4073 and the first pack from the other stream, respectively, may also have
4074 been written before.
4075 So the real data starts at SCR 36000+3*1200. */
4076 mux_preload= (36000+3*1200) / 90000.0; //0.44
4077 } else if(!strcmp(arg, "svcd")) {
4079 opt_video_codec("vcodec", "mpeg2video");
4080 opt_audio_codec("acodec", "mp2");
4081 opt_format("f", "svcd");
4083 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4084 opt_frame_rate("r", frame_rates[norm]);
4085 opt_default("g", norm == PAL ? "15" : "18");
4087 opt_default("b", "2040000");
4088 opt_default("maxrate", "2516000");
4089 opt_default("minrate", "0"); //1145000;
4090 opt_default("bufsize", "1835008"); //224*1024*8;
4091 opt_default("flags", "+scan_offset");
4094 opt_default("ab", "224000");
4095 audio_sample_rate = 44100;
4097 opt_default("packetsize", "2324");
4099 } else if(!strcmp(arg, "dvd")) {
4101 opt_video_codec("vcodec", "mpeg2video");
4102 opt_audio_codec("vcodec", "ac3");
4103 opt_format("f", "dvd");
4105 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4106 opt_frame_rate("r", frame_rates[norm]);
4107 opt_default("g", norm == PAL ? "15" : "18");
4109 opt_default("b", "6000000");
4110 opt_default("maxrate", "9000000");
4111 opt_default("minrate", "0"); //1500000;
4112 opt_default("bufsize", "1835008"); //224*1024*8;
4114 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4115 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4117 opt_default("ab", "448000");
4118 audio_sample_rate = 48000;
4120 } else if(!strncmp(arg, "dv", 2)) {
4122 opt_format("f", "dv");
4124 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4125 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4126 norm == PAL ? "yuv420p" : "yuv411p");
4127 opt_frame_rate("r", frame_rates[norm]);
4129 audio_sample_rate = 48000;
4133 fprintf(stderr, "Unknown target: %s\n", arg);
4134 return AVERROR(EINVAL);
4139 static int opt_vstats_file(const char *opt, const char *arg)
4141 av_free (vstats_filename);
4142 vstats_filename=av_strdup (arg);
4146 static int opt_vstats(const char *opt, const char *arg)
4149 time_t today2 = time(NULL);
4150 struct tm *today = localtime(&today2);
4152 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4154 return opt_vstats_file(opt, filename);
4157 static int opt_bsf(const char *opt, const char *arg)
4159 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4160 AVBitStreamFilterContext **bsfp;
4163 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4167 bsfp= *opt == 'v' ? &video_bitstream_filters :
4168 *opt == 'a' ? &audio_bitstream_filters :
4169 &subtitle_bitstream_filters;
4171 bsfp= &(*bsfp)->next;
4178 static int opt_preset(const char *opt, const char *arg)
4181 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4182 char *codec_name = *opt == 'v' ? video_codec_name :
4183 *opt == 'a' ? audio_codec_name :
4184 subtitle_codec_name;
4186 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4187 fprintf(stderr, "File for preset '%s' not found\n", arg);
4192 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4193 if(line[0] == '#' && !e)
4195 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4197 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4200 if(!strcmp(tmp, "acodec")){
4201 opt_audio_codec(tmp, tmp2);
4202 }else if(!strcmp(tmp, "vcodec")){
4203 opt_video_codec(tmp, tmp2);
4204 }else if(!strcmp(tmp, "scodec")){
4205 opt_subtitle_codec(tmp, tmp2);
4206 }else if(!strcmp(tmp, "dcodec")){
4207 opt_data_codec(tmp, tmp2);
4208 }else if(opt_default(tmp, tmp2) < 0){
4209 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4219 static const OptionDef options[] = {
4221 #include "cmdutils_common_opts.h"
4222 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4223 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4224 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4225 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4226 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4227 "outfile[,metadata]:infile[,metadata]" },
4228 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4229 "outfile[,metadata]:infile[,metadata]" },
4230 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4231 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4232 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4233 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4234 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4235 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4236 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4237 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4238 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4239 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4240 "add timings for benchmarking" },
4241 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4242 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4243 "dump each input packet" },
4244 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4245 "when dumping packets, also dump the payload" },
4246 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4247 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4248 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4249 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4250 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4251 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4252 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4253 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4254 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4255 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4256 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4257 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4258 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4259 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4260 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4261 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4264 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4265 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4266 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4267 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4268 { "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" },
4269 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4270 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4271 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4272 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4273 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4274 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4275 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4276 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4277 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4278 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4279 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4280 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4281 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4282 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4283 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4284 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4285 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4286 "use same quantizer as source (implies VBR)" },
4287 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4288 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4289 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4290 "deinterlace pictures" },
4291 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4292 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4293 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4295 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4297 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4298 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4299 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4300 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4301 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4302 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4303 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4304 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4305 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4306 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4307 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4310 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4311 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4312 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4313 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4314 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4315 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4316 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4317 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4318 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4319 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4320 { "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" },
4322 /* subtitle options */
4323 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4324 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4325 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4326 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4327 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4330 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4331 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4332 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4335 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4336 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4338 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4339 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4340 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4342 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4343 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4344 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4345 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4346 /* data codec support */
4347 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4349 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4353 int main(int argc, char **argv)
4357 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4359 avcodec_register_all();
4361 avdevice_register_all();
4364 avfilter_register_all();
4368 avio_set_interrupt_cb(decode_interrupt_cb);
4374 av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only "
4375 "provided for compatibility. Use avconv instead "
4376 "(see Changelog for the list of incompatible changes).\n");
4379 parse_options(NULL, argc, argv, options, opt_output_file);
4381 if(nb_output_files <= 0 && nb_input_files == 0) {
4383 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4387 /* file converter / grab */
4388 if (nb_output_files <= 0) {
4389 fprintf(stderr, "At least one output file must be specified\n");
4393 if (nb_input_files == 0) {
4394 fprintf(stderr, "At least one input file must be specified\n");
4399 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4400 stream_maps, nb_stream_maps) < 0)
4402 ti = getutime() - ti;
4404 int maxrss = getmaxrss() / 1024;
4405 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);