3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/vsink_buffer.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "ffmpeg";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
97 int sync_stream_index;
101 * select an input file for an output file
103 typedef struct MetadataMap {
104 int file; //< file index
105 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
106 int index; //< stream/chapter/program number
109 typedef struct ChapterMap {
114 static const OptionDef options[];
116 #define MAX_FILES 100
117 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
119 static const char *last_asked_format = NULL;
120 static double *input_files_ts_scale[MAX_FILES] = {NULL};
121 static int nb_input_files_ts_scale[MAX_FILES] = {0};
123 static AVFormatContext *output_files[MAX_FILES];
124 static int nb_output_files = 0;
126 static StreamMap *stream_maps = NULL;
127 static int nb_stream_maps;
129 /* first item specifies output metadata, second is input */
130 static MetadataMap (*meta_data_maps)[2] = NULL;
131 static int nb_meta_data_maps;
132 static int metadata_global_autocopy = 1;
133 static int metadata_streams_autocopy = 1;
134 static int metadata_chapters_autocopy = 1;
136 static ChapterMap *chapter_maps = NULL;
137 static int nb_chapter_maps;
139 /* indexed by output file stream index */
140 static int *streamid_map = NULL;
141 static int nb_streamid_map = 0;
143 static int frame_width = 0;
144 static int frame_height = 0;
145 static float frame_aspect_ratio = 0;
146 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
147 static int frame_bits_per_raw_sample = 0;
148 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
149 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
150 static AVRational frame_rate;
151 static float video_qscale = 0;
152 static uint16_t *intra_matrix = NULL;
153 static uint16_t *inter_matrix = NULL;
154 static const char *video_rc_override_string=NULL;
155 static int video_disable = 0;
156 static int video_discard = 0;
157 static char *video_codec_name = NULL;
158 static unsigned int video_codec_tag = 0;
159 static char *video_language = NULL;
160 static int same_quality = 0;
161 static int do_deinterlace = 0;
162 static int top_field_first = -1;
163 static int me_threshold = 0;
164 static int intra_dc_precision = 8;
165 static int loop_input = 0;
166 static int loop_output = AVFMT_NOOUTPUTLOOP;
167 static int qp_hist = 0;
169 static char *vfilters = NULL;
172 static int intra_only = 0;
173 static int audio_sample_rate = 0;
174 static int64_t channel_layout = 0;
175 #define QSCALE_NONE -99999
176 static float audio_qscale = QSCALE_NONE;
177 static int audio_disable = 0;
178 static int audio_channels = 0;
179 static char *audio_codec_name = NULL;
180 static unsigned int audio_codec_tag = 0;
181 static char *audio_language = NULL;
183 static int subtitle_disable = 0;
184 static char *subtitle_codec_name = NULL;
185 static char *subtitle_language = NULL;
186 static unsigned int subtitle_codec_tag = 0;
188 static int data_disable = 0;
189 static char *data_codec_name = NULL;
190 static unsigned int data_codec_tag = 0;
192 static float mux_preload= 0.5;
193 static float mux_max_delay= 0.7;
195 static int64_t recording_time = INT64_MAX;
196 static int64_t start_time = 0;
197 static int64_t recording_timestamp = 0;
198 static int64_t input_ts_offset = 0;
199 static int file_overwrite = 0;
200 static AVDictionary *metadata;
201 static int do_benchmark = 0;
202 static int do_hex_dump = 0;
203 static int do_pkt_dump = 0;
204 static int do_psnr = 0;
205 static int do_pass = 0;
206 static const char *pass_logfilename_prefix;
207 static int audio_stream_copy = 0;
208 static int video_stream_copy = 0;
209 static int subtitle_stream_copy = 0;
210 static int data_stream_copy = 0;
211 static int video_sync_method= -1;
212 static int audio_sync_method= 0;
213 static float audio_drift_threshold= 0.1;
214 static int copy_ts= 0;
215 static int copy_tb= 0;
216 static int opt_shortest = 0;
217 static char *vstats_filename;
218 static FILE *vstats_file;
219 static int opt_programid = 0;
220 static int copy_initial_nonkeyframes = 0;
222 static int rate_emu = 0;
224 static int video_channel = 0;
225 static char *video_standard;
227 static int audio_volume = 256;
229 static int exit_on_error = 0;
230 static int using_stdin = 0;
231 static int verbose = 1;
232 static int run_as_daemon = 0;
233 static int thread_count= 1;
234 static int q_pressed = 0;
235 static int64_t video_size = 0;
236 static int64_t audio_size = 0;
237 static int64_t extra_size = 0;
238 static int nb_frames_dup = 0;
239 static int nb_frames_drop = 0;
240 static int input_sync;
241 static uint64_t limit_filesize = 0;
242 static int force_fps = 0;
243 static char *forced_key_frames = NULL;
245 static float dts_delta_threshold = 10;
247 static int64_t timer_start;
249 static uint8_t *audio_buf;
250 static uint8_t *audio_out;
251 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
253 static short *samples;
255 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
256 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
257 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
259 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263 typedef struct OutputStream {
264 int file_index; /* file index */
265 int index; /* stream index in the output file */
266 int source_index; /* InputStream index */
267 AVStream *st; /* stream in the output file */
268 int encoding_needed; /* true if encoding needed for this stream */
270 /* input pts and corresponding output pts
272 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
273 struct InputStream *sync_ist; /* input stream to sync against */
274 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
275 AVBitStreamFilterContext *bitstream_filters;
280 AVFrame resample_frame; /* temporary frame for image resampling */
281 struct SwsContext *img_resample_ctx; /* for image resampling */
284 int resample_pix_fmt;
285 AVRational frame_rate;
287 float frame_aspect_ratio;
289 /* forced key frames */
290 int64_t *forced_kf_pts;
296 ReSampleContext *resample; /* for audio resampling */
297 int resample_sample_fmt;
298 int resample_channels;
299 int resample_sample_rate;
301 AVAudioConvert *reformat_ctx;
302 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
306 AVFilterContext *output_video_filter;
307 AVFilterContext *input_video_filter;
308 AVFilterBufferRef *picref;
310 AVFilterGraph *graph;
316 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
317 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
319 typedef struct InputStream {
322 int discard; /* true if stream data should be discarded */
323 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
326 int64_t start; /* time when read started */
327 int64_t next_pts; /* synthetic pts for cases where pkt.pts
329 int64_t pts; /* current pts */
330 int is_start; /* is 1 at the start and after a discontinuity */
331 int showed_multi_packet_warning;
332 int is_past_recording_time;
335 typedef struct InputFile {
336 AVFormatContext *ctx;
337 int eof_reached; /* true if eof reached */
338 int ist_index; /* index of first stream in ist_table */
339 int buffer_size; /* current total buffer size */
345 /* init terminal so that we can grab keys */
346 static struct termios oldtty;
349 static InputStream *input_streams = NULL;
350 static int nb_input_streams = 0;
351 static InputFile *input_files = NULL;
352 static int nb_input_files = 0;
356 static int configure_video_filters(InputStream *ist, OutputStream *ost)
358 AVFilterContext *last_filter, *filter;
359 /** filter graph containing all filters including input & output */
360 AVCodecContext *codec = ost->st->codec;
361 AVCodecContext *icodec = ist->st->codec;
362 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
363 AVRational sample_aspect_ratio;
367 ost->graph = avfilter_graph_alloc();
369 if (ist->st->sample_aspect_ratio.num){
370 sample_aspect_ratio = ist->st->sample_aspect_ratio;
372 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
374 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
375 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
376 sample_aspect_ratio.num, sample_aspect_ratio.den);
378 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
379 "src", args, NULL, ost->graph);
382 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
383 "out", NULL, pix_fmts, ost->graph);
386 last_filter = ost->input_video_filter;
388 if (codec->width != icodec->width || codec->height != icodec->height) {
389 snprintf(args, 255, "%d:%d:flags=0x%X",
393 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
394 NULL, args, NULL, ost->graph)) < 0)
396 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
398 last_filter = filter;
401 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
402 ost->graph->scale_sws_opts = av_strdup(args);
405 AVFilterInOut *outputs = avfilter_inout_alloc();
406 AVFilterInOut *inputs = avfilter_inout_alloc();
408 outputs->name = av_strdup("in");
409 outputs->filter_ctx = last_filter;
410 outputs->pad_idx = 0;
411 outputs->next = NULL;
413 inputs->name = av_strdup("out");
414 inputs->filter_ctx = ost->output_video_filter;
418 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
420 av_freep(&ost->avfilter);
422 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
426 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
429 codec->width = ost->output_video_filter->inputs[0]->w;
430 codec->height = ost->output_video_filter->inputs[0]->h;
431 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
432 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
433 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
434 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
438 #endif /* CONFIG_AVFILTER */
440 static void term_exit(void)
442 av_log(NULL, AV_LOG_QUIET, "%s", "");
445 tcsetattr (0, TCSANOW, &oldtty);
449 static volatile int received_sigterm = 0;
452 sigterm_handler(int sig)
454 received_sigterm = sig;
459 static void term_init(void)
469 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
470 |INLCR|IGNCR|ICRNL|IXON);
471 tty.c_oflag |= OPOST;
472 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
473 tty.c_cflag &= ~(CSIZE|PARENB);
478 tcsetattr (0, TCSANOW, &tty);
479 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
483 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
484 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
486 signal(SIGXCPU, sigterm_handler);
490 /* read a key without blocking */
491 static int read_key(void)
506 n = select(1, &rfds, NULL, NULL, &tv);
521 static int decode_interrupt_cb(void)
523 q_pressed += read_key() == 'q';
524 return q_pressed > 1;
527 static int ffmpeg_exit(int ret)
532 for(i=0;i<nb_output_files;i++) {
533 AVFormatContext *s = output_files[i];
534 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
536 avformat_free_context(s);
537 av_free(output_streams_for_file[i]);
539 for(i=0;i<nb_input_files;i++) {
540 av_close_input_file(input_files[i].ctx);
541 av_free(input_files_ts_scale[i]);
544 av_free(intra_matrix);
545 av_free(inter_matrix);
549 av_free(vstats_filename);
551 av_free(streamid_map);
552 av_free(stream_maps);
553 av_free(meta_data_maps);
555 av_freep(&input_streams);
556 av_freep(&input_files);
558 av_free(video_codec_name);
559 av_free(audio_codec_name);
560 av_free(subtitle_codec_name);
561 av_free(data_codec_name);
563 av_free(video_standard);
568 allocated_audio_buf_size= allocated_audio_out_size= 0;
575 if (received_sigterm) {
577 "Received signal %d: terminating.\n",
578 (int) received_sigterm);
582 exit(ret); /* not all OS-es handle main() return value */
586 /* similar to ff_dynarray_add() and av_fast_realloc() */
587 static void *grow_array(void *array, int elem_size, int *size, int new_size)
589 if (new_size >= INT_MAX / elem_size) {
590 fprintf(stderr, "Array too big.\n");
593 if (*size < new_size) {
594 uint8_t *tmp = av_realloc(array, new_size*elem_size);
596 fprintf(stderr, "Could not alloc buffer.\n");
599 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
606 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
608 if(codec && codec->sample_fmts){
609 const enum AVSampleFormat *p= codec->sample_fmts;
611 if(*p == st->codec->sample_fmt)
615 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
616 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
617 av_log(NULL, AV_LOG_WARNING,
618 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
619 av_get_sample_fmt_name(st->codec->sample_fmt),
621 av_get_sample_fmt_name(codec->sample_fmts[0]));
622 st->codec->sample_fmt = codec->sample_fmts[0];
627 static void choose_sample_rate(AVStream *st, AVCodec *codec)
629 if(codec && codec->supported_samplerates){
630 const int *p= codec->supported_samplerates;
632 int best_dist=INT_MAX;
634 int dist= abs(st->codec->sample_rate - *p);
635 if(dist < best_dist){
641 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
643 st->codec->sample_rate= best;
647 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
649 if(codec && codec->pix_fmts){
650 const enum PixelFormat *p= codec->pix_fmts;
651 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
652 if(st->codec->codec_id==CODEC_ID_MJPEG){
653 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
654 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
655 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};
659 if(*p == st->codec->pix_fmt)
663 if(st->codec->pix_fmt != PIX_FMT_NONE)
664 av_log(NULL, AV_LOG_WARNING,
665 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
666 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
668 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
669 st->codec->pix_fmt = codec->pix_fmts[0];
674 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
676 int idx = oc->nb_streams - 1;
679 output_streams_for_file[file_idx] =
680 grow_array(output_streams_for_file[file_idx],
681 sizeof(*output_streams_for_file[file_idx]),
682 &nb_output_streams_for_file[file_idx],
684 ost = output_streams_for_file[file_idx][idx] =
685 av_mallocz(sizeof(OutputStream));
687 fprintf(stderr, "Could not alloc output stream\n");
690 ost->file_index = file_idx;
693 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
697 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
703 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
706 /* copy stream format */
708 s->streams = av_mallocz(sizeof(AVStream *) * ic->nb_streams);
709 for(i=0;i<ic->nb_streams;i++) {
715 // FIXME: a more elegant solution is needed
716 st = av_mallocz(sizeof(AVStream));
717 memcpy(st, ic->streams[i], sizeof(AVStream));
718 st->info = av_malloc(sizeof(*st->info));
719 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
720 st->codec = avcodec_alloc_context();
722 print_error(filename, AVERROR(ENOMEM));
725 avcodec_copy_context(st->codec, ic->streams[i]->codec);
728 codec = avcodec_find_encoder(st->codec->codec_id);
729 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
730 if (audio_stream_copy) {
733 choose_sample_fmt(st, codec);
734 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
735 if (video_stream_copy) {
738 choose_pixel_fmt(st, codec);
741 if(st->codec->flags & CODEC_FLAG_BITEXACT)
744 new_output_stream(s, nb_output_files);
748 s->timestamp = av_gettime();
750 av_close_input_file(ic);
755 get_sync_ipts(const OutputStream *ost)
757 const InputStream *ist = ost->sync_ist;
758 return (double)(ist->pts - start_time)/AV_TIME_BASE;
761 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
765 AVPacket new_pkt= *pkt;
766 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
767 &new_pkt.data, &new_pkt.size,
768 pkt->data, pkt->size,
769 pkt->flags & AV_PKT_FLAG_KEY);
772 new_pkt.destruct= av_destruct_packet;
774 fprintf(stderr, "%s failed for stream %d, codec %s",
775 bsfc->filter->name, pkt->stream_index,
776 avctx->codec ? avctx->codec->name : "copy");
786 ret= av_interleaved_write_frame(s, pkt);
788 print_error("av_interleaved_write_frame()", ret);
793 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
795 static void do_audio_out(AVFormatContext *s,
798 unsigned char *buf, int size)
801 int64_t audio_out_size, audio_buf_size;
802 int64_t allocated_for_size= size;
804 int size_out, frame_bytes, ret, resample_changed;
805 AVCodecContext *enc= ost->st->codec;
806 AVCodecContext *dec= ist->st->codec;
807 int osize = av_get_bytes_per_sample(enc->sample_fmt);
808 int isize = av_get_bytes_per_sample(dec->sample_fmt);
809 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
812 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
813 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
814 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
815 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
816 audio_buf_size*= osize*enc->channels;
818 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
819 if(coded_bps > 8*osize)
820 audio_out_size= audio_out_size * coded_bps / (8*osize);
821 audio_out_size += FF_MIN_BUFFER_SIZE;
823 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
824 fprintf(stderr, "Buffer sizes too large\n");
828 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
829 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
830 if (!audio_buf || !audio_out){
831 fprintf(stderr, "Out of memory in do_audio_out\n");
835 if (enc->channels != dec->channels)
836 ost->audio_resample = 1;
838 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
839 ost->resample_channels != dec->channels ||
840 ost->resample_sample_rate != dec->sample_rate;
842 if ((ost->audio_resample && !ost->resample) || resample_changed) {
843 if (resample_changed) {
844 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",
845 ist->file_index, ist->st->index,
846 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
847 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
848 ost->resample_sample_fmt = dec->sample_fmt;
849 ost->resample_channels = dec->channels;
850 ost->resample_sample_rate = dec->sample_rate;
852 audio_resample_close(ost->resample);
854 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
855 if (audio_sync_method <= 1 &&
856 ost->resample_sample_fmt == enc->sample_fmt &&
857 ost->resample_channels == enc->channels &&
858 ost->resample_sample_rate == enc->sample_rate) {
859 ost->resample = NULL;
860 ost->audio_resample = 0;
862 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
863 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
864 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
865 enc->sample_rate, dec->sample_rate,
866 enc->sample_fmt, dec->sample_fmt,
868 if (!ost->resample) {
869 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
870 dec->channels, dec->sample_rate,
871 enc->channels, enc->sample_rate);
877 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
878 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
879 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
880 if (ost->reformat_ctx)
881 av_audio_convert_free(ost->reformat_ctx);
882 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
883 dec->sample_fmt, 1, NULL, 0);
884 if (!ost->reformat_ctx) {
885 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
886 av_get_sample_fmt_name(dec->sample_fmt),
887 av_get_sample_fmt_name(enc->sample_fmt));
890 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
893 if(audio_sync_method){
894 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
895 - av_fifo_size(ost->fifo)/(enc->channels * 2);
896 double idelta= delta*dec->sample_rate / enc->sample_rate;
897 int byte_delta= ((int)idelta)*2*dec->channels;
899 //FIXME resample delay
900 if(fabs(delta) > 50){
901 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
903 byte_delta= FFMAX(byte_delta, -size);
907 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
912 static uint8_t *input_tmp= NULL;
913 input_tmp= av_realloc(input_tmp, byte_delta + size);
915 if(byte_delta > allocated_for_size - size){
916 allocated_for_size= byte_delta + (int64_t)size;
921 memset(input_tmp, 0, byte_delta);
922 memcpy(input_tmp + byte_delta, buf, size);
926 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
928 }else if(audio_sync_method>1){
929 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
930 av_assert0(ost->audio_resample);
932 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
933 // 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));
934 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
938 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
939 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
941 if (ost->audio_resample) {
943 size_out = audio_resample(ost->resample,
944 (short *)buftmp, (short *)buf,
945 size / (dec->channels * isize));
946 size_out = size_out * enc->channels * osize;
952 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
953 const void *ibuf[6]= {buftmp};
954 void *obuf[6]= {audio_buf};
955 int istride[6]= {isize};
956 int ostride[6]= {osize};
957 int len= size_out/istride[0];
958 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
959 printf("av_audio_convert() failed\n");
965 size_out = len*osize;
968 /* now encode as many frames as possible */
969 if (enc->frame_size > 1) {
970 /* output resampled raw samples */
971 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
972 fprintf(stderr, "av_fifo_realloc2() failed\n");
975 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
977 frame_bytes = enc->frame_size * osize * enc->channels;
979 while (av_fifo_size(ost->fifo) >= frame_bytes) {
981 av_init_packet(&pkt);
983 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
985 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
987 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
990 fprintf(stderr, "Audio encoding failed\n");
994 pkt.stream_index= ost->index;
997 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
998 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
999 pkt.flags |= AV_PKT_FLAG_KEY;
1000 write_frame(s, &pkt, enc, ost->bitstream_filters);
1002 ost->sync_opts += enc->frame_size;
1006 av_init_packet(&pkt);
1008 ost->sync_opts += size_out / (osize * enc->channels);
1010 /* output a pcm frame */
1011 /* determine the size of the coded buffer */
1014 size_out = size_out*coded_bps/8;
1016 if(size_out > audio_out_size){
1017 fprintf(stderr, "Internal error, buffer size too small\n");
1021 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1022 ret = avcodec_encode_audio(enc, audio_out, size_out,
1025 fprintf(stderr, "Audio encoding failed\n");
1029 pkt.stream_index= ost->index;
1030 pkt.data= audio_out;
1032 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1033 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1034 pkt.flags |= AV_PKT_FLAG_KEY;
1035 write_frame(s, &pkt, enc, ost->bitstream_filters);
1039 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1041 AVCodecContext *dec;
1042 AVPicture *picture2;
1043 AVPicture picture_tmp;
1046 dec = ist->st->codec;
1048 /* deinterlace : must be done before any resize */
1049 if (do_deinterlace) {
1052 /* create temporary picture */
1053 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1054 buf = av_malloc(size);
1058 picture2 = &picture_tmp;
1059 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1061 if(avpicture_deinterlace(picture2, picture,
1062 dec->pix_fmt, dec->width, dec->height) < 0) {
1063 /* if error, do not deinterlace */
1064 fprintf(stderr, "Deinterlacing failed\n");
1073 if (picture != picture2)
1074 *picture = *picture2;
1078 /* we begin to correct av delay at this threshold */
1079 #define AV_DELAY_MAX 0.100
1081 static void do_subtitle_out(AVFormatContext *s,
1087 static uint8_t *subtitle_out = NULL;
1088 int subtitle_out_max_size = 1024 * 1024;
1089 int subtitle_out_size, nb, i;
1090 AVCodecContext *enc;
1093 if (pts == AV_NOPTS_VALUE) {
1094 fprintf(stderr, "Subtitle packets must have a pts\n");
1100 enc = ost->st->codec;
1102 if (!subtitle_out) {
1103 subtitle_out = av_malloc(subtitle_out_max_size);
1106 /* Note: DVB subtitle need one packet to draw them and one other
1107 packet to clear them */
1108 /* XXX: signal it in the codec context ? */
1109 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1114 for(i = 0; i < nb; i++) {
1115 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1116 // start_display_time is required to be 0
1117 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1118 sub->end_display_time -= sub->start_display_time;
1119 sub->start_display_time = 0;
1120 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1121 subtitle_out_max_size, sub);
1122 if (subtitle_out_size < 0) {
1123 fprintf(stderr, "Subtitle encoding failed\n");
1127 av_init_packet(&pkt);
1128 pkt.stream_index = ost->index;
1129 pkt.data = subtitle_out;
1130 pkt.size = subtitle_out_size;
1131 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1132 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1133 /* XXX: the pts correction is handled here. Maybe handling
1134 it in the codec would be better */
1136 pkt.pts += 90 * sub->start_display_time;
1138 pkt.pts += 90 * sub->end_display_time;
1140 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1144 static int bit_buffer_size= 1024*256;
1145 static uint8_t *bit_buffer= NULL;
1147 static void do_video_out(AVFormatContext *s,
1150 AVFrame *in_picture,
1151 int *frame_size, float quality)
1153 int nb_frames, i, ret, av_unused resample_changed;
1154 AVFrame *final_picture, *formatted_picture;
1155 AVCodecContext *enc, *dec;
1158 enc = ost->st->codec;
1159 dec = ist->st->codec;
1161 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1163 /* by default, we output a single frame */
1168 if(video_sync_method){
1169 double vdelta = sync_ipts - ost->sync_opts;
1170 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1173 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1176 }else if(vdelta>0.6)
1177 ost->sync_opts= lrintf(sync_ipts);
1178 }else if (vdelta > 1.1)
1179 nb_frames = lrintf(vdelta);
1180 //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);
1181 if (nb_frames == 0){
1184 fprintf(stderr, "*** drop!\n");
1185 }else if (nb_frames > 1) {
1186 nb_frames_dup += nb_frames - 1;
1188 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1191 ost->sync_opts= lrintf(sync_ipts);
1193 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1197 formatted_picture = in_picture;
1198 final_picture = formatted_picture;
1200 #if !CONFIG_AVFILTER
1201 resample_changed = ost->resample_width != dec->width ||
1202 ost->resample_height != dec->height ||
1203 ost->resample_pix_fmt != dec->pix_fmt;
1205 if (resample_changed) {
1206 av_log(NULL, AV_LOG_INFO,
1207 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1208 ist->file_index, ist->st->index,
1209 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1210 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1211 ost->resample_width = dec->width;
1212 ost->resample_height = dec->height;
1213 ost->resample_pix_fmt = dec->pix_fmt;
1216 ost->video_resample = dec->width != enc->width ||
1217 dec->height != enc->height ||
1218 dec->pix_fmt != enc->pix_fmt;
1220 if (ost->video_resample) {
1221 final_picture = &ost->resample_frame;
1222 if (!ost->img_resample_ctx || resample_changed) {
1223 /* initialize the destination picture */
1224 if (!ost->resample_frame.data[0]) {
1225 avcodec_get_frame_defaults(&ost->resample_frame);
1226 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1227 enc->width, enc->height)) {
1228 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1232 /* initialize a new scaler context */
1233 sws_freeContext(ost->img_resample_ctx);
1234 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1235 enc->width, enc->height, enc->pix_fmt,
1236 ost->sws_flags, NULL, NULL, NULL);
1237 if (ost->img_resample_ctx == NULL) {
1238 fprintf(stderr, "Cannot get resampling context\n");
1242 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1243 0, ost->resample_height, final_picture->data, final_picture->linesize);
1247 /* duplicates frame if needed */
1248 for(i=0;i<nb_frames;i++) {
1250 av_init_packet(&pkt);
1251 pkt.stream_index= ost->index;
1253 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1254 /* raw pictures are written as AVPicture structure to
1255 avoid any copies. We support temorarily the older
1257 AVFrame* old_frame = enc->coded_frame;
1258 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1259 pkt.data= (uint8_t *)final_picture;
1260 pkt.size= sizeof(AVPicture);
1261 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1262 pkt.flags |= AV_PKT_FLAG_KEY;
1264 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1265 enc->coded_frame = old_frame;
1267 AVFrame big_picture;
1269 big_picture= *final_picture;
1270 /* better than nothing: use input picture interlaced
1272 big_picture.interlaced_frame = in_picture->interlaced_frame;
1273 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1274 if(top_field_first == -1)
1275 big_picture.top_field_first = in_picture->top_field_first;
1277 big_picture.top_field_first = top_field_first;
1280 /* handles sameq here. This is not correct because it may
1281 not be a global option */
1282 big_picture.quality = quality;
1284 big_picture.pict_type = 0;
1285 // big_picture.pts = AV_NOPTS_VALUE;
1286 big_picture.pts= ost->sync_opts;
1287 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1288 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1289 if (ost->forced_kf_index < ost->forced_kf_count &&
1290 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1291 big_picture.pict_type = AV_PICTURE_TYPE_I;
1292 ost->forced_kf_index++;
1294 ret = avcodec_encode_video(enc,
1295 bit_buffer, bit_buffer_size,
1298 fprintf(stderr, "Video encoding failed\n");
1303 pkt.data= bit_buffer;
1305 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1306 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1307 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1308 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1309 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1311 if(enc->coded_frame->key_frame)
1312 pkt.flags |= AV_PKT_FLAG_KEY;
1313 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1316 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1317 // enc->frame_number-1, ret, enc->pict_type);
1318 /* if two pass, output log */
1319 if (ost->logfile && enc->stats_out) {
1320 fprintf(ost->logfile, "%s", enc->stats_out);
1325 ost->frame_number++;
1329 static double psnr(double d){
1330 return -10.0*log(d)/log(10.0);
1333 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1336 AVCodecContext *enc;
1338 double ti1, bitrate, avg_bitrate;
1340 /* this is executed just the first time do_video_stats is called */
1342 vstats_file = fopen(vstats_filename, "w");
1349 enc = ost->st->codec;
1350 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1351 frame_number = ost->frame_number;
1352 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1353 if (enc->flags&CODEC_FLAG_PSNR)
1354 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1356 fprintf(vstats_file,"f_size= %6d ", frame_size);
1357 /* compute pts value */
1358 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1362 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1363 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1364 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1365 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1366 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1370 static void print_report(AVFormatContext **output_files,
1371 OutputStream **ost_table, int nb_ostreams,
1376 AVFormatContext *oc;
1378 AVCodecContext *enc;
1379 int frame_number, vid, i;
1381 int64_t pts = INT64_MAX;
1382 static int64_t last_time = -1;
1383 static int qp_histogram[52];
1385 if (!is_last_report) {
1387 /* display the report every 0.5 seconds */
1388 cur_time = av_gettime();
1389 if (last_time == -1) {
1390 last_time = cur_time;
1393 if ((cur_time - last_time) < 500000)
1395 last_time = cur_time;
1399 oc = output_files[0];
1401 total_size = avio_size(oc->pb);
1402 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1403 total_size= avio_tell(oc->pb);
1407 for(i=0;i<nb_ostreams;i++) {
1410 enc = ost->st->codec;
1411 if (!ost->st->stream_copy && enc->coded_frame)
1412 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1413 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1414 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1416 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1417 float t = (av_gettime()-timer_start) / 1000000.0;
1419 frame_number = ost->frame_number;
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1421 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1423 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1427 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1430 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1432 if (enc->flags&CODEC_FLAG_PSNR){
1434 double error, error_sum=0;
1435 double scale, scale_sum=0;
1436 char type[3]= {'Y','U','V'};
1437 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1440 error= enc->error[j];
1441 scale= enc->width*enc->height*255.0*255.0*frame_number;
1443 error= enc->coded_frame->error[j];
1444 scale= enc->width*enc->height*255.0*255.0;
1449 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1451 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1455 /* compute min output value */
1456 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1457 ost->st->time_base, AV_TIME_BASE_Q));
1460 if (verbose > 0 || is_last_report) {
1461 int hours, mins, secs, us;
1462 secs = pts / AV_TIME_BASE;
1463 us = pts % AV_TIME_BASE;
1469 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1471 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1472 "size=%8.0fkB time=", total_size / 1024.0);
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1474 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1475 (100 * us) / AV_TIME_BASE);
1476 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1477 "bitrate=%6.1fkbits/s", bitrate);
1479 if (nb_frames_dup || nb_frames_drop)
1480 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1481 nb_frames_dup, nb_frames_drop);
1484 fprintf(stderr, "%s \r", buf);
1489 if (is_last_report && verbose >= 0){
1490 int64_t raw= audio_size + video_size + extra_size;
1491 fprintf(stderr, "\n");
1492 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1496 100.0*(total_size - raw)/raw
1501 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1503 int fill_char = 0x00;
1504 if (sample_fmt == AV_SAMPLE_FMT_U8)
1506 memset(buf, fill_char, size);
1509 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1510 static int output_packet(InputStream *ist, int ist_index,
1511 OutputStream **ost_table, int nb_ostreams,
1512 const AVPacket *pkt)
1514 AVFormatContext *os;
1519 void *buffer_to_free = NULL;
1520 static unsigned int samples_size= 0;
1521 AVSubtitle subtitle, *subtitle_to_free;
1522 int64_t pkt_pts = AV_NOPTS_VALUE;
1524 int frame_available;
1529 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1531 if(ist->next_pts == AV_NOPTS_VALUE)
1532 ist->next_pts= ist->pts;
1536 av_init_packet(&avpkt);
1544 if(pkt->dts != AV_NOPTS_VALUE)
1545 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1546 if(pkt->pts != AV_NOPTS_VALUE)
1547 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1549 //while we have more to decode or while the decoder did output something on EOF
1550 while (avpkt.size > 0 || (!pkt && got_output)) {
1551 uint8_t *data_buf, *decoded_data_buf;
1552 int data_size, decoded_data_size;
1554 ist->pts= ist->next_pts;
1556 if(avpkt.size && avpkt.size != pkt->size &&
1557 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1558 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1559 ist->showed_multi_packet_warning=1;
1562 /* decode the packet if needed */
1563 decoded_data_buf = NULL; /* fail safe */
1564 decoded_data_size= 0;
1565 data_buf = avpkt.data;
1566 data_size = avpkt.size;
1567 subtitle_to_free = NULL;
1568 if (ist->decoding_needed) {
1569 switch(ist->st->codec->codec_type) {
1570 case AVMEDIA_TYPE_AUDIO:{
1571 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1572 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1574 samples= av_malloc(samples_size);
1576 decoded_data_size= samples_size;
1577 /* XXX: could avoid copy if PCM 16 bits with same
1578 endianness as CPU */
1579 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1586 got_output = decoded_data_size > 0;
1587 /* Some bug in mpeg audio decoder gives */
1588 /* decoded_data_size < 0, it seems they are overflows */
1590 /* no audio frame */
1593 decoded_data_buf = (uint8_t *)samples;
1594 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1595 (ist->st->codec->sample_rate * ist->st->codec->channels);
1597 case AVMEDIA_TYPE_VIDEO:
1598 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1599 /* XXX: allocate picture correctly */
1600 avcodec_get_frame_defaults(&picture);
1601 avpkt.pts = pkt_pts;
1602 avpkt.dts = ist->pts;
1603 pkt_pts = AV_NOPTS_VALUE;
1605 ret = avcodec_decode_video2(ist->st->codec,
1606 &picture, &got_output, &avpkt);
1607 quality = same_quality ? picture.quality : 0;
1611 /* no picture yet */
1612 goto discard_packet;
1614 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1615 if (ist->st->codec->time_base.num != 0) {
1616 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1617 ist->next_pts += ((int64_t)AV_TIME_BASE *
1618 ist->st->codec->time_base.num * ticks) /
1619 ist->st->codec->time_base.den;
1622 buffer_to_free = NULL;
1623 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1625 case AVMEDIA_TYPE_SUBTITLE:
1626 ret = avcodec_decode_subtitle2(ist->st->codec,
1627 &subtitle, &got_output, &avpkt);
1631 goto discard_packet;
1633 subtitle_to_free = &subtitle;
1640 switch(ist->st->codec->codec_type) {
1641 case AVMEDIA_TYPE_AUDIO:
1642 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1643 ist->st->codec->sample_rate;
1645 case AVMEDIA_TYPE_VIDEO:
1646 if (ist->st->codec->time_base.num != 0) {
1647 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1648 ist->next_pts += ((int64_t)AV_TIME_BASE *
1649 ist->st->codec->time_base.num * ticks) /
1650 ist->st->codec->time_base.den;
1659 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1660 if (start_time == 0 || ist->pts >= start_time) {
1661 for(i=0;i<nb_ostreams;i++) {
1663 if (ost->input_video_filter && ost->source_index == ist_index) {
1664 if (!picture.sample_aspect_ratio.num)
1665 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1666 picture.pts = ist->pts;
1668 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1674 // preprocess audio (volume)
1675 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1676 if (audio_volume != 256) {
1679 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1680 int v = ((*volp) * audio_volume + 128) >> 8;
1681 if (v < -32768) v = -32768;
1682 if (v > 32767) v = 32767;
1688 /* frame rate emulation */
1690 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1691 int64_t now = av_gettime() - ist->start;
1695 /* if output time reached then transcode raw format,
1696 encode packets and output them */
1697 if (start_time == 0 || ist->pts >= start_time)
1698 for(i=0;i<nb_ostreams;i++) {
1702 if (ost->source_index == ist_index) {
1704 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1705 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1706 while (frame_available) {
1707 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1708 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1709 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1712 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1713 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1717 os = output_files[ost->file_index];
1719 /* set the input output pts pairs */
1720 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1722 if (ost->encoding_needed) {
1723 av_assert0(ist->decoding_needed);
1724 switch(ost->st->codec->codec_type) {
1725 case AVMEDIA_TYPE_AUDIO:
1726 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1728 case AVMEDIA_TYPE_VIDEO:
1730 if (ost->picref->video && !ost->frame_aspect_ratio)
1731 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1733 do_video_out(os, ost, ist, &picture, &frame_size,
1734 same_quality ? quality : ost->st->codec->global_quality);
1735 if (vstats_filename && frame_size)
1736 do_video_stats(os, ost, frame_size);
1738 case AVMEDIA_TYPE_SUBTITLE:
1739 do_subtitle_out(os, ost, ist, &subtitle,
1746 AVFrame avframe; //FIXME/XXX remove this
1749 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1751 av_init_packet(&opkt);
1753 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1754 #if !CONFIG_AVFILTER
1760 /* no reencoding needed : output the packet directly */
1761 /* force the input stream PTS */
1763 avcodec_get_frame_defaults(&avframe);
1764 ost->st->codec->coded_frame= &avframe;
1765 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1767 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1768 audio_size += data_size;
1769 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1770 video_size += data_size;
1774 opkt.stream_index= ost->index;
1775 if(pkt->pts != AV_NOPTS_VALUE)
1776 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1778 opkt.pts= AV_NOPTS_VALUE;
1780 if (pkt->dts == AV_NOPTS_VALUE)
1781 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1783 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1784 opkt.dts -= ost_tb_start_time;
1786 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1787 opkt.flags= pkt->flags;
1789 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1790 if( ost->st->codec->codec_id != CODEC_ID_H264
1791 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1792 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1794 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1795 opkt.destruct= av_destruct_packet;
1797 opkt.data = data_buf;
1798 opkt.size = data_size;
1801 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1802 /* store AVPicture in AVPacket, as expected by the output format */
1803 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1804 opkt.data = (uint8_t *)&pict;
1805 opkt.size = sizeof(AVPicture);
1806 opkt.flags |= AV_PKT_FLAG_KEY;
1808 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1809 ost->st->codec->frame_number++;
1810 ost->frame_number++;
1811 av_free_packet(&opkt);
1815 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1816 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1817 avfilter_unref_buffer(ost->picref);
1823 av_free(buffer_to_free);
1824 /* XXX: allocate the subtitles in the codec ? */
1825 if (subtitle_to_free) {
1826 avsubtitle_free(subtitle_to_free);
1827 subtitle_to_free = NULL;
1834 for(i=0;i<nb_ostreams;i++) {
1836 if (ost->source_index == ist_index) {
1837 AVCodecContext *enc= ost->st->codec;
1838 os = output_files[ost->file_index];
1840 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1842 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1845 if (ost->encoding_needed) {
1849 av_init_packet(&pkt);
1850 pkt.stream_index= ost->index;
1852 switch(ost->st->codec->codec_type) {
1853 case AVMEDIA_TYPE_AUDIO:
1854 fifo_bytes = av_fifo_size(ost->fifo);
1856 /* encode any samples remaining in fifo */
1857 if (fifo_bytes > 0) {
1858 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1859 int fs_tmp = enc->frame_size;
1861 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1862 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1863 enc->frame_size = fifo_bytes / (osize * enc->channels);
1865 int frame_bytes = enc->frame_size*osize*enc->channels;
1866 if (allocated_audio_buf_size < frame_bytes)
1868 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1871 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1872 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1873 ost->st->time_base.num, enc->sample_rate);
1874 enc->frame_size = fs_tmp;
1877 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1880 fprintf(stderr, "Audio encoding failed\n");
1884 pkt.flags |= AV_PKT_FLAG_KEY;
1886 case AVMEDIA_TYPE_VIDEO:
1887 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1889 fprintf(stderr, "Video encoding failed\n");
1893 if(enc->coded_frame && enc->coded_frame->key_frame)
1894 pkt.flags |= AV_PKT_FLAG_KEY;
1895 if (ost->logfile && enc->stats_out) {
1896 fprintf(ost->logfile, "%s", enc->stats_out);
1905 pkt.data= bit_buffer;
1907 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1908 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1909 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1921 static void print_sdp(AVFormatContext **avc, int n)
1925 av_sdp_create(avc, n, sdp, sizeof(sdp));
1926 printf("SDP:\n%s\n", sdp);
1930 static int copy_chapters(int infile, int outfile)
1932 AVFormatContext *is = input_files[infile].ctx;
1933 AVFormatContext *os = output_files[outfile];
1936 for (i = 0; i < is->nb_chapters; i++) {
1937 AVChapter *in_ch = is->chapters[i], *out_ch;
1938 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1939 AV_TIME_BASE_Q, in_ch->time_base);
1940 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1941 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1944 if (in_ch->end < ts_off)
1946 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1949 out_ch = av_mallocz(sizeof(AVChapter));
1951 return AVERROR(ENOMEM);
1953 out_ch->id = in_ch->id;
1954 out_ch->time_base = in_ch->time_base;
1955 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1956 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1958 if (metadata_chapters_autocopy)
1959 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1962 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1964 return AVERROR(ENOMEM);
1965 os->chapters[os->nb_chapters - 1] = out_ch;
1970 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1971 AVCodecContext *avctx)
1977 for (p = kf; *p; p++)
1980 ost->forced_kf_count = n;
1981 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1982 if (!ost->forced_kf_pts) {
1983 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1986 for (i = 0; i < n; i++) {
1987 p = i ? strchr(p, ',') + 1 : kf;
1988 t = parse_time_or_die("force_key_frames", p, 1);
1989 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1994 * The following code is the main loop of the file converter
1996 static int transcode(AVFormatContext **output_files,
1997 int nb_output_files,
1998 InputFile *input_files,
2000 StreamMap *stream_maps, int nb_stream_maps)
2002 int ret = 0, i, j, k, n, nb_ostreams = 0, step;
2004 AVFormatContext *is, *os;
2005 AVCodecContext *codec, *icodec;
2006 OutputStream *ost, **ost_table = NULL;
2011 uint8_t no_packet[MAX_FILES]={0};
2012 int no_packet_count=0;
2013 int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
2014 int nb_streams[AVMEDIA_TYPE_NB]={0};
2017 for (i = 0; i < nb_input_streams; i++)
2018 input_streams[i].start = av_gettime();
2020 /* output stream init */
2022 for(i=0;i<nb_output_files;i++) {
2023 os = output_files[i];
2024 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2025 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2026 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2027 ret = AVERROR(EINVAL);
2030 nb_ostreams += os->nb_streams;
2032 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2033 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2034 ret = AVERROR(EINVAL);
2038 /* Sanity check the mapping args -- do the input files & streams exist? */
2039 for(i=0;i<nb_stream_maps;i++) {
2040 int fi = stream_maps[i].file_index;
2041 int si = stream_maps[i].stream_index;
2043 if (fi < 0 || fi > nb_input_files - 1 ||
2044 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2045 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2046 ret = AVERROR(EINVAL);
2049 fi = stream_maps[i].sync_file_index;
2050 si = stream_maps[i].sync_stream_index;
2051 if (fi < 0 || fi > nb_input_files - 1 ||
2052 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2053 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2054 ret = AVERROR(EINVAL);
2059 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2063 for(k=0;k<nb_output_files;k++) {
2064 os = output_files[k];
2065 for(i=0;i<os->nb_streams;i++,n++) {
2066 nb_streams[os->streams[i]->codec->codec_type]++;
2069 for(step=1<<30; step; step>>=1){
2070 int found_streams[AVMEDIA_TYPE_NB]={0};
2071 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2072 nb_frame_threshold[j] += step;
2074 for(j=0; j<nb_input_streams; j++) {
2076 ist = &input_streams[j];
2079 AVFormatContext *f= input_files[ ist->file_index ].ctx;
2081 for(pi=0; pi<f->nb_programs; pi++){
2082 AVProgram *p= f->programs[pi];
2083 if(p->id == opt_programid)
2084 for(si=0; si<p->nb_stream_indexes; si++){
2085 if(f->streams[ p->stream_index[si] ] == ist->st)
2090 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2091 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2092 found_streams[ist->st->codec->codec_type]++;
2095 for(j=0; j<AVMEDIA_TYPE_NB; j++)
2096 if(found_streams[j] < nb_streams[j])
2097 nb_frame_threshold[j] -= step;
2100 for(k=0;k<nb_output_files;k++) {
2101 os = output_files[k];
2102 for(i=0;i<os->nb_streams;i++,n++) {
2104 ost = ost_table[n] = output_streams_for_file[k][i];
2105 ost->st = os->streams[i];
2106 if (nb_stream_maps > 0) {
2107 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2108 stream_maps[n].stream_index;
2110 /* Sanity check that the stream types match */
2111 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2112 int i= ost->file_index;
2113 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2114 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2115 stream_maps[n].file_index, stream_maps[n].stream_index,
2116 ost->file_index, ost->index);
2121 /* get corresponding input stream index : we select the first one with the right type */
2123 for (j = 0; j < nb_input_streams; j++) {
2125 ist = &input_streams[j];
2128 AVFormatContext *f = input_files[ist->file_index].ctx;
2130 for(pi=0; pi<f->nb_programs; pi++){
2131 AVProgram *p= f->programs[pi];
2132 if(p->id == opt_programid)
2133 for(si=0; si<p->nb_stream_indexes; si++){
2134 if(f->streams[ p->stream_index[si] ] == ist->st)
2139 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2140 ist->st->codec->codec_type == ost->st->codec->codec_type &&
2141 nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2142 ost->source_index = j;
2149 if(! opt_programid) {
2150 /* try again and reuse existing stream */
2151 for (j = 0; j < nb_input_streams; j++) {
2152 ist = &input_streams[j];
2153 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2154 && ist->st->discard != AVDISCARD_ALL) {
2155 ost->source_index = j;
2161 int i= ost->file_index;
2162 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2163 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2164 ost->file_index, ost->index);
2169 ist = &input_streams[ost->source_index];
2171 ost->sync_ist = (nb_stream_maps > 0) ?
2172 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2173 stream_maps[n].sync_stream_index] : ist;
2177 /* for each output stream, we compute the right encoding parameters */
2178 for(i=0;i<nb_ostreams;i++) {
2180 os = output_files[ost->file_index];
2181 ist = &input_streams[ost->source_index];
2183 codec = ost->st->codec;
2184 icodec = ist->st->codec;
2186 if (metadata_streams_autocopy)
2187 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2188 AV_DICT_DONT_OVERWRITE);
2190 ost->st->disposition = ist->st->disposition;
2191 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2192 codec->chroma_sample_location = icodec->chroma_sample_location;
2194 if (ost->st->stream_copy) {
2195 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2197 if (extra_size > INT_MAX)
2200 /* if stream_copy is selected, no need to decode or encode */
2201 codec->codec_id = icodec->codec_id;
2202 codec->codec_type = icodec->codec_type;
2204 if(!codec->codec_tag){
2205 if( !os->oformat->codec_tag
2206 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2207 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2208 codec->codec_tag = icodec->codec_tag;
2211 codec->bit_rate = icodec->bit_rate;
2212 codec->rc_max_rate = icodec->rc_max_rate;
2213 codec->rc_buffer_size = icodec->rc_buffer_size;
2214 codec->extradata= av_mallocz(extra_size);
2215 if (!codec->extradata)
2217 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2218 codec->extradata_size= icodec->extradata_size;
2219 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){
2220 codec->time_base = icodec->time_base;
2221 codec->time_base.num *= icodec->ticks_per_frame;
2222 av_reduce(&codec->time_base.num, &codec->time_base.den,
2223 codec->time_base.num, codec->time_base.den, INT_MAX);
2225 codec->time_base = ist->st->time_base;
2226 switch(codec->codec_type) {
2227 case AVMEDIA_TYPE_AUDIO:
2228 if(audio_volume != 256) {
2229 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2232 codec->channel_layout = icodec->channel_layout;
2233 codec->sample_rate = icodec->sample_rate;
2234 codec->channels = icodec->channels;
2235 codec->frame_size = icodec->frame_size;
2236 codec->audio_service_type = icodec->audio_service_type;
2237 codec->block_align= icodec->block_align;
2238 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2239 codec->block_align= 0;
2240 if(codec->codec_id == CODEC_ID_AC3)
2241 codec->block_align= 0;
2243 case AVMEDIA_TYPE_VIDEO:
2244 codec->pix_fmt = icodec->pix_fmt;
2245 codec->width = icodec->width;
2246 codec->height = icodec->height;
2247 codec->has_b_frames = icodec->has_b_frames;
2248 if (!codec->sample_aspect_ratio.num) {
2249 codec->sample_aspect_ratio =
2250 ost->st->sample_aspect_ratio =
2251 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2252 ist->st->codec->sample_aspect_ratio.num ?
2253 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2256 case AVMEDIA_TYPE_SUBTITLE:
2257 codec->width = icodec->width;
2258 codec->height = icodec->height;
2260 case AVMEDIA_TYPE_DATA:
2267 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2268 switch(codec->codec_type) {
2269 case AVMEDIA_TYPE_AUDIO:
2270 ost->fifo= av_fifo_alloc(1024);
2273 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2274 if (!codec->sample_rate) {
2275 codec->sample_rate = icodec->sample_rate;
2277 codec->sample_rate >>= icodec->lowres;
2279 choose_sample_rate(ost->st, ost->enc);
2280 codec->time_base = (AVRational){1, codec->sample_rate};
2281 if (!codec->channels) {
2282 codec->channels = icodec->channels;
2283 codec->channel_layout = icodec->channel_layout;
2285 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2286 codec->channel_layout = 0;
2287 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2288 icodec->request_channels = codec->channels;
2289 ist->decoding_needed = 1;
2290 ost->encoding_needed = 1;
2291 ost->resample_sample_fmt = icodec->sample_fmt;
2292 ost->resample_sample_rate = icodec->sample_rate;
2293 ost->resample_channels = icodec->channels;
2295 case AVMEDIA_TYPE_VIDEO:
2296 if (codec->pix_fmt == PIX_FMT_NONE)
2297 codec->pix_fmt = icodec->pix_fmt;
2298 choose_pixel_fmt(ost->st, ost->enc);
2300 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2301 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2304 ost->video_resample = codec->width != icodec->width ||
2305 codec->height != icodec->height ||
2306 codec->pix_fmt != icodec->pix_fmt;
2307 if (ost->video_resample) {
2308 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2310 if (!codec->width || !codec->height) {
2311 codec->width = icodec->width;
2312 codec->height = icodec->height;
2314 ost->resample_height = icodec->height;
2315 ost->resample_width = icodec->width;
2316 ost->resample_pix_fmt= icodec->pix_fmt;
2317 ost->encoding_needed = 1;
2318 ist->decoding_needed = 1;
2320 if (!ost->frame_rate.num)
2321 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2322 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2323 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2324 ost->frame_rate = ost->enc->supported_framerates[idx];
2326 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2327 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2328 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2329 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2330 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2334 if (configure_video_filters(ist, ost)) {
2335 fprintf(stderr, "Error opening filters!\n");
2340 case AVMEDIA_TYPE_SUBTITLE:
2341 ost->encoding_needed = 1;
2342 ist->decoding_needed = 1;
2349 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2350 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2351 char logfilename[1024];
2354 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2355 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2357 if (codec->flags & CODEC_FLAG_PASS1) {
2358 f = fopen(logfilename, "wb");
2360 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2366 size_t logbuffer_size;
2367 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2368 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2371 codec->stats_in = logbuffer;
2375 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2376 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2377 int size= codec->width * codec->height;
2378 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2383 bit_buffer = av_malloc(bit_buffer_size);
2385 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2387 ret = AVERROR(ENOMEM);
2391 /* open each encoder */
2392 for(i=0;i<nb_ostreams;i++) {
2394 if (ost->encoding_needed) {
2395 AVCodec *codec = ost->enc;
2396 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2398 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2399 ost->st->codec->codec_id, ost->file_index, ost->index);
2400 ret = AVERROR(EINVAL);
2403 if (dec->subtitle_header) {
2404 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2405 if (!ost->st->codec->subtitle_header) {
2406 ret = AVERROR(ENOMEM);
2409 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2410 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2412 if (avcodec_open(ost->st->codec, codec) < 0) {
2413 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2414 ost->file_index, ost->index);
2415 ret = AVERROR(EINVAL);
2418 extra_size += ost->st->codec->extradata_size;
2422 /* open each decoder */
2423 for (i = 0; i < nb_input_streams; i++) {
2424 ist = &input_streams[i];
2425 if (ist->decoding_needed) {
2426 AVCodec *codec = ist->dec;
2428 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2430 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2431 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2432 ret = AVERROR(EINVAL);
2435 if (avcodec_open(ist->st->codec, codec) < 0) {
2436 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2437 ist->file_index, ist->st->index);
2438 ret = AVERROR(EINVAL);
2441 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2442 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2447 for (i = 0; i < nb_input_streams; i++) {
2449 ist = &input_streams[i];
2451 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2452 ist->next_pts = AV_NOPTS_VALUE;
2456 /* set meta data information from input file if required */
2457 for (i=0;i<nb_meta_data_maps;i++) {
2458 AVFormatContext *files[2];
2459 AVDictionary **meta[2];
2462 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2463 if ((index) < 0 || (index) >= (nb_elems)) {\
2464 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2466 ret = AVERROR(EINVAL);\
2470 int out_file_index = meta_data_maps[i][0].file;
2471 int in_file_index = meta_data_maps[i][1].file;
2472 if (in_file_index < 0 || out_file_index < 0)
2474 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2475 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2477 files[0] = output_files[out_file_index];
2478 files[1] = input_files[in_file_index].ctx;
2480 for (j = 0; j < 2; j++) {
2481 MetadataMap *map = &meta_data_maps[i][j];
2483 switch (map->type) {
2485 meta[j] = &files[j]->metadata;
2488 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2489 meta[j] = &files[j]->streams[map->index]->metadata;
2492 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2493 meta[j] = &files[j]->chapters[map->index]->metadata;
2496 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2497 meta[j] = &files[j]->programs[map->index]->metadata;
2502 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2505 /* copy global metadata by default */
2506 if (metadata_global_autocopy) {
2508 for (i = 0; i < nb_output_files; i++)
2509 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2510 AV_DICT_DONT_OVERWRITE);
2513 /* copy chapters according to chapter maps */
2514 for (i = 0; i < nb_chapter_maps; i++) {
2515 int infile = chapter_maps[i].in_file;
2516 int outfile = chapter_maps[i].out_file;
2518 if (infile < 0 || outfile < 0)
2520 if (infile >= nb_input_files) {
2521 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2522 ret = AVERROR(EINVAL);
2525 if (outfile >= nb_output_files) {
2526 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2527 ret = AVERROR(EINVAL);
2530 copy_chapters(infile, outfile);
2533 /* copy chapters from the first input file that has them*/
2534 if (!nb_chapter_maps)
2535 for (i = 0; i < nb_input_files; i++) {
2536 if (!input_files[i].ctx->nb_chapters)
2539 for (j = 0; j < nb_output_files; j++)
2540 if ((ret = copy_chapters(i, j)) < 0)
2545 /* open files and write file headers */
2546 for(i=0;i<nb_output_files;i++) {
2547 os = output_files[i];
2548 if (av_write_header(os) < 0) {
2549 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2550 ret = AVERROR(EINVAL);
2553 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2559 /* dump the file output parameters - cannot be done before in case
2561 for(i=0;i<nb_output_files;i++) {
2562 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2565 /* dump the stream mapping */
2567 fprintf(stderr, "Stream mapping:\n");
2568 for(i=0;i<nb_ostreams;i++) {
2570 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2571 input_streams[ost->source_index].file_index,
2572 input_streams[ost->source_index].st->index,
2575 if (ost->sync_ist != &input_streams[ost->source_index])
2576 fprintf(stderr, " [sync #%d.%d]",
2577 ost->sync_ist->file_index,
2578 ost->sync_ist->st->index);
2579 fprintf(stderr, "\n");
2584 fprintf(stderr, "%s\n", error);
2589 print_sdp(output_files, nb_output_files);
2594 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2595 avio_set_interrupt_cb(decode_interrupt_cb);
2599 timer_start = av_gettime();
2601 for(; received_sigterm == 0;) {
2602 int file_index, ist_index;
2610 /* if 'q' pressed, exits */
2614 /* read_key() returns 0 on EOF */
2618 if (key == '+') verbose++;
2619 if (key == '-') verbose--;
2620 if (key == 's') qp_hist ^= 1;
2623 do_hex_dump = do_pkt_dump = 0;
2624 } else if(do_pkt_dump){
2628 av_log_set_level(AV_LOG_DEBUG);
2630 if (key == 'd' || key == 'D'){
2633 debug = input_streams[0].st->codec->debug<<1;
2634 if(!debug) debug = 1;
2635 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2638 scanf("%d", &debug);
2639 for(i=0;i<nb_input_streams;i++) {
2640 input_streams[i].st->codec->debug = debug;
2642 for(i=0;i<nb_ostreams;i++) {
2644 ost->st->codec->debug = debug;
2646 if(debug) av_log_set_level(AV_LOG_DEBUG);
2647 fprintf(stderr,"debug=%d\n", debug);
2650 fprintf(stderr, "key function\n"
2651 "? show this help\n"
2652 "+ increase verbosity\n"
2653 "- decrease verbosity\n"
2654 "D cycle through available debug modes\n"
2655 "h dump packets/hex press to cycle through the 3 states\n"
2657 "s Show QP histogram\n"
2662 /* select the stream that we must read now by looking at the
2663 smallest output pts */
2665 for(i=0;i<nb_ostreams;i++) {
2668 os = output_files[ost->file_index];
2669 ist = &input_streams[ost->source_index];
2670 if(ist->is_past_recording_time || no_packet[ist->file_index])
2672 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2673 ipts = (double)ist->pts;
2674 if (!input_files[ist->file_index].eof_reached){
2675 if(ipts < ipts_min) {
2677 if(input_sync ) file_index = ist->file_index;
2679 if(opts < opts_min) {
2681 if(!input_sync) file_index = ist->file_index;
2684 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2689 /* if none, if is finished */
2690 if (file_index < 0) {
2691 if(no_packet_count){
2693 memset(no_packet, 0, sizeof(no_packet));
2700 /* finish if limit size exhausted */
2701 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2704 /* read a frame from it and output it in the fifo */
2705 is = input_files[file_index].ctx;
2706 ret= av_read_frame(is, &pkt);
2707 if(ret == AVERROR(EAGAIN)){
2708 no_packet[file_index]=1;
2713 input_files[file_index].eof_reached = 1;
2721 memset(no_packet, 0, sizeof(no_packet));
2724 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2725 is->streams[pkt.stream_index]);
2727 /* the following test is needed in case new streams appear
2728 dynamically in stream : we ignore them */
2729 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2730 goto discard_packet;
2731 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2732 ist = &input_streams[ist_index];
2734 goto discard_packet;
2736 if (pkt.dts != AV_NOPTS_VALUE)
2737 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2738 if (pkt.pts != AV_NOPTS_VALUE)
2739 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2741 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2742 && input_files_ts_scale[file_index][pkt.stream_index]){
2743 if(pkt.pts != AV_NOPTS_VALUE)
2744 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2745 if(pkt.dts != AV_NOPTS_VALUE)
2746 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2749 // 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);
2750 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2751 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2752 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2753 int64_t delta= pkt_dts - ist->next_pts;
2754 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2755 input_files[ist->file_index].ts_offset -= delta;
2757 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2758 delta, input_files[ist->file_index].ts_offset);
2759 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2760 if(pkt.pts != AV_NOPTS_VALUE)
2761 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2765 /* finish if recording time exhausted */
2766 if (recording_time != INT64_MAX &&
2767 (pkt.pts != AV_NOPTS_VALUE ?
2768 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2770 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2772 ist->is_past_recording_time = 1;
2773 goto discard_packet;
2776 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2777 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2780 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2781 ist->file_index, ist->st->index);
2784 av_free_packet(&pkt);
2789 av_free_packet(&pkt);
2791 /* dump report by using the output first video and audio streams */
2792 print_report(output_files, ost_table, nb_ostreams, 0);
2795 /* at the end of stream, we must flush the decoder buffers */
2796 for (i = 0; i < nb_input_streams; i++) {
2797 ist = &input_streams[i];
2798 if (ist->decoding_needed) {
2799 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2805 /* write the trailer if needed and close file */
2806 for(i=0;i<nb_output_files;i++) {
2807 os = output_files[i];
2808 av_write_trailer(os);
2811 /* dump report by using the first video and audio streams */
2812 print_report(output_files, ost_table, nb_ostreams, 1);
2814 /* close each encoder */
2815 for(i=0;i<nb_ostreams;i++) {
2817 if (ost->encoding_needed) {
2818 av_freep(&ost->st->codec->stats_in);
2819 avcodec_close(ost->st->codec);
2822 avfilter_graph_free(&ost->graph);
2826 /* close each decoder */
2827 for (i = 0; i < nb_input_streams; i++) {
2828 ist = &input_streams[i];
2829 if (ist->decoding_needed) {
2830 avcodec_close(ist->st->codec);
2838 av_freep(&bit_buffer);
2841 for(i=0;i<nb_ostreams;i++) {
2844 if (ost->st->stream_copy)
2845 av_freep(&ost->st->codec->extradata);
2847 fclose(ost->logfile);
2848 ost->logfile = NULL;
2850 av_fifo_free(ost->fifo); /* works even if fifo is not
2851 initialized but set to zero */
2852 av_freep(&ost->st->codec->subtitle_header);
2853 av_free(ost->resample_frame.data[0]);
2854 av_free(ost->forced_kf_pts);
2855 if (ost->video_resample)
2856 sws_freeContext(ost->img_resample_ctx);
2858 audio_resample_close(ost->resample);
2859 if (ost->reformat_ctx)
2860 av_audio_convert_free(ost->reformat_ctx);
2869 static int opt_format(const char *opt, const char *arg)
2871 last_asked_format = arg;
2875 static int opt_video_rc_override_string(const char *opt, const char *arg)
2877 video_rc_override_string = arg;
2881 static int opt_me_threshold(const char *opt, const char *arg)
2883 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2887 static int opt_verbose(const char *opt, const char *arg)
2889 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2893 static int opt_frame_rate(const char *opt, const char *arg)
2895 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2896 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2902 static int opt_bitrate(const char *opt, const char *arg)
2904 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2906 opt_default(opt, arg);
2908 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2909 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2914 static int opt_frame_crop(const char *opt, const char *arg)
2916 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2917 return AVERROR(EINVAL);
2920 static int opt_frame_size(const char *opt, const char *arg)
2922 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2923 fprintf(stderr, "Incorrect frame size\n");
2924 return AVERROR(EINVAL);
2929 static int opt_pad(const char *opt, const char *arg) {
2930 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2934 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2936 if (strcmp(arg, "list")) {
2937 frame_pix_fmt = av_get_pix_fmt(arg);
2938 if (frame_pix_fmt == PIX_FMT_NONE) {
2939 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2940 return AVERROR(EINVAL);
2943 opt_pix_fmts(NULL, NULL);
2949 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2956 p = strchr(arg, ':');
2958 x = strtol(arg, &end, 10);
2960 y = strtol(end+1, &end, 10);
2962 ar = (double)x / (double)y;
2964 ar = strtod(arg, NULL);
2967 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2968 return AVERROR(EINVAL);
2970 frame_aspect_ratio = ar;
2974 static int opt_metadata(const char *opt, const char *arg)
2976 char *mid= strchr(arg, '=');
2979 fprintf(stderr, "Missing =\n");
2984 av_dict_set(&metadata, arg, mid, 0);
2989 static int opt_qscale(const char *opt, const char *arg)
2991 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2992 if (video_qscale <= 0 || video_qscale > 255) {
2993 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2994 return AVERROR(EINVAL);
2999 static int opt_top_field_first(const char *opt, const char *arg)
3001 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
3002 opt_default(opt, arg);
3006 static int opt_thread_count(const char *opt, const char *arg)
3008 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3011 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
3016 static int opt_audio_sample_fmt(const char *opt, const char *arg)
3018 if (strcmp(arg, "list")) {
3019 audio_sample_fmt = av_get_sample_fmt(arg);
3020 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3021 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3022 return AVERROR(EINVAL);
3027 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3028 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3034 static int opt_audio_rate(const char *opt, const char *arg)
3036 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3040 static int opt_audio_channels(const char *opt, const char *arg)
3042 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3046 static int opt_video_channel(const char *opt, const char *arg)
3048 video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3052 static int opt_video_standard(const char *opt, const char *arg)
3054 video_standard = av_strdup(arg);
3058 static int opt_codec(const char *opt, const char *arg)
3060 int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3062 if (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy; pcodec_name = &audio_codec_name; codec_type = AVMEDIA_TYPE_AUDIO; }
3063 else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy; pcodec_name = &video_codec_name; codec_type = AVMEDIA_TYPE_VIDEO; }
3064 else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3065 else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy; pcodec_name = &data_codec_name; codec_type = AVMEDIA_TYPE_DATA; }
3067 av_freep(pcodec_name);
3068 if (!strcmp(arg, "copy")) {
3071 *pcodec_name = av_strdup(arg);
3076 static int opt_codec_tag(const char *opt, const char *arg)
3079 uint32_t *codec_tag;
3081 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3082 !strcmp(opt, "vtag") ? &video_codec_tag :
3083 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3087 *codec_tag = strtol(arg, &tail, 0);
3089 *codec_tag = AV_RL32(arg);
3094 static int opt_map(const char *opt, const char *arg)
3099 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3100 m = &stream_maps[nb_stream_maps-1];
3102 m->file_index = strtol(arg, &p, 0);
3106 m->stream_index = strtol(p, &p, 0);
3109 m->sync_file_index = strtol(p, &p, 0);
3112 m->sync_stream_index = strtol(p, &p, 0);
3114 m->sync_file_index = m->file_index;
3115 m->sync_stream_index = m->stream_index;
3120 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3131 *index = strtol(++arg, endptr, 0);
3134 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3141 static int opt_map_metadata(const char *opt, const char *arg)
3143 MetadataMap *m, *m1;
3146 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3147 &nb_meta_data_maps, nb_meta_data_maps + 1);
3149 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3150 m->file = strtol(arg, &p, 0);
3151 parse_meta_type(p, &m->type, &m->index, &p);
3155 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3156 m1->file = strtol(p, &p, 0);
3157 parse_meta_type(p, &m1->type, &m1->index, &p);
3159 if (m->type == 'g' || m1->type == 'g')
3160 metadata_global_autocopy = 0;
3161 if (m->type == 's' || m1->type == 's')
3162 metadata_streams_autocopy = 0;
3163 if (m->type == 'c' || m1->type == 'c')
3164 metadata_chapters_autocopy = 0;
3169 static int opt_map_meta_data(const char *opt, const char *arg)
3171 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3172 "Use -map_metadata instead.\n");
3173 return opt_map_metadata(opt, arg);
3176 static int opt_map_chapters(const char *opt, const char *arg)
3181 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3182 nb_chapter_maps + 1);
3183 c = &chapter_maps[nb_chapter_maps - 1];
3184 c->out_file = strtol(arg, &p, 0);
3188 c->in_file = strtol(p, &p, 0);
3192 static int opt_input_ts_scale(const char *opt, const char *arg)
3194 unsigned int stream;
3198 stream = strtol(arg, &p, 0);
3201 scale= strtod(p, &p);
3203 if(stream >= MAX_STREAMS)
3206 input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3207 input_files_ts_scale[nb_input_files][stream]= scale;
3211 static int opt_recording_time(const char *opt, const char *arg)
3213 recording_time = parse_time_or_die(opt, arg, 1);
3217 static int opt_start_time(const char *opt, const char *arg)
3219 start_time = parse_time_or_die(opt, arg, 1);
3223 static int opt_recording_timestamp(const char *opt, const char *arg)
3225 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3229 static int opt_input_ts_offset(const char *opt, const char *arg)
3231 input_ts_offset = parse_time_or_die(opt, arg, 1);
3235 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3237 const char *codec_string = encoder ? "encoder" : "decoder";
3241 return CODEC_ID_NONE;
3243 avcodec_find_encoder_by_name(name) :
3244 avcodec_find_decoder_by_name(name);
3246 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3249 if(codec->type != type) {
3250 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3253 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3254 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3255 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3256 "results.\nAdd '-strict experimental' if you want to use it.\n",
3257 codec_string, codec->name);
3259 avcodec_find_encoder(codec->id) :
3260 avcodec_find_decoder(codec->id);
3261 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3262 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3263 codec_string, codec->name);
3269 static int opt_input_file(const char *opt, const char *filename)
3271 AVFormatContext *ic;
3272 AVFormatParameters params, *ap = ¶ms;
3273 AVInputFormat *file_iformat = NULL;
3274 int err, i, ret, rfps, rfps_base;
3277 if (last_asked_format) {
3278 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3279 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3282 last_asked_format = NULL;
3285 if (!strcmp(filename, "-"))
3288 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3289 !strcmp(filename, "/dev/stdin");
3291 /* get default parameters from command line */
3292 ic = avformat_alloc_context();
3294 print_error(filename, AVERROR(ENOMEM));
3298 memset(ap, 0, sizeof(*ap));
3299 ap->prealloced_context = 1;
3300 ap->sample_rate = audio_sample_rate;
3301 ap->channels = audio_channels;
3302 ap->time_base.den = frame_rate.num;
3303 ap->time_base.num = frame_rate.den;
3304 ap->width = frame_width;
3305 ap->height = frame_height;
3306 ap->pix_fmt = frame_pix_fmt;
3307 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3308 ap->channel = video_channel;
3309 ap->standard = video_standard;
3311 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3313 ic->video_codec_id =
3314 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3315 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3316 ic->audio_codec_id =
3317 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3318 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3319 ic->subtitle_codec_id=
3320 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3321 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3322 ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3324 /* open the input file with generic libav function */
3325 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3327 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3328 err = av_demuxer_open(ic, ap);
3330 avformat_free_context(ic);
3333 print_error(filename, err);
3339 for(i=0; i<ic->nb_streams; i++){
3340 ic->streams[i]->discard= AVDISCARD_ALL;
3342 for(i=0; i<ic->nb_programs; i++){
3343 AVProgram *p= ic->programs[i];
3344 if(p->id != opt_programid){
3345 p->discard = AVDISCARD_ALL;
3348 for(j=0; j<p->nb_stream_indexes; j++){
3349 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3354 fprintf(stderr, "Specified program id not found\n");
3361 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3362 ic->loop_input = loop_input;
3365 /* If not enough info to get the stream parameters, we decode the
3366 first frames to get it. (used in mpeg case for example) */
3367 ret = av_find_stream_info(ic);
3368 if (ret < 0 && verbose >= 0) {
3369 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3370 av_close_input_file(ic);
3374 timestamp = start_time;
3375 /* add the stream start time */
3376 if (ic->start_time != AV_NOPTS_VALUE)
3377 timestamp += ic->start_time;
3379 /* if seeking requested, we execute it */
3380 if (start_time != 0) {
3381 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3383 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3384 filename, (double)timestamp / AV_TIME_BASE);
3386 /* reset seek info */
3390 /* update the current parameters so that they match the one of the input stream */
3391 for(i=0;i<ic->nb_streams;i++) {
3392 AVStream *st = ic->streams[i];
3393 AVCodecContext *dec = st->codec;
3396 dec->thread_count = thread_count;
3398 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3399 ist = &input_streams[nb_input_streams - 1];
3401 ist->file_index = nb_input_files;
3404 switch (dec->codec_type) {
3405 case AVMEDIA_TYPE_AUDIO:
3406 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3408 ist->dec = avcodec_find_decoder(dec->codec_id);
3409 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3410 channel_layout = dec->channel_layout;
3411 audio_sample_fmt = dec->sample_fmt;
3413 st->discard= AVDISCARD_ALL;
3415 case AVMEDIA_TYPE_VIDEO:
3416 ist->dec= avcodec_find_decoder_by_name(video_codec_name);
3418 ist->dec = avcodec_find_decoder(dec->codec_id);
3419 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
3420 rfps = ic->streams[i]->r_frame_rate.num;
3421 rfps_base = ic->streams[i]->r_frame_rate.den;
3423 dec->flags |= CODEC_FLAG_EMU_EDGE;
3424 dec->height >>= dec->lowres;
3425 dec->width >>= dec->lowres;
3428 dec->debug |= FF_DEBUG_MV;
3430 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3433 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3434 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3436 (float)rfps / rfps_base, rfps, rfps_base);
3440 st->discard= AVDISCARD_ALL;
3441 else if(video_discard)
3442 st->discard= video_discard;
3444 case AVMEDIA_TYPE_DATA:
3446 case AVMEDIA_TYPE_SUBTITLE:
3447 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3449 ist->dec = avcodec_find_decoder(dec->codec_id);
3450 if(subtitle_disable)
3451 st->discard = AVDISCARD_ALL;
3453 case AVMEDIA_TYPE_ATTACHMENT:
3454 case AVMEDIA_TYPE_UNKNOWN:
3461 /* dump the file content */
3463 av_dump_format(ic, nb_input_files, filename, 0);
3465 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3466 input_files[nb_input_files - 1].ctx = ic;
3467 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3468 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3470 top_field_first = -1;
3472 frame_rate = (AVRational){0, 0};
3473 frame_pix_fmt = PIX_FMT_NONE;
3476 audio_sample_rate = 0;
3479 av_freep(&video_codec_name);
3480 av_freep(&audio_codec_name);
3481 av_freep(&subtitle_codec_name);
3487 static void check_inputs(int *has_video_ptr,
3489 int *has_subtitle_ptr,
3492 int has_video, has_audio, has_subtitle, has_data, i, j;
3493 AVFormatContext *ic;
3500 for(j=0;j<nb_input_files;j++) {
3501 ic = input_files[j].ctx;
3502 for(i=0;i<ic->nb_streams;i++) {
3503 AVCodecContext *enc = ic->streams[i]->codec;
3504 switch(enc->codec_type) {
3505 case AVMEDIA_TYPE_AUDIO:
3508 case AVMEDIA_TYPE_VIDEO:
3511 case AVMEDIA_TYPE_SUBTITLE:
3514 case AVMEDIA_TYPE_DATA:
3515 case AVMEDIA_TYPE_ATTACHMENT:
3516 case AVMEDIA_TYPE_UNKNOWN:
3524 *has_video_ptr = has_video;
3525 *has_audio_ptr = has_audio;
3526 *has_subtitle_ptr = has_subtitle;
3527 *has_data_ptr = has_data;
3530 static void new_video_stream(AVFormatContext *oc, int file_idx)
3534 AVCodecContext *video_enc;
3535 enum CodecID codec_id = CODEC_ID_NONE;
3536 AVCodec *codec= NULL;
3538 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3540 fprintf(stderr, "Could not alloc stream\n");
3543 ost = new_output_stream(oc, file_idx);
3545 if(!video_stream_copy){
3546 if (video_codec_name) {
3547 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3548 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3549 codec = avcodec_find_encoder_by_name(video_codec_name);
3552 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3553 codec = avcodec_find_encoder(codec_id);
3555 ost->frame_aspect_ratio = frame_aspect_ratio;
3556 frame_aspect_ratio = 0;
3558 ost->avfilter = vfilters;
3563 avcodec_get_context_defaults3(st->codec, codec);
3564 ost->bitstream_filters = video_bitstream_filters;
3565 video_bitstream_filters= NULL;
3567 st->codec->thread_count= thread_count;
3569 video_enc = st->codec;
3572 video_enc->codec_tag= video_codec_tag;
3574 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3575 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3576 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3579 if (video_stream_copy) {
3580 st->stream_copy = 1;
3581 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3582 video_enc->sample_aspect_ratio =
3583 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3589 ost->frame_rate = frame_rate;
3590 video_enc->codec_id = codec_id;
3591 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3593 video_enc->width = frame_width;
3594 video_enc->height = frame_height;
3595 video_enc->pix_fmt = frame_pix_fmt;
3596 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3597 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3600 video_enc->gop_size = 0;
3601 if (video_qscale || same_quality) {
3602 video_enc->flags |= CODEC_FLAG_QSCALE;
3603 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3607 video_enc->intra_matrix = intra_matrix;
3609 video_enc->inter_matrix = inter_matrix;
3611 p= video_rc_override_string;
3614 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3616 fprintf(stderr, "error parsing rc_override\n");
3619 video_enc->rc_override=
3620 av_realloc(video_enc->rc_override,
3621 sizeof(RcOverride)*(i+1));
3622 video_enc->rc_override[i].start_frame= start;
3623 video_enc->rc_override[i].end_frame = end;
3625 video_enc->rc_override[i].qscale= q;
3626 video_enc->rc_override[i].quality_factor= 1.0;
3629 video_enc->rc_override[i].qscale= 0;
3630 video_enc->rc_override[i].quality_factor= -q/100.0;
3635 video_enc->rc_override_count=i;
3636 if (!video_enc->rc_initial_buffer_occupancy)
3637 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3638 video_enc->me_threshold= me_threshold;
3639 video_enc->intra_dc_precision= intra_dc_precision - 8;
3642 video_enc->flags|= CODEC_FLAG_PSNR;
3647 video_enc->flags |= CODEC_FLAG_PASS1;
3649 video_enc->flags |= CODEC_FLAG_PASS2;
3653 if (forced_key_frames)
3654 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3656 if (video_language) {
3657 av_dict_set(&st->metadata, "language", video_language, 0);
3658 av_freep(&video_language);
3661 /* reset some key parameters */
3663 av_freep(&video_codec_name);
3664 av_freep(&forced_key_frames);
3665 video_stream_copy = 0;
3666 frame_pix_fmt = PIX_FMT_NONE;
3669 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3673 AVCodec *codec= NULL;
3674 AVCodecContext *audio_enc;
3675 enum CodecID codec_id = CODEC_ID_NONE;
3677 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3679 fprintf(stderr, "Could not alloc stream\n");
3682 ost = new_output_stream(oc, file_idx);
3684 if(!audio_stream_copy){
3685 if (audio_codec_name) {
3686 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3687 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3688 codec = avcodec_find_encoder_by_name(audio_codec_name);
3691 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3692 codec = avcodec_find_encoder(codec_id);
3696 avcodec_get_context_defaults3(st->codec, codec);
3698 ost->bitstream_filters = audio_bitstream_filters;
3699 audio_bitstream_filters= NULL;
3701 st->codec->thread_count= thread_count;
3703 audio_enc = st->codec;
3704 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3707 audio_enc->codec_tag= audio_codec_tag;
3709 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3710 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3711 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3713 if (audio_stream_copy) {
3714 st->stream_copy = 1;
3716 audio_enc->codec_id = codec_id;
3717 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3719 if (audio_qscale > QSCALE_NONE) {
3720 audio_enc->flags |= CODEC_FLAG_QSCALE;
3721 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3724 audio_enc->channels = audio_channels;
3725 audio_enc->sample_fmt = audio_sample_fmt;
3726 if (audio_sample_rate)
3727 audio_enc->sample_rate = audio_sample_rate;
3728 audio_enc->channel_layout = channel_layout;
3729 choose_sample_fmt(st, codec);
3731 if (audio_language) {
3732 av_dict_set(&st->metadata, "language", audio_language, 0);
3733 av_freep(&audio_language);
3736 /* reset some key parameters */
3738 av_freep(&audio_codec_name);
3739 audio_stream_copy = 0;
3742 static void new_data_stream(AVFormatContext *oc, int file_idx)
3745 AVCodec *codec=NULL;
3746 AVCodecContext *data_enc;
3748 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3750 fprintf(stderr, "Could not alloc stream\n");
3753 new_output_stream(oc, file_idx);
3754 data_enc = st->codec;
3755 if (!data_stream_copy) {
3756 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3759 avcodec_get_context_defaults3(st->codec, codec);
3761 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3764 data_enc->codec_tag= data_codec_tag;
3766 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3767 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3768 avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3770 if (data_stream_copy) {
3771 st->stream_copy = 1;
3775 av_freep(&data_codec_name);
3776 data_stream_copy = 0;
3779 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3783 AVCodec *codec=NULL;
3784 AVCodecContext *subtitle_enc;
3785 enum CodecID codec_id = CODEC_ID_NONE;
3787 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3789 fprintf(stderr, "Could not alloc stream\n");
3792 ost = new_output_stream(oc, file_idx);
3793 subtitle_enc = st->codec;
3794 if(!subtitle_stream_copy){
3795 if (subtitle_codec_name) {
3796 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3797 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3798 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3801 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3802 codec = avcodec_find_encoder(codec_id);
3805 avcodec_get_context_defaults3(st->codec, codec);
3807 ost->bitstream_filters = subtitle_bitstream_filters;
3808 subtitle_bitstream_filters= NULL;
3810 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3812 if(subtitle_codec_tag)
3813 subtitle_enc->codec_tag= subtitle_codec_tag;
3815 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3816 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3817 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3819 if (subtitle_stream_copy) {
3820 st->stream_copy = 1;
3822 subtitle_enc->codec_id = codec_id;
3823 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3826 if (subtitle_language) {
3827 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3828 av_freep(&subtitle_language);
3831 subtitle_disable = 0;
3832 av_freep(&subtitle_codec_name);
3833 subtitle_stream_copy = 0;
3836 static int opt_new_stream(const char *opt, const char *arg)
3838 AVFormatContext *oc;
3839 int file_idx = nb_output_files - 1;
3840 if (nb_output_files <= 0) {
3841 fprintf(stderr, "At least one output file must be specified\n");
3844 oc = output_files[file_idx];
3846 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3847 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3848 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3849 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3854 /* arg format is "output-stream-index:streamid-value". */
3855 static int opt_streamid(const char *opt, const char *arg)
3861 av_strlcpy(idx_str, arg, sizeof(idx_str));
3862 p = strchr(idx_str, ':');
3865 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3870 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3871 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3872 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3876 static int opt_output_file(const char *opt, const char *filename)
3878 AVFormatContext *oc;
3879 int err, use_video, use_audio, use_subtitle, use_data;
3880 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3881 AVFormatParameters params, *ap = ¶ms;
3882 AVOutputFormat *file_oformat;
3884 if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3885 fprintf(stderr, "Too many output files\n");
3889 if (!strcmp(filename, "-"))
3892 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3893 last_asked_format = NULL;
3895 print_error(filename, err);
3898 file_oformat= oc->oformat;
3900 if (!strcmp(file_oformat->name, "ffm") &&
3901 av_strstart(filename, "http:", NULL)) {
3902 /* special case for files sent to ffserver: we get the stream
3903 parameters from ffserver */
3904 int err = read_ffserver_streams(oc, filename);
3906 print_error(filename, err);
3910 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3911 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3912 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3913 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 */
3915 /* disable if no corresponding type found */
3916 check_inputs(&input_has_video,
3918 &input_has_subtitle,
3921 if (!input_has_video)
3923 if (!input_has_audio)
3925 if (!input_has_subtitle)
3927 if (!input_has_data)
3930 /* manual disable */
3931 if (audio_disable) use_audio = 0;
3932 if (video_disable) use_video = 0;
3933 if (subtitle_disable) use_subtitle = 0;
3934 if (data_disable) use_data = 0;
3936 if (use_video) new_video_stream(oc, nb_output_files);
3937 if (use_audio) new_audio_stream(oc, nb_output_files);
3938 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3939 if (use_data) new_data_stream(oc, nb_output_files);
3941 oc->timestamp = recording_timestamp;
3943 av_dict_copy(&oc->metadata, metadata, 0);
3944 av_dict_free(&metadata);
3947 output_files[nb_output_files++] = oc;
3949 /* check filename in case of an image number is expected */
3950 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3951 if (!av_filename_number_test(oc->filename)) {
3952 print_error(oc->filename, AVERROR(EINVAL));
3957 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3958 /* test if it already exists to avoid loosing precious files */
3959 if (!file_overwrite &&
3960 (strchr(filename, ':') == NULL ||
3961 filename[1] == ':' ||
3962 av_strstart(filename, "file:", NULL))) {
3963 if (avio_check(filename, 0) == 0) {
3965 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3967 if (!read_yesno()) {
3968 fprintf(stderr, "Not overwriting - exiting\n");
3973 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3980 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3981 print_error(filename, err);
3986 memset(ap, 0, sizeof(*ap));
3987 if (av_set_parameters(oc, ap) < 0) {
3988 fprintf(stderr, "%s: Invalid encoding parameters\n",
3993 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3994 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3996 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3997 if (loop_output >= 0) {
3998 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3999 oc->loop_output = loop_output;
4001 oc->flags |= AVFMT_FLAG_NONBLOCK;
4003 frame_rate = (AVRational){0, 0};
4006 audio_sample_rate = 0;
4009 av_freep(&forced_key_frames);
4015 /* same option as mencoder */
4016 static int opt_pass(const char *opt, const char *arg)
4018 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4022 static int64_t getutime(void)
4025 struct rusage rusage;
4027 getrusage(RUSAGE_SELF, &rusage);
4028 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4029 #elif HAVE_GETPROCESSTIMES
4031 FILETIME c, e, k, u;
4032 proc = GetCurrentProcess();
4033 GetProcessTimes(proc, &c, &e, &k, &u);
4034 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4036 return av_gettime();
4040 static int64_t getmaxrss(void)
4042 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4043 struct rusage rusage;
4044 getrusage(RUSAGE_SELF, &rusage);
4045 return (int64_t)rusage.ru_maxrss * 1024;
4046 #elif HAVE_GETPROCESSMEMORYINFO
4048 PROCESS_MEMORY_COUNTERS memcounters;
4049 proc = GetCurrentProcess();
4050 memcounters.cb = sizeof(memcounters);
4051 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4052 return memcounters.PeakPagefileUsage;
4058 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4061 const char *p = str;
4068 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4075 static int opt_inter_matrix(const char *opt, const char *arg)
4077 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4078 parse_matrix_coeffs(inter_matrix, arg);
4082 static int opt_intra_matrix(const char *opt, const char *arg)
4084 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4085 parse_matrix_coeffs(intra_matrix, arg);
4089 static void show_usage(void)
4091 printf("Hyper fast Audio and Video encoder\n");
4092 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4096 static int opt_help(const char *opt, const char *arg)
4099 AVOutputFormat *oformat = NULL;
4101 av_log_set_callback(log_callback_help);
4103 show_help_options(options, "Main options:\n",
4104 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4105 show_help_options(options, "\nAdvanced options:\n",
4106 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4108 show_help_options(options, "\nVideo options:\n",
4109 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4111 show_help_options(options, "\nAdvanced Video options:\n",
4112 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4113 OPT_VIDEO | OPT_EXPERT);
4114 show_help_options(options, "\nAudio options:\n",
4115 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4117 show_help_options(options, "\nAdvanced Audio options:\n",
4118 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4119 OPT_AUDIO | OPT_EXPERT);
4120 show_help_options(options, "\nSubtitle options:\n",
4121 OPT_SUBTITLE | OPT_GRAB,
4123 show_help_options(options, "\nAudio/Video grab options:\n",
4127 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4130 /* individual codec options */
4132 while ((c = av_codec_next(c))) {
4133 if (c->priv_class) {
4134 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4139 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4142 /* individual muxer options */
4143 while ((oformat = av_oformat_next(oformat))) {
4144 if (oformat->priv_class) {
4145 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4150 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4154 static int opt_target(const char *opt, const char *arg)
4156 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4157 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4159 if(!strncmp(arg, "pal-", 4)) {
4162 } else if(!strncmp(arg, "ntsc-", 5)) {
4165 } else if(!strncmp(arg, "film-", 5)) {
4170 /* Calculate FR via float to avoid int overflow */
4171 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4174 } else if((fr == 29970) || (fr == 23976)) {
4177 /* Try to determine PAL/NTSC by peeking in the input files */
4178 if(nb_input_files) {
4180 for (j = 0; j < nb_input_files; j++) {
4181 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4182 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4183 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4185 fr = c->time_base.den * 1000 / c->time_base.num;
4189 } else if((fr == 29970) || (fr == 23976)) {
4199 if(verbose > 0 && norm != UNKNOWN)
4200 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4203 if(norm == UNKNOWN) {
4204 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4205 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4206 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4210 if(!strcmp(arg, "vcd")) {
4211 opt_codec("vcodec", "mpeg1video");
4212 opt_codec("acodec", "mp2");
4213 opt_format("f", "vcd");
4215 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4216 opt_frame_rate("r", frame_rates[norm]);
4217 opt_default("g", norm == PAL ? "15" : "18");
4219 opt_default("b", "1150000");
4220 opt_default("maxrate", "1150000");
4221 opt_default("minrate", "1150000");
4222 opt_default("bufsize", "327680"); // 40*1024*8;
4224 opt_default("ab", "224000");
4225 audio_sample_rate = 44100;
4228 opt_default("packetsize", "2324");
4229 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4231 /* We have to offset the PTS, so that it is consistent with the SCR.
4232 SCR starts at 36000, but the first two packs contain only padding
4233 and the first pack from the other stream, respectively, may also have
4234 been written before.
4235 So the real data starts at SCR 36000+3*1200. */
4236 mux_preload= (36000+3*1200) / 90000.0; //0.44
4237 } else if(!strcmp(arg, "svcd")) {
4239 opt_codec("vcodec", "mpeg2video");
4240 opt_codec("acodec", "mp2");
4241 opt_format("f", "svcd");
4243 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4244 opt_frame_rate("r", frame_rates[norm]);
4245 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4246 opt_default("g", norm == PAL ? "15" : "18");
4248 opt_default("b", "2040000");
4249 opt_default("maxrate", "2516000");
4250 opt_default("minrate", "0"); //1145000;
4251 opt_default("bufsize", "1835008"); //224*1024*8;
4252 opt_default("flags", "+scan_offset");
4255 opt_default("ab", "224000");
4256 audio_sample_rate = 44100;
4258 opt_default("packetsize", "2324");
4260 } else if(!strcmp(arg, "dvd")) {
4262 opt_codec("vcodec", "mpeg2video");
4263 opt_codec("acodec", "ac3");
4264 opt_format("f", "dvd");
4266 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4267 opt_frame_rate("r", frame_rates[norm]);
4268 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4269 opt_default("g", norm == PAL ? "15" : "18");
4271 opt_default("b", "6000000");
4272 opt_default("maxrate", "9000000");
4273 opt_default("minrate", "0"); //1500000;
4274 opt_default("bufsize", "1835008"); //224*1024*8;
4276 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4277 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4279 opt_default("ab", "448000");
4280 audio_sample_rate = 48000;
4282 } else if(!strncmp(arg, "dv", 2)) {
4284 opt_format("f", "dv");
4286 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4287 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4288 norm == PAL ? "yuv420p" : "yuv411p");
4289 opt_frame_rate("r", frame_rates[norm]);
4291 audio_sample_rate = 48000;
4295 fprintf(stderr, "Unknown target: %s\n", arg);
4296 return AVERROR(EINVAL);
4301 static int opt_vstats_file(const char *opt, const char *arg)
4303 av_free (vstats_filename);
4304 vstats_filename=av_strdup (arg);
4308 static int opt_vstats(const char *opt, const char *arg)
4311 time_t today2 = time(NULL);
4312 struct tm *today = localtime(&today2);
4314 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4316 return opt_vstats_file(opt, filename);
4319 static int opt_bsf(const char *opt, const char *arg)
4321 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4322 AVBitStreamFilterContext **bsfp;
4325 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4329 bsfp= *opt == 'v' ? &video_bitstream_filters :
4330 *opt == 'a' ? &audio_bitstream_filters :
4331 &subtitle_bitstream_filters;
4333 bsfp= &(*bsfp)->next;
4340 static int opt_preset(const char *opt, const char *arg)
4343 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4344 char *codec_name = *opt == 'v' ? video_codec_name :
4345 *opt == 'a' ? audio_codec_name :
4346 subtitle_codec_name;
4348 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4349 fprintf(stderr, "File for preset '%s' not found\n", arg);
4354 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4355 if(line[0] == '#' && !e)
4357 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4359 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4362 if (!strcmp(tmp, "acodec") ||
4363 !strcmp(tmp, "vcodec") ||
4364 !strcmp(tmp, "scodec") ||
4365 !strcmp(tmp, "dcodec")) {
4366 opt_codec(tmp, tmp2);
4367 }else if(opt_default(tmp, tmp2) < 0){
4368 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4378 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4382 static int opt_passlogfile(const char *opt, const char *arg)
4384 pass_logfilename_prefix = arg;
4385 opt_default("passlogfile", arg);
4389 static const OptionDef options[] = {
4391 #include "cmdutils_common_opts.h"
4392 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4393 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4394 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4395 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4396 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4397 "outfile[,metadata]:infile[,metadata]" },
4398 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4399 "outfile[,metadata]:infile[,metadata]" },
4400 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4401 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4402 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4403 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4404 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4405 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4406 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4407 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4408 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4409 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4410 "add timings for benchmarking" },
4411 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4412 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4413 "dump each input packet" },
4414 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4415 "when dumping packets, also dump the payload" },
4416 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4417 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4418 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4419 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4420 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4421 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4422 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4423 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4424 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4425 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4426 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4427 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4428 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4429 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4430 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4431 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4434 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4435 { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4436 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4437 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4438 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4439 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4440 { "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" },
4441 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4442 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4443 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4444 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4445 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4446 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4447 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4448 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4449 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4450 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4451 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4452 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4453 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4454 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4455 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4456 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4457 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4458 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4459 "use same quantizer as source (implies VBR)" },
4460 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4461 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4462 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4463 "deinterlace pictures" },
4464 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4465 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4466 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4468 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4470 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4471 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4472 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4473 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4474 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4475 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4476 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4477 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4478 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4479 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4480 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4483 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4484 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4485 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4486 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4487 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4488 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4489 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4490 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4491 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4492 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4493 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4494 { "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" },
4496 /* subtitle options */
4497 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4498 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4499 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4500 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4501 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4504 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4505 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4506 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4509 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4510 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4512 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4513 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4514 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4516 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4517 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4518 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4519 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4520 /* data codec support */
4521 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4523 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4527 int main(int argc, char **argv)
4531 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4533 if(argc>1 && !strcmp(argv[1], "-d")){
4536 av_log_set_callback(log_callback_null);
4541 avcodec_register_all();
4543 avdevice_register_all();
4546 avfilter_register_all();
4551 if(isatty(STDIN_FILENO))
4552 avio_set_interrupt_cb(decode_interrupt_cb);
4561 parse_options(argc, argv, options, opt_output_file);
4563 if(nb_output_files <= 0 && nb_input_files == 0) {
4565 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4569 /* file converter / grab */
4570 if (nb_output_files <= 0) {
4571 fprintf(stderr, "At least one output file must be specified\n");
4575 if (nb_input_files == 0) {
4576 fprintf(stderr, "At least one input file must be specified\n");
4581 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4582 stream_maps, nb_stream_maps) < 0)
4584 ti = getutime() - ti;
4586 int maxrss = getmaxrss() / 1024;
4587 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4590 return ffmpeg_exit(0);