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
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcore/audioconvert.h"
40 #include "libavcore/parseutils.h"
41 #include "libavcore/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/libm.h"
48 #include "libavformat/os_support.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/vsrc_buffer.h"
56 #if HAVE_SYS_RESOURCE_H
57 #include <sys/types.h>
59 #include <sys/resource.h>
60 #elif HAVE_GETPROCESSTIMES
63 #if HAVE_GETPROCESSMEMORYINFO
69 #include <sys/select.h>
74 #include <sys/ioctl.h>
84 #include "libavutil/avassert.h"
86 const char program_name[] = "FFmpeg";
87 const int program_birth_year = 2000;
89 /* select an input stream for an output stream */
90 typedef struct AVStreamMap {
94 int sync_stream_index;
98 * select an input file for an output file
100 typedef struct AVMetaDataMap {
101 int file; //< file index
102 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103 int index; //< stream/chapter/program number
106 typedef struct AVChapterMap {
111 static const OptionDef options[];
113 #define MAX_FILES 100
114 #if !FF_API_MAX_STREAMS
115 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
118 static const char *last_asked_format = NULL;
119 static AVFormatContext *input_files[MAX_FILES];
120 static int64_t input_files_ts_offset[MAX_FILES];
121 static double *input_files_ts_scale[MAX_FILES] = {NULL};
122 static AVCodec **input_codecs = NULL;
123 static int nb_input_files = 0;
124 static int nb_input_codecs = 0;
125 static int nb_input_files_ts_scale[MAX_FILES] = {0};
127 static AVFormatContext *output_files[MAX_FILES];
128 static AVCodec **output_codecs = NULL;
129 static int nb_output_files = 0;
130 static int nb_output_codecs = 0;
132 static AVStreamMap *stream_maps = NULL;
133 static int nb_stream_maps;
135 /* first item specifies output metadata, second is input */
136 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137 static int nb_meta_data_maps;
138 static int metadata_global_autocopy = 1;
139 static int metadata_streams_autocopy = 1;
140 static int metadata_chapters_autocopy = 1;
142 static AVChapterMap *chapter_maps = NULL;
143 static int nb_chapter_maps;
145 /* indexed by output file stream index */
146 static int *streamid_map = NULL;
147 static int nb_streamid_map = 0;
149 static int frame_width = 0;
150 static int frame_height = 0;
151 static float frame_aspect_ratio = 0;
152 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155 static AVRational frame_rate;
156 static float video_qscale = 0;
157 static uint16_t *intra_matrix = NULL;
158 static uint16_t *inter_matrix = NULL;
159 static const char *video_rc_override_string=NULL;
160 static int video_disable = 0;
161 static int video_discard = 0;
162 static char *video_codec_name = NULL;
163 static unsigned int video_codec_tag = 0;
164 static char *video_language = NULL;
165 static int same_quality = 0;
166 static int do_deinterlace = 0;
167 static int top_field_first = -1;
168 static int me_threshold = 0;
169 static int intra_dc_precision = 8;
170 static int loop_input = 0;
171 static int loop_output = AVFMT_NOOUTPUTLOOP;
172 static int qp_hist = 0;
174 static char *vfilters = NULL;
175 AVFilterGraph *graph = NULL;
178 static int intra_only = 0;
179 static int audio_sample_rate = 44100;
180 static int64_t channel_layout = 0;
181 #define QSCALE_NONE -99999
182 static float audio_qscale = QSCALE_NONE;
183 static int audio_disable = 0;
184 static int audio_channels = 1;
185 static char *audio_codec_name = NULL;
186 static unsigned int audio_codec_tag = 0;
187 static char *audio_language = NULL;
189 static int subtitle_disable = 0;
190 static char *subtitle_codec_name = NULL;
191 static char *subtitle_language = NULL;
192 static unsigned int subtitle_codec_tag = 0;
194 static float mux_preload= 0.5;
195 static float mux_max_delay= 0.7;
197 static int64_t recording_time = INT64_MAX;
198 static int64_t start_time = 0;
199 static int64_t recording_timestamp = 0;
200 static int64_t input_ts_offset = 0;
201 static int file_overwrite = 0;
202 static AVMetadata *metadata;
203 static int do_benchmark = 0;
204 static int do_hex_dump = 0;
205 static int do_pkt_dump = 0;
206 static int do_psnr = 0;
207 static int do_pass = 0;
208 static char *pass_logfilename_prefix = NULL;
209 static int audio_stream_copy = 0;
210 static int video_stream_copy = 0;
211 static int subtitle_stream_copy = 0;
212 static int video_sync_method= -1;
213 static int audio_sync_method= 0;
214 static float audio_drift_threshold= 0.1;
215 static int copy_ts= 0;
216 static int opt_shortest = 0;
217 static int video_global_header = 0;
218 static char *vstats_filename;
219 static FILE *vstats_file;
220 static int opt_programid = 0;
221 static int copy_initial_nonkeyframes = 0;
223 static int rate_emu = 0;
225 static int video_channel = 0;
226 static char *video_standard;
228 static int audio_volume = 256;
230 static int exit_on_error = 0;
231 static int using_stdin = 0;
232 static int verbose = 1;
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 unsigned int sws_flags = SWS_BICUBIC;
249 static int64_t timer_start;
251 static uint8_t *audio_buf;
252 static uint8_t *audio_out;
253 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
255 static short *samples;
257 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
258 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
261 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263 struct AVInputStream;
265 typedef struct AVOutputStream {
266 int file_index; /* file index */
267 int index; /* stream index in the output file */
268 int source_index; /* AVInputStream index */
269 AVStream *st; /* stream in the output file */
270 int encoding_needed; /* true if encoding needed for this stream */
272 /* input pts and corresponding output pts
274 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
275 struct AVInputStream *sync_ist; /* input stream to sync against */
276 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
277 AVBitStreamFilterContext *bitstream_filters;
280 AVFrame pict_tmp; /* temporary image for resampling */
281 struct SwsContext *img_resample_ctx; /* for image resampling */
284 int resample_pix_fmt;
286 /* full frame size of first frame */
290 /* forced key frames */
291 int64_t *forced_kf_pts;
297 ReSampleContext *resample; /* for audio resampling */
298 int resample_sample_fmt;
299 int resample_channels;
300 int resample_sample_rate;
302 AVAudioConvert *reformat_ctx;
303 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
307 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
308 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
310 typedef struct AVInputStream {
314 int discard; /* true if stream data should be discarded */
315 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
316 int64_t sample_index; /* current sample */
318 int64_t start; /* time when read started */
319 int64_t next_pts; /* synthetic pts for cases where pkt.pts
321 int64_t pts; /* current pts */
322 PtsCorrectionContext pts_ctx;
323 int is_start; /* is 1 at the start and after a discontinuity */
324 int showed_multi_packet_warning;
325 int is_past_recording_time;
327 AVFilterContext *output_video_filter;
328 AVFilterContext *input_video_filter;
329 AVFrame *filter_frame;
330 int has_filter_frame;
331 AVFilterBufferRef *picref;
335 typedef struct AVInputFile {
336 int eof_reached; /* true if eof reached */
337 int ist_index; /* index of first stream in ist_table */
338 int buffer_size; /* current total buffer size */
339 int nb_streams; /* nb streams we are aware of */
344 /* init terminal so that we can grab keys */
345 static struct termios oldtty;
350 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
352 AVFilterContext *last_filter, *filter;
353 /** filter graph containing all filters including input & output */
354 AVCodecContext *codec = ost->st->codec;
355 AVCodecContext *icodec = ist->st->codec;
356 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
360 graph = avfilter_graph_alloc();
362 snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
363 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
364 ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
365 "src", args, NULL, graph);
368 ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
369 "out", NULL, &ffsink_ctx, graph);
372 last_filter = ist->input_video_filter;
374 if (codec->width != icodec->width || codec->height != icodec->height) {
375 snprintf(args, 255, "%d:%d:flags=0x%X",
378 (int)av_get_int(sws_opts, "sws_flags", NULL));
379 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
380 NULL, args, NULL, graph)) < 0)
382 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
384 last_filter = filter;
387 snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
388 graph->scale_sws_opts = av_strdup(args);
391 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
392 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
394 outputs->name = av_strdup("in");
395 outputs->filter_ctx = last_filter;
396 outputs->pad_idx = 0;
397 outputs->next = NULL;
399 inputs->name = av_strdup("out");
400 inputs->filter_ctx = ist->output_video_filter;
404 if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
408 if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
412 if ((ret = avfilter_graph_config(graph, NULL)) < 0)
415 codec->width = ist->output_video_filter->inputs[0]->w;
416 codec->height = ist->output_video_filter->inputs[0]->h;
420 #endif /* CONFIG_AVFILTER */
422 static void term_exit(void)
424 av_log(NULL, AV_LOG_QUIET, "");
426 tcsetattr (0, TCSANOW, &oldtty);
430 static volatile int received_sigterm = 0;
433 sigterm_handler(int sig)
435 received_sigterm = sig;
439 static void term_init(void)
448 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
449 |INLCR|IGNCR|ICRNL|IXON);
450 tty.c_oflag |= OPOST;
451 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
452 tty.c_cflag &= ~(CSIZE|PARENB);
457 tcsetattr (0, TCSANOW, &tty);
458 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
461 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
462 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
464 signal(SIGXCPU, sigterm_handler);
468 /* read a key without blocking */
469 static int read_key(void)
481 n = select(1, &rfds, NULL, NULL, &tv);
496 static int decode_interrupt_cb(void)
498 return q_pressed || (q_pressed = read_key() == 'q');
501 static int ffmpeg_exit(int ret)
506 for(i=0;i<nb_output_files;i++) {
507 /* maybe av_close_output_file ??? */
508 AVFormatContext *s = output_files[i];
510 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
512 for(j=0;j<s->nb_streams;j++) {
513 av_metadata_free(&s->streams[j]->metadata);
514 av_free(s->streams[j]->codec);
515 av_free(s->streams[j]->info);
516 av_free(s->streams[j]);
518 for(j=0;j<s->nb_programs;j++) {
519 av_metadata_free(&s->programs[j]->metadata);
521 for(j=0;j<s->nb_chapters;j++) {
522 av_metadata_free(&s->chapters[j]->metadata);
524 av_metadata_free(&s->metadata);
526 av_free(output_streams_for_file[i]);
528 for(i=0;i<nb_input_files;i++) {
529 av_close_input_file(input_files[i]);
530 av_free(input_files_ts_scale[i]);
533 av_free(intra_matrix);
534 av_free(inter_matrix);
538 av_free(vstats_filename);
541 av_free(streamid_map);
542 av_free(input_codecs);
543 av_free(output_codecs);
544 av_free(stream_maps);
545 av_free(meta_data_maps);
547 av_free(video_codec_name);
548 av_free(audio_codec_name);
549 av_free(subtitle_codec_name);
551 av_free(video_standard);
556 allocated_audio_buf_size= allocated_audio_out_size= 0;
563 if (received_sigterm) {
565 "Received signal %d: terminating.\n",
566 (int) received_sigterm);
570 exit(ret); /* not all OS-es handle main() return value */
574 /* similar to ff_dynarray_add() and av_fast_realloc() */
575 static void *grow_array(void *array, int elem_size, int *size, int new_size)
577 if (new_size >= INT_MAX / elem_size) {
578 fprintf(stderr, "Array too big.\n");
581 if (*size < new_size) {
582 uint8_t *tmp = av_realloc(array, new_size*elem_size);
584 fprintf(stderr, "Could not alloc buffer.\n");
587 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
594 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
596 if(codec && codec->sample_fmts){
597 const enum AVSampleFormat *p= codec->sample_fmts;
599 if(*p == st->codec->sample_fmt)
603 st->codec->sample_fmt = codec->sample_fmts[0];
607 static void choose_sample_rate(AVStream *st, AVCodec *codec)
609 if(codec && codec->supported_samplerates){
610 const int *p= codec->supported_samplerates;
612 int best_dist=INT_MAX;
614 int dist= abs(st->codec->sample_rate - *p);
615 if(dist < best_dist){
621 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
623 st->codec->sample_rate= best;
627 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
629 if(codec && codec->pix_fmts){
630 const enum PixelFormat *p= codec->pix_fmts;
632 if(*p == st->codec->pix_fmt)
636 && !( st->codec->codec_id==CODEC_ID_MJPEG
637 && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
638 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
639 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
640 st->codec->pix_fmt = codec->pix_fmts[0];
644 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
646 int idx = oc->nb_streams - 1;
649 output_streams_for_file[file_idx] =
650 grow_array(output_streams_for_file[file_idx],
651 sizeof(*output_streams_for_file[file_idx]),
652 &nb_output_streams_for_file[file_idx],
654 ost = output_streams_for_file[file_idx][idx] =
655 av_mallocz(sizeof(AVOutputStream));
657 fprintf(stderr, "Could not alloc output stream\n");
660 ost->file_index = file_idx;
665 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
671 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
674 /* copy stream format */
676 for(i=0;i<ic->nb_streams;i++) {
682 // FIXME: a more elegant solution is needed
683 st = av_mallocz(sizeof(AVStream));
684 memcpy(st, ic->streams[i], sizeof(AVStream));
685 st->codec = avcodec_alloc_context();
687 print_error(filename, AVERROR(ENOMEM));
690 avcodec_copy_context(st->codec, ic->streams[i]->codec);
693 codec = avcodec_find_encoder(st->codec->codec_id);
694 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
695 if (audio_stream_copy) {
698 choose_sample_fmt(st, codec);
699 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
700 if (video_stream_copy) {
703 choose_pixel_fmt(st, codec);
706 if(!st->codec->thread_count)
707 st->codec->thread_count = 1;
708 if(st->codec->thread_count>1)
709 avcodec_thread_init(st->codec, st->codec->thread_count);
711 if(st->codec->flags & CODEC_FLAG_BITEXACT)
714 new_output_stream(s, nb_output_files);
718 s->timestamp = av_gettime();
720 av_close_input_file(ic);
725 get_sync_ipts(const AVOutputStream *ost)
727 const AVInputStream *ist = ost->sync_ist;
728 return (double)(ist->pts - start_time)/AV_TIME_BASE;
731 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
735 AVPacket new_pkt= *pkt;
736 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
737 &new_pkt.data, &new_pkt.size,
738 pkt->data, pkt->size,
739 pkt->flags & AV_PKT_FLAG_KEY);
742 new_pkt.destruct= av_destruct_packet;
744 fprintf(stderr, "%s failed for stream %d, codec %s",
745 bsfc->filter->name, pkt->stream_index,
746 avctx->codec ? avctx->codec->name : "copy");
756 ret= av_interleaved_write_frame(s, pkt);
758 print_error("av_interleaved_write_frame()", ret);
763 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
765 static void do_audio_out(AVFormatContext *s,
768 unsigned char *buf, int size)
771 int64_t audio_out_size, audio_buf_size;
772 int64_t allocated_for_size= size;
774 int size_out, frame_bytes, ret, resample_changed;
775 AVCodecContext *enc= ost->st->codec;
776 AVCodecContext *dec= ist->st->codec;
777 int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
778 int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
779 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
782 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
783 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
784 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
785 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
786 audio_buf_size*= osize*enc->channels;
788 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
789 if(coded_bps > 8*osize)
790 audio_out_size= audio_out_size * coded_bps / (8*osize);
791 audio_out_size += FF_MIN_BUFFER_SIZE;
793 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
794 fprintf(stderr, "Buffer sizes too large\n");
798 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
799 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
800 if (!audio_buf || !audio_out){
801 fprintf(stderr, "Out of memory in do_audio_out\n");
805 if (enc->channels != dec->channels)
806 ost->audio_resample = 1;
808 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
809 ost->resample_channels != dec->channels ||
810 ost->resample_sample_rate != dec->sample_rate;
812 if ((ost->audio_resample && !ost->resample) || resample_changed) {
813 if (resample_changed) {
814 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",
815 ist->file_index, ist->index,
816 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
817 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
818 ost->resample_sample_fmt = dec->sample_fmt;
819 ost->resample_channels = dec->channels;
820 ost->resample_sample_rate = dec->sample_rate;
822 audio_resample_close(ost->resample);
824 if (ost->resample_sample_fmt == enc->sample_fmt &&
825 ost->resample_channels == enc->channels &&
826 ost->resample_sample_rate == enc->sample_rate) {
827 ost->resample = NULL;
828 ost->audio_resample = 0;
830 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
831 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
832 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
833 enc->sample_rate, dec->sample_rate,
834 enc->sample_fmt, dec->sample_fmt,
836 if (!ost->resample) {
837 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
838 dec->channels, dec->sample_rate,
839 enc->channels, enc->sample_rate);
845 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
846 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
847 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
848 if (ost->reformat_ctx)
849 av_audio_convert_free(ost->reformat_ctx);
850 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
851 dec->sample_fmt, 1, NULL, 0);
852 if (!ost->reformat_ctx) {
853 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
854 av_get_sample_fmt_name(dec->sample_fmt),
855 av_get_sample_fmt_name(enc->sample_fmt));
858 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
861 if(audio_sync_method){
862 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
863 - av_fifo_size(ost->fifo)/(enc->channels * 2);
864 double idelta= delta*dec->sample_rate / enc->sample_rate;
865 int byte_delta= ((int)idelta)*2*dec->channels;
867 //FIXME resample delay
868 if(fabs(delta) > 50){
869 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
871 byte_delta= FFMAX(byte_delta, -size);
875 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
880 static uint8_t *input_tmp= NULL;
881 input_tmp= av_realloc(input_tmp, byte_delta + size);
883 if(byte_delta > allocated_for_size - size){
884 allocated_for_size= byte_delta + (int64_t)size;
889 memset(input_tmp, 0, byte_delta);
890 memcpy(input_tmp + byte_delta, buf, size);
894 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
896 }else if(audio_sync_method>1){
897 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
898 av_assert0(ost->audio_resample);
900 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
901 // 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));
902 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
906 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
907 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
909 if (ost->audio_resample) {
911 size_out = audio_resample(ost->resample,
912 (short *)buftmp, (short *)buf,
913 size / (dec->channels * isize));
914 size_out = size_out * enc->channels * osize;
920 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
921 const void *ibuf[6]= {buftmp};
922 void *obuf[6]= {audio_buf};
923 int istride[6]= {isize};
924 int ostride[6]= {osize};
925 int len= size_out/istride[0];
926 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
927 printf("av_audio_convert() failed\n");
933 size_out = len*osize;
936 /* now encode as many frames as possible */
937 if (enc->frame_size > 1) {
938 /* output resampled raw samples */
939 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
940 fprintf(stderr, "av_fifo_realloc2() failed\n");
943 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
945 frame_bytes = enc->frame_size * osize * enc->channels;
947 while (av_fifo_size(ost->fifo) >= frame_bytes) {
949 av_init_packet(&pkt);
951 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
953 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
955 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
958 fprintf(stderr, "Audio encoding failed\n");
962 pkt.stream_index= ost->index;
965 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
966 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
967 pkt.flags |= AV_PKT_FLAG_KEY;
968 write_frame(s, &pkt, enc, ost->bitstream_filters);
970 ost->sync_opts += enc->frame_size;
974 av_init_packet(&pkt);
976 ost->sync_opts += size_out / (osize * enc->channels);
978 /* output a pcm frame */
979 /* determine the size of the coded buffer */
982 size_out = size_out*coded_bps/8;
984 if(size_out > audio_out_size){
985 fprintf(stderr, "Internal error, buffer size too small\n");
989 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
990 ret = avcodec_encode_audio(enc, audio_out, size_out,
993 fprintf(stderr, "Audio encoding failed\n");
997 pkt.stream_index= ost->index;
1000 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1001 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1002 pkt.flags |= AV_PKT_FLAG_KEY;
1003 write_frame(s, &pkt, enc, ost->bitstream_filters);
1007 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1009 AVCodecContext *dec;
1010 AVPicture *picture2;
1011 AVPicture picture_tmp;
1014 dec = ist->st->codec;
1016 /* deinterlace : must be done before any resize */
1017 if (do_deinterlace) {
1020 /* create temporary picture */
1021 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1022 buf = av_malloc(size);
1026 picture2 = &picture_tmp;
1027 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1029 if(avpicture_deinterlace(picture2, picture,
1030 dec->pix_fmt, dec->width, dec->height) < 0) {
1031 /* if error, do not deinterlace */
1032 fprintf(stderr, "Deinterlacing failed\n");
1041 if (picture != picture2)
1042 *picture = *picture2;
1046 /* we begin to correct av delay at this threshold */
1047 #define AV_DELAY_MAX 0.100
1049 static void do_subtitle_out(AVFormatContext *s,
1050 AVOutputStream *ost,
1055 static uint8_t *subtitle_out = NULL;
1056 int subtitle_out_max_size = 1024 * 1024;
1057 int subtitle_out_size, nb, i;
1058 AVCodecContext *enc;
1061 if (pts == AV_NOPTS_VALUE) {
1062 fprintf(stderr, "Subtitle packets must have a pts\n");
1068 enc = ost->st->codec;
1070 if (!subtitle_out) {
1071 subtitle_out = av_malloc(subtitle_out_max_size);
1074 /* Note: DVB subtitle need one packet to draw them and one other
1075 packet to clear them */
1076 /* XXX: signal it in the codec context ? */
1077 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1082 for(i = 0; i < nb; i++) {
1083 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1084 // start_display_time is required to be 0
1085 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1086 sub->end_display_time -= sub->start_display_time;
1087 sub->start_display_time = 0;
1088 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1089 subtitle_out_max_size, sub);
1090 if (subtitle_out_size < 0) {
1091 fprintf(stderr, "Subtitle encoding failed\n");
1095 av_init_packet(&pkt);
1096 pkt.stream_index = ost->index;
1097 pkt.data = subtitle_out;
1098 pkt.size = subtitle_out_size;
1099 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1100 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1101 /* XXX: the pts correction is handled here. Maybe handling
1102 it in the codec would be better */
1104 pkt.pts += 90 * sub->start_display_time;
1106 pkt.pts += 90 * sub->end_display_time;
1108 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1112 static int bit_buffer_size= 1024*256;
1113 static uint8_t *bit_buffer= NULL;
1115 static void do_video_out(AVFormatContext *s,
1116 AVOutputStream *ost,
1118 AVFrame *in_picture,
1121 int nb_frames, i, ret;
1122 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1123 AVCodecContext *enc, *dec;
1126 enc = ost->st->codec;
1127 dec = ist->st->codec;
1129 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1131 /* by default, we output a single frame */
1136 if(video_sync_method){
1137 double vdelta = sync_ipts - ost->sync_opts;
1138 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1141 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1144 }else if(vdelta>0.6)
1145 ost->sync_opts= lrintf(sync_ipts);
1146 }else if (vdelta > 1.1)
1147 nb_frames = lrintf(vdelta);
1148 //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);
1149 if (nb_frames == 0){
1152 fprintf(stderr, "*** drop!\n");
1153 }else if (nb_frames > 1) {
1154 nb_frames_dup += nb_frames - 1;
1156 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1159 ost->sync_opts= lrintf(sync_ipts);
1161 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1165 formatted_picture = in_picture;
1166 final_picture = formatted_picture;
1167 padding_src = formatted_picture;
1168 resampling_dst = &ost->pict_tmp;
1170 if ( ost->resample_height != ist->st->codec->height
1171 || ost->resample_width != ist->st->codec->width
1172 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1174 fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1175 if(!ost->video_resample)
1179 #if !CONFIG_AVFILTER
1180 if (ost->video_resample) {
1182 final_picture = &ost->pict_tmp;
1183 if( ost->resample_height != ist->st->codec->height
1184 || ost->resample_width != ist->st->codec->width
1185 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1187 /* initialize a new scaler context */
1188 sws_freeContext(ost->img_resample_ctx);
1189 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1190 ost->img_resample_ctx = sws_getContext(
1191 ist->st->codec->width,
1192 ist->st->codec->height,
1193 ist->st->codec->pix_fmt,
1194 ost->st->codec->width,
1195 ost->st->codec->height,
1196 ost->st->codec->pix_fmt,
1197 sws_flags, NULL, NULL, NULL);
1198 if (ost->img_resample_ctx == NULL) {
1199 fprintf(stderr, "Cannot get resampling context\n");
1203 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1204 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1208 /* duplicates frame if needed */
1209 for(i=0;i<nb_frames;i++) {
1211 av_init_packet(&pkt);
1212 pkt.stream_index= ost->index;
1214 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1215 /* raw pictures are written as AVPicture structure to
1216 avoid any copies. We support temorarily the older
1218 AVFrame* old_frame = enc->coded_frame;
1219 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1220 pkt.data= (uint8_t *)final_picture;
1221 pkt.size= sizeof(AVPicture);
1222 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1223 pkt.flags |= AV_PKT_FLAG_KEY;
1225 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1226 enc->coded_frame = old_frame;
1228 AVFrame big_picture;
1230 big_picture= *final_picture;
1231 /* better than nothing: use input picture interlaced
1233 big_picture.interlaced_frame = in_picture->interlaced_frame;
1234 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1235 if(top_field_first == -1)
1236 big_picture.top_field_first = in_picture->top_field_first;
1238 big_picture.top_field_first = top_field_first;
1241 /* handles sameq here. This is not correct because it may
1242 not be a global option */
1243 big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1245 big_picture.pict_type = 0;
1246 // big_picture.pts = AV_NOPTS_VALUE;
1247 big_picture.pts= ost->sync_opts;
1248 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1249 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1250 if (ost->forced_kf_index < ost->forced_kf_count &&
1251 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1252 big_picture.pict_type = FF_I_TYPE;
1253 ost->forced_kf_index++;
1255 ret = avcodec_encode_video(enc,
1256 bit_buffer, bit_buffer_size,
1259 fprintf(stderr, "Video encoding failed\n");
1264 pkt.data= bit_buffer;
1266 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1267 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1268 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1269 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1270 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1272 if(enc->coded_frame->key_frame)
1273 pkt.flags |= AV_PKT_FLAG_KEY;
1274 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1277 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1278 // enc->frame_number-1, ret, enc->pict_type);
1279 /* if two pass, output log */
1280 if (ost->logfile && enc->stats_out) {
1281 fprintf(ost->logfile, "%s", enc->stats_out);
1286 ost->frame_number++;
1290 static double psnr(double d){
1291 return -10.0*log(d)/log(10.0);
1294 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1297 AVCodecContext *enc;
1299 double ti1, bitrate, avg_bitrate;
1301 /* this is executed just the first time do_video_stats is called */
1303 vstats_file = fopen(vstats_filename, "w");
1310 enc = ost->st->codec;
1311 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1312 frame_number = ost->frame_number;
1313 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1314 if (enc->flags&CODEC_FLAG_PSNR)
1315 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1317 fprintf(vstats_file,"f_size= %6d ", frame_size);
1318 /* compute pts value */
1319 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1323 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1324 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1325 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1326 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1327 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1331 static void print_report(AVFormatContext **output_files,
1332 AVOutputStream **ost_table, int nb_ostreams,
1336 AVOutputStream *ost;
1337 AVFormatContext *oc;
1339 AVCodecContext *enc;
1340 int frame_number, vid, i;
1341 double bitrate, ti1, pts;
1342 static int64_t last_time = -1;
1343 static int qp_histogram[52];
1345 if (!is_last_report) {
1347 /* display the report every 0.5 seconds */
1348 cur_time = av_gettime();
1349 if (last_time == -1) {
1350 last_time = cur_time;
1353 if ((cur_time - last_time) < 500000)
1355 last_time = cur_time;
1359 oc = output_files[0];
1361 total_size = url_fsize(oc->pb);
1362 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1363 total_size= url_ftell(oc->pb);
1368 for(i=0;i<nb_ostreams;i++) {
1370 enc = ost->st->codec;
1371 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1373 !ost->st->stream_copy ?
1374 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1376 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1377 float t = (av_gettime()-timer_start) / 1000000.0;
1379 frame_number = ost->frame_number;
1380 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1381 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1382 !ost->st->stream_copy ?
1383 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1385 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1388 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1389 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1392 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1394 if (enc->flags&CODEC_FLAG_PSNR){
1396 double error, error_sum=0;
1397 double scale, scale_sum=0;
1398 char type[3]= {'Y','U','V'};
1399 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1402 error= enc->error[j];
1403 scale= enc->width*enc->height*255.0*255.0*frame_number;
1405 error= enc->coded_frame->error[j];
1406 scale= enc->width*enc->height*255.0*255.0;
1411 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1413 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1417 /* compute min output value */
1418 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1419 if ((pts < ti1) && (pts > 0))
1425 if (verbose || is_last_report) {
1426 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1428 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1429 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1430 (double)total_size / 1024, ti1, bitrate);
1432 if (nb_frames_dup || nb_frames_drop)
1433 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1434 nb_frames_dup, nb_frames_drop);
1437 fprintf(stderr, "%s \r", buf);
1442 if (is_last_report && verbose >= 0){
1443 int64_t raw= audio_size + video_size + extra_size;
1444 fprintf(stderr, "\n");
1445 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1449 100.0*(total_size - raw)/raw
1454 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1455 static int output_packet(AVInputStream *ist, int ist_index,
1456 AVOutputStream **ost_table, int nb_ostreams,
1457 const AVPacket *pkt)
1459 AVFormatContext *os;
1460 AVOutputStream *ost;
1464 void *buffer_to_free;
1465 static unsigned int samples_size= 0;
1466 AVSubtitle subtitle, *subtitle_to_free;
1467 int64_t pkt_pts = AV_NOPTS_VALUE;
1469 int frame_available;
1473 int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1475 if(ist->next_pts == AV_NOPTS_VALUE)
1476 ist->next_pts= ist->pts;
1480 av_init_packet(&avpkt);
1488 if(pkt->dts != AV_NOPTS_VALUE)
1489 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1490 if(pkt->pts != AV_NOPTS_VALUE)
1491 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1493 //while we have more to decode or while the decoder did output something on EOF
1494 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1495 uint8_t *data_buf, *decoded_data_buf;
1496 int data_size, decoded_data_size;
1498 ist->pts= ist->next_pts;
1500 if(avpkt.size && avpkt.size != pkt->size &&
1501 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1502 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1503 ist->showed_multi_packet_warning=1;
1506 /* decode the packet if needed */
1507 decoded_data_buf = NULL; /* fail safe */
1508 decoded_data_size= 0;
1509 data_buf = avpkt.data;
1510 data_size = avpkt.size;
1511 subtitle_to_free = NULL;
1512 if (ist->decoding_needed) {
1513 switch(ist->st->codec->codec_type) {
1514 case AVMEDIA_TYPE_AUDIO:{
1515 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1516 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1518 samples= av_malloc(samples_size);
1520 decoded_data_size= samples_size;
1521 /* XXX: could avoid copy if PCM 16 bits with same
1522 endianness as CPU */
1523 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1530 /* Some bug in mpeg audio decoder gives */
1531 /* decoded_data_size < 0, it seems they are overflows */
1532 if (decoded_data_size <= 0) {
1533 /* no audio frame */
1536 decoded_data_buf = (uint8_t *)samples;
1537 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1538 (ist->st->codec->sample_rate * ist->st->codec->channels);
1540 case AVMEDIA_TYPE_VIDEO:
1541 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1542 /* XXX: allocate picture correctly */
1543 avcodec_get_frame_defaults(&picture);
1544 ist->st->codec->reordered_opaque = pkt_pts;
1545 pkt_pts = AV_NOPTS_VALUE;
1547 ret = avcodec_decode_video2(ist->st->codec,
1548 &picture, &got_picture, &avpkt);
1549 ist->st->quality= picture.quality;
1553 /* no picture yet */
1554 goto discard_packet;
1556 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1557 if (ist->st->codec->time_base.num != 0) {
1558 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1559 ist->next_pts += ((int64_t)AV_TIME_BASE *
1560 ist->st->codec->time_base.num * ticks) /
1561 ist->st->codec->time_base.den;
1565 case AVMEDIA_TYPE_SUBTITLE:
1566 ret = avcodec_decode_subtitle2(ist->st->codec,
1567 &subtitle, &got_picture, &avpkt);
1571 goto discard_packet;
1573 subtitle_to_free = &subtitle;
1580 switch(ist->st->codec->codec_type) {
1581 case AVMEDIA_TYPE_AUDIO:
1582 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1583 ist->st->codec->sample_rate;
1585 case AVMEDIA_TYPE_VIDEO:
1586 if (ist->st->codec->time_base.num != 0) {
1587 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1588 ist->next_pts += ((int64_t)AV_TIME_BASE *
1589 ist->st->codec->time_base.num * ticks) /
1590 ist->st->codec->time_base.den;
1598 buffer_to_free = NULL;
1599 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1600 pre_process_video_frame(ist, (AVPicture *)&picture,
1605 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1606 // add it to be filtered
1607 av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1609 ist->st->codec->sample_aspect_ratio);
1613 // preprocess audio (volume)
1614 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1615 if (audio_volume != 256) {
1618 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1619 int v = ((*volp) * audio_volume + 128) >> 8;
1620 if (v < -32768) v = -32768;
1621 if (v > 32767) v = 32767;
1627 /* frame rate emulation */
1629 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1630 int64_t now = av_gettime() - ist->start;
1635 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1636 !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1638 /* if output time reached then transcode raw format,
1639 encode packets and output them */
1640 if (start_time == 0 || ist->pts >= start_time)
1642 while (frame_available) {
1643 AVRational ist_pts_tb;
1644 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1645 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1647 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1649 for(i=0;i<nb_ostreams;i++) {
1653 if (ost->source_index == ist_index) {
1654 os = output_files[ost->file_index];
1656 /* set the input output pts pairs */
1657 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1659 if (ost->encoding_needed) {
1660 av_assert0(ist->decoding_needed);
1661 switch(ost->st->codec->codec_type) {
1662 case AVMEDIA_TYPE_AUDIO:
1663 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1665 case AVMEDIA_TYPE_VIDEO:
1667 if (ist->picref->video)
1668 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1670 do_video_out(os, ost, ist, &picture, &frame_size);
1671 if (vstats_filename && frame_size)
1672 do_video_stats(os, ost, frame_size);
1674 case AVMEDIA_TYPE_SUBTITLE:
1675 do_subtitle_out(os, ost, ist, &subtitle,
1682 AVFrame avframe; //FIXME/XXX remove this
1684 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1686 av_init_packet(&opkt);
1688 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1691 /* no reencoding needed : output the packet directly */
1692 /* force the input stream PTS */
1694 avcodec_get_frame_defaults(&avframe);
1695 ost->st->codec->coded_frame= &avframe;
1696 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1698 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1699 audio_size += data_size;
1700 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1701 video_size += data_size;
1705 opkt.stream_index= ost->index;
1706 if(pkt->pts != AV_NOPTS_VALUE)
1707 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1709 opkt.pts= AV_NOPTS_VALUE;
1711 if (pkt->dts == AV_NOPTS_VALUE)
1712 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1714 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1715 opkt.dts -= ost_tb_start_time;
1717 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1718 opkt.flags= pkt->flags;
1720 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1721 if( ost->st->codec->codec_id != CODEC_ID_H264
1722 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1723 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1725 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1726 opkt.destruct= av_destruct_packet;
1728 opkt.data = data_buf;
1729 opkt.size = data_size;
1732 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1733 ost->st->codec->frame_number++;
1734 ost->frame_number++;
1735 av_free_packet(&opkt);
1741 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1742 ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1744 avfilter_unref_buffer(ist->picref);
1747 av_free(buffer_to_free);
1748 /* XXX: allocate the subtitles in the codec ? */
1749 if (subtitle_to_free) {
1750 if (subtitle_to_free->rects != NULL) {
1751 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1752 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1753 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1754 av_freep(&subtitle_to_free->rects[i]);
1756 av_freep(&subtitle_to_free->rects);
1758 subtitle_to_free->num_rects = 0;
1759 subtitle_to_free = NULL;
1766 for(i=0;i<nb_ostreams;i++) {
1768 if (ost->source_index == ist_index) {
1769 AVCodecContext *enc= ost->st->codec;
1770 os = output_files[ost->file_index];
1772 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1774 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1777 if (ost->encoding_needed) {
1781 av_init_packet(&pkt);
1782 pkt.stream_index= ost->index;
1784 switch(ost->st->codec->codec_type) {
1785 case AVMEDIA_TYPE_AUDIO:
1786 fifo_bytes = av_fifo_size(ost->fifo);
1788 /* encode any samples remaining in fifo */
1789 if (fifo_bytes > 0) {
1790 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1791 int fs_tmp = enc->frame_size;
1793 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1794 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1795 enc->frame_size = fifo_bytes / (osize * enc->channels);
1797 int frame_bytes = enc->frame_size*osize*enc->channels;
1798 if (allocated_audio_buf_size < frame_bytes)
1800 memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1803 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1804 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1805 ost->st->time_base.num, enc->sample_rate);
1806 enc->frame_size = fs_tmp;
1809 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1812 fprintf(stderr, "Audio encoding failed\n");
1816 pkt.flags |= AV_PKT_FLAG_KEY;
1818 case AVMEDIA_TYPE_VIDEO:
1819 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1821 fprintf(stderr, "Video encoding failed\n");
1825 if(enc->coded_frame && enc->coded_frame->key_frame)
1826 pkt.flags |= AV_PKT_FLAG_KEY;
1827 if (ost->logfile && enc->stats_out) {
1828 fprintf(ost->logfile, "%s", enc->stats_out);
1837 pkt.data= bit_buffer;
1839 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1840 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1841 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1853 static void print_sdp(AVFormatContext **avc, int n)
1857 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1858 printf("SDP:\n%s\n", sdp);
1862 static int copy_chapters(int infile, int outfile)
1864 AVFormatContext *is = input_files[infile];
1865 AVFormatContext *os = output_files[outfile];
1868 for (i = 0; i < is->nb_chapters; i++) {
1869 AVChapter *in_ch = is->chapters[i], *out_ch;
1870 AVMetadataTag *t = NULL;
1871 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1872 AV_TIME_BASE_Q, in_ch->time_base);
1873 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1874 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1877 if (in_ch->end < ts_off)
1879 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1882 out_ch = av_mallocz(sizeof(AVChapter));
1884 return AVERROR(ENOMEM);
1886 out_ch->id = in_ch->id;
1887 out_ch->time_base = in_ch->time_base;
1888 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1889 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1891 if (metadata_chapters_autocopy)
1892 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1893 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1896 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1898 return AVERROR(ENOMEM);
1899 os->chapters[os->nb_chapters - 1] = out_ch;
1904 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1905 AVCodecContext *avctx)
1911 for (p = kf; *p; p++)
1914 ost->forced_kf_count = n;
1915 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1916 if (!ost->forced_kf_pts) {
1917 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1920 for (i = 0; i < n; i++) {
1921 p = i ? strchr(p, ',') + 1 : kf;
1922 t = parse_time_or_die("force_key_frames", p, 1);
1923 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1928 * The following code is the main loop of the file converter
1930 static int transcode(AVFormatContext **output_files,
1931 int nb_output_files,
1932 AVFormatContext **input_files,
1934 AVStreamMap *stream_maps, int nb_stream_maps)
1936 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1937 AVFormatContext *is, *os;
1938 AVCodecContext *codec, *icodec;
1939 AVOutputStream *ost, **ost_table = NULL;
1940 AVInputStream *ist, **ist_table = NULL;
1941 AVInputFile *file_table;
1945 uint8_t no_packet[MAX_FILES]={0};
1946 int no_packet_count=0;
1948 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1952 /* input stream init */
1954 for(i=0;i<nb_input_files;i++) {
1955 is = input_files[i];
1956 file_table[i].ist_index = j;
1957 file_table[i].nb_streams = is->nb_streams;
1958 j += is->nb_streams;
1962 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1966 for(i=0;i<nb_istreams;i++) {
1967 ist = av_mallocz(sizeof(AVInputStream));
1973 for(i=0;i<nb_input_files;i++) {
1974 is = input_files[i];
1975 for(k=0;k<is->nb_streams;k++) {
1976 ist = ist_table[j++];
1977 ist->st = is->streams[k];
1978 ist->file_index = i;
1980 ist->discard = 1; /* the stream is discarded by default
1984 ist->start = av_gettime();
1989 /* output stream init */
1991 for(i=0;i<nb_output_files;i++) {
1992 os = output_files[i];
1993 if (!os->nb_streams) {
1994 dump_format(output_files[i], i, output_files[i]->filename, 1);
1995 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1996 ret = AVERROR(EINVAL);
1999 nb_ostreams += os->nb_streams;
2001 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2002 fprintf(stderr, "Number of stream maps must match number of output streams\n");
2003 ret = AVERROR(EINVAL);
2007 /* Sanity check the mapping args -- do the input files & streams exist? */
2008 for(i=0;i<nb_stream_maps;i++) {
2009 int fi = stream_maps[i].file_index;
2010 int si = stream_maps[i].stream_index;
2012 if (fi < 0 || fi > nb_input_files - 1 ||
2013 si < 0 || si > file_table[fi].nb_streams - 1) {
2014 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2015 ret = AVERROR(EINVAL);
2018 fi = stream_maps[i].sync_file_index;
2019 si = stream_maps[i].sync_stream_index;
2020 if (fi < 0 || fi > nb_input_files - 1 ||
2021 si < 0 || si > file_table[fi].nb_streams - 1) {
2022 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2023 ret = AVERROR(EINVAL);
2028 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2032 for(k=0;k<nb_output_files;k++) {
2033 os = output_files[k];
2034 for(i=0;i<os->nb_streams;i++,n++) {
2036 ost = ost_table[n] = output_streams_for_file[k][i];
2037 ost->st = os->streams[i];
2038 if (nb_stream_maps > 0) {
2039 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2040 stream_maps[n].stream_index;
2042 /* Sanity check that the stream types match */
2043 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2044 int i= ost->file_index;
2045 dump_format(output_files[i], i, output_files[i]->filename, 1);
2046 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2047 stream_maps[n].file_index, stream_maps[n].stream_index,
2048 ost->file_index, ost->index);
2053 int best_nb_frames=-1;
2054 /* get corresponding input stream index : we select the first one with the right type */
2056 for(j=0;j<nb_istreams;j++) {
2061 AVFormatContext *f= input_files[ ist->file_index ];
2063 for(pi=0; pi<f->nb_programs; pi++){
2064 AVProgram *p= f->programs[pi];
2065 if(p->id == opt_programid)
2066 for(si=0; si<p->nb_stream_indexes; si++){
2067 if(f->streams[ p->stream_index[si] ] == ist->st)
2072 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2073 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2074 if(best_nb_frames < ist->st->codec_info_nb_frames){
2075 best_nb_frames= ist->st->codec_info_nb_frames;
2076 ost->source_index = j;
2083 if(! opt_programid) {
2084 /* try again and reuse existing stream */
2085 for(j=0;j<nb_istreams;j++) {
2087 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2088 && ist->st->discard != AVDISCARD_ALL) {
2089 ost->source_index = j;
2095 int i= ost->file_index;
2096 dump_format(output_files[i], i, output_files[i]->filename, 1);
2097 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2098 ost->file_index, ost->index);
2103 ist = ist_table[ost->source_index];
2105 ost->sync_ist = (nb_stream_maps > 0) ?
2106 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2107 stream_maps[n].sync_stream_index] : ist;
2111 /* for each output stream, we compute the right encoding parameters */
2112 for(i=0;i<nb_ostreams;i++) {
2113 AVMetadataTag *t = NULL;
2115 os = output_files[ost->file_index];
2116 ist = ist_table[ost->source_index];
2118 codec = ost->st->codec;
2119 icodec = ist->st->codec;
2121 if (metadata_streams_autocopy)
2122 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2123 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2126 ost->st->disposition = ist->st->disposition;
2127 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2128 codec->chroma_sample_location = icodec->chroma_sample_location;
2130 if (ost->st->stream_copy) {
2131 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2133 if (extra_size > INT_MAX)
2136 /* if stream_copy is selected, no need to decode or encode */
2137 codec->codec_id = icodec->codec_id;
2138 codec->codec_type = icodec->codec_type;
2140 if(!codec->codec_tag){
2141 if( !os->oformat->codec_tag
2142 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2143 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2144 codec->codec_tag = icodec->codec_tag;
2147 codec->bit_rate = icodec->bit_rate;
2148 codec->rc_max_rate = icodec->rc_max_rate;
2149 codec->rc_buffer_size = icodec->rc_buffer_size;
2150 codec->extradata= av_mallocz(extra_size);
2151 if (!codec->extradata)
2153 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2154 codec->extradata_size= icodec->extradata_size;
2155 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2156 codec->time_base = icodec->time_base;
2157 codec->time_base.num *= icodec->ticks_per_frame;
2158 av_reduce(&codec->time_base.num, &codec->time_base.den,
2159 codec->time_base.num, codec->time_base.den, INT_MAX);
2161 codec->time_base = ist->st->time_base;
2162 switch(codec->codec_type) {
2163 case AVMEDIA_TYPE_AUDIO:
2164 if(audio_volume != 256) {
2165 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2168 codec->channel_layout = icodec->channel_layout;
2169 codec->sample_rate = icodec->sample_rate;
2170 codec->channels = icodec->channels;
2171 codec->frame_size = icodec->frame_size;
2172 codec->block_align= icodec->block_align;
2173 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2174 codec->block_align= 0;
2175 if(codec->codec_id == CODEC_ID_AC3)
2176 codec->block_align= 0;
2178 case AVMEDIA_TYPE_VIDEO:
2179 codec->pix_fmt = icodec->pix_fmt;
2180 codec->width = icodec->width;
2181 codec->height = icodec->height;
2182 codec->has_b_frames = icodec->has_b_frames;
2184 case AVMEDIA_TYPE_SUBTITLE:
2185 codec->width = icodec->width;
2186 codec->height = icodec->height;
2192 switch(codec->codec_type) {
2193 case AVMEDIA_TYPE_AUDIO:
2194 ost->fifo= av_fifo_alloc(1024);
2197 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2198 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2199 icodec->request_channels = codec->channels;
2200 ist->decoding_needed = 1;
2201 ost->encoding_needed = 1;
2202 ost->resample_sample_fmt = icodec->sample_fmt;
2203 ost->resample_sample_rate = icodec->sample_rate;
2204 ost->resample_channels = icodec->channels;
2206 case AVMEDIA_TYPE_VIDEO:
2207 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2208 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2211 ost->video_resample = (codec->width != icodec->width ||
2212 codec->height != icodec->height ||
2213 (codec->pix_fmt != icodec->pix_fmt));
2214 if (ost->video_resample) {
2215 avcodec_get_frame_defaults(&ost->pict_tmp);
2216 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2217 codec->width, codec->height)) {
2218 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2221 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2222 ost->img_resample_ctx = sws_getContext(
2229 sws_flags, NULL, NULL, NULL);
2230 if (ost->img_resample_ctx == NULL) {
2231 fprintf(stderr, "Cannot get resampling context\n");
2235 #if !CONFIG_AVFILTER
2236 ost->original_height = icodec->height;
2237 ost->original_width = icodec->width;
2239 codec->bits_per_raw_sample= 0;
2241 ost->resample_height = icodec->height;
2242 ost->resample_width = icodec->width;
2243 ost->resample_pix_fmt= icodec->pix_fmt;
2244 ost->encoding_needed = 1;
2245 ist->decoding_needed = 1;
2248 if (configure_filters(ist, ost)) {
2249 fprintf(stderr, "Error opening filters!\n");
2254 case AVMEDIA_TYPE_SUBTITLE:
2255 ost->encoding_needed = 1;
2256 ist->decoding_needed = 1;
2263 if (ost->encoding_needed &&
2264 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2265 char logfilename[1024];
2268 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2269 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2271 if (codec->flags & CODEC_FLAG_PASS1) {
2272 f = fopen(logfilename, "wb");
2274 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2280 size_t logbuffer_size;
2281 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2282 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2285 codec->stats_in = logbuffer;
2289 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2290 int size= codec->width * codec->height;
2291 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2296 bit_buffer = av_malloc(bit_buffer_size);
2298 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2300 ret = AVERROR(ENOMEM);
2304 /* open each encoder */
2305 for(i=0;i<nb_ostreams;i++) {
2307 if (ost->encoding_needed) {
2308 AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2309 AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2311 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2313 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2314 ost->st->codec->codec_id, ost->file_index, ost->index);
2315 ret = AVERROR(EINVAL);
2318 if (dec->subtitle_header) {
2319 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2320 if (!ost->st->codec->subtitle_header) {
2321 ret = AVERROR(ENOMEM);
2324 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2325 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2327 if (avcodec_open(ost->st->codec, codec) < 0) {
2328 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2329 ost->file_index, ost->index);
2330 ret = AVERROR(EINVAL);
2333 extra_size += ost->st->codec->extradata_size;
2337 /* open each decoder */
2338 for(i=0;i<nb_istreams;i++) {
2340 if (ist->decoding_needed) {
2341 AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2343 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2345 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2346 ist->st->codec->codec_id, ist->file_index, ist->index);
2347 ret = AVERROR(EINVAL);
2350 if (avcodec_open(ist->st->codec, codec) < 0) {
2351 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2352 ist->file_index, ist->index);
2353 ret = AVERROR(EINVAL);
2356 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2357 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2362 for(i=0;i<nb_istreams;i++) {
2366 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2367 ist->next_pts = AV_NOPTS_VALUE;
2368 init_pts_correction(&ist->pts_ctx);
2372 /* set meta data information from input file if required */
2373 for (i=0;i<nb_meta_data_maps;i++) {
2374 AVFormatContext *files[2];
2375 AVMetadata **meta[2];
2376 AVMetadataTag *mtag;
2379 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2380 if ((index) < 0 || (index) >= (nb_elems)) {\
2381 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2383 ret = AVERROR(EINVAL);\
2387 int out_file_index = meta_data_maps[i][0].file;
2388 int in_file_index = meta_data_maps[i][1].file;
2389 if (in_file_index < 0 || out_file_index < 0)
2391 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2392 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2394 files[0] = output_files[out_file_index];
2395 files[1] = input_files[in_file_index];
2397 for (j = 0; j < 2; j++) {
2398 AVMetaDataMap *map = &meta_data_maps[i][j];
2400 switch (map->type) {
2402 meta[j] = &files[j]->metadata;
2405 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2406 meta[j] = &files[j]->streams[map->index]->metadata;
2409 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2410 meta[j] = &files[j]->chapters[map->index]->metadata;
2413 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2414 meta[j] = &files[j]->programs[map->index]->metadata;
2420 while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2421 av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2424 /* copy global metadata by default */
2425 if (metadata_global_autocopy) {
2426 AVMetadataTag *t = NULL;
2428 while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
2429 for (i = 0; i < nb_output_files; i++)
2430 av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2433 /* copy chapters according to chapter maps */
2434 for (i = 0; i < nb_chapter_maps; i++) {
2435 int infile = chapter_maps[i].in_file;
2436 int outfile = chapter_maps[i].out_file;
2438 if (infile < 0 || outfile < 0)
2440 if (infile >= nb_input_files) {
2441 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2442 ret = AVERROR(EINVAL);
2445 if (outfile >= nb_output_files) {
2446 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2447 ret = AVERROR(EINVAL);
2450 copy_chapters(infile, outfile);
2453 /* copy chapters from the first input file that has them*/
2454 if (!nb_chapter_maps)
2455 for (i = 0; i < nb_input_files; i++) {
2456 if (!input_files[i]->nb_chapters)
2459 for (j = 0; j < nb_output_files; j++)
2460 if ((ret = copy_chapters(i, j)) < 0)
2465 /* open files and write file headers */
2466 for(i=0;i<nb_output_files;i++) {
2467 os = output_files[i];
2468 if (av_write_header(os) < 0) {
2469 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2470 ret = AVERROR(EINVAL);
2473 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2479 /* dump the file output parameters - cannot be done before in case
2481 for(i=0;i<nb_output_files;i++) {
2482 dump_format(output_files[i], i, output_files[i]->filename, 1);
2485 /* dump the stream mapping */
2487 fprintf(stderr, "Stream mapping:\n");
2488 for(i=0;i<nb_ostreams;i++) {
2490 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2491 ist_table[ost->source_index]->file_index,
2492 ist_table[ost->source_index]->index,
2495 if (ost->sync_ist != ist_table[ost->source_index])
2496 fprintf(stderr, " [sync #%d.%d]",
2497 ost->sync_ist->file_index,
2498 ost->sync_ist->index);
2499 fprintf(stderr, "\n");
2504 fprintf(stderr, "%s\n", error);
2509 print_sdp(output_files, nb_output_files);
2512 if (!using_stdin && verbose >= 0) {
2513 fprintf(stderr, "Press [q] to stop encoding\n");
2514 url_set_interrupt_cb(decode_interrupt_cb);
2518 timer_start = av_gettime();
2520 for(; received_sigterm == 0;) {
2521 int file_index, ist_index;
2529 /* if 'q' pressed, exits */
2533 /* read_key() returns 0 on EOF */
2539 /* select the stream that we must read now by looking at the
2540 smallest output pts */
2542 for(i=0;i<nb_ostreams;i++) {
2545 os = output_files[ost->file_index];
2546 ist = ist_table[ost->source_index];
2547 if(ist->is_past_recording_time || no_packet[ist->file_index])
2549 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2550 ipts = (double)ist->pts;
2551 if (!file_table[ist->file_index].eof_reached){
2552 if(ipts < ipts_min) {
2554 if(input_sync ) file_index = ist->file_index;
2556 if(opts < opts_min) {
2558 if(!input_sync) file_index = ist->file_index;
2561 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2566 /* if none, if is finished */
2567 if (file_index < 0) {
2568 if(no_packet_count){
2570 memset(no_packet, 0, sizeof(no_packet));
2577 /* finish if limit size exhausted */
2578 if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2581 /* read a frame from it and output it in the fifo */
2582 is = input_files[file_index];
2583 ret= av_read_frame(is, &pkt);
2584 if(ret == AVERROR(EAGAIN)){
2585 no_packet[file_index]=1;
2590 file_table[file_index].eof_reached = 1;
2598 memset(no_packet, 0, sizeof(no_packet));
2601 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2603 /* the following test is needed in case new streams appear
2604 dynamically in stream : we ignore them */
2605 if (pkt.stream_index >= file_table[file_index].nb_streams)
2606 goto discard_packet;
2607 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2608 ist = ist_table[ist_index];
2610 goto discard_packet;
2612 if (pkt.dts != AV_NOPTS_VALUE)
2613 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2614 if (pkt.pts != AV_NOPTS_VALUE)
2615 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2617 if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2618 && input_files_ts_scale[file_index][pkt.stream_index]){
2619 if(pkt.pts != AV_NOPTS_VALUE)
2620 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2621 if(pkt.dts != AV_NOPTS_VALUE)
2622 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2625 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2626 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2627 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2628 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2629 int64_t delta= pkt_dts - ist->next_pts;
2630 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2631 input_files_ts_offset[ist->file_index]-= delta;
2633 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2634 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2635 if(pkt.pts != AV_NOPTS_VALUE)
2636 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2640 /* finish if recording time exhausted */
2641 if (recording_time != INT64_MAX &&
2642 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2643 ist->is_past_recording_time = 1;
2644 goto discard_packet;
2647 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2648 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2651 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2652 ist->file_index, ist->index);
2655 av_free_packet(&pkt);
2660 av_free_packet(&pkt);
2662 /* dump report by using the output first video and audio streams */
2663 print_report(output_files, ost_table, nb_ostreams, 0);
2666 /* at the end of stream, we must flush the decoder buffers */
2667 for(i=0;i<nb_istreams;i++) {
2669 if (ist->decoding_needed) {
2670 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2676 /* write the trailer if needed and close file */
2677 for(i=0;i<nb_output_files;i++) {
2678 os = output_files[i];
2679 av_write_trailer(os);
2682 /* dump report by using the first video and audio streams */
2683 print_report(output_files, ost_table, nb_ostreams, 1);
2685 /* close each encoder */
2686 for(i=0;i<nb_ostreams;i++) {
2688 if (ost->encoding_needed) {
2689 av_freep(&ost->st->codec->stats_in);
2690 avcodec_close(ost->st->codec);
2694 /* close each decoder */
2695 for(i=0;i<nb_istreams;i++) {
2697 if (ist->decoding_needed) {
2698 avcodec_close(ist->st->codec);
2703 avfilter_graph_free(graph);
2712 av_freep(&bit_buffer);
2713 av_free(file_table);
2716 for(i=0;i<nb_istreams;i++) {
2723 for(i=0;i<nb_ostreams;i++) {
2726 if (ost->st->stream_copy)
2727 av_freep(&ost->st->codec->extradata);
2729 fclose(ost->logfile);
2730 ost->logfile = NULL;
2732 av_fifo_free(ost->fifo); /* works even if fifo is not
2733 initialized but set to zero */
2734 av_freep(&ost->st->codec->subtitle_header);
2735 av_free(ost->pict_tmp.data[0]);
2736 av_free(ost->forced_kf_pts);
2737 if (ost->video_resample)
2738 sws_freeContext(ost->img_resample_ctx);
2740 audio_resample_close(ost->resample);
2741 if (ost->reformat_ctx)
2742 av_audio_convert_free(ost->reformat_ctx);
2751 static void opt_format(const char *arg)
2753 last_asked_format = arg;
2756 static void opt_video_rc_override_string(const char *arg)
2758 video_rc_override_string = arg;
2761 static int opt_me_threshold(const char *opt, const char *arg)
2763 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2767 static int opt_verbose(const char *opt, const char *arg)
2769 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2773 static int opt_frame_rate(const char *opt, const char *arg)
2775 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2776 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2782 static int opt_bitrate(const char *opt, const char *arg)
2784 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2786 opt_default(opt, arg);
2788 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2789 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2794 static int opt_frame_crop(const char *opt, const char *arg)
2796 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2797 return AVERROR(EINVAL);
2800 static void opt_frame_size(const char *arg)
2802 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2803 fprintf(stderr, "Incorrect frame size\n");
2808 static int opt_pad(const char *opt, const char *arg) {
2809 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2813 static void opt_frame_pix_fmt(const char *arg)
2815 if (strcmp(arg, "list")) {
2816 frame_pix_fmt = av_get_pix_fmt(arg);
2817 if (frame_pix_fmt == PIX_FMT_NONE) {
2818 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2827 static void opt_frame_aspect_ratio(const char *arg)
2834 p = strchr(arg, ':');
2836 x = strtol(arg, &end, 10);
2838 y = strtol(end+1, &end, 10);
2840 ar = (double)x / (double)y;
2842 ar = strtod(arg, NULL);
2845 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2848 frame_aspect_ratio = ar;
2851 static int opt_metadata(const char *opt, const char *arg)
2853 char *mid= strchr(arg, '=');
2856 fprintf(stderr, "Missing =\n");
2861 av_metadata_set2(&metadata, arg, mid, 0);
2866 static void opt_qscale(const char *arg)
2868 video_qscale = atof(arg);
2869 if (video_qscale <= 0 ||
2870 video_qscale > 255) {
2871 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2876 static void opt_top_field_first(const char *arg)
2878 top_field_first= atoi(arg);
2881 static int opt_thread_count(const char *opt, const char *arg)
2883 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2886 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2891 static void opt_audio_sample_fmt(const char *arg)
2893 if (strcmp(arg, "list"))
2894 audio_sample_fmt = av_get_sample_fmt(arg);
2896 list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2901 static int opt_audio_rate(const char *opt, const char *arg)
2903 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2907 static int opt_audio_channels(const char *opt, const char *arg)
2909 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2913 static void opt_video_channel(const char *arg)
2915 video_channel = strtol(arg, NULL, 0);
2918 static void opt_video_standard(const char *arg)
2920 video_standard = av_strdup(arg);
2923 static void opt_codec(int *pstream_copy, char **pcodec_name,
2924 int codec_type, const char *arg)
2926 av_freep(pcodec_name);
2927 if (!strcmp(arg, "copy")) {
2930 *pcodec_name = av_strdup(arg);
2934 static void opt_audio_codec(const char *arg)
2936 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2939 static void opt_video_codec(const char *arg)
2941 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2944 static void opt_subtitle_codec(const char *arg)
2946 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2949 static int opt_codec_tag(const char *opt, const char *arg)
2952 uint32_t *codec_tag;
2954 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2955 !strcmp(opt, "vtag") ? &video_codec_tag :
2956 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2960 *codec_tag = strtol(arg, &tail, 0);
2962 *codec_tag = AV_RL32(arg);
2967 static void opt_map(const char *arg)
2972 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2973 m = &stream_maps[nb_stream_maps-1];
2975 m->file_index = strtol(arg, &p, 0);
2979 m->stream_index = strtol(p, &p, 0);
2982 m->sync_file_index = strtol(p, &p, 0);
2985 m->sync_stream_index = strtol(p, &p, 0);
2987 m->sync_file_index = m->file_index;
2988 m->sync_stream_index = m->stream_index;
2992 static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
3003 *index = strtol(++arg, endptr, 0);
3006 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3013 static void opt_map_meta_data(const char *arg)
3015 AVMetaDataMap *m, *m1;
3018 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3019 &nb_meta_data_maps, nb_meta_data_maps + 1);
3021 m = &meta_data_maps[nb_meta_data_maps - 1][0];
3022 m->file = strtol(arg, &p, 0);
3023 parse_meta_type(p, &m->type, &m->index, &p);
3027 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3028 m1->file = strtol(p, &p, 0);
3029 parse_meta_type(p, &m1->type, &m1->index, &p);
3031 if (m->type == 'g' || m1->type == 'g')
3032 metadata_global_autocopy = 0;
3033 if (m->type == 's' || m1->type == 's')
3034 metadata_streams_autocopy = 0;
3035 if (m->type == 'c' || m1->type == 'c')
3036 metadata_chapters_autocopy = 0;
3039 static void opt_map_chapters(const char *arg)
3044 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3045 nb_chapter_maps + 1);
3046 c = &chapter_maps[nb_chapter_maps - 1];
3047 c->out_file = strtol(arg, &p, 0);
3051 c->in_file = strtol(p, &p, 0);
3054 static void opt_input_ts_scale(const char *arg)
3056 unsigned int stream;
3060 stream = strtol(arg, &p, 0);
3063 scale= strtod(p, &p);
3065 if(stream >= MAX_STREAMS)
3068 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);
3069 input_files_ts_scale[nb_input_files][stream]= scale;
3072 static int opt_recording_time(const char *opt, const char *arg)
3074 recording_time = parse_time_or_die(opt, arg, 1);
3078 static int opt_start_time(const char *opt, const char *arg)
3080 start_time = parse_time_or_die(opt, arg, 1);
3084 static int opt_recording_timestamp(const char *opt, const char *arg)
3086 recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3090 static int opt_input_ts_offset(const char *opt, const char *arg)
3092 input_ts_offset = parse_time_or_die(opt, arg, 1);
3096 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3098 const char *codec_string = encoder ? "encoder" : "decoder";
3102 return CODEC_ID_NONE;
3104 avcodec_find_encoder_by_name(name) :
3105 avcodec_find_decoder_by_name(name);
3107 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3110 if(codec->type != type) {
3111 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3114 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3115 strict > FF_COMPLIANCE_EXPERIMENTAL) {
3116 fprintf(stderr, "%s '%s' is experimental and might produce bad "
3117 "results.\nAdd '-strict experimental' if you want to use it.\n",
3118 codec_string, codec->name);
3120 avcodec_find_encoder(codec->id) :
3121 avcodec_find_decoder(codec->id);
3122 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3123 fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3124 codec_string, codec->name);
3130 static void opt_input_file(const char *filename)
3132 AVFormatContext *ic;
3133 AVFormatParameters params, *ap = ¶ms;
3134 AVInputFormat *file_iformat = NULL;
3135 int err, i, ret, rfps, rfps_base;
3138 if (last_asked_format) {
3139 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3140 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3143 last_asked_format = NULL;
3146 if (!strcmp(filename, "-"))
3149 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3150 !strcmp(filename, "/dev/stdin");
3152 /* get default parameters from command line */
3153 ic = avformat_alloc_context();
3155 print_error(filename, AVERROR(ENOMEM));
3159 memset(ap, 0, sizeof(*ap));
3160 ap->prealloced_context = 1;
3161 ap->sample_rate = audio_sample_rate;
3162 ap->channels = audio_channels;
3163 ap->time_base.den = frame_rate.num;
3164 ap->time_base.num = frame_rate.den;
3165 ap->width = frame_width;
3166 ap->height = frame_height;
3167 ap->pix_fmt = frame_pix_fmt;
3168 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3169 ap->channel = video_channel;
3170 ap->standard = video_standard;
3172 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3174 ic->video_codec_id =
3175 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
3176 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
3177 ic->audio_codec_id =
3178 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
3179 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
3180 ic->subtitle_codec_id=
3181 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3182 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3183 ic->flags |= AVFMT_FLAG_NONBLOCK;
3185 /* open the input file with generic libav function */
3186 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3188 print_error(filename, err);
3194 for(i=0; i<ic->nb_streams; i++){
3195 ic->streams[i]->discard= AVDISCARD_ALL;
3197 for(i=0; i<ic->nb_programs; i++){
3198 AVProgram *p= ic->programs[i];
3199 if(p->id != opt_programid){
3200 p->discard = AVDISCARD_ALL;
3203 for(j=0; j<p->nb_stream_indexes; j++){
3204 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3209 fprintf(stderr, "Specified program id not found\n");
3215 ic->loop_input = loop_input;
3217 /* If not enough info to get the stream parameters, we decode the
3218 first frames to get it. (used in mpeg case for example) */
3219 ret = av_find_stream_info(ic);
3220 if (ret < 0 && verbose >= 0) {
3221 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3222 av_close_input_file(ic);
3226 timestamp = start_time;
3227 /* add the stream start time */
3228 if (ic->start_time != AV_NOPTS_VALUE)
3229 timestamp += ic->start_time;
3231 /* if seeking requested, we execute it */
3232 if (start_time != 0) {
3233 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3235 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3236 filename, (double)timestamp / AV_TIME_BASE);
3238 /* reset seek info */
3242 /* update the current parameters so that they match the one of the input stream */
3243 for(i=0;i<ic->nb_streams;i++) {
3244 AVStream *st = ic->streams[i];
3245 AVCodecContext *dec = st->codec;
3246 avcodec_thread_init(dec, thread_count);
3247 input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3248 switch (dec->codec_type) {
3249 case AVMEDIA_TYPE_AUDIO:
3250 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3251 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3252 //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3253 channel_layout = dec->channel_layout;
3254 audio_channels = dec->channels;
3255 audio_sample_rate = dec->sample_rate;
3256 audio_sample_fmt = dec->sample_fmt;
3258 st->discard= AVDISCARD_ALL;
3259 /* Note that av_find_stream_info can add more streams, and we
3260 * currently have no chance of setting up lowres decoding
3261 * early enough for them. */
3263 audio_sample_rate >>= dec->lowres;
3265 case AVMEDIA_TYPE_VIDEO:
3266 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3267 set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3268 frame_height = dec->height;
3269 frame_width = dec->width;
3270 if(ic->streams[i]->sample_aspect_ratio.num)
3271 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3273 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3274 frame_aspect_ratio *= (float) dec->width / dec->height;
3275 frame_pix_fmt = dec->pix_fmt;
3276 rfps = ic->streams[i]->r_frame_rate.num;
3277 rfps_base = ic->streams[i]->r_frame_rate.den;
3279 dec->flags |= CODEC_FLAG_EMU_EDGE;
3280 frame_height >>= dec->lowres;
3281 frame_width >>= dec->lowres;
3284 dec->debug |= FF_DEBUG_MV;
3286 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3289 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3290 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3292 (float)rfps / rfps_base, rfps, rfps_base);
3294 /* update the current frame rate to match the stream frame rate */
3295 frame_rate.num = rfps;
3296 frame_rate.den = rfps_base;
3299 st->discard= AVDISCARD_ALL;
3300 else if(video_discard)
3301 st->discard= video_discard;
3303 case AVMEDIA_TYPE_DATA:
3305 case AVMEDIA_TYPE_SUBTITLE:
3306 input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3307 if(subtitle_disable)
3308 st->discard = AVDISCARD_ALL;
3310 case AVMEDIA_TYPE_ATTACHMENT:
3311 case AVMEDIA_TYPE_UNKNOWN:
3318 input_files[nb_input_files] = ic;
3319 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3320 /* dump the file content */
3322 dump_format(ic, nb_input_files, filename, 0);
3328 av_freep(&video_codec_name);
3329 av_freep(&audio_codec_name);
3330 av_freep(&subtitle_codec_name);
3333 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3334 int *has_subtitle_ptr)
3336 int has_video, has_audio, has_subtitle, i, j;
3337 AVFormatContext *ic;
3342 for(j=0;j<nb_input_files;j++) {
3343 ic = input_files[j];
3344 for(i=0;i<ic->nb_streams;i++) {
3345 AVCodecContext *enc = ic->streams[i]->codec;
3346 switch(enc->codec_type) {
3347 case AVMEDIA_TYPE_AUDIO:
3350 case AVMEDIA_TYPE_VIDEO:
3353 case AVMEDIA_TYPE_SUBTITLE:
3356 case AVMEDIA_TYPE_DATA:
3357 case AVMEDIA_TYPE_ATTACHMENT:
3358 case AVMEDIA_TYPE_UNKNOWN:
3365 *has_video_ptr = has_video;
3366 *has_audio_ptr = has_audio;
3367 *has_subtitle_ptr = has_subtitle;
3370 static void new_video_stream(AVFormatContext *oc, int file_idx)
3373 AVOutputStream *ost;
3374 AVCodecContext *video_enc;
3375 enum CodecID codec_id;
3376 AVCodec *codec= NULL;
3378 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3380 fprintf(stderr, "Could not alloc stream\n");
3383 ost = new_output_stream(oc, file_idx);
3385 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3386 if(!video_stream_copy){
3387 if (video_codec_name) {
3388 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3389 avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3390 codec = avcodec_find_encoder_by_name(video_codec_name);
3391 output_codecs[nb_output_codecs-1] = codec;
3393 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3394 codec = avcodec_find_encoder(codec_id);
3398 avcodec_get_context_defaults3(st->codec, codec);
3399 ost->bitstream_filters = video_bitstream_filters;
3400 video_bitstream_filters= NULL;
3402 avcodec_thread_init(st->codec, thread_count);
3404 video_enc = st->codec;
3407 video_enc->codec_tag= video_codec_tag;
3409 if( (video_global_header&1)
3410 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3411 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3412 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3414 if(video_global_header&2){
3415 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3416 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3419 if (video_stream_copy) {
3420 st->stream_copy = 1;
3421 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3422 video_enc->sample_aspect_ratio =
3423 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3427 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3429 video_enc->codec_id = codec_id;
3430 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3432 if (codec && codec->supported_framerates && !force_fps)
3433 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3434 video_enc->time_base.den = fps.num;
3435 video_enc->time_base.num = fps.den;
3437 video_enc->width = frame_width;
3438 video_enc->height = frame_height;
3439 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3440 video_enc->pix_fmt = frame_pix_fmt;
3441 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3443 choose_pixel_fmt(st, codec);
3446 video_enc->gop_size = 0;
3447 if (video_qscale || same_quality) {
3448 video_enc->flags |= CODEC_FLAG_QSCALE;
3449 video_enc->global_quality=
3450 st->quality = FF_QP2LAMBDA * video_qscale;
3454 video_enc->intra_matrix = intra_matrix;
3456 video_enc->inter_matrix = inter_matrix;
3458 p= video_rc_override_string;
3461 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3463 fprintf(stderr, "error parsing rc_override\n");
3466 video_enc->rc_override=
3467 av_realloc(video_enc->rc_override,
3468 sizeof(RcOverride)*(i+1));
3469 video_enc->rc_override[i].start_frame= start;
3470 video_enc->rc_override[i].end_frame = end;
3472 video_enc->rc_override[i].qscale= q;
3473 video_enc->rc_override[i].quality_factor= 1.0;
3476 video_enc->rc_override[i].qscale= 0;
3477 video_enc->rc_override[i].quality_factor= -q/100.0;
3482 video_enc->rc_override_count=i;
3483 if (!video_enc->rc_initial_buffer_occupancy)
3484 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3485 video_enc->me_threshold= me_threshold;
3486 video_enc->intra_dc_precision= intra_dc_precision - 8;
3489 video_enc->flags|= CODEC_FLAG_PSNR;
3494 video_enc->flags |= CODEC_FLAG_PASS1;
3496 video_enc->flags |= CODEC_FLAG_PASS2;
3500 if (forced_key_frames)
3501 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3503 if (video_language) {
3504 av_metadata_set2(&st->metadata, "language", video_language, 0);
3505 av_freep(&video_language);
3508 /* reset some key parameters */
3510 av_freep(&video_codec_name);
3511 av_freep(&forced_key_frames);
3512 video_stream_copy = 0;
3513 frame_pix_fmt = PIX_FMT_NONE;
3516 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3519 AVOutputStream *ost;
3520 AVCodec *codec= NULL;
3521 AVCodecContext *audio_enc;
3522 enum CodecID codec_id;
3524 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3526 fprintf(stderr, "Could not alloc stream\n");
3529 ost = new_output_stream(oc, file_idx);
3531 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3532 if(!audio_stream_copy){
3533 if (audio_codec_name) {
3534 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3535 avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3536 codec = avcodec_find_encoder_by_name(audio_codec_name);
3537 output_codecs[nb_output_codecs-1] = codec;
3539 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3540 codec = avcodec_find_encoder(codec_id);
3544 avcodec_get_context_defaults3(st->codec, codec);
3546 ost->bitstream_filters = audio_bitstream_filters;
3547 audio_bitstream_filters= NULL;
3549 avcodec_thread_init(st->codec, thread_count);
3551 audio_enc = st->codec;
3552 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3555 audio_enc->codec_tag= audio_codec_tag;
3557 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3558 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3559 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3561 if (audio_stream_copy) {
3562 st->stream_copy = 1;
3563 audio_enc->channels = audio_channels;
3564 audio_enc->sample_rate = audio_sample_rate;
3566 audio_enc->codec_id = codec_id;
3567 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3569 if (audio_qscale > QSCALE_NONE) {
3570 audio_enc->flags |= CODEC_FLAG_QSCALE;
3571 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3573 audio_enc->channels = audio_channels;
3574 audio_enc->sample_fmt = audio_sample_fmt;
3575 audio_enc->sample_rate = audio_sample_rate;
3576 audio_enc->channel_layout = channel_layout;
3577 if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3578 audio_enc->channel_layout = 0;
3579 choose_sample_fmt(st, codec);
3580 choose_sample_rate(st, codec);
3582 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3583 if (audio_language) {
3584 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3585 av_freep(&audio_language);
3588 /* reset some key parameters */
3590 av_freep(&audio_codec_name);
3591 audio_stream_copy = 0;
3594 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3597 AVOutputStream *ost;
3598 AVCodec *codec=NULL;
3599 AVCodecContext *subtitle_enc;
3600 enum CodecID codec_id;
3602 st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3604 fprintf(stderr, "Could not alloc stream\n");
3607 ost = new_output_stream(oc, file_idx);
3608 subtitle_enc = st->codec;
3609 output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3610 if(!subtitle_stream_copy){
3611 if (subtitle_codec_name) {
3612 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3613 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3614 codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3616 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3617 codec = avcodec_find_encoder(codec_id);
3620 avcodec_get_context_defaults3(st->codec, codec);
3622 ost->bitstream_filters = subtitle_bitstream_filters;
3623 subtitle_bitstream_filters= NULL;
3625 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3627 if(subtitle_codec_tag)
3628 subtitle_enc->codec_tag= subtitle_codec_tag;
3630 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3631 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3632 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3634 if (subtitle_stream_copy) {
3635 st->stream_copy = 1;
3637 subtitle_enc->codec_id = codec_id;
3638 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3641 if (subtitle_language) {
3642 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3643 av_freep(&subtitle_language);
3646 subtitle_disable = 0;
3647 av_freep(&subtitle_codec_name);
3648 subtitle_stream_copy = 0;
3651 static int opt_new_stream(const char *opt, const char *arg)
3653 AVFormatContext *oc;
3654 int file_idx = nb_output_files - 1;
3655 if (nb_output_files <= 0) {
3656 fprintf(stderr, "At least one output file must be specified\n");
3659 oc = output_files[file_idx];
3661 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3662 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3663 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3668 /* arg format is "output-stream-index:streamid-value". */
3669 static int opt_streamid(const char *opt, const char *arg)
3675 strncpy(idx_str, arg, sizeof(idx_str));
3676 idx_str[sizeof(idx_str)-1] = '\0';
3677 p = strchr(idx_str, ':');
3680 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3685 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3686 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3687 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3691 static void opt_output_file(const char *filename)
3693 AVFormatContext *oc;
3694 int err, use_video, use_audio, use_subtitle;
3695 int input_has_video, input_has_audio, input_has_subtitle;
3696 AVFormatParameters params, *ap = ¶ms;
3697 AVOutputFormat *file_oformat;
3698 AVMetadataTag *tag = NULL;
3700 if (!strcmp(filename, "-"))
3703 oc = avformat_alloc_context();
3705 print_error(filename, AVERROR(ENOMEM));
3709 if (last_asked_format) {
3710 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3711 if (!file_oformat) {
3712 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3715 last_asked_format = NULL;
3717 file_oformat = av_guess_format(NULL, filename, NULL);
3718 if (!file_oformat) {
3719 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3725 oc->oformat = file_oformat;
3726 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3728 if (!strcmp(file_oformat->name, "ffm") &&
3729 av_strstart(filename, "http:", NULL)) {
3730 /* special case for files sent to ffserver: we get the stream
3731 parameters from ffserver */
3732 int err = read_ffserver_streams(oc, filename);
3734 print_error(filename, err);
3738 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3739 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3740 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3742 /* disable if no corresponding type found and at least one
3744 if (nb_input_files > 0) {
3745 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3746 &input_has_subtitle);
3747 if (!input_has_video)
3749 if (!input_has_audio)
3751 if (!input_has_subtitle)
3755 /* manual disable */
3756 if (audio_disable) use_audio = 0;
3757 if (video_disable) use_video = 0;
3758 if (subtitle_disable) use_subtitle = 0;
3760 if (use_video) new_video_stream(oc, nb_output_files);
3761 if (use_audio) new_audio_stream(oc, nb_output_files);
3762 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3764 oc->timestamp = recording_timestamp;
3766 while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3767 av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3768 av_metadata_free(&metadata);
3771 output_files[nb_output_files++] = oc;
3773 /* check filename in case of an image number is expected */
3774 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3775 if (!av_filename_number_test(oc->filename)) {
3776 print_error(oc->filename, AVERROR_NUMEXPECTED);
3781 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3782 /* test if it already exists to avoid loosing precious files */
3783 if (!file_overwrite &&
3784 (strchr(filename, ':') == NULL ||
3785 filename[1] == ':' ||
3786 av_strstart(filename, "file:", NULL))) {
3787 if (url_exist(filename)) {
3789 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3791 if (!read_yesno()) {
3792 fprintf(stderr, "Not overwriting - exiting\n");
3797 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3804 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3805 print_error(filename, err);
3810 memset(ap, 0, sizeof(*ap));
3811 if (av_set_parameters(oc, ap) < 0) {
3812 fprintf(stderr, "%s: Invalid encoding parameters\n",
3817 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3818 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3819 oc->loop_output = loop_output;
3820 oc->flags |= AVFMT_FLAG_NONBLOCK;
3822 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3824 nb_streamid_map = 0;
3825 av_freep(&forced_key_frames);
3828 /* same option as mencoder */
3829 static void opt_pass(const char *pass_str)
3832 pass = atoi(pass_str);
3833 if (pass != 1 && pass != 2) {
3834 fprintf(stderr, "pass number can be only 1 or 2\n");
3840 static int64_t getutime(void)
3843 struct rusage rusage;
3845 getrusage(RUSAGE_SELF, &rusage);
3846 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3847 #elif HAVE_GETPROCESSTIMES
3849 FILETIME c, e, k, u;
3850 proc = GetCurrentProcess();
3851 GetProcessTimes(proc, &c, &e, &k, &u);
3852 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3854 return av_gettime();
3858 static int64_t getmaxrss(void)
3860 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3861 struct rusage rusage;
3862 getrusage(RUSAGE_SELF, &rusage);
3863 return (int64_t)rusage.ru_maxrss * 1024;
3864 #elif HAVE_GETPROCESSMEMORYINFO
3866 PROCESS_MEMORY_COUNTERS memcounters;
3867 proc = GetCurrentProcess();
3868 memcounters.cb = sizeof(memcounters);
3869 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3870 return memcounters.PeakPagefileUsage;
3876 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3879 const char *p = str;
3886 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3893 static void opt_inter_matrix(const char *arg)
3895 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3896 parse_matrix_coeffs(inter_matrix, arg);
3899 static void opt_intra_matrix(const char *arg)
3901 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3902 parse_matrix_coeffs(intra_matrix, arg);
3905 static void show_usage(void)
3907 printf("Hyper fast Audio and Video encoder\n");
3908 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3912 static void show_help(void)
3916 av_log_set_callback(log_callback_help);
3918 show_help_options(options, "Main options:\n",
3919 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3920 show_help_options(options, "\nAdvanced options:\n",
3921 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3923 show_help_options(options, "\nVideo options:\n",
3924 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3926 show_help_options(options, "\nAdvanced Video options:\n",
3927 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3928 OPT_VIDEO | OPT_EXPERT);
3929 show_help_options(options, "\nAudio options:\n",
3930 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3932 show_help_options(options, "\nAdvanced Audio options:\n",
3933 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3934 OPT_AUDIO | OPT_EXPERT);
3935 show_help_options(options, "\nSubtitle options:\n",
3936 OPT_SUBTITLE | OPT_GRAB,
3938 show_help_options(options, "\nAudio/Video grab options:\n",
3942 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3945 /* individual codec options */
3947 while ((c = av_codec_next(c))) {
3948 if (c->priv_class) {
3949 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3954 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3956 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3959 static void opt_target(const char *arg)
3961 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3962 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3964 if(!strncmp(arg, "pal-", 4)) {
3967 } else if(!strncmp(arg, "ntsc-", 5)) {
3970 } else if(!strncmp(arg, "film-", 5)) {
3975 /* Calculate FR via float to avoid int overflow */
3976 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3979 } else if((fr == 29970) || (fr == 23976)) {
3982 /* Try to determine PAL/NTSC by peeking in the input files */
3983 if(nb_input_files) {
3985 for(j = 0; j < nb_input_files; j++) {
3986 for(i = 0; i < input_files[j]->nb_streams; i++) {
3987 AVCodecContext *c = input_files[j]->streams[i]->codec;
3988 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3990 fr = c->time_base.den * 1000 / c->time_base.num;
3994 } else if((fr == 29970) || (fr == 23976)) {
4004 if(verbose && norm != UNKNOWN)
4005 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4008 if(norm == UNKNOWN) {
4009 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4010 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4011 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4015 if(!strcmp(arg, "vcd")) {
4017 opt_video_codec("mpeg1video");
4018 opt_audio_codec("mp2");
4021 opt_frame_size(norm == PAL ? "352x288" : "352x240");
4022 opt_frame_rate(NULL, frame_rates[norm]);
4023 opt_default("g", norm == PAL ? "15" : "18");
4025 opt_default("b", "1150000");
4026 opt_default("maxrate", "1150000");
4027 opt_default("minrate", "1150000");
4028 opt_default("bufsize", "327680"); // 40*1024*8;
4030 opt_default("ab", "224000");
4031 audio_sample_rate = 44100;
4034 opt_default("packetsize", "2324");
4035 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4037 /* We have to offset the PTS, so that it is consistent with the SCR.
4038 SCR starts at 36000, but the first two packs contain only padding
4039 and the first pack from the other stream, respectively, may also have
4040 been written before.
4041 So the real data starts at SCR 36000+3*1200. */
4042 mux_preload= (36000+3*1200) / 90000.0; //0.44
4043 } else if(!strcmp(arg, "svcd")) {
4045 opt_video_codec("mpeg2video");
4046 opt_audio_codec("mp2");
4049 opt_frame_size(norm == PAL ? "480x576" : "480x480");
4050 opt_frame_rate(NULL, frame_rates[norm]);
4051 opt_default("g", norm == PAL ? "15" : "18");
4053 opt_default("b", "2040000");
4054 opt_default("maxrate", "2516000");
4055 opt_default("minrate", "0"); //1145000;
4056 opt_default("bufsize", "1835008"); //224*1024*8;
4057 opt_default("flags", "+scan_offset");
4060 opt_default("ab", "224000");
4061 audio_sample_rate = 44100;
4063 opt_default("packetsize", "2324");
4065 } else if(!strcmp(arg, "dvd")) {
4067 opt_video_codec("mpeg2video");
4068 opt_audio_codec("ac3");
4071 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4072 opt_frame_rate(NULL, frame_rates[norm]);
4073 opt_default("g", norm == PAL ? "15" : "18");
4075 opt_default("b", "6000000");
4076 opt_default("maxrate", "9000000");
4077 opt_default("minrate", "0"); //1500000;
4078 opt_default("bufsize", "1835008"); //224*1024*8;
4080 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4081 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4083 opt_default("ab", "448000");
4084 audio_sample_rate = 48000;
4086 } else if(!strncmp(arg, "dv", 2)) {
4090 opt_frame_size(norm == PAL ? "720x576" : "720x480");
4091 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4092 (norm == PAL ? "yuv420p" : "yuv411p"));
4093 opt_frame_rate(NULL, frame_rates[norm]);
4095 audio_sample_rate = 48000;
4099 fprintf(stderr, "Unknown target: %s\n", arg);
4104 static void opt_vstats_file (const char *arg)
4106 av_free (vstats_filename);
4107 vstats_filename=av_strdup (arg);
4110 static void opt_vstats (void)
4113 time_t today2 = time(NULL);
4114 struct tm *today = localtime(&today2);
4116 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4118 opt_vstats_file(filename);
4121 static int opt_bsf(const char *opt, const char *arg)
4123 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4124 AVBitStreamFilterContext **bsfp;
4127 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4131 bsfp= *opt == 'v' ? &video_bitstream_filters :
4132 *opt == 'a' ? &audio_bitstream_filters :
4133 &subtitle_bitstream_filters;
4135 bsfp= &(*bsfp)->next;
4142 static int opt_preset(const char *opt, const char *arg)
4145 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4146 char *codec_name = *opt == 'v' ? video_codec_name :
4147 *opt == 'a' ? audio_codec_name :
4148 subtitle_codec_name;
4150 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4151 fprintf(stderr, "File for preset '%s' not found\n", arg);
4156 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4157 if(line[0] == '#' && !e)
4159 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4161 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4164 if(!strcmp(tmp, "acodec")){
4165 opt_audio_codec(tmp2);
4166 }else if(!strcmp(tmp, "vcodec")){
4167 opt_video_codec(tmp2);
4168 }else if(!strcmp(tmp, "scodec")){
4169 opt_subtitle_codec(tmp2);
4170 }else if(opt_default(tmp, tmp2) < 0){
4171 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4181 static const OptionDef options[] = {
4183 #include "cmdutils_common_opts.h"
4184 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4185 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4186 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4187 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4188 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4189 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
4190 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4191 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4192 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4193 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4194 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4195 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4196 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4197 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4198 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4199 "add timings for benchmarking" },
4200 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4201 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4202 "dump each input packet" },
4203 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4204 "when dumping packets, also dump the payload" },
4205 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4206 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4207 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4208 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4209 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4210 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4211 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4212 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4213 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4214 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4215 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4216 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4217 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4218 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4219 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4220 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4223 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4224 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4225 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4226 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4227 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4228 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4229 { "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" },
4230 { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4231 { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4232 { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4233 { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4234 { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4235 { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4236 { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4237 { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4238 { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4239 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4240 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4241 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4242 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4243 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4244 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4245 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4246 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4247 "use same video quality as source (implies VBR)" },
4248 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4249 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4250 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4251 "deinterlace pictures" },
4252 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4253 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4254 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4256 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4258 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4259 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4260 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4261 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4262 { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4263 { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4264 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4265 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4266 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4267 { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4268 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4271 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4272 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4273 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4274 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4275 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4276 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4277 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4278 { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4279 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4280 { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4281 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4282 { "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" },
4284 /* subtitle options */
4285 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4286 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4287 { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4288 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4289 { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4292 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4293 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4294 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4297 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4298 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4300 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4301 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4302 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4304 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4305 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4306 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4307 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4309 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4313 int main(int argc, char **argv)
4317 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4319 avcodec_register_all();
4321 avdevice_register_all();
4324 avfilter_register_all();
4329 if(isatty(STDIN_FILENO))
4330 url_set_interrupt_cb(decode_interrupt_cb);
4338 parse_options(argc, argv, options, opt_output_file);
4340 if(nb_output_files <= 0 && nb_input_files == 0) {
4342 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4346 /* file converter / grab */
4347 if (nb_output_files <= 0) {
4348 fprintf(stderr, "At least one output file must be specified\n");
4352 if (nb_input_files == 0) {
4353 fprintf(stderr, "At least one input file must be specified\n");
4358 if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4359 stream_maps, nb_stream_maps) < 0)
4361 ti = getutime() - ti;
4363 int maxrss = getmaxrss() / 1024;
4364 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4367 return ffmpeg_exit(0);