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;
296 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
297 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
299 typedef struct InputStream {
302 int discard; /* true if stream data should be discarded */
303 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
306 int64_t start; /* time when read started */
307 int64_t next_pts; /* synthetic pts for cases where pkt.pts
309 int64_t pts; /* current pts */
310 PtsCorrectionContext pts_ctx;
312 int is_start; /* is 1 at the start and after a discontinuity */
313 int showed_multi_packet_warning;
314 int is_past_recording_time;
317 typedef struct InputFile {
318 AVFormatContext *ctx;
319 int eof_reached; /* true if eof reached */
320 int ist_index; /* index of first stream in ist_table */
321 int buffer_size; /* current total buffer size */
325 static InputStream *input_streams = NULL;
326 static int nb_input_streams = 0;
327 static InputFile *input_files = NULL;
328 static int nb_input_files = 0;
332 static int configure_video_filters(InputStream *ist, OutputStream *ost)
334 AVFilterContext *last_filter, *filter;
335 /** filter graph containing all filters including input & output */
336 AVCodecContext *codec = ost->st->codec;
337 AVCodecContext *icodec = ist->st->codec;
338 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
339 AVRational sample_aspect_ratio;
343 ost->graph = avfilter_graph_alloc();
345 if (ist->st->sample_aspect_ratio.num){
346 sample_aspect_ratio = ist->st->sample_aspect_ratio;
348 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
350 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
351 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
352 sample_aspect_ratio.num, sample_aspect_ratio.den);
354 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
355 "src", args, NULL, ost->graph);
358 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
359 "out", NULL, &ffsink_ctx, ost->graph);
362 last_filter = ost->input_video_filter;
364 if (codec->width != icodec->width || codec->height != icodec->height) {
365 snprintf(args, 255, "%d:%d:flags=0x%X",
369 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
370 NULL, args, NULL, ost->graph)) < 0)
372 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
374 last_filter = filter;
377 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
378 ost->graph->scale_sws_opts = av_strdup(args);
381 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
382 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
384 outputs->name = av_strdup("in");
385 outputs->filter_ctx = last_filter;
386 outputs->pad_idx = 0;
387 outputs->next = NULL;
389 inputs->name = av_strdup("out");
390 inputs->filter_ctx = ost->output_video_filter;
394 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
396 av_freep(&ost->avfilter);
398 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
402 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
405 codec->width = ost->output_video_filter->inputs[0]->w;
406 codec->height = ost->output_video_filter->inputs[0]->h;
407 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
408 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
409 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
410 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
414 #endif /* CONFIG_AVFILTER */
416 static void term_exit(void)
418 av_log(NULL, AV_LOG_QUIET, "");
421 static volatile int received_sigterm = 0;
422 static volatile int received_nb_signals = 0;
425 sigterm_handler(int sig)
427 received_sigterm = sig;
428 received_nb_signals++;
432 static void term_init(void)
434 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
435 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
437 signal(SIGXCPU, sigterm_handler);
441 static int decode_interrupt_cb(void)
443 return received_nb_signals > 1;
446 static int ffmpeg_exit(int ret)
451 for(i=0;i<nb_output_files;i++) {
452 AVFormatContext *s = output_files[i];
453 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
455 avformat_free_context(s);
456 av_free(output_streams_for_file[i]);
457 av_dict_free(&output_opts[i]);
459 for(i=0;i<nb_input_files;i++) {
460 av_close_input_file(input_files[i].ctx);
463 av_free(intra_matrix);
464 av_free(inter_matrix);
468 av_free(vstats_filename);
470 av_free(streamid_map);
471 av_free(stream_maps);
472 av_free(meta_data_maps);
474 av_freep(&input_streams);
475 av_freep(&input_files);
477 av_free(video_codec_name);
478 av_free(audio_codec_name);
479 av_free(subtitle_codec_name);
480 av_free(data_codec_name);
485 allocated_audio_buf_size= allocated_audio_out_size= 0;
492 if (received_sigterm) {
494 "Received signal %d: terminating.\n",
495 (int) received_sigterm);
499 exit(ret); /* not all OS-es handle main() return value */
503 static void assert_avoptions(AVDictionary *m)
505 AVDictionaryEntry *t;
506 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
507 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
512 /* similar to ff_dynarray_add() and av_fast_realloc() */
513 static void *grow_array(void *array, int elem_size, int *size, int new_size)
515 if (new_size >= INT_MAX / elem_size) {
516 fprintf(stderr, "Array too big.\n");
519 if (*size < new_size) {
520 uint8_t *tmp = av_realloc(array, new_size*elem_size);
522 fprintf(stderr, "Could not alloc buffer.\n");
525 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
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 avcodec_get_context_defaults3(st->codec, codec);
667 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
671 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
674 AVFormatContext *ic = NULL;
677 err = avformat_open_input(&ic, filename, NULL, NULL);
680 /* copy stream format */
681 for(i=0;i<ic->nb_streams;i++) {
686 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
687 ost = new_output_stream(s, nb_output_files, codec);
690 // FIXME: a more elegant solution is needed
691 memcpy(st, ic->streams[i], sizeof(AVStream));
693 avcodec_copy_context(st->codec, ic->streams[i]->codec);
695 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
696 if (audio_stream_copy) {
699 choose_sample_fmt(st, codec);
700 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
701 if (video_stream_copy) {
704 choose_pixel_fmt(st, codec);
707 if(st->codec->flags & CODEC_FLAG_BITEXACT)
711 av_close_input_file(ic);
716 get_sync_ipts(const OutputStream *ost)
718 const InputStream *ist = ost->sync_ist;
719 return (double)(ist->pts - start_time)/AV_TIME_BASE;
722 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
726 AVPacket new_pkt= *pkt;
727 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
728 &new_pkt.data, &new_pkt.size,
729 pkt->data, pkt->size,
730 pkt->flags & AV_PKT_FLAG_KEY);
733 new_pkt.destruct= av_destruct_packet;
735 fprintf(stderr, "%s failed for stream %d, codec %s",
736 bsfc->filter->name, pkt->stream_index,
737 avctx->codec ? avctx->codec->name : "copy");
747 ret= av_interleaved_write_frame(s, pkt);
749 print_error("av_interleaved_write_frame()", ret);
754 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
756 static void do_audio_out(AVFormatContext *s,
759 unsigned char *buf, int size)
762 int64_t audio_out_size, audio_buf_size;
763 int64_t allocated_for_size= size;
765 int size_out, frame_bytes, ret, resample_changed;
766 AVCodecContext *enc= ost->st->codec;
767 AVCodecContext *dec= ist->st->codec;
768 int osize = av_get_bytes_per_sample(enc->sample_fmt);
769 int isize = av_get_bytes_per_sample(dec->sample_fmt);
770 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
773 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
774 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
775 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
776 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
777 audio_buf_size*= osize*enc->channels;
779 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
780 if(coded_bps > 8*osize)
781 audio_out_size= audio_out_size * coded_bps / (8*osize);
782 audio_out_size += FF_MIN_BUFFER_SIZE;
784 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
785 fprintf(stderr, "Buffer sizes too large\n");
789 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
790 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
791 if (!audio_buf || !audio_out){
792 fprintf(stderr, "Out of memory in do_audio_out\n");
796 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
797 ost->audio_resample = 1;
799 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
800 ost->resample_channels != dec->channels ||
801 ost->resample_sample_rate != dec->sample_rate;
803 if ((ost->audio_resample && !ost->resample) || resample_changed) {
804 if (resample_changed) {
805 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",
806 ist->file_index, ist->st->index,
807 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
808 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
809 ost->resample_sample_fmt = dec->sample_fmt;
810 ost->resample_channels = dec->channels;
811 ost->resample_sample_rate = dec->sample_rate;
813 audio_resample_close(ost->resample);
815 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
816 if (audio_sync_method <= 1 &&
817 ost->resample_sample_fmt == enc->sample_fmt &&
818 ost->resample_channels == enc->channels &&
819 ost->resample_sample_rate == enc->sample_rate) {
820 ost->resample = NULL;
821 ost->audio_resample = 0;
822 } else if (ost->audio_resample) {
823 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
824 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
825 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
826 enc->sample_rate, dec->sample_rate,
827 enc->sample_fmt, dec->sample_fmt,
829 if (!ost->resample) {
830 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
831 dec->channels, dec->sample_rate,
832 enc->channels, enc->sample_rate);
838 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
839 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
840 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
841 if (ost->reformat_ctx)
842 av_audio_convert_free(ost->reformat_ctx);
843 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
844 dec->sample_fmt, 1, NULL, 0);
845 if (!ost->reformat_ctx) {
846 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
847 av_get_sample_fmt_name(dec->sample_fmt),
848 av_get_sample_fmt_name(enc->sample_fmt));
851 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
854 if(audio_sync_method){
855 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
856 - av_fifo_size(ost->fifo)/(enc->channels * 2);
857 double idelta= delta*dec->sample_rate / enc->sample_rate;
858 int byte_delta= ((int)idelta)*2*dec->channels;
860 //FIXME resample delay
861 if(fabs(delta) > 50){
862 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
864 byte_delta= FFMAX(byte_delta, -size);
868 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
873 static uint8_t *input_tmp= NULL;
874 input_tmp= av_realloc(input_tmp, byte_delta + size);
876 if(byte_delta > allocated_for_size - size){
877 allocated_for_size= byte_delta + (int64_t)size;
882 memset(input_tmp, 0, byte_delta);
883 memcpy(input_tmp + byte_delta, buf, size);
887 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
889 }else if(audio_sync_method>1){
890 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
891 av_assert0(ost->audio_resample);
893 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
894 // 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));
895 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
899 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
900 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
902 if (ost->audio_resample) {
904 size_out = audio_resample(ost->resample,
905 (short *)buftmp, (short *)buf,
906 size / (dec->channels * isize));
907 size_out = size_out * enc->channels * osize;
913 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
914 const void *ibuf[6]= {buftmp};
915 void *obuf[6]= {audio_buf};
916 int istride[6]= {isize};
917 int ostride[6]= {osize};
918 int len= size_out/istride[0];
919 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
920 printf("av_audio_convert() failed\n");
926 size_out = len*osize;
929 /* now encode as many frames as possible */
930 if (enc->frame_size > 1) {
931 /* output resampled raw samples */
932 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
933 fprintf(stderr, "av_fifo_realloc2() failed\n");
936 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
938 frame_bytes = enc->frame_size * osize * enc->channels;
940 while (av_fifo_size(ost->fifo) >= frame_bytes) {
942 av_init_packet(&pkt);
944 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
946 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
948 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
951 fprintf(stderr, "Audio encoding failed\n");
955 pkt.stream_index= ost->index;
958 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
959 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
960 pkt.flags |= AV_PKT_FLAG_KEY;
961 write_frame(s, &pkt, enc, ost->bitstream_filters);
963 ost->sync_opts += enc->frame_size;
967 av_init_packet(&pkt);
969 ost->sync_opts += size_out / (osize * enc->channels);
971 /* output a pcm frame */
972 /* determine the size of the coded buffer */
975 size_out = size_out*coded_bps/8;
977 if(size_out > audio_out_size){
978 fprintf(stderr, "Internal error, buffer size too small\n");
982 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
983 ret = avcodec_encode_audio(enc, audio_out, size_out,
986 fprintf(stderr, "Audio encoding failed\n");
990 pkt.stream_index= ost->index;
993 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
994 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
995 pkt.flags |= AV_PKT_FLAG_KEY;
996 write_frame(s, &pkt, enc, ost->bitstream_filters);
1000 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1002 AVCodecContext *dec;
1003 AVPicture *picture2;
1004 AVPicture picture_tmp;
1007 dec = ist->st->codec;
1009 /* deinterlace : must be done before any resize */
1010 if (do_deinterlace) {
1013 /* create temporary picture */
1014 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1015 buf = av_malloc(size);
1019 picture2 = &picture_tmp;
1020 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1022 if(avpicture_deinterlace(picture2, picture,
1023 dec->pix_fmt, dec->width, dec->height) < 0) {
1024 /* if error, do not deinterlace */
1025 fprintf(stderr, "Deinterlacing failed\n");
1034 if (picture != picture2)
1035 *picture = *picture2;
1039 /* we begin to correct av delay at this threshold */
1040 #define AV_DELAY_MAX 0.100
1042 static void do_subtitle_out(AVFormatContext *s,
1048 static uint8_t *subtitle_out = NULL;
1049 int subtitle_out_max_size = 1024 * 1024;
1050 int subtitle_out_size, nb, i;
1051 AVCodecContext *enc;
1054 if (pts == AV_NOPTS_VALUE) {
1055 fprintf(stderr, "Subtitle packets must have a pts\n");
1061 enc = ost->st->codec;
1063 if (!subtitle_out) {
1064 subtitle_out = av_malloc(subtitle_out_max_size);
1067 /* Note: DVB subtitle need one packet to draw them and one other
1068 packet to clear them */
1069 /* XXX: signal it in the codec context ? */
1070 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1075 for(i = 0; i < nb; i++) {
1076 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1077 // start_display_time is required to be 0
1078 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1079 sub->end_display_time -= sub->start_display_time;
1080 sub->start_display_time = 0;
1081 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1082 subtitle_out_max_size, sub);
1083 if (subtitle_out_size < 0) {
1084 fprintf(stderr, "Subtitle encoding failed\n");
1088 av_init_packet(&pkt);
1089 pkt.stream_index = ost->index;
1090 pkt.data = subtitle_out;
1091 pkt.size = subtitle_out_size;
1092 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1093 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1094 /* XXX: the pts correction is handled here. Maybe handling
1095 it in the codec would be better */
1097 pkt.pts += 90 * sub->start_display_time;
1099 pkt.pts += 90 * sub->end_display_time;
1101 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1105 static int bit_buffer_size= 1024*256;
1106 static uint8_t *bit_buffer= NULL;
1108 static void do_video_out(AVFormatContext *s,
1111 AVFrame *in_picture,
1112 int *frame_size, float quality)
1114 int nb_frames, i, ret, resample_changed;
1115 AVFrame *final_picture, *formatted_picture;
1116 AVCodecContext *enc, *dec;
1119 enc = ost->st->codec;
1120 dec = ist->st->codec;
1122 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1124 /* by default, we output a single frame */
1129 if(video_sync_method){
1130 double vdelta = sync_ipts - ost->sync_opts;
1131 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1134 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1137 }else if(vdelta>0.6)
1138 ost->sync_opts= lrintf(sync_ipts);
1139 }else if (vdelta > 1.1)
1140 nb_frames = lrintf(vdelta);
1141 //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);
1142 if (nb_frames == 0){
1145 fprintf(stderr, "*** drop!\n");
1146 }else if (nb_frames > 1) {
1147 nb_frames_dup += nb_frames - 1;
1149 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1152 ost->sync_opts= lrintf(sync_ipts);
1154 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1158 formatted_picture = in_picture;
1159 final_picture = formatted_picture;
1161 resample_changed = ost->resample_width != dec->width ||
1162 ost->resample_height != dec->height ||
1163 ost->resample_pix_fmt != dec->pix_fmt;
1165 if (resample_changed) {
1166 av_log(NULL, AV_LOG_INFO,
1167 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1168 ist->file_index, ist->st->index,
1169 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1170 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1171 if(!ost->video_resample)
1175 #if !CONFIG_AVFILTER
1176 if (ost->video_resample) {
1177 final_picture = &ost->pict_tmp;
1178 if (resample_changed) {
1179 /* initialize a new scaler context */
1180 sws_freeContext(ost->img_resample_ctx);
1181 ost->img_resample_ctx = sws_getContext(
1182 ist->st->codec->width,
1183 ist->st->codec->height,
1184 ist->st->codec->pix_fmt,
1185 ost->st->codec->width,
1186 ost->st->codec->height,
1187 ost->st->codec->pix_fmt,
1188 ost->sws_flags, NULL, NULL, NULL);
1189 if (ost->img_resample_ctx == NULL) {
1190 fprintf(stderr, "Cannot get resampling context\n");
1194 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1195 0, ost->resample_height, final_picture->data, final_picture->linesize);
1199 /* duplicates frame if needed */
1200 for(i=0;i<nb_frames;i++) {
1202 av_init_packet(&pkt);
1203 pkt.stream_index= ost->index;
1205 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1206 /* raw pictures are written as AVPicture structure to
1207 avoid any copies. We support temorarily the older
1209 AVFrame* old_frame = enc->coded_frame;
1210 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1211 pkt.data= (uint8_t *)final_picture;
1212 pkt.size= sizeof(AVPicture);
1213 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1214 pkt.flags |= AV_PKT_FLAG_KEY;
1216 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1217 enc->coded_frame = old_frame;
1219 AVFrame big_picture;
1221 big_picture= *final_picture;
1222 /* better than nothing: use input picture interlaced
1224 big_picture.interlaced_frame = in_picture->interlaced_frame;
1225 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1226 if(top_field_first == -1)
1227 big_picture.top_field_first = in_picture->top_field_first;
1229 big_picture.top_field_first = top_field_first;
1232 /* handles sameq here. This is not correct because it may
1233 not be a global option */
1234 big_picture.quality = quality;
1236 big_picture.pict_type = 0;
1237 // big_picture.pts = AV_NOPTS_VALUE;
1238 big_picture.pts= ost->sync_opts;
1239 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1240 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1241 if (ost->forced_kf_index < ost->forced_kf_count &&
1242 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1243 big_picture.pict_type = AV_PICTURE_TYPE_I;
1244 ost->forced_kf_index++;
1246 ret = avcodec_encode_video(enc,
1247 bit_buffer, bit_buffer_size,
1250 fprintf(stderr, "Video encoding failed\n");
1255 pkt.data= bit_buffer;
1257 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1258 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1259 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1260 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1261 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1263 if(enc->coded_frame->key_frame)
1264 pkt.flags |= AV_PKT_FLAG_KEY;
1265 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1268 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1269 // enc->frame_number-1, ret, enc->pict_type);
1270 /* if two pass, output log */
1271 if (ost->logfile && enc->stats_out) {
1272 fprintf(ost->logfile, "%s", enc->stats_out);
1277 ost->frame_number++;
1281 static double psnr(double d){
1282 return -10.0*log(d)/log(10.0);
1285 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1288 AVCodecContext *enc;
1290 double ti1, bitrate, avg_bitrate;
1292 /* this is executed just the first time do_video_stats is called */
1294 vstats_file = fopen(vstats_filename, "w");
1301 enc = ost->st->codec;
1302 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1303 frame_number = ost->frame_number;
1304 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1305 if (enc->flags&CODEC_FLAG_PSNR)
1306 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1308 fprintf(vstats_file,"f_size= %6d ", frame_size);
1309 /* compute pts value */
1310 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1314 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1315 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1316 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1317 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1318 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1322 static void print_report(AVFormatContext **output_files,
1323 OutputStream **ost_table, int nb_ostreams,
1328 AVFormatContext *oc;
1330 AVCodecContext *enc;
1331 int frame_number, vid, i;
1332 double bitrate, ti1, pts;
1333 static int64_t last_time = -1;
1334 static int qp_histogram[52];
1336 if (!is_last_report) {
1338 /* display the report every 0.5 seconds */
1339 cur_time = av_gettime();
1340 if (last_time == -1) {
1341 last_time = cur_time;
1344 if ((cur_time - last_time) < 500000)
1346 last_time = cur_time;
1350 oc = output_files[0];
1352 total_size = avio_size(oc->pb);
1353 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1354 total_size= avio_tell(oc->pb);
1359 for(i=0;i<nb_ostreams;i++) {
1362 enc = ost->st->codec;
1363 if (!ost->st->stream_copy && enc->coded_frame)
1364 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1365 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1368 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1369 float t = (av_gettime()-timer_start) / 1000000.0;
1371 frame_number = ost->frame_number;
1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1373 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1375 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1379 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1384 if (enc->flags&CODEC_FLAG_PSNR){
1386 double error, error_sum=0;
1387 double scale, scale_sum=0;
1388 char type[3]= {'Y','U','V'};
1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1392 error= enc->error[j];
1393 scale= enc->width*enc->height*255.0*255.0*frame_number;
1395 error= enc->coded_frame->error[j];
1396 scale= enc->width*enc->height*255.0*255.0;
1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1403 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1407 /* compute min output value */
1408 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1409 if ((pts < ti1) && (pts > 0))
1415 if (verbose > 0 || is_last_report) {
1416 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1419 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1420 (double)total_size / 1024, ti1, bitrate);
1422 if (nb_frames_dup || nb_frames_drop)
1423 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1424 nb_frames_dup, nb_frames_drop);
1427 fprintf(stderr, "%s \r", buf);
1432 if (is_last_report && verbose >= 0){
1433 int64_t raw= audio_size + video_size + extra_size;
1434 fprintf(stderr, "\n");
1435 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1439 100.0*(total_size - raw)/raw
1444 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1446 int fill_char = 0x00;
1447 if (sample_fmt == AV_SAMPLE_FMT_U8)
1449 memset(buf, fill_char, size);
1452 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1453 static int output_packet(InputStream *ist, int ist_index,
1454 OutputStream **ost_table, int nb_ostreams,
1455 const AVPacket *pkt)
1457 AVFormatContext *os;
1462 void *buffer_to_free = NULL;
1463 static unsigned int samples_size= 0;
1464 AVSubtitle subtitle, *subtitle_to_free;
1465 int64_t pkt_pts = AV_NOPTS_VALUE;
1467 int frame_available;
1472 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1474 if(ist->next_pts == AV_NOPTS_VALUE)
1475 ist->next_pts= ist->pts;
1479 av_init_packet(&avpkt);
1487 if(pkt->dts != AV_NOPTS_VALUE)
1488 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1489 if(pkt->pts != AV_NOPTS_VALUE)
1490 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1492 //while we have more to decode or while the decoder did output something on EOF
1493 while (avpkt.size > 0 || (!pkt && got_output)) {
1494 uint8_t *data_buf, *decoded_data_buf;
1495 int data_size, decoded_data_size;
1497 ist->pts= ist->next_pts;
1499 if(avpkt.size && avpkt.size != pkt->size &&
1500 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1501 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1502 ist->showed_multi_packet_warning=1;
1505 /* decode the packet if needed */
1506 decoded_data_buf = NULL; /* fail safe */
1507 decoded_data_size= 0;
1508 data_buf = avpkt.data;
1509 data_size = avpkt.size;
1510 subtitle_to_free = NULL;
1511 if (ist->decoding_needed) {
1512 switch(ist->st->codec->codec_type) {
1513 case AVMEDIA_TYPE_AUDIO:{
1514 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1515 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1517 samples= av_malloc(samples_size);
1519 decoded_data_size= samples_size;
1520 /* XXX: could avoid copy if PCM 16 bits with same
1521 endianness as CPU */
1522 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1529 got_output = decoded_data_size > 0;
1530 /* Some bug in mpeg audio decoder gives */
1531 /* decoded_data_size < 0, it seems they are overflows */
1533 /* no audio frame */
1536 decoded_data_buf = (uint8_t *)samples;
1537 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1538 (ist->st->codec->sample_rate * ist->st->codec->channels);
1540 case AVMEDIA_TYPE_VIDEO:
1541 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1542 /* XXX: allocate picture correctly */
1543 avcodec_get_frame_defaults(&picture);
1544 avpkt.pts = pkt_pts;
1545 avpkt.dts = ist->pts;
1546 pkt_pts = AV_NOPTS_VALUE;
1548 ret = avcodec_decode_video2(ist->st->codec,
1549 &picture, &got_output, &avpkt);
1550 quality = same_quality ? picture.quality : 0;
1554 /* no picture yet */
1555 goto discard_packet;
1557 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1558 if (ist->st->codec->time_base.num != 0) {
1559 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1560 ist->next_pts += ((int64_t)AV_TIME_BASE *
1561 ist->st->codec->time_base.num * ticks) /
1562 ist->st->codec->time_base.den;
1565 buffer_to_free = NULL;
1566 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1568 case AVMEDIA_TYPE_SUBTITLE:
1569 ret = avcodec_decode_subtitle2(ist->st->codec,
1570 &subtitle, &got_output, &avpkt);
1574 goto discard_packet;
1576 subtitle_to_free = &subtitle;
1583 switch(ist->st->codec->codec_type) {
1584 case AVMEDIA_TYPE_AUDIO:
1585 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1586 ist->st->codec->sample_rate;
1588 case AVMEDIA_TYPE_VIDEO:
1589 if (ist->st->codec->time_base.num != 0) {
1590 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1591 ist->next_pts += ((int64_t)AV_TIME_BASE *
1592 ist->st->codec->time_base.num * ticks) /
1593 ist->st->codec->time_base.den;
1602 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1603 for (i = 0; i < nb_ostreams; i++) {
1605 if (ost->input_video_filter && ost->source_index == ist_index) {
1607 if (ist->st->sample_aspect_ratio.num)
1608 sar = ist->st->sample_aspect_ratio;
1610 sar = ist->st->codec->sample_aspect_ratio;
1611 // add it to be filtered
1612 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1620 // preprocess audio (volume)
1621 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1622 if (audio_volume != 256) {
1625 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1626 int v = ((*volp) * audio_volume + 128) >> 8;
1627 if (v < -32768) v = -32768;
1628 if (v > 32767) v = 32767;
1634 /* frame rate emulation */
1636 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1637 int64_t now = av_gettime() - ist->start;
1641 /* if output time reached then transcode raw format,
1642 encode packets and output them */
1643 if (start_time == 0 || ist->pts >= start_time)
1644 for(i=0;i<nb_ostreams;i++) {
1648 if (ost->source_index == ist_index) {
1650 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1651 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1652 while (frame_available) {
1653 AVRational ist_pts_tb;
1654 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1655 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1657 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1659 os = output_files[ost->file_index];
1661 /* set the input output pts pairs */
1662 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1664 if (ost->encoding_needed) {
1665 av_assert0(ist->decoding_needed);
1666 switch(ost->st->codec->codec_type) {
1667 case AVMEDIA_TYPE_AUDIO:
1668 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1670 case AVMEDIA_TYPE_VIDEO:
1672 if (ost->picref->video && !ost->frame_aspect_ratio)
1673 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1675 do_video_out(os, ost, ist, &picture, &frame_size,
1676 same_quality ? quality : ost->st->codec->global_quality);
1677 if (vstats_filename && frame_size)
1678 do_video_stats(os, ost, frame_size);
1680 case AVMEDIA_TYPE_SUBTITLE:
1681 do_subtitle_out(os, ost, ist, &subtitle,
1688 AVFrame avframe; //FIXME/XXX remove this
1690 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1692 av_init_packet(&opkt);
1694 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1695 #if !CONFIG_AVFILTER
1701 /* no reencoding needed : output the packet directly */
1702 /* force the input stream PTS */
1704 avcodec_get_frame_defaults(&avframe);
1705 ost->st->codec->coded_frame= &avframe;
1706 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1708 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1709 audio_size += data_size;
1710 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1711 video_size += data_size;
1715 opkt.stream_index= ost->index;
1716 if(pkt->pts != AV_NOPTS_VALUE)
1717 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1719 opkt.pts= AV_NOPTS_VALUE;
1721 if (pkt->dts == AV_NOPTS_VALUE)
1722 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1724 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1725 opkt.dts -= ost_tb_start_time;
1727 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1728 opkt.flags= pkt->flags;
1730 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1731 if( ost->st->codec->codec_id != CODEC_ID_H264
1732 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1733 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1735 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1736 opkt.destruct= av_destruct_packet;
1738 opkt.data = data_buf;
1739 opkt.size = data_size;
1742 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1743 ost->st->codec->frame_number++;
1744 ost->frame_number++;
1745 av_free_packet(&opkt);
1749 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1750 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1752 avfilter_unref_buffer(ost->picref);
1758 av_free(buffer_to_free);
1759 /* XXX: allocate the subtitles in the codec ? */
1760 if (subtitle_to_free) {
1761 avsubtitle_free(subtitle_to_free);
1762 subtitle_to_free = NULL;
1769 for(i=0;i<nb_ostreams;i++) {
1771 if (ost->source_index == ist_index) {
1772 AVCodecContext *enc= ost->st->codec;
1773 os = output_files[ost->file_index];
1775 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1777 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1780 if (ost->encoding_needed) {
1784 av_init_packet(&pkt);
1785 pkt.stream_index= ost->index;
1787 switch(ost->st->codec->codec_type) {
1788 case AVMEDIA_TYPE_AUDIO:
1789 fifo_bytes = av_fifo_size(ost->fifo);
1791 /* encode any samples remaining in fifo */
1792 if (fifo_bytes > 0) {
1793 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1794 int fs_tmp = enc->frame_size;
1796 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1797 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1798 enc->frame_size = fifo_bytes / (osize * enc->channels);
1800 int frame_bytes = enc->frame_size*osize*enc->channels;
1801 if (allocated_audio_buf_size < frame_bytes)
1803 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1806 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1807 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1808 ost->st->time_base.num, enc->sample_rate);
1809 enc->frame_size = fs_tmp;
1812 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1815 fprintf(stderr, "Audio encoding failed\n");
1819 pkt.flags |= AV_PKT_FLAG_KEY;
1821 case AVMEDIA_TYPE_VIDEO:
1822 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1824 fprintf(stderr, "Video encoding failed\n");
1828 if(enc->coded_frame && enc->coded_frame->key_frame)
1829 pkt.flags |= AV_PKT_FLAG_KEY;
1830 if (ost->logfile && enc->stats_out) {
1831 fprintf(ost->logfile, "%s", enc->stats_out);
1840 pkt.data= bit_buffer;
1842 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1843 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1844 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1854 static void print_sdp(AVFormatContext **avc, int n)
1858 av_sdp_create(avc, n, sdp, sizeof(sdp));
1859 printf("SDP:\n%s\n", sdp);
1863 static int copy_chapters(int infile, int outfile)
1865 AVFormatContext *is = input_files[infile].ctx;
1866 AVFormatContext *os = output_files[outfile];
1869 for (i = 0; i < is->nb_chapters; i++) {
1870 AVChapter *in_ch = is->chapters[i], *out_ch;
1871 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1872 AV_TIME_BASE_Q, in_ch->time_base);
1873 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1874 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1877 if (in_ch->end < ts_off)
1879 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1882 out_ch = av_mallocz(sizeof(AVChapter));
1884 return AVERROR(ENOMEM);
1886 out_ch->id = in_ch->id;
1887 out_ch->time_base = in_ch->time_base;
1888 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1889 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1891 if (metadata_chapters_autocopy)
1892 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1895 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1897 return AVERROR(ENOMEM);
1898 os->chapters[os->nb_chapters - 1] = out_ch;
1903 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1904 AVCodecContext *avctx)
1910 for (p = kf; *p; p++)
1913 ost->forced_kf_count = n;
1914 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1915 if (!ost->forced_kf_pts) {
1916 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1919 for (i = 0; i < n; i++) {
1920 p = i ? strchr(p, ',') + 1 : kf;
1921 t = parse_time_or_die("force_key_frames", p, 1);
1922 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1927 * The following code is the main loop of the file converter
1929 static int transcode(AVFormatContext **output_files,
1930 int nb_output_files,
1931 InputFile *input_files,
1933 StreamMap *stream_maps, int nb_stream_maps)
1935 int ret = 0, i, j, k, n, nb_ostreams = 0;
1936 AVFormatContext *is, *os;
1937 AVCodecContext *codec, *icodec;
1938 OutputStream *ost, **ost_table = NULL;
1942 uint8_t no_packet[MAX_FILES]={0};
1943 int no_packet_count=0;
1946 for (i = 0; i < nb_input_streams; i++)
1947 input_streams[i].start = av_gettime();
1949 /* output stream init */
1951 for(i=0;i<nb_output_files;i++) {
1952 os = output_files[i];
1953 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1954 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1955 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1956 ret = AVERROR(EINVAL);
1959 nb_ostreams += os->nb_streams;
1961 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1962 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1963 ret = AVERROR(EINVAL);
1967 /* Sanity check the mapping args -- do the input files & streams exist? */
1968 for(i=0;i<nb_stream_maps;i++) {
1969 int fi = stream_maps[i].file_index;
1970 int si = stream_maps[i].stream_index;
1972 if (fi < 0 || fi > nb_input_files - 1 ||
1973 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1974 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1975 ret = AVERROR(EINVAL);
1978 fi = stream_maps[i].sync_file_index;
1979 si = stream_maps[i].sync_stream_index;
1980 if (fi < 0 || fi > nb_input_files - 1 ||
1981 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1982 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1983 ret = AVERROR(EINVAL);
1988 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1992 for(k=0;k<nb_output_files;k++) {
1993 os = output_files[k];
1994 for(i=0;i<os->nb_streams;i++,n++) {
1996 ost = ost_table[n] = output_streams_for_file[k][i];
1997 if (nb_stream_maps > 0) {
1998 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
1999 stream_maps[n].stream_index;
2001 /* Sanity check that the stream types match */
2002 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2003 int i= ost->file_index;
2004 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2005 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2006 stream_maps[n].file_index, stream_maps[n].stream_index,
2007 ost->file_index, ost->index);
2012 int best_nb_frames=-1;
2013 /* get corresponding input stream index : we select the first one with the right type */
2015 for (j = 0; j < nb_input_streams; j++) {
2017 ist = &input_streams[j];
2020 AVFormatContext *f = input_files[ist->file_index].ctx;
2022 for(pi=0; pi<f->nb_programs; pi++){
2023 AVProgram *p= f->programs[pi];
2024 if(p->id == opt_programid)
2025 for(si=0; si<p->nb_stream_indexes; si++){
2026 if(f->streams[ p->stream_index[si] ] == ist->st)
2031 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2032 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2033 if(best_nb_frames < ist->st->codec_info_nb_frames){
2034 best_nb_frames= ist->st->codec_info_nb_frames;
2035 ost->source_index = j;
2042 if(! opt_programid) {
2043 /* try again and reuse existing stream */
2044 for (j = 0; j < nb_input_streams; j++) {
2045 ist = &input_streams[j];
2046 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2047 && ist->st->discard != AVDISCARD_ALL) {
2048 ost->source_index = j;
2054 int i= ost->file_index;
2055 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2056 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2057 ost->file_index, ost->index);
2062 ist = &input_streams[ost->source_index];
2064 ost->sync_ist = (nb_stream_maps > 0) ?
2065 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2066 stream_maps[n].sync_stream_index] : ist;
2070 /* for each output stream, we compute the right encoding parameters */
2071 for(i=0;i<nb_ostreams;i++) {
2073 os = output_files[ost->file_index];
2074 ist = &input_streams[ost->source_index];
2076 codec = ost->st->codec;
2077 icodec = ist->st->codec;
2079 if (metadata_streams_autocopy)
2080 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2081 AV_DICT_DONT_OVERWRITE);
2083 ost->st->disposition = ist->st->disposition;
2084 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2085 codec->chroma_sample_location = icodec->chroma_sample_location;
2087 if (ost->st->stream_copy) {
2088 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2090 if (extra_size > INT_MAX)
2093 /* if stream_copy is selected, no need to decode or encode */
2094 codec->codec_id = icodec->codec_id;
2095 codec->codec_type = icodec->codec_type;
2097 if(!codec->codec_tag){
2098 if( !os->oformat->codec_tag
2099 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2100 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2101 codec->codec_tag = icodec->codec_tag;
2104 codec->bit_rate = icodec->bit_rate;
2105 codec->rc_max_rate = icodec->rc_max_rate;
2106 codec->rc_buffer_size = icodec->rc_buffer_size;
2107 codec->extradata= av_mallocz(extra_size);
2108 if (!codec->extradata)
2110 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2111 codec->extradata_size= icodec->extradata_size;
2112 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){
2113 codec->time_base = icodec->time_base;
2114 codec->time_base.num *= icodec->ticks_per_frame;
2115 av_reduce(&codec->time_base.num, &codec->time_base.den,
2116 codec->time_base.num, codec->time_base.den, INT_MAX);
2118 codec->time_base = ist->st->time_base;
2119 switch(codec->codec_type) {
2120 case AVMEDIA_TYPE_AUDIO:
2121 if(audio_volume != 256) {
2122 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2125 codec->channel_layout = icodec->channel_layout;
2126 codec->sample_rate = icodec->sample_rate;
2127 codec->channels = icodec->channels;
2128 codec->frame_size = icodec->frame_size;
2129 codec->audio_service_type = icodec->audio_service_type;
2130 codec->block_align= icodec->block_align;
2131 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2132 codec->block_align= 0;
2133 if(codec->codec_id == CODEC_ID_AC3)
2134 codec->block_align= 0;
2136 case AVMEDIA_TYPE_VIDEO:
2137 codec->pix_fmt = icodec->pix_fmt;
2138 codec->width = icodec->width;
2139 codec->height = icodec->height;
2140 codec->has_b_frames = icodec->has_b_frames;
2141 if (!codec->sample_aspect_ratio.num) {
2142 codec->sample_aspect_ratio =
2143 ost->st->sample_aspect_ratio =
2144 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2145 ist->st->codec->sample_aspect_ratio.num ?
2146 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2149 case AVMEDIA_TYPE_SUBTITLE:
2150 codec->width = icodec->width;
2151 codec->height = icodec->height;
2153 case AVMEDIA_TYPE_DATA:
2160 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2161 switch(codec->codec_type) {
2162 case AVMEDIA_TYPE_AUDIO:
2163 ost->fifo= av_fifo_alloc(1024);
2166 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2167 if (!codec->sample_rate) {
2168 codec->sample_rate = icodec->sample_rate;
2170 codec->sample_rate >>= icodec->lowres;
2172 choose_sample_rate(ost->st, ost->enc);
2173 codec->time_base = (AVRational){1, codec->sample_rate};
2174 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2175 codec->sample_fmt = icodec->sample_fmt;
2176 choose_sample_fmt(ost->st, ost->enc);
2177 if (!codec->channels)
2178 codec->channels = icodec->channels;
2179 codec->channel_layout = icodec->channel_layout;
2180 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2181 codec->channel_layout = 0;
2182 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2183 icodec->request_channels = codec->channels;
2184 ist->decoding_needed = 1;
2185 ost->encoding_needed = 1;
2186 ost->resample_sample_fmt = icodec->sample_fmt;
2187 ost->resample_sample_rate = icodec->sample_rate;
2188 ost->resample_channels = icodec->channels;
2190 case AVMEDIA_TYPE_VIDEO:
2191 if (codec->pix_fmt == PIX_FMT_NONE)
2192 codec->pix_fmt = icodec->pix_fmt;
2193 choose_pixel_fmt(ost->st, ost->enc);
2195 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2196 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2199 ost->video_resample = codec->width != icodec->width ||
2200 codec->height != icodec->height ||
2201 codec->pix_fmt != icodec->pix_fmt;
2202 if (ost->video_resample) {
2203 #if !CONFIG_AVFILTER
2204 avcodec_get_frame_defaults(&ost->pict_tmp);
2205 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2206 codec->width, codec->height)) {
2207 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2210 ost->img_resample_ctx = sws_getContext(
2217 ost->sws_flags, NULL, NULL, NULL);
2218 if (ost->img_resample_ctx == NULL) {
2219 fprintf(stderr, "Cannot get resampling context\n");
2223 codec->bits_per_raw_sample= 0;
2225 if (!codec->width || !codec->height) {
2226 codec->width = icodec->width;
2227 codec->height = icodec->height;
2229 ost->resample_height = icodec->height;
2230 ost->resample_width = icodec->width;
2231 ost->resample_pix_fmt= icodec->pix_fmt;
2232 ost->encoding_needed = 1;
2233 ist->decoding_needed = 1;
2235 if (!ost->frame_rate.num)
2236 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2237 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2238 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2239 ost->frame_rate = ost->enc->supported_framerates[idx];
2241 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2244 if (configure_video_filters(ist, ost)) {
2245 fprintf(stderr, "Error opening filters!\n");
2250 case AVMEDIA_TYPE_SUBTITLE:
2251 ost->encoding_needed = 1;
2252 ist->decoding_needed = 1;
2259 if (ost->encoding_needed &&
2260 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2261 char logfilename[1024];
2264 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2265 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2267 if (codec->flags & CODEC_FLAG_PASS1) {
2268 f = fopen(logfilename, "wb");
2270 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2276 size_t logbuffer_size;
2277 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2278 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2281 codec->stats_in = logbuffer;
2285 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2286 int size= codec->width * codec->height;
2287 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2292 bit_buffer = av_malloc(bit_buffer_size);
2294 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2296 ret = AVERROR(ENOMEM);
2300 /* open each encoder */
2301 for(i=0;i<nb_ostreams;i++) {
2303 if (ost->encoding_needed) {
2304 AVCodec *codec = ost->enc;
2305 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2307 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2308 ost->st->codec->codec_id, ost->file_index, ost->index);
2309 ret = AVERROR(EINVAL);
2312 if (dec->subtitle_header) {
2313 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2314 if (!ost->st->codec->subtitle_header) {
2315 ret = AVERROR(ENOMEM);
2318 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2319 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2321 if (avcodec_open(ost->st->codec, codec) < 0) {
2322 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2323 ost->file_index, ost->index);
2324 ret = AVERROR(EINVAL);
2327 extra_size += ost->st->codec->extradata_size;
2331 /* open each decoder */
2332 for (i = 0; i < nb_input_streams; i++) {
2333 ist = &input_streams[i];
2334 if (ist->decoding_needed) {
2335 AVCodec *codec = ist->dec;
2337 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2339 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2340 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2341 ret = AVERROR(EINVAL);
2345 /* update requested sample format for the decoder based on the
2346 corresponding encoder sample format */
2347 for (j = 0; j < nb_ostreams; j++) {
2349 if (ost->source_index == i) {
2350 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2355 if (avcodec_open(ist->st->codec, codec) < 0) {
2356 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2357 ist->file_index, ist->st->index);
2358 ret = AVERROR(EINVAL);
2361 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2362 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2367 for (i = 0; i < nb_input_streams; i++) {
2369 ist = &input_streams[i];
2371 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2372 ist->next_pts = AV_NOPTS_VALUE;
2373 init_pts_correction(&ist->pts_ctx);
2377 /* set meta data information from input file if required */
2378 for (i=0;i<nb_meta_data_maps;i++) {
2379 AVFormatContext *files[2];
2380 AVDictionary **meta[2];
2383 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2384 if ((index) < 0 || (index) >= (nb_elems)) {\
2385 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2387 ret = AVERROR(EINVAL);\
2391 int out_file_index = meta_data_maps[i][0].file;
2392 int in_file_index = meta_data_maps[i][1].file;
2393 if (in_file_index < 0 || out_file_index < 0)
2395 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2396 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2398 files[0] = output_files[out_file_index];
2399 files[1] = input_files[in_file_index].ctx;
2401 for (j = 0; j < 2; j++) {
2402 MetadataMap *map = &meta_data_maps[i][j];
2404 switch (map->type) {
2406 meta[j] = &files[j]->metadata;
2409 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2410 meta[j] = &files[j]->streams[map->index]->metadata;
2413 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2414 meta[j] = &files[j]->chapters[map->index]->metadata;
2417 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2418 meta[j] = &files[j]->programs[map->index]->metadata;
2423 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2426 /* copy global metadata by default */
2427 if (metadata_global_autocopy) {
2429 for (i = 0; i < nb_output_files; i++)
2430 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2431 AV_DICT_DONT_OVERWRITE);
2434 /* copy chapters according to chapter maps */
2435 for (i = 0; i < nb_chapter_maps; i++) {
2436 int infile = chapter_maps[i].in_file;
2437 int outfile = chapter_maps[i].out_file;
2439 if (infile < 0 || outfile < 0)
2441 if (infile >= nb_input_files) {
2442 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2443 ret = AVERROR(EINVAL);
2446 if (outfile >= nb_output_files) {
2447 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2448 ret = AVERROR(EINVAL);
2451 copy_chapters(infile, outfile);
2454 /* copy chapters from the first input file that has them*/
2455 if (!nb_chapter_maps)
2456 for (i = 0; i < nb_input_files; i++) {
2457 if (!input_files[i].ctx->nb_chapters)
2460 for (j = 0; j < nb_output_files; j++)
2461 if ((ret = copy_chapters(i, j)) < 0)
2466 /* open files and write file headers */
2467 for(i=0;i<nb_output_files;i++) {
2468 os = output_files[i];
2469 if (avformat_write_header(os, &output_opts[i]) < 0) {
2470 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2471 ret = AVERROR(EINVAL);
2474 assert_avoptions(output_opts[i]);
2475 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2481 /* dump the file output parameters - cannot be done before in case
2483 for(i=0;i<nb_output_files;i++) {
2484 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2487 /* dump the stream mapping */
2489 fprintf(stderr, "Stream mapping:\n");
2490 for(i=0;i<nb_ostreams;i++) {
2492 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2493 input_streams[ost->source_index].file_index,
2494 input_streams[ost->source_index].st->index,
2497 if (ost->sync_ist != &input_streams[ost->source_index])
2498 fprintf(stderr, " [sync #%d.%d]",
2499 ost->sync_ist->file_index,
2500 ost->sync_ist->st->index);
2501 fprintf(stderr, "\n");
2506 fprintf(stderr, "%s\n", error);
2511 print_sdp(output_files, nb_output_files);
2515 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2518 timer_start = av_gettime();
2520 for(; received_sigterm == 0;) {
2521 int file_index, ist_index;
2530 /* select the stream that we must read now by looking at the
2531 smallest output pts */
2533 for(i=0;i<nb_ostreams;i++) {
2536 os = output_files[ost->file_index];
2537 ist = &input_streams[ost->source_index];
2538 if(ist->is_past_recording_time || no_packet[ist->file_index])
2540 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2541 ipts = (double)ist->pts;
2542 if (!input_files[ist->file_index].eof_reached){
2543 if(ipts < ipts_min) {
2545 if(input_sync ) file_index = ist->file_index;
2547 if(opts < opts_min) {
2549 if(!input_sync) file_index = ist->file_index;
2552 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2557 /* if none, if is finished */
2558 if (file_index < 0) {
2559 if(no_packet_count){
2561 memset(no_packet, 0, sizeof(no_packet));
2568 /* finish if limit size exhausted */
2569 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2572 /* read a frame from it and output it in the fifo */
2573 is = input_files[file_index].ctx;
2574 ret= av_read_frame(is, &pkt);
2575 if(ret == AVERROR(EAGAIN)){
2576 no_packet[file_index]=1;
2581 input_files[file_index].eof_reached = 1;
2589 memset(no_packet, 0, sizeof(no_packet));
2592 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2593 is->streams[pkt.stream_index]);
2595 /* the following test is needed in case new streams appear
2596 dynamically in stream : we ignore them */
2597 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2598 goto discard_packet;
2599 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2600 ist = &input_streams[ist_index];
2602 goto discard_packet;
2604 if (pkt.dts != AV_NOPTS_VALUE)
2605 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2606 if (pkt.pts != AV_NOPTS_VALUE)
2607 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2609 if (ist->ts_scale) {
2610 if(pkt.pts != AV_NOPTS_VALUE)
2611 pkt.pts *= ist->ts_scale;
2612 if(pkt.dts != AV_NOPTS_VALUE)
2613 pkt.dts *= ist->ts_scale;
2616 // 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);
2617 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2618 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2619 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2620 int64_t delta= pkt_dts - ist->next_pts;
2621 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2622 input_files[ist->file_index].ts_offset -= delta;
2624 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2625 delta, input_files[ist->file_index].ts_offset);
2626 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2627 if(pkt.pts != AV_NOPTS_VALUE)
2628 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2632 /* finish if recording time exhausted */
2633 if (recording_time != INT64_MAX &&
2634 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2635 ist->is_past_recording_time = 1;
2636 goto discard_packet;
2639 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2640 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2643 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2644 ist->file_index, ist->st->index);
2647 av_free_packet(&pkt);
2652 av_free_packet(&pkt);
2654 /* dump report by using the output first video and audio streams */
2655 print_report(output_files, ost_table, nb_ostreams, 0);
2658 /* at the end of stream, we must flush the decoder buffers */
2659 for (i = 0; i < nb_input_streams; i++) {
2660 ist = &input_streams[i];
2661 if (ist->decoding_needed) {
2662 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2668 /* write the trailer if needed and close file */
2669 for(i=0;i<nb_output_files;i++) {
2670 os = output_files[i];
2671 av_write_trailer(os);
2674 /* dump report by using the first video and audio streams */
2675 print_report(output_files, ost_table, nb_ostreams, 1);
2677 /* close each encoder */
2678 for(i=0;i<nb_ostreams;i++) {
2680 if (ost->encoding_needed) {
2681 av_freep(&ost->st->codec->stats_in);
2682 avcodec_close(ost->st->codec);
2685 avfilter_graph_free(&ost->graph);
2689 /* close each decoder */
2690 for (i = 0; i < nb_input_streams; i++) {
2691 ist = &input_streams[i];
2692 if (ist->decoding_needed) {
2693 avcodec_close(ist->st->codec);
2701 av_freep(&bit_buffer);
2704 for(i=0;i<nb_ostreams;i++) {
2707 if (ost->st->stream_copy)
2708 av_freep(&ost->st->codec->extradata);
2710 fclose(ost->logfile);
2711 ost->logfile = NULL;
2713 av_fifo_free(ost->fifo); /* works even if fifo is not
2714 initialized but set to zero */
2715 av_freep(&ost->st->codec->subtitle_header);
2716 av_free(ost->pict_tmp.data[0]);
2717 av_free(ost->forced_kf_pts);
2718 if (ost->video_resample)
2719 sws_freeContext(ost->img_resample_ctx);
2721 audio_resample_close(ost->resample);
2722 if (ost->reformat_ctx)
2723 av_audio_convert_free(ost->reformat_ctx);
2732 static int opt_format(const char *opt, const char *arg)
2734 last_asked_format = arg;
2738 static int opt_video_rc_override_string(const char *opt, const char *arg)
2740 video_rc_override_string = arg;
2744 static int opt_me_threshold(const char *opt, const char *arg)
2746 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2750 static int opt_verbose(const char *opt, const char *arg)
2752 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2756 static int opt_frame_rate(const char *opt, const char *arg)
2758 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2759 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2765 static int opt_bitrate(const char *opt, const char *arg)
2767 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2769 opt_default(opt, arg);
2771 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2772 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2777 static int opt_frame_crop(const char *opt, const char *arg)
2779 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2780 return AVERROR(EINVAL);
2783 static int opt_frame_size(const char *opt, const char *arg)
2785 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2786 fprintf(stderr, "Incorrect frame size\n");
2787 return AVERROR(EINVAL);
2792 static int opt_pad(const char *opt, const char *arg) {
2793 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2797 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2799 if (strcmp(arg, "list")) {
2800 frame_pix_fmt = av_get_pix_fmt(arg);
2801 if (frame_pix_fmt == PIX_FMT_NONE) {
2802 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2803 return AVERROR(EINVAL);
2812 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2819 p = strchr(arg, ':');
2821 x = strtol(arg, &end, 10);
2823 y = strtol(end+1, &end, 10);
2825 ar = (double)x / (double)y;
2827 ar = strtod(arg, NULL);
2830 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2831 return AVERROR(EINVAL);
2833 frame_aspect_ratio = ar;
2837 static int opt_metadata(const char *opt, const char *arg)
2839 char *mid= strchr(arg, '=');
2842 fprintf(stderr, "Missing =\n");
2847 av_dict_set(&metadata, arg, mid, 0);
2852 static int opt_qscale(const char *opt, const char *arg)
2854 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2855 if (video_qscale == 0) {
2856 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2857 return AVERROR(EINVAL);
2862 static int opt_top_field_first(const char *opt, const char *arg)
2864 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2868 static int opt_thread_count(const char *opt, const char *arg)
2870 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2873 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2878 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2880 if (strcmp(arg, "list")) {
2881 audio_sample_fmt = av_get_sample_fmt(arg);
2882 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2883 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2884 return AVERROR(EINVAL);
2889 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2890 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2896 static int opt_audio_rate(const char *opt, const char *arg)
2898 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2902 static int opt_audio_channels(const char *opt, const char *arg)
2904 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2908 static int opt_video_channel(const char *opt, const char *arg)
2910 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2911 opt_default("channel", arg);
2915 static int opt_video_standard(const char *opt, const char *arg)
2917 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2918 opt_default("standard", arg);
2922 static int opt_codec(int *pstream_copy, char **pcodec_name,
2923 int codec_type, const char *arg)
2925 av_freep(pcodec_name);
2926 if (!strcmp(arg, "copy")) {
2929 *pcodec_name = av_strdup(arg);
2934 static int opt_audio_codec(const char *opt, const char *arg)
2936 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2939 static int opt_video_codec(const char *opt, const char *arg)
2941 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2944 static int opt_subtitle_codec(const char *opt, const char *arg)
2946 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2949 static int opt_data_codec(const char *opt, const char *arg)
2951 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2954 static int opt_codec_tag(const char *opt, const char *arg)
2957 uint32_t *codec_tag;
2959 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2960 !strcmp(opt, "vtag") ? &video_codec_tag :
2961 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2965 *codec_tag = strtol(arg, &tail, 0);
2967 *codec_tag = AV_RL32(arg);
2972 static int opt_map(const char *opt, const char *arg)
2977 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2978 m = &stream_maps[nb_stream_maps-1];
2980 m->file_index = strtol(arg, &p, 0);
2984 m->stream_index = strtol(p, &p, 0);
2987 m->sync_file_index = strtol(p, &p, 0);
2990 m->sync_stream_index = strtol(p, &p, 0);
2992 m->sync_file_index = m->file_index;
2993 m->sync_stream_index = m->stream_index;
2998 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3009 *index = strtol(++arg, endptr, 0);
3012 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3019 static int opt_map_metadata(const char *opt, const char *arg)
3021 MetadataMap *m, *m1;
3024 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3025 &nb_meta_data_maps, nb_meta_data_maps + 1);
3027 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3028 m->file = strtol(arg, &p, 0);
3029 parse_meta_type(p, &m->type, &m->index, &p);
3033 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3034 m1->file = strtol(p, &p, 0);
3035 parse_meta_type(p, &m1->type, &m1->index, &p);
3037 if (m->type == 'g' || m1->type == 'g')
3038 metadata_global_autocopy = 0;
3039 if (m->type == 's' || m1->type == 's')
3040 metadata_streams_autocopy = 0;
3041 if (m->type == 'c' || m1->type == 'c')
3042 metadata_chapters_autocopy = 0;
3047 static int opt_map_meta_data(const char *opt, const char *arg)
3049 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3050 "Use -map_metadata instead.\n");
3051 return opt_map_metadata(opt, arg);
3054 static int opt_map_chapters(const char *opt, const char *arg)
3059 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3060 nb_chapter_maps + 1);
3061 c = &chapter_maps[nb_chapter_maps - 1];
3062 c->out_file = strtol(arg, &p, 0);
3066 c->in_file = strtol(p, &p, 0);
3070 static int opt_input_ts_scale(const char *opt, const char *arg)
3072 unsigned int stream;
3076 stream = strtol(arg, &p, 0);
3079 scale= strtod(p, &p);
3081 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3082 ts_scale[stream] = scale;
3086 static int opt_recording_time(const char *opt, const char *arg)
3088 recording_time = parse_time_or_die(opt, arg, 1);
3092 static int opt_start_time(const char *opt, const char *arg)
3094 start_time = parse_time_or_die(opt, arg, 1);
3098 static int opt_recording_timestamp(const char *opt, const char *arg)
3101 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3102 struct tm time = *gmtime((time_t*)&recording_timestamp);
3103 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3104 opt_metadata("metadata", buf);
3106 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3107 "tag instead.\n", opt);
3111 static int opt_input_ts_offset(const char *opt, const char *arg)
3113 input_ts_offset = parse_time_or_die(opt, arg, 1);
3117 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3119 const char *codec_string = encoder ? "encoder" : "decoder";
3123 return CODEC_ID_NONE;
3125 avcodec_find_encoder_by_name(name) :
3126 avcodec_find_decoder_by_name(name);
3128 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3131 if(codec->type != type) {
3132 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3135 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3136 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3137 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3138 "results.\nAdd '-strict experimental' if you want to use it.\n",
3139 codec_string, codec->name);
3141 avcodec_find_encoder(codec->id) :
3142 avcodec_find_decoder(codec->id);
3143 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3144 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3145 codec_string, codec->name);
3151 static int opt_input_file(const char *opt, const char *filename)
3153 AVFormatContext *ic;
3154 AVInputFormat *file_iformat = NULL;
3155 int err, i, ret, rfps, rfps_base;
3159 if (last_asked_format) {
3160 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3161 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3164 last_asked_format = NULL;
3167 if (!strcmp(filename, "-"))
3170 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3171 !strcmp(filename, "/dev/stdin");
3173 /* get default parameters from command line */
3174 ic = avformat_alloc_context();
3176 print_error(filename, AVERROR(ENOMEM));
3179 if (audio_sample_rate) {
3180 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3181 av_dict_set(&format_opts, "sample_rate", buf, 0);
3183 if (audio_channels) {
3184 snprintf(buf, sizeof(buf), "%d", audio_channels);
3185 av_dict_set(&format_opts, "channels", buf, 0);
3187 if (frame_rate.num) {
3188 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3189 av_dict_set(&format_opts, "framerate", buf, 0);
3191 if (frame_width && frame_height) {
3192 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3193 av_dict_set(&format_opts, "video_size", buf, 0);
3195 if (frame_pix_fmt != PIX_FMT_NONE)
3196 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3198 ic->video_codec_id =
3199 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3200 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3201 ic->audio_codec_id =
3202 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3203 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3204 ic->subtitle_codec_id=
3205 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3206 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3207 ic->flags |= AVFMT_FLAG_NONBLOCK;
3209 /* open the input file with generic libav function */
3210 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3212 print_error(filename, err);
3215 assert_avoptions(format_opts);
3220 for(i=0; i<ic->nb_streams; i++){
3221 ic->streams[i]->discard= AVDISCARD_ALL;
3223 for(i=0; i<ic->nb_programs; i++){
3224 AVProgram *p= ic->programs[i];
3225 if(p->id != opt_programid){
3226 p->discard = AVDISCARD_ALL;
3229 for(j=0; j<p->nb_stream_indexes; j++){
3230 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3235 fprintf(stderr, "Specified program id not found\n");
3242 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3243 ic->loop_input = loop_input;
3246 /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3247 for (i = 0; i < ic->nb_streams; i++) {
3248 AVCodecContext *dec = ic->streams[i]->codec;
3249 switch (dec->codec_type) {
3250 case AVMEDIA_TYPE_AUDIO:
3251 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3252 AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3255 case AVMEDIA_TYPE_VIDEO:
3256 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3257 AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3263 /* If not enough info to get the stream parameters, we decode the
3264 first frames to get it. (used in mpeg case for example) */
3265 ret = av_find_stream_info(ic);
3266 if (ret < 0 && verbose >= 0) {
3267 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3268 av_close_input_file(ic);
3272 timestamp = start_time;
3273 /* add the stream start time */
3274 if (ic->start_time != AV_NOPTS_VALUE)
3275 timestamp += ic->start_time;
3277 /* if seeking requested, we execute it */
3278 if (start_time != 0) {
3279 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3281 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3282 filename, (double)timestamp / AV_TIME_BASE);
3284 /* reset seek info */
3288 /* update the current parameters so that they match the one of the input stream */
3289 for(i=0;i<ic->nb_streams;i++) {
3290 AVStream *st = ic->streams[i];
3291 AVCodecContext *dec = st->codec;
3294 dec->thread_count = thread_count;
3296 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3297 ist = &input_streams[nb_input_streams - 1];
3299 ist->file_index = nb_input_files;
3302 if (i < nb_ts_scale)
3303 ist->ts_scale = ts_scale[i];
3305 switch (dec->codec_type) {
3306 case AVMEDIA_TYPE_AUDIO:
3307 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3308 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3310 st->discard= AVDISCARD_ALL;
3312 case AVMEDIA_TYPE_VIDEO:
3313 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3314 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3315 rfps = ic->streams[i]->r_frame_rate.num;
3316 rfps_base = ic->streams[i]->r_frame_rate.den;
3318 dec->flags |= CODEC_FLAG_EMU_EDGE;
3319 dec->height >>= dec->lowres;
3320 dec->width >>= dec->lowres;
3323 dec->debug |= FF_DEBUG_MV;
3325 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3328 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3329 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3331 (float)rfps / rfps_base, rfps, rfps_base);
3335 st->discard= AVDISCARD_ALL;
3336 else if(video_discard)
3337 st->discard= video_discard;
3339 case AVMEDIA_TYPE_DATA:
3341 case AVMEDIA_TYPE_SUBTITLE:
3342 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3343 if(subtitle_disable)
3344 st->discard = AVDISCARD_ALL;
3346 case AVMEDIA_TYPE_ATTACHMENT:
3347 case AVMEDIA_TYPE_UNKNOWN:
3354 /* dump the file content */
3356 av_dump_format(ic, nb_input_files, filename, 0);
3358 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3359 input_files[nb_input_files - 1].ctx = ic;
3360 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3361 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3363 frame_rate = (AVRational){0, 0};
3364 frame_pix_fmt = PIX_FMT_NONE;
3367 audio_sample_rate = 0;
3369 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3370 av_freep(&ts_scale);
3373 av_freep(&video_codec_name);
3374 av_freep(&audio_codec_name);
3375 av_freep(&subtitle_codec_name);
3381 static void check_inputs(int *has_video_ptr,
3383 int *has_subtitle_ptr,
3386 int has_video, has_audio, has_subtitle, has_data, i, j;
3387 AVFormatContext *ic;
3394 for(j=0;j<nb_input_files;j++) {
3395 ic = input_files[j].ctx;
3396 for(i=0;i<ic->nb_streams;i++) {
3397 AVCodecContext *enc = ic->streams[i]->codec;
3398 switch(enc->codec_type) {
3399 case AVMEDIA_TYPE_AUDIO:
3402 case AVMEDIA_TYPE_VIDEO:
3405 case AVMEDIA_TYPE_SUBTITLE:
3408 case AVMEDIA_TYPE_DATA:
3409 case AVMEDIA_TYPE_ATTACHMENT:
3410 case AVMEDIA_TYPE_UNKNOWN:
3418 *has_video_ptr = has_video;
3419 *has_audio_ptr = has_audio;
3420 *has_subtitle_ptr = has_subtitle;
3421 *has_data_ptr = has_data;
3424 static void new_video_stream(AVFormatContext *oc, int file_idx)
3428 AVCodecContext *video_enc;
3429 enum CodecID codec_id = CODEC_ID_NONE;
3430 AVCodec *codec= NULL;
3432 if(!video_stream_copy){
3433 if (video_codec_name) {
3434 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3435 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3436 codec = avcodec_find_encoder_by_name(video_codec_name);
3438 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3439 codec = avcodec_find_encoder(codec_id);
3443 ost = new_output_stream(oc, file_idx, codec);
3445 if (!video_stream_copy) {
3446 ost->frame_aspect_ratio = frame_aspect_ratio;
3447 frame_aspect_ratio = 0;
3449 ost->avfilter= vfilters;
3454 ost->bitstream_filters = video_bitstream_filters;
3455 video_bitstream_filters= NULL;
3457 st->codec->thread_count= thread_count;
3459 video_enc = st->codec;
3462 video_enc->codec_tag= video_codec_tag;
3464 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3465 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3466 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3469 if (video_stream_copy) {
3470 st->stream_copy = 1;
3471 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3472 video_enc->sample_aspect_ratio =
3473 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3479 ost->frame_rate = frame_rate;
3480 video_enc->codec_id = codec_id;
3481 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3483 video_enc->width = frame_width;
3484 video_enc->height = frame_height;
3485 video_enc->pix_fmt = frame_pix_fmt;
3486 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3489 video_enc->gop_size = 0;
3490 if (video_qscale || same_quality) {
3491 video_enc->flags |= CODEC_FLAG_QSCALE;
3492 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3496 video_enc->intra_matrix = intra_matrix;
3498 video_enc->inter_matrix = inter_matrix;
3500 p= video_rc_override_string;
3503 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3505 fprintf(stderr, "error parsing rc_override\n");
3508 video_enc->rc_override=
3509 av_realloc(video_enc->rc_override,
3510 sizeof(RcOverride)*(i+1));
3511 video_enc->rc_override[i].start_frame= start;
3512 video_enc->rc_override[i].end_frame = end;
3514 video_enc->rc_override[i].qscale= q;
3515 video_enc->rc_override[i].quality_factor= 1.0;
3518 video_enc->rc_override[i].qscale= 0;
3519 video_enc->rc_override[i].quality_factor= -q/100.0;
3524 video_enc->rc_override_count=i;
3525 if (!video_enc->rc_initial_buffer_occupancy)
3526 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3527 video_enc->me_threshold= me_threshold;
3528 video_enc->intra_dc_precision= intra_dc_precision - 8;
3531 video_enc->flags|= CODEC_FLAG_PSNR;
3536 video_enc->flags |= CODEC_FLAG_PASS1;
3538 video_enc->flags |= CODEC_FLAG_PASS2;
3542 if (forced_key_frames)
3543 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3545 if (video_language) {
3546 av_dict_set(&st->metadata, "language", video_language, 0);
3547 av_freep(&video_language);
3550 /* reset some key parameters */
3552 av_freep(&video_codec_name);
3553 av_freep(&forced_key_frames);
3554 video_stream_copy = 0;
3555 frame_pix_fmt = PIX_FMT_NONE;
3558 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3562 AVCodec *codec= NULL;
3563 AVCodecContext *audio_enc;
3564 enum CodecID codec_id = CODEC_ID_NONE;
3566 if(!audio_stream_copy){
3567 if (audio_codec_name) {
3568 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3569 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3570 codec = avcodec_find_encoder_by_name(audio_codec_name);
3572 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3573 codec = avcodec_find_encoder(codec_id);
3576 ost = new_output_stream(oc, file_idx, codec);
3579 ost->bitstream_filters = audio_bitstream_filters;
3580 audio_bitstream_filters= NULL;
3582 st->codec->thread_count= thread_count;
3584 audio_enc = st->codec;
3585 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3588 audio_enc->codec_tag= audio_codec_tag;
3590 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3591 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3592 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3594 if (audio_stream_copy) {
3595 st->stream_copy = 1;
3597 audio_enc->codec_id = codec_id;
3598 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3600 if (audio_qscale > QSCALE_NONE) {
3601 audio_enc->flags |= CODEC_FLAG_QSCALE;
3602 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3605 audio_enc->channels = audio_channels;
3606 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3607 audio_enc->sample_fmt = audio_sample_fmt;
3608 if (audio_sample_rate)
3609 audio_enc->sample_rate = audio_sample_rate;
3611 if (audio_language) {
3612 av_dict_set(&st->metadata, "language", audio_language, 0);
3613 av_freep(&audio_language);
3616 /* reset some key parameters */
3618 av_freep(&audio_codec_name);
3619 audio_stream_copy = 0;
3622 static void new_data_stream(AVFormatContext *oc, int file_idx)
3626 AVCodecContext *data_enc;
3628 ost = new_output_stream(oc, file_idx, NULL);
3630 data_enc = st->codec;
3631 if (!data_stream_copy) {
3632 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3636 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3639 data_enc->codec_tag= data_codec_tag;
3641 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3642 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3643 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3645 if (data_stream_copy) {
3646 st->stream_copy = 1;
3650 av_freep(&data_codec_name);
3651 data_stream_copy = 0;
3654 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3658 AVCodec *codec=NULL;
3659 AVCodecContext *subtitle_enc;
3660 enum CodecID codec_id = CODEC_ID_NONE;
3662 if(!subtitle_stream_copy){
3663 if (subtitle_codec_name) {
3664 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3665 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3666 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3668 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3669 codec = avcodec_find_encoder(codec_id);
3672 ost = new_output_stream(oc, file_idx, codec);
3674 subtitle_enc = st->codec;
3676 ost->bitstream_filters = subtitle_bitstream_filters;
3677 subtitle_bitstream_filters= NULL;
3679 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3681 if(subtitle_codec_tag)
3682 subtitle_enc->codec_tag= subtitle_codec_tag;
3684 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3685 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3686 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3688 if (subtitle_stream_copy) {
3689 st->stream_copy = 1;
3691 subtitle_enc->codec_id = codec_id;
3692 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3695 if (subtitle_language) {
3696 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3697 av_freep(&subtitle_language);
3700 subtitle_disable = 0;
3701 av_freep(&subtitle_codec_name);
3702 subtitle_stream_copy = 0;
3705 static int opt_new_stream(const char *opt, const char *arg)
3707 AVFormatContext *oc;
3708 int file_idx = nb_output_files - 1;
3709 if (nb_output_files <= 0) {
3710 fprintf(stderr, "At least one output file must be specified\n");
3713 oc = output_files[file_idx];
3715 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3716 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3717 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3718 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3723 /* arg format is "output-stream-index:streamid-value". */
3724 static int opt_streamid(const char *opt, const char *arg)
3730 av_strlcpy(idx_str, arg, sizeof(idx_str));
3731 p = strchr(idx_str, ':');
3734 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3739 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3740 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3741 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3745 static void opt_output_file(const char *filename)
3747 AVFormatContext *oc;
3748 int err, use_video, use_audio, use_subtitle, use_data;
3749 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3750 AVOutputFormat *file_oformat;
3752 if (!strcmp(filename, "-"))
3755 oc = avformat_alloc_context();
3757 print_error(filename, AVERROR(ENOMEM));
3761 if (last_asked_format) {
3762 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3763 if (!file_oformat) {
3764 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3767 last_asked_format = NULL;
3769 file_oformat = av_guess_format(NULL, filename, NULL);
3770 if (!file_oformat) {
3771 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3777 oc->oformat = file_oformat;
3778 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3780 if (!strcmp(file_oformat->name, "ffm") &&
3781 av_strstart(filename, "http:", NULL)) {
3782 /* special case for files sent to ffserver: we get the stream
3783 parameters from ffserver */
3784 int err = read_ffserver_streams(oc, filename);
3786 print_error(filename, err);
3790 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3791 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3792 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3793 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 */
3795 /* disable if no corresponding type found */
3796 check_inputs(&input_has_video,
3798 &input_has_subtitle,
3801 if (!input_has_video)
3803 if (!input_has_audio)
3805 if (!input_has_subtitle)
3807 if (!input_has_data)
3810 /* manual disable */
3811 if (audio_disable) use_audio = 0;
3812 if (video_disable) use_video = 0;
3813 if (subtitle_disable) use_subtitle = 0;
3814 if (data_disable) use_data = 0;
3816 if (use_video) new_video_stream(oc, nb_output_files);
3817 if (use_audio) new_audio_stream(oc, nb_output_files);
3818 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3819 if (use_data) new_data_stream(oc, nb_output_files);
3821 av_dict_copy(&oc->metadata, metadata, 0);
3822 av_dict_free(&metadata);
3825 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3826 output_files[nb_output_files++] = oc;
3828 /* check filename in case of an image number is expected */
3829 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3830 if (!av_filename_number_test(oc->filename)) {
3831 print_error(oc->filename, AVERROR(EINVAL));
3836 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3837 /* test if it already exists to avoid loosing precious files */
3838 if (!file_overwrite &&
3839 (strchr(filename, ':') == NULL ||
3840 filename[1] == ':' ||
3841 av_strstart(filename, "file:", NULL))) {
3842 if (avio_check(filename, 0) == 0) {
3844 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3846 if (!read_yesno()) {
3847 fprintf(stderr, "Not overwriting - exiting\n");
3852 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3859 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3860 print_error(filename, err);
3865 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3866 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3867 if (loop_output >= 0) {
3868 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3869 oc->loop_output = loop_output;
3871 oc->flags |= AVFMT_FLAG_NONBLOCK;
3873 frame_rate = (AVRational){0, 0};
3876 audio_sample_rate = 0;
3878 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3880 av_freep(&forced_key_frames);
3885 /* same option as mencoder */
3886 static int opt_pass(const char *opt, const char *arg)
3888 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3892 static int64_t getutime(void)
3895 struct rusage rusage;
3897 getrusage(RUSAGE_SELF, &rusage);
3898 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3899 #elif HAVE_GETPROCESSTIMES
3901 FILETIME c, e, k, u;
3902 proc = GetCurrentProcess();
3903 GetProcessTimes(proc, &c, &e, &k, &u);
3904 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3906 return av_gettime();
3910 static int64_t getmaxrss(void)
3912 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3913 struct rusage rusage;
3914 getrusage(RUSAGE_SELF, &rusage);
3915 return (int64_t)rusage.ru_maxrss * 1024;
3916 #elif HAVE_GETPROCESSMEMORYINFO
3918 PROCESS_MEMORY_COUNTERS memcounters;
3919 proc = GetCurrentProcess();
3920 memcounters.cb = sizeof(memcounters);
3921 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3922 return memcounters.PeakPagefileUsage;
3928 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3931 const char *p = str;
3938 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3945 static void opt_inter_matrix(const char *arg)
3947 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3948 parse_matrix_coeffs(inter_matrix, arg);
3951 static void opt_intra_matrix(const char *arg)
3953 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3954 parse_matrix_coeffs(intra_matrix, arg);
3957 static void show_usage(void)
3959 printf("Hyper fast Audio and Video encoder\n");
3960 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3964 static void show_help(void)
3967 AVOutputFormat *oformat = NULL;
3968 AVInputFormat *iformat = NULL;
3970 av_log_set_callback(log_callback_help);
3972 show_help_options(options, "Main options:\n",
3973 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3974 show_help_options(options, "\nAdvanced options:\n",
3975 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3977 show_help_options(options, "\nVideo options:\n",
3978 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3980 show_help_options(options, "\nAdvanced Video options:\n",
3981 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3982 OPT_VIDEO | OPT_EXPERT);
3983 show_help_options(options, "\nAudio options:\n",
3984 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3986 show_help_options(options, "\nAdvanced Audio options:\n",
3987 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3988 OPT_AUDIO | OPT_EXPERT);
3989 show_help_options(options, "\nSubtitle options:\n",
3990 OPT_SUBTITLE | OPT_GRAB,
3992 show_help_options(options, "\nAudio/Video grab options:\n",
3996 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3999 /* individual codec options */
4001 while ((c = av_codec_next(c))) {
4002 if (c->priv_class) {
4003 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4008 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4011 /* individual muxer options */
4012 while ((oformat = av_oformat_next(oformat))) {
4013 if (oformat->priv_class) {
4014 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4019 /* individual demuxer options */
4020 while ((iformat = av_iformat_next(iformat))) {
4021 if (iformat->priv_class) {
4022 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4027 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4030 static int opt_target(const char *opt, const char *arg)
4032 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4033 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4035 if(!strncmp(arg, "pal-", 4)) {
4038 } else if(!strncmp(arg, "ntsc-", 5)) {
4041 } else if(!strncmp(arg, "film-", 5)) {
4046 /* Calculate FR via float to avoid int overflow */
4047 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4050 } else if((fr == 29970) || (fr == 23976)) {
4053 /* Try to determine PAL/NTSC by peeking in the input files */
4054 if(nb_input_files) {
4056 for (j = 0; j < nb_input_files; j++) {
4057 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4058 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4059 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4061 fr = c->time_base.den * 1000 / c->time_base.num;
4065 } else if((fr == 29970) || (fr == 23976)) {
4075 if(verbose > 0 && norm != UNKNOWN)
4076 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4079 if(norm == UNKNOWN) {
4080 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4081 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4082 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4086 if(!strcmp(arg, "vcd")) {
4087 opt_video_codec("vcodec", "mpeg1video");
4088 opt_audio_codec("vcodec", "mp2");
4089 opt_format("f", "vcd");
4091 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4092 opt_frame_rate("r", frame_rates[norm]);
4093 opt_default("g", norm == PAL ? "15" : "18");
4095 opt_default("b", "1150000");
4096 opt_default("maxrate", "1150000");
4097 opt_default("minrate", "1150000");
4098 opt_default("bufsize", "327680"); // 40*1024*8;
4100 opt_default("ab", "224000");
4101 audio_sample_rate = 44100;
4104 opt_default("packetsize", "2324");
4105 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4107 /* We have to offset the PTS, so that it is consistent with the SCR.
4108 SCR starts at 36000, but the first two packs contain only padding
4109 and the first pack from the other stream, respectively, may also have
4110 been written before.
4111 So the real data starts at SCR 36000+3*1200. */
4112 mux_preload= (36000+3*1200) / 90000.0; //0.44
4113 } else if(!strcmp(arg, "svcd")) {
4115 opt_video_codec("vcodec", "mpeg2video");
4116 opt_audio_codec("acodec", "mp2");
4117 opt_format("f", "svcd");
4119 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4120 opt_frame_rate("r", frame_rates[norm]);
4121 opt_default("g", norm == PAL ? "15" : "18");
4123 opt_default("b", "2040000");
4124 opt_default("maxrate", "2516000");
4125 opt_default("minrate", "0"); //1145000;
4126 opt_default("bufsize", "1835008"); //224*1024*8;
4127 opt_default("flags", "+scan_offset");
4130 opt_default("ab", "224000");
4131 audio_sample_rate = 44100;
4133 opt_default("packetsize", "2324");
4135 } else if(!strcmp(arg, "dvd")) {
4137 opt_video_codec("vcodec", "mpeg2video");
4138 opt_audio_codec("vcodec", "ac3");
4139 opt_format("f", "dvd");
4141 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4142 opt_frame_rate("r", frame_rates[norm]);
4143 opt_default("g", norm == PAL ? "15" : "18");
4145 opt_default("b", "6000000");
4146 opt_default("maxrate", "9000000");
4147 opt_default("minrate", "0"); //1500000;
4148 opt_default("bufsize", "1835008"); //224*1024*8;
4150 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4151 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4153 opt_default("ab", "448000");
4154 audio_sample_rate = 48000;
4156 } else if(!strncmp(arg, "dv", 2)) {
4158 opt_format("f", "dv");
4160 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4161 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4162 norm == PAL ? "yuv420p" : "yuv411p");
4163 opt_frame_rate("r", frame_rates[norm]);
4165 audio_sample_rate = 48000;
4169 fprintf(stderr, "Unknown target: %s\n", arg);
4170 return AVERROR(EINVAL);
4175 static int opt_vstats_file(const char *opt, const char *arg)
4177 av_free (vstats_filename);
4178 vstats_filename=av_strdup (arg);
4182 static int opt_vstats(const char *opt, const char *arg)
4185 time_t today2 = time(NULL);
4186 struct tm *today = localtime(&today2);
4188 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4190 return opt_vstats_file(opt, filename);
4193 static int opt_bsf(const char *opt, const char *arg)
4195 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4196 AVBitStreamFilterContext **bsfp;
4199 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4203 bsfp= *opt == 'v' ? &video_bitstream_filters :
4204 *opt == 'a' ? &audio_bitstream_filters :
4205 &subtitle_bitstream_filters;
4207 bsfp= &(*bsfp)->next;
4214 static int opt_preset(const char *opt, const char *arg)
4217 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4218 char *codec_name = *opt == 'v' ? video_codec_name :
4219 *opt == 'a' ? audio_codec_name :
4220 subtitle_codec_name;
4222 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4223 fprintf(stderr, "File for preset '%s' not found\n", arg);
4228 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4229 if(line[0] == '#' && !e)
4231 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4233 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4236 if(!strcmp(tmp, "acodec")){
4237 opt_audio_codec(tmp, tmp2);
4238 }else if(!strcmp(tmp, "vcodec")){
4239 opt_video_codec(tmp, tmp2);
4240 }else if(!strcmp(tmp, "scodec")){
4241 opt_subtitle_codec(tmp, tmp2);
4242 }else if(!strcmp(tmp, "dcodec")){
4243 opt_data_codec(tmp, tmp2);
4244 }else if(opt_default(tmp, tmp2) < 0){
4245 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4255 static const OptionDef options[] = {
4257 #include "cmdutils_common_opts.h"
4258 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4259 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4260 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4261 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4262 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4263 "outfile[,metadata]:infile[,metadata]" },
4264 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4265 "outfile[,metadata]:infile[,metadata]" },
4266 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4267 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4268 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4269 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4270 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4271 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4272 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4273 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4274 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4275 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4276 "add timings for benchmarking" },
4277 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4278 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4279 "dump each input packet" },
4280 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4281 "when dumping packets, also dump the payload" },
4282 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4283 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4284 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4285 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4286 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4287 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4288 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4289 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4290 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4291 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4292 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4293 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4294 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4295 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4296 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4297 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4300 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4301 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4302 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4303 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4304 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4305 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4306 { "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" },
4307 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4308 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4309 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4310 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4311 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4312 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4313 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4314 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4315 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4316 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4317 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4318 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4319 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4320 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4321 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4322 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4323 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4324 "use same quantizer as source (implies VBR)" },
4325 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4326 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4327 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4328 "deinterlace pictures" },
4329 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4330 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4331 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4333 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4335 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4336 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4337 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4338 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4339 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4340 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4341 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4342 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4343 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4344 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4345 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4348 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4349 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4350 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4351 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4352 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4353 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4354 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4355 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4356 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4357 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4358 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4359 { "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" },
4361 /* subtitle options */
4362 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4363 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4364 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4365 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4366 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4369 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4370 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4371 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4374 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4375 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4377 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4378 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4379 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4381 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4382 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4383 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4384 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4385 /* data codec support */
4386 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4388 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4392 int main(int argc, char **argv)
4396 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4398 avcodec_register_all();
4400 avdevice_register_all();
4403 avfilter_register_all();
4407 avio_set_interrupt_cb(decode_interrupt_cb);
4414 parse_options(argc, argv, options, opt_output_file);
4416 if(nb_output_files <= 0 && nb_input_files == 0) {
4418 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4422 /* file converter / grab */
4423 if (nb_output_files <= 0) {
4424 fprintf(stderr, "At least one output file must be specified\n");
4428 if (nb_input_files == 0) {
4429 fprintf(stderr, "At least one input file must be specified\n");
4434 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4435 stream_maps, nb_stream_maps) < 0)
4437 ti = getutime() - ti;
4439 int maxrss = getmaxrss() / 1024;
4440 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4443 return ffmpeg_exit(0);