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 "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/avstring.h"
43 #include "libavutil/libm.h"
44 #include "libavformat/os_support.h"
46 #if HAVE_SYS_RESOURCE_H
47 #include <sys/types.h>
49 #include <sys/resource.h>
50 #elif HAVE_GETPROCESSTIMES
53 #if HAVE_GETPROCESSMEMORYINFO
59 #include <sys/select.h>
64 #include <sys/ioctl.h>
77 const char program_name[] = "FFmpeg";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct AVStreamMap {
85 int sync_stream_index;
88 /** select an input file for an output file */
89 typedef struct AVMetaDataMap {
94 static const OptionDef options[];
98 static const char *last_asked_format = NULL;
99 static AVFormatContext *input_files[MAX_FILES];
100 static int64_t input_files_ts_offset[MAX_FILES];
101 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
102 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
103 static int nb_input_files = 0;
104 static int nb_icodecs;
106 static AVFormatContext *output_files[MAX_FILES];
107 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
108 static int nb_output_files = 0;
109 static int nb_ocodecs;
111 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
112 static int nb_stream_maps;
114 static AVMetaDataMap meta_data_maps[MAX_FILES];
115 static int nb_meta_data_maps;
117 static int frame_width = 0;
118 static int frame_height = 0;
119 static float frame_aspect_ratio = 0;
120 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
121 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
122 static int frame_padtop = 0;
123 static int frame_padbottom = 0;
124 static int frame_padleft = 0;
125 static int frame_padright = 0;
126 static int padcolor[3] = {16,128,128}; /* default to black */
127 static int frame_topBand = 0;
128 static int frame_bottomBand = 0;
129 static int frame_leftBand = 0;
130 static int frame_rightBand = 0;
131 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
132 static AVRational frame_rate;
133 static float video_qscale = 0;
134 static uint16_t *intra_matrix = NULL;
135 static uint16_t *inter_matrix = NULL;
136 static const char *video_rc_override_string=NULL;
137 static int video_disable = 0;
138 static int video_discard = 0;
139 static char *video_codec_name = NULL;
140 static int video_codec_tag = 0;
141 static char *video_language = NULL;
142 static int same_quality = 0;
143 static int do_deinterlace = 0;
144 static int top_field_first = -1;
145 static int me_threshold = 0;
146 static int intra_dc_precision = 8;
147 static int loop_input = 0;
148 static int loop_output = AVFMT_NOOUTPUTLOOP;
149 static int qp_hist = 0;
151 static int intra_only = 0;
152 static int audio_sample_rate = 44100;
153 static int64_t channel_layout = 0;
154 #define QSCALE_NONE -99999
155 static float audio_qscale = QSCALE_NONE;
156 static int audio_disable = 0;
157 static int audio_channels = 1;
158 static char *audio_codec_name = NULL;
159 static int audio_codec_tag = 0;
160 static char *audio_language = NULL;
162 static int subtitle_disable = 0;
163 static char *subtitle_codec_name = NULL;
164 static char *subtitle_language = NULL;
165 static int subtitle_codec_tag = 0;
167 static float mux_preload= 0.5;
168 static float mux_max_delay= 0.7;
170 static int64_t recording_time = INT64_MAX;
171 static int64_t start_time = 0;
172 static int64_t rec_timestamp = 0;
173 static int64_t input_ts_offset = 0;
174 static int file_overwrite = 0;
175 static int metadata_count;
176 static AVMetadataTag *metadata;
177 static int do_benchmark = 0;
178 static int do_hex_dump = 0;
179 static int do_pkt_dump = 0;
180 static int do_psnr = 0;
181 static int do_pass = 0;
182 static char *pass_logfilename_prefix = NULL;
183 static int audio_stream_copy = 0;
184 static int video_stream_copy = 0;
185 static int subtitle_stream_copy = 0;
186 static int video_sync_method= -1;
187 static int audio_sync_method= 0;
188 static float audio_drift_threshold= 0.1;
189 static int copy_ts= 0;
190 static int opt_shortest = 0;
191 static int video_global_header = 0;
192 static char *vstats_filename;
193 static FILE *vstats_file;
194 static int opt_programid = 0;
195 static int copy_initial_nonkeyframes = 0;
197 static int rate_emu = 0;
199 static int video_channel = 0;
200 static char *video_standard;
202 static int audio_volume = 256;
204 static int exit_on_error = 0;
205 static int using_stdin = 0;
206 static int verbose = 1;
207 static int thread_count= 1;
208 static int q_pressed = 0;
209 static int64_t video_size = 0;
210 static int64_t audio_size = 0;
211 static int64_t extra_size = 0;
212 static int nb_frames_dup = 0;
213 static int nb_frames_drop = 0;
214 static int input_sync;
215 static uint64_t limit_filesize = 0;
216 static int force_fps = 0;
218 static int pgmyuv_compatibility_hack=0;
219 static float dts_delta_threshold = 10;
221 static unsigned int sws_flags = SWS_BICUBIC;
223 static int64_t timer_start;
225 static uint8_t *audio_buf;
226 static uint8_t *audio_out;
227 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
229 static short *samples;
231 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
232 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
233 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
234 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
236 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
238 struct AVInputStream;
240 typedef struct AVOutputStream {
241 int file_index; /* file index */
242 int index; /* stream index in the output file */
243 int source_index; /* AVInputStream index */
244 AVStream *st; /* stream in the output file */
245 int encoding_needed; /* true if encoding needed for this stream */
247 /* input pts and corresponding output pts
249 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
250 struct AVInputStream *sync_ist; /* input stream to sync against */
251 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
254 AVFrame pict_tmp; /* temporary image for resampling */
255 struct SwsContext *img_resample_ctx; /* for image resampling */
258 int resample_pix_fmt;
260 /* full frame size of first frame */
264 /* cropping area sizes */
271 /* cropping area of first frame */
272 int original_topBand;
273 int original_bottomBand;
274 int original_leftBand;
275 int original_rightBand;
277 /* padding area sizes */
286 ReSampleContext *resample; /* for audio resampling */
288 AVAudioConvert *reformat_ctx;
289 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
293 typedef struct AVInputStream {
297 int discard; /* true if stream data should be discarded */
298 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
299 int64_t sample_index; /* current sample */
301 int64_t start; /* time when read started */
302 int64_t next_pts; /* synthetic pts for cases where pkt.pts
304 int64_t pts; /* current pts */
305 int is_start; /* is 1 at the start and after a discontinuity */
306 int showed_multi_packet_warning;
307 int is_past_recording_time;
310 typedef struct AVInputFile {
311 int eof_reached; /* true if eof reached */
312 int ist_index; /* index of first stream in ist_table */
313 int buffer_size; /* current total buffer size */
314 int nb_streams; /* nb streams we are aware of */
319 /* init terminal so that we can grab keys */
320 static struct termios oldtty;
323 static void term_exit(void)
326 tcsetattr (0, TCSANOW, &oldtty);
330 static volatile int received_sigterm = 0;
333 sigterm_handler(int sig)
335 received_sigterm = sig;
339 static void term_init(void)
348 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
349 |INLCR|IGNCR|ICRNL|IXON);
350 tty.c_oflag |= OPOST;
351 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
352 tty.c_cflag &= ~(CSIZE|PARENB);
357 tcsetattr (0, TCSANOW, &tty);
358 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
361 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
362 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
364 signal(SIGXCPU, sigterm_handler);
367 #if CONFIG_BEOS_NETSERVER
368 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
372 /* read a key without blocking */
373 static int read_key(void)
378 #if !CONFIG_BEOS_NETSERVER
386 n = select(1, &rfds, NULL, NULL, &tv);
402 static int decode_interrupt_cb(void)
404 return q_pressed || (q_pressed = read_key() == 'q');
407 static int av_exit(int ret)
412 for(i=0;i<nb_output_files;i++) {
413 /* maybe av_close_output_file ??? */
414 AVFormatContext *s = output_files[i];
416 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
418 for(j=0;j<s->nb_streams;j++) {
419 av_metadata_free(&s->streams[j]->metadata);
420 av_free(s->streams[j]->codec);
421 av_free(s->streams[j]);
423 for(j=0;j<s->nb_programs;j++) {
424 av_metadata_free(&s->programs[j]->metadata);
426 for(j=0;j<s->nb_chapters;j++) {
427 av_metadata_free(&s->chapters[j]->metadata);
429 av_metadata_free(&s->metadata);
432 for(i=0;i<nb_input_files;i++)
433 av_close_input_file(input_files[i]);
435 av_free(intra_matrix);
436 av_free(inter_matrix);
440 av_free(vstats_filename);
444 av_free(video_codec_name);
445 av_free(audio_codec_name);
446 av_free(subtitle_codec_name);
448 av_free(video_standard);
450 #if CONFIG_POWERPC_PERF
451 void powerpc_display_perf_report(void);
452 powerpc_display_perf_report();
453 #endif /* CONFIG_POWERPC_PERF */
455 for (i=0;i<AVMEDIA_TYPE_NB;i++)
456 av_free(avcodec_opts[i]);
457 av_free(avformat_opts);
461 allocated_audio_buf_size= allocated_audio_out_size= 0;
464 if (received_sigterm) {
466 "Received signal %d: terminating.\n",
467 (int) received_sigterm);
471 exit(ret); /* not all OS-es handle main() return value */
475 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
477 if(codec && codec->sample_fmts){
478 const enum SampleFormat *p= codec->sample_fmts;
480 if(*p == st->codec->sample_fmt)
484 st->codec->sample_fmt = codec->sample_fmts[0];
488 static void choose_sample_rate(AVStream *st, AVCodec *codec)
490 if(codec && codec->supported_samplerates){
491 const int *p= codec->supported_samplerates;
493 int best_dist=INT_MAX;
495 int dist= abs(st->codec->sample_rate - *p);
496 if(dist < best_dist){
502 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
504 st->codec->sample_rate= best;
508 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
510 if(codec && codec->pix_fmts){
511 const enum PixelFormat *p= codec->pix_fmts;
513 if(*p == st->codec->pix_fmt)
517 && !( st->codec->codec_id==CODEC_ID_MJPEG
518 && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL
519 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
520 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
521 st->codec->pix_fmt = codec->pix_fmts[0];
525 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
531 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
534 /* copy stream format */
535 s->nb_streams = ic->nb_streams;
536 for(i=0;i<ic->nb_streams;i++) {
540 // FIXME: a more elegant solution is needed
541 st = av_mallocz(sizeof(AVStream));
542 memcpy(st, ic->streams[i], sizeof(AVStream));
543 st->codec = avcodec_alloc_context();
545 print_error(filename, AVERROR(ENOMEM));
548 avcodec_copy_context(st->codec, ic->streams[i]->codec);
551 codec = avcodec_find_encoder(st->codec->codec_id);
552 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
553 if (audio_stream_copy) {
556 choose_sample_fmt(st, codec);
557 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
558 if (video_stream_copy) {
561 choose_pixel_fmt(st, codec);
564 if(!st->codec->thread_count)
565 st->codec->thread_count = 1;
566 if(st->codec->thread_count>1)
567 avcodec_thread_init(st->codec, st->codec->thread_count);
569 if(st->codec->flags & CODEC_FLAG_BITEXACT)
574 s->timestamp = av_gettime();
576 av_close_input_file(ic);
581 get_sync_ipts(const AVOutputStream *ost)
583 const AVInputStream *ist = ost->sync_ist;
584 return (double)(ist->pts - start_time)/AV_TIME_BASE;
587 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
591 AVPacket new_pkt= *pkt;
592 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
593 &new_pkt.data, &new_pkt.size,
594 pkt->data, pkt->size,
595 pkt->flags & AV_PKT_FLAG_KEY);
598 new_pkt.destruct= av_destruct_packet;
600 fprintf(stderr, "%s failed for stream %d, codec %s",
601 bsfc->filter->name, pkt->stream_index,
602 avctx->codec ? avctx->codec->name : "copy");
612 ret= av_interleaved_write_frame(s, pkt);
614 print_error("av_interleaved_write_frame()", ret);
619 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
621 static void do_audio_out(AVFormatContext *s,
624 unsigned char *buf, int size)
627 int64_t audio_out_size, audio_buf_size;
628 int64_t allocated_for_size= size;
630 int size_out, frame_bytes, ret;
631 AVCodecContext *enc= ost->st->codec;
632 AVCodecContext *dec= ist->st->codec;
633 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
634 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
635 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
638 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
639 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
640 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
641 audio_buf_size*= osize*enc->channels;
643 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
644 if(coded_bps > 8*osize)
645 audio_out_size= audio_out_size * coded_bps / (8*osize);
646 audio_out_size += FF_MIN_BUFFER_SIZE;
648 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
649 fprintf(stderr, "Buffer sizes too large\n");
653 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
654 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
655 if (!audio_buf || !audio_out){
656 fprintf(stderr, "Out of memory in do_audio_out\n");
660 if (enc->channels != dec->channels)
661 ost->audio_resample = 1;
663 if (ost->audio_resample && !ost->resample) {
664 if (dec->sample_fmt != SAMPLE_FMT_S16)
665 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
666 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
667 enc->sample_rate, dec->sample_rate,
668 enc->sample_fmt, dec->sample_fmt,
670 if (!ost->resample) {
671 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
672 dec->channels, dec->sample_rate,
673 enc->channels, enc->sample_rate);
678 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
679 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
680 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
681 if (ost->reformat_ctx)
682 av_audio_convert_free(ost->reformat_ctx);
683 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
684 dec->sample_fmt, 1, NULL, 0);
685 if (!ost->reformat_ctx) {
686 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
687 avcodec_get_sample_fmt_name(dec->sample_fmt),
688 avcodec_get_sample_fmt_name(enc->sample_fmt));
691 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
694 if(audio_sync_method){
695 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
696 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
697 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
698 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
700 //FIXME resample delay
701 if(fabs(delta) > 50){
702 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
704 byte_delta= FFMAX(byte_delta, -size);
708 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
713 static uint8_t *input_tmp= NULL;
714 input_tmp= av_realloc(input_tmp, byte_delta + size);
716 if(byte_delta > allocated_for_size - size){
717 allocated_for_size= byte_delta + (int64_t)size;
722 memset(input_tmp, 0, byte_delta);
723 memcpy(input_tmp + byte_delta, buf, size);
727 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
729 }else if(audio_sync_method>1){
730 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
731 assert(ost->audio_resample);
733 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
734 // 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));
735 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
739 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
740 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
742 if (ost->audio_resample) {
744 size_out = audio_resample(ost->resample,
745 (short *)buftmp, (short *)buf,
746 size / (ist->st->codec->channels * isize));
747 size_out = size_out * enc->channels * osize;
753 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
754 const void *ibuf[6]= {buftmp};
755 void *obuf[6]= {audio_buf};
756 int istride[6]= {isize};
757 int ostride[6]= {osize};
758 int len= size_out/istride[0];
759 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
760 printf("av_audio_convert() failed\n");
766 size_out = len*osize;
769 /* now encode as many frames as possible */
770 if (enc->frame_size > 1) {
771 /* output resampled raw samples */
772 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
773 fprintf(stderr, "av_fifo_realloc2() failed\n");
776 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
778 frame_bytes = enc->frame_size * osize * enc->channels;
780 while (av_fifo_size(ost->fifo) >= frame_bytes) {
782 av_init_packet(&pkt);
784 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
786 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
788 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
791 fprintf(stderr, "Audio encoding failed\n");
795 pkt.stream_index= ost->index;
798 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
799 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
800 pkt.flags |= AV_PKT_FLAG_KEY;
801 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
803 ost->sync_opts += enc->frame_size;
807 av_init_packet(&pkt);
809 ost->sync_opts += size_out / (osize * enc->channels);
811 /* output a pcm frame */
812 /* determine the size of the coded buffer */
815 size_out = size_out*coded_bps/8;
817 if(size_out > audio_out_size){
818 fprintf(stderr, "Internal error, buffer size too small\n");
822 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
823 ret = avcodec_encode_audio(enc, audio_out, size_out,
826 fprintf(stderr, "Audio encoding failed\n");
830 pkt.stream_index= ost->index;
833 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
834 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
835 pkt.flags |= AV_PKT_FLAG_KEY;
836 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
840 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
844 AVPicture picture_tmp;
847 dec = ist->st->codec;
849 /* deinterlace : must be done before any resize */
850 if (do_deinterlace) {
853 /* create temporary picture */
854 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
855 buf = av_malloc(size);
859 picture2 = &picture_tmp;
860 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
862 if(avpicture_deinterlace(picture2, picture,
863 dec->pix_fmt, dec->width, dec->height) < 0) {
864 /* if error, do not deinterlace */
865 fprintf(stderr, "Deinterlacing failed\n");
874 if (picture != picture2)
875 *picture = *picture2;
879 /* we begin to correct av delay at this threshold */
880 #define AV_DELAY_MAX 0.100
882 static void do_subtitle_out(AVFormatContext *s,
888 static uint8_t *subtitle_out = NULL;
889 int subtitle_out_max_size = 1024 * 1024;
890 int subtitle_out_size, nb, i;
894 if (pts == AV_NOPTS_VALUE) {
895 fprintf(stderr, "Subtitle packets must have a pts\n");
901 enc = ost->st->codec;
904 subtitle_out = av_malloc(subtitle_out_max_size);
907 /* Note: DVB subtitle need one packet to draw them and one other
908 packet to clear them */
909 /* XXX: signal it in the codec context ? */
910 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
915 for(i = 0; i < nb; i++) {
916 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
917 // start_display_time is required to be 0
918 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
919 sub->end_display_time -= sub->start_display_time;
920 sub->start_display_time = 0;
921 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
922 subtitle_out_max_size, sub);
923 if (subtitle_out_size < 0) {
924 fprintf(stderr, "Subtitle encoding failed\n");
928 av_init_packet(&pkt);
929 pkt.stream_index = ost->index;
930 pkt.data = subtitle_out;
931 pkt.size = subtitle_out_size;
932 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
933 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
934 /* XXX: the pts correction is handled here. Maybe handling
935 it in the codec would be better */
937 pkt.pts += 90 * sub->start_display_time;
939 pkt.pts += 90 * sub->end_display_time;
941 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
945 static int bit_buffer_size= 1024*256;
946 static uint8_t *bit_buffer= NULL;
948 static void do_video_out(AVFormatContext *s,
954 int nb_frames, i, ret;
955 int64_t topBand, bottomBand, leftBand, rightBand;
956 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
957 AVFrame picture_crop_temp, picture_pad_temp;
958 AVCodecContext *enc, *dec;
961 avcodec_get_frame_defaults(&picture_crop_temp);
962 avcodec_get_frame_defaults(&picture_pad_temp);
964 enc = ost->st->codec;
965 dec = ist->st->codec;
967 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
969 /* by default, we output a single frame */
974 if(video_sync_method){
975 double vdelta = sync_ipts - ost->sync_opts;
976 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
979 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
983 ost->sync_opts= lrintf(sync_ipts);
984 }else if (vdelta > 1.1)
985 nb_frames = lrintf(vdelta);
986 //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);
990 fprintf(stderr, "*** drop!\n");
991 }else if (nb_frames > 1) {
992 nb_frames_dup += nb_frames - 1;
994 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
997 ost->sync_opts= lrintf(sync_ipts);
999 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1003 if (ost->video_crop) {
1004 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1005 fprintf(stderr, "error cropping picture\n");
1010 formatted_picture = &picture_crop_temp;
1012 formatted_picture = in_picture;
1015 final_picture = formatted_picture;
1016 padding_src = formatted_picture;
1017 resampling_dst = &ost->pict_tmp;
1018 if (ost->video_pad) {
1019 final_picture = &ost->pict_tmp;
1020 if (ost->video_resample) {
1021 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
1022 fprintf(stderr, "error padding picture\n");
1027 resampling_dst = &picture_pad_temp;
1031 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1032 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1033 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1035 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));
1036 if(!ost->video_resample)
1040 if (ost->video_resample) {
1042 final_picture = &ost->pict_tmp;
1043 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1044 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1045 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1047 /* keep bands proportional to the frame size */
1048 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
1049 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1050 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
1051 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
1053 /* sanity check to ensure no bad band sizes sneak in */
1054 assert(topBand <= INT_MAX && topBand >= 0);
1055 assert(bottomBand <= INT_MAX && bottomBand >= 0);
1056 assert(leftBand <= INT_MAX && leftBand >= 0);
1057 assert(rightBand <= INT_MAX && rightBand >= 0);
1059 ost->topBand = topBand;
1060 ost->bottomBand = bottomBand;
1061 ost->leftBand = leftBand;
1062 ost->rightBand = rightBand;
1064 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
1065 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
1066 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1068 /* initialize a new scaler context */
1069 sws_freeContext(ost->img_resample_ctx);
1070 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1071 ost->img_resample_ctx = sws_getContext(
1072 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1073 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1074 ist->st->codec->pix_fmt,
1075 ost->st->codec->width - (ost->padleft + ost->padright),
1076 ost->st->codec->height - (ost->padtop + ost->padbottom),
1077 ost->st->codec->pix_fmt,
1078 sws_flags, NULL, NULL, NULL);
1079 if (ost->img_resample_ctx == NULL) {
1080 fprintf(stderr, "Cannot get resampling context\n");
1084 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1085 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1088 if (ost->video_pad) {
1089 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1090 enc->height, enc->width, enc->pix_fmt,
1091 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1094 /* duplicates frame if needed */
1095 for(i=0;i<nb_frames;i++) {
1097 av_init_packet(&pkt);
1098 pkt.stream_index= ost->index;
1100 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1101 /* raw pictures are written as AVPicture structure to
1102 avoid any copies. We support temorarily the older
1104 AVFrame* old_frame = enc->coded_frame;
1105 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1106 pkt.data= (uint8_t *)final_picture;
1107 pkt.size= sizeof(AVPicture);
1108 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1109 pkt.flags |= AV_PKT_FLAG_KEY;
1111 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1112 enc->coded_frame = old_frame;
1114 AVFrame big_picture;
1116 big_picture= *final_picture;
1117 /* better than nothing: use input picture interlaced
1119 big_picture.interlaced_frame = in_picture->interlaced_frame;
1120 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1121 if(top_field_first == -1)
1122 big_picture.top_field_first = in_picture->top_field_first;
1124 big_picture.top_field_first = top_field_first;
1127 /* handles sameq here. This is not correct because it may
1128 not be a global option */
1130 big_picture.quality = ist->st->quality;
1132 big_picture.quality = ost->st->quality;
1134 big_picture.pict_type = 0;
1135 // big_picture.pts = AV_NOPTS_VALUE;
1136 big_picture.pts= ost->sync_opts;
1137 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1138 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1139 ret = avcodec_encode_video(enc,
1140 bit_buffer, bit_buffer_size,
1143 fprintf(stderr, "Video encoding failed\n");
1148 pkt.data= bit_buffer;
1150 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1151 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1152 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1153 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1154 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1156 if(enc->coded_frame->key_frame)
1157 pkt.flags |= AV_PKT_FLAG_KEY;
1158 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1161 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1162 // enc->frame_number-1, ret, enc->pict_type);
1163 /* if two pass, output log */
1164 if (ost->logfile && enc->stats_out) {
1165 fprintf(ost->logfile, "%s", enc->stats_out);
1170 ost->frame_number++;
1174 static double psnr(double d){
1175 return -10.0*log(d)/log(10.0);
1178 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1181 AVCodecContext *enc;
1183 double ti1, bitrate, avg_bitrate;
1185 /* this is executed just the first time do_video_stats is called */
1187 vstats_file = fopen(vstats_filename, "w");
1194 enc = ost->st->codec;
1195 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1196 frame_number = ost->frame_number;
1197 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1198 if (enc->flags&CODEC_FLAG_PSNR)
1199 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1201 fprintf(vstats_file,"f_size= %6d ", frame_size);
1202 /* compute pts value */
1203 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1207 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1208 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1209 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1210 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1211 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1215 static void print_report(AVFormatContext **output_files,
1216 AVOutputStream **ost_table, int nb_ostreams,
1220 AVOutputStream *ost;
1221 AVFormatContext *oc;
1223 AVCodecContext *enc;
1224 int frame_number, vid, i;
1225 double bitrate, ti1, pts;
1226 static int64_t last_time = -1;
1227 static int qp_histogram[52];
1229 if (!is_last_report) {
1231 /* display the report every 0.5 seconds */
1232 cur_time = av_gettime();
1233 if (last_time == -1) {
1234 last_time = cur_time;
1237 if ((cur_time - last_time) < 500000)
1239 last_time = cur_time;
1243 oc = output_files[0];
1245 total_size = url_fsize(oc->pb);
1246 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1247 total_size= url_ftell(oc->pb);
1252 for(i=0;i<nb_ostreams;i++) {
1254 enc = ost->st->codec;
1255 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1256 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1257 !ost->st->stream_copy ?
1258 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1260 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1261 float t = (av_gettime()-timer_start) / 1000000.0;
1263 frame_number = ost->frame_number;
1264 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1265 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1266 !ost->st->stream_copy ?
1267 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1269 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1272 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1273 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1276 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1278 if (enc->flags&CODEC_FLAG_PSNR){
1280 double error, error_sum=0;
1281 double scale, scale_sum=0;
1282 char type[3]= {'Y','U','V'};
1283 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1286 error= enc->error[j];
1287 scale= enc->width*enc->height*255.0*255.0*frame_number;
1289 error= enc->coded_frame->error[j];
1290 scale= enc->width*enc->height*255.0*255.0;
1295 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1297 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1301 /* compute min output value */
1302 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1303 if ((pts < ti1) && (pts > 0))
1309 if (verbose || is_last_report) {
1310 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1312 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1313 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1314 (double)total_size / 1024, ti1, bitrate);
1316 if (nb_frames_dup || nb_frames_drop)
1317 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1318 nb_frames_dup, nb_frames_drop);
1321 fprintf(stderr, "%s \r", buf);
1326 if (is_last_report && verbose >= 0){
1327 int64_t raw= audio_size + video_size + extra_size;
1328 fprintf(stderr, "\n");
1329 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1333 100.0*(total_size - raw)/raw
1338 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1339 static int output_packet(AVInputStream *ist, int ist_index,
1340 AVOutputStream **ost_table, int nb_ostreams,
1341 const AVPacket *pkt)
1343 AVFormatContext *os;
1344 AVOutputStream *ost;
1348 void *buffer_to_free;
1349 static unsigned int samples_size= 0;
1350 AVSubtitle subtitle, *subtitle_to_free;
1353 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1355 if(ist->next_pts == AV_NOPTS_VALUE)
1356 ist->next_pts= ist->pts;
1360 av_init_packet(&avpkt);
1368 if(pkt->dts != AV_NOPTS_VALUE)
1369 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1371 //while we have more to decode or while the decoder did output something on EOF
1372 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1373 uint8_t *data_buf, *decoded_data_buf;
1374 int data_size, decoded_data_size;
1376 ist->pts= ist->next_pts;
1378 if(avpkt.size && avpkt.size != pkt->size &&
1379 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1380 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1381 ist->showed_multi_packet_warning=1;
1384 /* decode the packet if needed */
1385 decoded_data_buf = NULL; /* fail safe */
1386 decoded_data_size= 0;
1387 data_buf = avpkt.data;
1388 data_size = avpkt.size;
1389 subtitle_to_free = NULL;
1390 if (ist->decoding_needed) {
1391 switch(ist->st->codec->codec_type) {
1392 case AVMEDIA_TYPE_AUDIO:{
1393 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1394 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1396 samples= av_malloc(samples_size);
1398 decoded_data_size= samples_size;
1399 /* XXX: could avoid copy if PCM 16 bits with same
1400 endianness as CPU */
1401 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1408 /* Some bug in mpeg audio decoder gives */
1409 /* decoded_data_size < 0, it seems they are overflows */
1410 if (decoded_data_size <= 0) {
1411 /* no audio frame */
1414 decoded_data_buf = (uint8_t *)samples;
1415 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1416 (ist->st->codec->sample_rate * ist->st->codec->channels);
1418 case AVMEDIA_TYPE_VIDEO:
1419 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1420 /* XXX: allocate picture correctly */
1421 avcodec_get_frame_defaults(&picture);
1423 ret = avcodec_decode_video2(ist->st->codec,
1424 &picture, &got_picture, &avpkt);
1425 ist->st->quality= picture.quality;
1429 /* no picture yet */
1430 goto discard_packet;
1432 if (ist->st->codec->time_base.num != 0) {
1433 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1434 ist->next_pts += ((int64_t)AV_TIME_BASE *
1435 ist->st->codec->time_base.num * ticks) /
1436 ist->st->codec->time_base.den;
1440 case AVMEDIA_TYPE_SUBTITLE:
1441 ret = avcodec_decode_subtitle2(ist->st->codec,
1442 &subtitle, &got_subtitle, &avpkt);
1445 if (!got_subtitle) {
1446 goto discard_packet;
1448 subtitle_to_free = &subtitle;
1455 switch(ist->st->codec->codec_type) {
1456 case AVMEDIA_TYPE_AUDIO:
1457 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1458 ist->st->codec->sample_rate;
1460 case AVMEDIA_TYPE_VIDEO:
1461 if (ist->st->codec->time_base.num != 0) {
1462 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1463 ist->next_pts += ((int64_t)AV_TIME_BASE *
1464 ist->st->codec->time_base.num * ticks) /
1465 ist->st->codec->time_base.den;
1473 buffer_to_free = NULL;
1474 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1475 pre_process_video_frame(ist, (AVPicture *)&picture,
1479 // preprocess audio (volume)
1480 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1481 if (audio_volume != 256) {
1484 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1485 int v = ((*volp) * audio_volume + 128) >> 8;
1486 if (v < -32768) v = -32768;
1487 if (v > 32767) v = 32767;
1493 /* frame rate emulation */
1495 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1496 int64_t now = av_gettime() - ist->start;
1501 /* if output time reached then transcode raw format,
1502 encode packets and output them */
1503 if (start_time == 0 || ist->pts >= start_time)
1504 for(i=0;i<nb_ostreams;i++) {
1508 if (ost->source_index == ist_index) {
1509 os = output_files[ost->file_index];
1511 /* set the input output pts pairs */
1512 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1514 if (ost->encoding_needed) {
1515 assert(ist->decoding_needed);
1516 switch(ost->st->codec->codec_type) {
1517 case AVMEDIA_TYPE_AUDIO:
1518 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1520 case AVMEDIA_TYPE_VIDEO:
1521 do_video_out(os, ost, ist, &picture, &frame_size);
1522 if (vstats_filename && frame_size)
1523 do_video_stats(os, ost, frame_size);
1525 case AVMEDIA_TYPE_SUBTITLE:
1526 do_subtitle_out(os, ost, ist, &subtitle,
1533 AVFrame avframe; //FIXME/XXX remove this
1535 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1537 av_init_packet(&opkt);
1539 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1542 /* no reencoding needed : output the packet directly */
1543 /* force the input stream PTS */
1545 avcodec_get_frame_defaults(&avframe);
1546 ost->st->codec->coded_frame= &avframe;
1547 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1549 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1550 audio_size += data_size;
1551 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1552 video_size += data_size;
1556 opkt.stream_index= ost->index;
1557 if(pkt->pts != AV_NOPTS_VALUE)
1558 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1560 opkt.pts= AV_NOPTS_VALUE;
1562 if (pkt->dts == AV_NOPTS_VALUE)
1563 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1565 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1566 opkt.dts -= ost_tb_start_time;
1568 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1569 opkt.flags= pkt->flags;
1571 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1572 if( ost->st->codec->codec_id != CODEC_ID_H264
1573 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1574 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1576 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1577 opkt.destruct= av_destruct_packet;
1579 opkt.data = data_buf;
1580 opkt.size = data_size;
1583 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1584 ost->st->codec->frame_number++;
1585 ost->frame_number++;
1586 av_free_packet(&opkt);
1590 av_free(buffer_to_free);
1591 /* XXX: allocate the subtitles in the codec ? */
1592 if (subtitle_to_free) {
1593 if (subtitle_to_free->rects != NULL) {
1594 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1595 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1596 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1597 av_freep(&subtitle_to_free->rects[i]);
1599 av_freep(&subtitle_to_free->rects);
1601 subtitle_to_free->num_rects = 0;
1602 subtitle_to_free = NULL;
1609 for(i=0;i<nb_ostreams;i++) {
1611 if (ost->source_index == ist_index) {
1612 AVCodecContext *enc= ost->st->codec;
1613 os = output_files[ost->file_index];
1615 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1617 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1620 if (ost->encoding_needed) {
1624 av_init_packet(&pkt);
1625 pkt.stream_index= ost->index;
1627 switch(ost->st->codec->codec_type) {
1628 case AVMEDIA_TYPE_AUDIO:
1629 fifo_bytes = av_fifo_size(ost->fifo);
1631 /* encode any samples remaining in fifo */
1632 if (fifo_bytes > 0) {
1633 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1634 int fs_tmp = enc->frame_size;
1636 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1637 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1638 enc->frame_size = fifo_bytes / (osize * enc->channels);
1640 int frame_bytes = enc->frame_size*osize*enc->channels;
1641 if (samples_size < frame_bytes)
1643 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1646 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1647 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1648 ost->st->time_base.num, enc->sample_rate);
1649 enc->frame_size = fs_tmp;
1652 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1655 fprintf(stderr, "Audio encoding failed\n");
1659 pkt.flags |= AV_PKT_FLAG_KEY;
1661 case AVMEDIA_TYPE_VIDEO:
1662 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1664 fprintf(stderr, "Video encoding failed\n");
1668 if(enc->coded_frame && enc->coded_frame->key_frame)
1669 pkt.flags |= AV_PKT_FLAG_KEY;
1670 if (ost->logfile && enc->stats_out) {
1671 fprintf(ost->logfile, "%s", enc->stats_out);
1680 pkt.data= bit_buffer;
1682 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1683 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1684 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1696 static void print_sdp(AVFormatContext **avc, int n)
1700 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1701 printf("SDP:\n%s\n", sdp);
1705 static int copy_chapters(int infile, int outfile)
1707 AVFormatContext *is = input_files[infile];
1708 AVFormatContext *os = output_files[outfile];
1711 for (i = 0; i < is->nb_chapters; i++) {
1712 AVChapter *in_ch = is->chapters[i], *out_ch;
1713 AVMetadataTag *t = NULL;
1714 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1715 AV_TIME_BASE_Q, in_ch->time_base);
1716 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1717 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1720 if (in_ch->end < ts_off)
1722 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1725 out_ch = av_mallocz(sizeof(AVChapter));
1727 return AVERROR(ENOMEM);
1729 out_ch->id = in_ch->id;
1730 out_ch->time_base = in_ch->time_base;
1731 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1732 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1734 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1735 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1738 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1740 return AVERROR(ENOMEM);
1741 os->chapters[os->nb_chapters - 1] = out_ch;
1747 * The following code is the main loop of the file converter
1749 static int av_transcode(AVFormatContext **output_files,
1750 int nb_output_files,
1751 AVFormatContext **input_files,
1753 AVStreamMap *stream_maps, int nb_stream_maps)
1755 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1756 AVFormatContext *is, *os;
1757 AVCodecContext *codec, *icodec;
1758 AVOutputStream *ost, **ost_table = NULL;
1759 AVInputStream *ist, **ist_table = NULL;
1760 AVInputFile *file_table;
1764 uint8_t no_packet[MAX_FILES]={0};
1765 int no_packet_count=0;
1767 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1771 /* input stream init */
1773 for(i=0;i<nb_input_files;i++) {
1774 is = input_files[i];
1775 file_table[i].ist_index = j;
1776 file_table[i].nb_streams = is->nb_streams;
1777 j += is->nb_streams;
1781 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1785 for(i=0;i<nb_istreams;i++) {
1786 ist = av_mallocz(sizeof(AVInputStream));
1792 for(i=0;i<nb_input_files;i++) {
1793 is = input_files[i];
1794 for(k=0;k<is->nb_streams;k++) {
1795 ist = ist_table[j++];
1796 ist->st = is->streams[k];
1797 ist->file_index = i;
1799 ist->discard = 1; /* the stream is discarded by default
1803 ist->start = av_gettime();
1808 /* output stream init */
1810 for(i=0;i<nb_output_files;i++) {
1811 os = output_files[i];
1812 if (!os->nb_streams) {
1813 dump_format(output_files[i], i, output_files[i]->filename, 1);
1814 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1817 nb_ostreams += os->nb_streams;
1819 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1820 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1824 /* Sanity check the mapping args -- do the input files & streams exist? */
1825 for(i=0;i<nb_stream_maps;i++) {
1826 int fi = stream_maps[i].file_index;
1827 int si = stream_maps[i].stream_index;
1829 if (fi < 0 || fi > nb_input_files - 1 ||
1830 si < 0 || si > file_table[fi].nb_streams - 1) {
1831 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1834 fi = stream_maps[i].sync_file_index;
1835 si = stream_maps[i].sync_stream_index;
1836 if (fi < 0 || fi > nb_input_files - 1 ||
1837 si < 0 || si > file_table[fi].nb_streams - 1) {
1838 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1843 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1846 for(i=0;i<nb_ostreams;i++) {
1847 ost = av_mallocz(sizeof(AVOutputStream));
1854 for(k=0;k<nb_output_files;k++) {
1855 os = output_files[k];
1856 for(i=0;i<os->nb_streams;i++,n++) {
1859 ost->file_index = k;
1861 ost->st = os->streams[i];
1862 if (nb_stream_maps > 0) {
1863 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1864 stream_maps[n].stream_index;
1866 /* Sanity check that the stream types match */
1867 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1868 int i= ost->file_index;
1869 dump_format(output_files[i], i, output_files[i]->filename, 1);
1870 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1871 stream_maps[n].file_index, stream_maps[n].stream_index,
1872 ost->file_index, ost->index);
1877 int best_nb_frames=-1;
1878 /* get corresponding input stream index : we select the first one with the right type */
1880 for(j=0;j<nb_istreams;j++) {
1885 AVFormatContext *f= input_files[ ist->file_index ];
1887 for(pi=0; pi<f->nb_programs; pi++){
1888 AVProgram *p= f->programs[pi];
1889 if(p->id == opt_programid)
1890 for(si=0; si<p->nb_stream_indexes; si++){
1891 if(f->streams[ p->stream_index[si] ] == ist->st)
1896 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
1897 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1898 if(best_nb_frames < ist->st->codec_info_nb_frames){
1899 best_nb_frames= ist->st->codec_info_nb_frames;
1900 ost->source_index = j;
1907 if(! opt_programid) {
1908 /* try again and reuse existing stream */
1909 for(j=0;j<nb_istreams;j++) {
1911 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
1912 && ist->st->discard != AVDISCARD_ALL) {
1913 ost->source_index = j;
1919 int i= ost->file_index;
1920 dump_format(output_files[i], i, output_files[i]->filename, 1);
1921 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1922 ost->file_index, ost->index);
1927 ist = ist_table[ost->source_index];
1929 ost->sync_ist = (nb_stream_maps > 0) ?
1930 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1931 stream_maps[n].sync_stream_index] : ist;
1935 /* for each output stream, we compute the right encoding parameters */
1936 for(i=0;i<nb_ostreams;i++) {
1937 AVMetadataTag *t = NULL;
1939 os = output_files[ost->file_index];
1940 ist = ist_table[ost->source_index];
1942 codec = ost->st->codec;
1943 icodec = ist->st->codec;
1945 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
1946 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
1949 ost->st->disposition = ist->st->disposition;
1950 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1951 codec->chroma_sample_location = icodec->chroma_sample_location;
1953 if (ost->st->stream_copy) {
1954 /* if stream_copy is selected, no need to decode or encode */
1955 codec->codec_id = icodec->codec_id;
1956 codec->codec_type = icodec->codec_type;
1958 if(!codec->codec_tag){
1959 if( !os->oformat->codec_tag
1960 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1961 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1962 codec->codec_tag = icodec->codec_tag;
1965 codec->bit_rate = icodec->bit_rate;
1966 codec->extradata= icodec->extradata;
1967 codec->extradata_size= icodec->extradata_size;
1968 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){
1969 codec->time_base = icodec->time_base;
1970 codec->time_base.num *= icodec->ticks_per_frame;
1972 codec->time_base = ist->st->time_base;
1973 switch(codec->codec_type) {
1974 case AVMEDIA_TYPE_AUDIO:
1975 if(audio_volume != 256) {
1976 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1979 codec->channel_layout = icodec->channel_layout;
1980 codec->sample_rate = icodec->sample_rate;
1981 codec->channels = icodec->channels;
1982 codec->frame_size = icodec->frame_size;
1983 codec->block_align= icodec->block_align;
1984 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1985 codec->block_align= 0;
1986 if(codec->codec_id == CODEC_ID_AC3)
1987 codec->block_align= 0;
1989 case AVMEDIA_TYPE_VIDEO:
1990 codec->pix_fmt = icodec->pix_fmt;
1991 codec->width = icodec->width;
1992 codec->height = icodec->height;
1993 codec->has_b_frames = icodec->has_b_frames;
1995 case AVMEDIA_TYPE_SUBTITLE:
1996 codec->width = icodec->width;
1997 codec->height = icodec->height;
2003 switch(codec->codec_type) {
2004 case AVMEDIA_TYPE_AUDIO:
2005 ost->fifo= av_fifo_alloc(1024);
2008 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2009 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2010 icodec->request_channels = codec->channels;
2011 ist->decoding_needed = 1;
2012 ost->encoding_needed = 1;
2014 case AVMEDIA_TYPE_VIDEO:
2015 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2016 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2019 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2020 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
2021 ost->video_resample = ((codec->width != icodec->width -
2022 (frame_leftBand + frame_rightBand) +
2023 (frame_padleft + frame_padright)) ||
2024 (codec->height != icodec->height -
2025 (frame_topBand + frame_bottomBand) +
2026 (frame_padtop + frame_padbottom)) ||
2027 (codec->pix_fmt != icodec->pix_fmt));
2028 if (ost->video_crop) {
2029 ost->topBand = ost->original_topBand = frame_topBand;
2030 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2031 ost->leftBand = ost->original_leftBand = frame_leftBand;
2032 ost->rightBand = ost->original_rightBand = frame_rightBand;
2034 if (ost->video_pad) {
2035 ost->padtop = frame_padtop;
2036 ost->padleft = frame_padleft;
2037 ost->padbottom = frame_padbottom;
2038 ost->padright = frame_padright;
2039 if (!ost->video_resample) {
2040 avcodec_get_frame_defaults(&ost->pict_tmp);
2041 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2042 codec->width, codec->height))
2046 if (ost->video_resample) {
2047 avcodec_get_frame_defaults(&ost->pict_tmp);
2048 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2049 codec->width, codec->height)) {
2050 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2053 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2054 ost->img_resample_ctx = sws_getContext(
2055 icodec->width - (frame_leftBand + frame_rightBand),
2056 icodec->height - (frame_topBand + frame_bottomBand),
2058 codec->width - (frame_padleft + frame_padright),
2059 codec->height - (frame_padtop + frame_padbottom),
2061 sws_flags, NULL, NULL, NULL);
2062 if (ost->img_resample_ctx == NULL) {
2063 fprintf(stderr, "Cannot get resampling context\n");
2067 ost->original_height = icodec->height;
2068 ost->original_width = icodec->width;
2070 codec->bits_per_raw_sample= 0;
2072 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
2073 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
2074 ost->resample_pix_fmt= icodec->pix_fmt;
2075 ost->encoding_needed = 1;
2076 ist->decoding_needed = 1;
2078 case AVMEDIA_TYPE_SUBTITLE:
2079 ost->encoding_needed = 1;
2080 ist->decoding_needed = 1;
2087 if (ost->encoding_needed &&
2088 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2089 char logfilename[1024];
2092 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2093 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2095 if (codec->flags & CODEC_FLAG_PASS1) {
2096 f = fopen(logfilename, "w");
2098 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2104 size_t logbuffer_size;
2105 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2106 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2109 codec->stats_in = logbuffer;
2113 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2114 int size= codec->width * codec->height;
2115 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2120 bit_buffer = av_malloc(bit_buffer_size);
2122 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2124 ret = AVERROR(ENOMEM);
2128 /* open each encoder */
2129 for(i=0;i<nb_ostreams;i++) {
2131 if (ost->encoding_needed) {
2132 AVCodec *codec = output_codecs[i];
2134 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2136 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2137 ost->st->codec->codec_id, ost->file_index, ost->index);
2138 ret = AVERROR(EINVAL);
2141 if (avcodec_open(ost->st->codec, codec) < 0) {
2142 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2143 ost->file_index, ost->index);
2144 ret = AVERROR(EINVAL);
2147 extra_size += ost->st->codec->extradata_size;
2151 /* open each decoder */
2152 for(i=0;i<nb_istreams;i++) {
2154 if (ist->decoding_needed) {
2155 AVCodec *codec = input_codecs[i];
2157 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2159 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2160 ist->st->codec->codec_id, ist->file_index, ist->index);
2161 ret = AVERROR(EINVAL);
2164 if (avcodec_open(ist->st->codec, codec) < 0) {
2165 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2166 ist->file_index, ist->index);
2167 ret = AVERROR(EINVAL);
2170 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2171 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2176 for(i=0;i<nb_istreams;i++) {
2180 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2181 ist->next_pts = AV_NOPTS_VALUE;
2185 /* set meta data information from input file if required */
2186 for (i=0;i<nb_meta_data_maps;i++) {
2187 AVFormatContext *out_file;
2188 AVFormatContext *in_file;
2189 AVMetadataTag *mtag;
2191 int out_file_index = meta_data_maps[i].out_file;
2192 int in_file_index = meta_data_maps[i].in_file;
2193 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2194 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2195 out_file_index, out_file_index, in_file_index);
2196 ret = AVERROR(EINVAL);
2199 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2200 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2201 in_file_index, out_file_index, in_file_index);
2202 ret = AVERROR(EINVAL);
2206 out_file = output_files[out_file_index];
2207 in_file = input_files[in_file_index];
2211 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2212 av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2213 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2214 in_file->iformat->metadata_conv);
2217 /* copy chapters from the first input file that has them*/
2218 for (i = 0; i < nb_input_files; i++) {
2219 if (!input_files[i]->nb_chapters)
2222 for (j = 0; j < nb_output_files; j++)
2223 if ((ret = copy_chapters(i, j)) < 0)
2227 /* open files and write file headers */
2228 for(i=0;i<nb_output_files;i++) {
2229 os = output_files[i];
2230 if (av_write_header(os) < 0) {
2231 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2232 ret = AVERROR(EINVAL);
2235 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2241 /* dump the file output parameters - cannot be done before in case
2243 for(i=0;i<nb_output_files;i++) {
2244 dump_format(output_files[i], i, output_files[i]->filename, 1);
2247 /* dump the stream mapping */
2249 fprintf(stderr, "Stream mapping:\n");
2250 for(i=0;i<nb_ostreams;i++) {
2252 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2253 ist_table[ost->source_index]->file_index,
2254 ist_table[ost->source_index]->index,
2257 if (ost->sync_ist != ist_table[ost->source_index])
2258 fprintf(stderr, " [sync #%d.%d]",
2259 ost->sync_ist->file_index,
2260 ost->sync_ist->index);
2261 fprintf(stderr, "\n");
2266 fprintf(stderr, "%s\n", error);
2271 print_sdp(output_files, nb_output_files);
2274 if (!using_stdin && verbose >= 0) {
2275 fprintf(stderr, "Press [q] to stop encoding\n");
2276 url_set_interrupt_cb(decode_interrupt_cb);
2280 timer_start = av_gettime();
2282 for(; received_sigterm == 0;) {
2283 int file_index, ist_index;
2291 /* if 'q' pressed, exits */
2295 /* read_key() returns 0 on EOF */
2301 /* select the stream that we must read now by looking at the
2302 smallest output pts */
2304 for(i=0;i<nb_ostreams;i++) {
2307 os = output_files[ost->file_index];
2308 ist = ist_table[ost->source_index];
2309 if(ist->is_past_recording_time || no_packet[ist->file_index])
2311 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2312 ipts = (double)ist->pts;
2313 if (!file_table[ist->file_index].eof_reached){
2314 if(ipts < ipts_min) {
2316 if(input_sync ) file_index = ist->file_index;
2318 if(opts < opts_min) {
2320 if(!input_sync) file_index = ist->file_index;
2323 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2328 /* if none, if is finished */
2329 if (file_index < 0) {
2330 if(no_packet_count){
2332 memset(no_packet, 0, sizeof(no_packet));
2339 /* finish if limit size exhausted */
2340 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2343 /* read a frame from it and output it in the fifo */
2344 is = input_files[file_index];
2345 ret= av_read_frame(is, &pkt);
2346 if(ret == AVERROR(EAGAIN)){
2347 no_packet[file_index]=1;
2352 file_table[file_index].eof_reached = 1;
2360 memset(no_packet, 0, sizeof(no_packet));
2363 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2365 /* the following test is needed in case new streams appear
2366 dynamically in stream : we ignore them */
2367 if (pkt.stream_index >= file_table[file_index].nb_streams)
2368 goto discard_packet;
2369 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2370 ist = ist_table[ist_index];
2372 goto discard_packet;
2374 if (pkt.dts != AV_NOPTS_VALUE)
2375 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2376 if (pkt.pts != AV_NOPTS_VALUE)
2377 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2379 if(input_files_ts_scale[file_index][pkt.stream_index]){
2380 if(pkt.pts != AV_NOPTS_VALUE)
2381 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2382 if(pkt.dts != AV_NOPTS_VALUE)
2383 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2386 // 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);
2387 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2388 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2389 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2390 int64_t delta= pkt_dts - ist->next_pts;
2391 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2392 input_files_ts_offset[ist->file_index]-= delta;
2394 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2395 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2396 if(pkt.pts != AV_NOPTS_VALUE)
2397 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2401 /* finish if recording time exhausted */
2402 if (recording_time != INT64_MAX &&
2403 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2404 ist->is_past_recording_time = 1;
2405 goto discard_packet;
2408 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2409 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2412 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2413 ist->file_index, ist->index);
2416 av_free_packet(&pkt);
2421 av_free_packet(&pkt);
2423 /* dump report by using the output first video and audio streams */
2424 print_report(output_files, ost_table, nb_ostreams, 0);
2427 /* at the end of stream, we must flush the decoder buffers */
2428 for(i=0;i<nb_istreams;i++) {
2430 if (ist->decoding_needed) {
2431 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2437 /* write the trailer if needed and close file */
2438 for(i=0;i<nb_output_files;i++) {
2439 os = output_files[i];
2440 av_write_trailer(os);
2443 /* dump report by using the first video and audio streams */
2444 print_report(output_files, ost_table, nb_ostreams, 1);
2446 /* close each encoder */
2447 for(i=0;i<nb_ostreams;i++) {
2449 if (ost->encoding_needed) {
2450 av_freep(&ost->st->codec->stats_in);
2451 avcodec_close(ost->st->codec);
2455 /* close each decoder */
2456 for(i=0;i<nb_istreams;i++) {
2458 if (ist->decoding_needed) {
2459 avcodec_close(ist->st->codec);
2467 av_freep(&bit_buffer);
2468 av_free(file_table);
2471 for(i=0;i<nb_istreams;i++) {
2478 for(i=0;i<nb_ostreams;i++) {
2482 fclose(ost->logfile);
2483 ost->logfile = NULL;
2485 av_fifo_free(ost->fifo); /* works even if fifo is not
2486 initialized but set to zero */
2487 av_free(ost->pict_tmp.data[0]);
2488 if (ost->video_resample)
2489 sws_freeContext(ost->img_resample_ctx);
2491 audio_resample_close(ost->resample);
2492 if (ost->reformat_ctx)
2493 av_audio_convert_free(ost->reformat_ctx);
2502 static void opt_format(const char *arg)
2504 /* compatibility stuff for pgmyuv */
2505 if (!strcmp(arg, "pgmyuv")) {
2506 pgmyuv_compatibility_hack=1;
2507 // opt_image_format(arg);
2509 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2512 last_asked_format = arg;
2515 static void opt_video_rc_override_string(const char *arg)
2517 video_rc_override_string = arg;
2520 static int opt_me_threshold(const char *opt, const char *arg)
2522 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2526 static int opt_verbose(const char *opt, const char *arg)
2528 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2532 static int opt_frame_rate(const char *opt, const char *arg)
2534 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2535 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2541 static int opt_bitrate(const char *opt, const char *arg)
2543 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2545 opt_default(opt, arg);
2547 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2548 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2553 static void opt_frame_crop_top(const char *arg)
2555 frame_topBand = atoi(arg);
2556 if (frame_topBand < 0) {
2557 fprintf(stderr, "Incorrect top crop size\n");
2560 if ((frame_topBand) >= frame_height){
2561 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2564 frame_height -= frame_topBand;
2567 static void opt_frame_crop_bottom(const char *arg)
2569 frame_bottomBand = atoi(arg);
2570 if (frame_bottomBand < 0) {
2571 fprintf(stderr, "Incorrect bottom crop size\n");
2574 if ((frame_bottomBand) >= frame_height){
2575 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2578 frame_height -= frame_bottomBand;
2581 static void opt_frame_crop_left(const char *arg)
2583 frame_leftBand = atoi(arg);
2584 if (frame_leftBand < 0) {
2585 fprintf(stderr, "Incorrect left crop size\n");
2588 if ((frame_leftBand) >= frame_width){
2589 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2592 frame_width -= frame_leftBand;
2595 static void opt_frame_crop_right(const char *arg)
2597 frame_rightBand = atoi(arg);
2598 if (frame_rightBand < 0) {
2599 fprintf(stderr, "Incorrect right crop size\n");
2602 if ((frame_rightBand) >= frame_width){
2603 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2606 frame_width -= frame_rightBand;
2609 static void opt_frame_size(const char *arg)
2611 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2612 fprintf(stderr, "Incorrect frame size\n");
2617 static void opt_pad_color(const char *arg) {
2618 /* Input is expected to be six hex digits similar to
2619 how colors are expressed in html tags (but without the #) */
2620 int rgb = strtol(arg, NULL, 16);
2624 g = ((rgb >> 8) & 255);
2627 padcolor[0] = RGB_TO_Y(r,g,b);
2628 padcolor[1] = RGB_TO_U(r,g,b,0);
2629 padcolor[2] = RGB_TO_V(r,g,b,0);
2632 static void opt_frame_pad_top(const char *arg)
2634 frame_padtop = atoi(arg);
2635 if (frame_padtop < 0) {
2636 fprintf(stderr, "Incorrect top pad size\n");
2641 static void opt_frame_pad_bottom(const char *arg)
2643 frame_padbottom = atoi(arg);
2644 if (frame_padbottom < 0) {
2645 fprintf(stderr, "Incorrect bottom pad size\n");
2651 static void opt_frame_pad_left(const char *arg)
2653 frame_padleft = atoi(arg);
2654 if (frame_padleft < 0) {
2655 fprintf(stderr, "Incorrect left pad size\n");
2661 static void opt_frame_pad_right(const char *arg)
2663 frame_padright = atoi(arg);
2664 if (frame_padright < 0) {
2665 fprintf(stderr, "Incorrect right pad size\n");
2670 static void opt_frame_pix_fmt(const char *arg)
2672 if (strcmp(arg, "list")) {
2673 frame_pix_fmt = av_get_pix_fmt(arg);
2674 if (frame_pix_fmt == PIX_FMT_NONE) {
2675 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2684 static void opt_frame_aspect_ratio(const char *arg)
2691 p = strchr(arg, ':');
2693 x = strtol(arg, &end, 10);
2695 y = strtol(end+1, &end, 10);
2697 ar = (double)x / (double)y;
2699 ar = strtod(arg, NULL);
2702 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2705 frame_aspect_ratio = ar;
2708 static int opt_metadata(const char *opt, const char *arg)
2710 char *mid= strchr(arg, '=');
2713 fprintf(stderr, "Missing =\n");
2719 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2720 metadata[metadata_count-1].key = av_strdup(arg);
2721 metadata[metadata_count-1].value= av_strdup(mid);
2726 static void opt_qscale(const char *arg)
2728 video_qscale = atof(arg);
2729 if (video_qscale <= 0 ||
2730 video_qscale > 255) {
2731 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2736 static void opt_top_field_first(const char *arg)
2738 top_field_first= atoi(arg);
2741 static int opt_thread_count(const char *opt, const char *arg)
2743 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2746 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2751 static void opt_audio_sample_fmt(const char *arg)
2753 if (strcmp(arg, "list"))
2754 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2756 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2761 static int opt_audio_rate(const char *opt, const char *arg)
2763 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2767 static int opt_audio_channels(const char *opt, const char *arg)
2769 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2773 static void opt_video_channel(const char *arg)
2775 video_channel = strtol(arg, NULL, 0);
2778 static void opt_video_standard(const char *arg)
2780 video_standard = av_strdup(arg);
2783 static void opt_codec(int *pstream_copy, char **pcodec_name,
2784 int codec_type, const char *arg)
2786 av_freep(pcodec_name);
2787 if (!strcmp(arg, "copy")) {
2790 *pcodec_name = av_strdup(arg);
2794 static void opt_audio_codec(const char *arg)
2796 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2799 static void opt_audio_tag(const char *arg)
2802 audio_codec_tag= strtol(arg, &tail, 0);
2805 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2808 static void opt_video_tag(const char *arg)
2811 video_codec_tag= strtol(arg, &tail, 0);
2814 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2817 static void opt_video_codec(const char *arg)
2819 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2822 static void opt_subtitle_codec(const char *arg)
2824 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2827 static void opt_subtitle_tag(const char *arg)
2830 subtitle_codec_tag= strtol(arg, &tail, 0);
2833 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2836 static void opt_map(const char *arg)
2841 m = &stream_maps[nb_stream_maps++];
2843 m->file_index = strtol(arg, &p, 0);
2847 m->stream_index = strtol(p, &p, 0);
2850 m->sync_file_index = strtol(p, &p, 0);
2853 m->sync_stream_index = strtol(p, &p, 0);
2855 m->sync_file_index = m->file_index;
2856 m->sync_stream_index = m->stream_index;
2860 static void opt_map_meta_data(const char *arg)
2865 m = &meta_data_maps[nb_meta_data_maps++];
2867 m->out_file = strtol(arg, &p, 0);
2871 m->in_file = strtol(p, &p, 0);
2874 static void opt_input_ts_scale(const char *arg)
2876 unsigned int stream;
2880 stream = strtol(arg, &p, 0);
2883 scale= strtod(p, &p);
2885 if(stream >= MAX_STREAMS)
2888 input_files_ts_scale[nb_input_files][stream]= scale;
2891 static int opt_recording_time(const char *opt, const char *arg)
2893 recording_time = parse_time_or_die(opt, arg, 1);
2897 static int opt_start_time(const char *opt, const char *arg)
2899 start_time = parse_time_or_die(opt, arg, 1);
2903 static int opt_rec_timestamp(const char *opt, const char *arg)
2905 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2909 static int opt_input_ts_offset(const char *opt, const char *arg)
2911 input_ts_offset = parse_time_or_die(opt, arg, 1);
2915 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2917 const char *codec_string = encoder ? "encoder" : "decoder";
2921 return CODEC_ID_NONE;
2923 avcodec_find_encoder_by_name(name) :
2924 avcodec_find_decoder_by_name(name);
2926 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2929 if(codec->type != type) {
2930 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2936 static void opt_input_file(const char *filename)
2938 AVFormatContext *ic;
2939 AVFormatParameters params, *ap = ¶ms;
2940 AVInputFormat *file_iformat = NULL;
2941 int err, i, ret, rfps, rfps_base;
2944 if (last_asked_format) {
2945 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2946 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2949 last_asked_format = NULL;
2952 if (!strcmp(filename, "-"))
2955 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2956 !strcmp(filename, "/dev/stdin");
2958 /* get default parameters from command line */
2959 ic = avformat_alloc_context();
2961 print_error(filename, AVERROR(ENOMEM));
2965 memset(ap, 0, sizeof(*ap));
2966 ap->prealloced_context = 1;
2967 ap->sample_rate = audio_sample_rate;
2968 ap->channels = audio_channels;
2969 ap->time_base.den = frame_rate.num;
2970 ap->time_base.num = frame_rate.den;
2971 ap->width = frame_width + frame_padleft + frame_padright;
2972 ap->height = frame_height + frame_padtop + frame_padbottom;
2973 ap->pix_fmt = frame_pix_fmt;
2974 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2975 ap->channel = video_channel;
2976 ap->standard = video_standard;
2978 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2980 ic->video_codec_id = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
2981 ic->audio_codec_id = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
2982 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
2983 ic->flags |= AVFMT_FLAG_NONBLOCK;
2985 if(pgmyuv_compatibility_hack)
2986 ic->video_codec_id= CODEC_ID_PGMYUV;
2988 /* open the input file with generic libav function */
2989 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2991 print_error(filename, err);
2997 for(i=0; i<ic->nb_streams; i++){
2998 ic->streams[i]->discard= AVDISCARD_ALL;
3000 for(i=0; i<ic->nb_programs; i++){
3001 AVProgram *p= ic->programs[i];
3002 if(p->id != opt_programid){
3003 p->discard = AVDISCARD_ALL;
3006 for(j=0; j<p->nb_stream_indexes; j++){
3007 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3012 fprintf(stderr, "Specified program id not found\n");
3018 ic->loop_input = loop_input;
3020 /* If not enough info to get the stream parameters, we decode the
3021 first frames to get it. (used in mpeg case for example) */
3022 ret = av_find_stream_info(ic);
3023 if (ret < 0 && verbose >= 0) {
3024 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3028 timestamp = start_time;
3029 /* add the stream start time */
3030 if (ic->start_time != AV_NOPTS_VALUE)
3031 timestamp += ic->start_time;
3033 /* if seeking requested, we execute it */
3034 if (start_time != 0) {
3035 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3037 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3038 filename, (double)timestamp / AV_TIME_BASE);
3040 /* reset seek info */
3044 /* update the current parameters so that they match the one of the input stream */
3045 for(i=0;i<ic->nb_streams;i++) {
3046 AVStream *st = ic->streams[i];
3047 AVCodecContext *enc = st->codec;
3048 avcodec_thread_init(enc, thread_count);
3049 switch(enc->codec_type) {
3050 case AVMEDIA_TYPE_AUDIO:
3051 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3052 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3053 channel_layout = enc->channel_layout;
3054 audio_channels = enc->channels;
3055 audio_sample_rate = enc->sample_rate;
3056 audio_sample_fmt = enc->sample_fmt;
3057 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3059 st->discard= AVDISCARD_ALL;
3061 case AVMEDIA_TYPE_VIDEO:
3062 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3063 frame_height = enc->height;
3064 frame_width = enc->width;
3065 if(ic->streams[i]->sample_aspect_ratio.num)
3066 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3068 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
3069 frame_aspect_ratio *= (float) enc->width / enc->height;
3070 frame_pix_fmt = enc->pix_fmt;
3071 rfps = ic->streams[i]->r_frame_rate.num;
3072 rfps_base = ic->streams[i]->r_frame_rate.den;
3074 enc->flags |= CODEC_FLAG_EMU_EDGE;
3075 frame_height >>= enc->lowres;
3076 frame_width >>= enc->lowres;
3079 enc->debug |= FF_DEBUG_MV;
3081 if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {
3084 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3085 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3087 (float)rfps / rfps_base, rfps, rfps_base);
3089 /* update the current frame rate to match the stream frame rate */
3090 frame_rate.num = rfps;
3091 frame_rate.den = rfps_base;
3093 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3095 st->discard= AVDISCARD_ALL;
3096 else if(video_discard)
3097 st->discard= video_discard;
3099 case AVMEDIA_TYPE_DATA:
3101 case AVMEDIA_TYPE_SUBTITLE:
3102 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3103 if(subtitle_disable)
3104 st->discard = AVDISCARD_ALL;
3106 case AVMEDIA_TYPE_ATTACHMENT:
3107 case AVMEDIA_TYPE_UNKNOWN:
3115 input_files[nb_input_files] = ic;
3116 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3117 /* dump the file content */
3119 dump_format(ic, nb_input_files, filename, 0);
3125 av_freep(&video_codec_name);
3126 av_freep(&audio_codec_name);
3127 av_freep(&subtitle_codec_name);
3130 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3131 int *has_subtitle_ptr)
3133 int has_video, has_audio, has_subtitle, i, j;
3134 AVFormatContext *ic;
3139 for(j=0;j<nb_input_files;j++) {
3140 ic = input_files[j];
3141 for(i=0;i<ic->nb_streams;i++) {
3142 AVCodecContext *enc = ic->streams[i]->codec;
3143 switch(enc->codec_type) {
3144 case AVMEDIA_TYPE_AUDIO:
3147 case AVMEDIA_TYPE_VIDEO:
3150 case AVMEDIA_TYPE_SUBTITLE:
3153 case AVMEDIA_TYPE_DATA:
3154 case AVMEDIA_TYPE_ATTACHMENT:
3155 case AVMEDIA_TYPE_UNKNOWN:
3162 *has_video_ptr = has_video;
3163 *has_audio_ptr = has_audio;
3164 *has_subtitle_ptr = has_subtitle;
3167 static void new_video_stream(AVFormatContext *oc)
3170 AVCodecContext *video_enc;
3171 enum CodecID codec_id;
3173 st = av_new_stream(oc, oc->nb_streams);
3175 fprintf(stderr, "Could not alloc stream\n");
3178 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3179 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3180 video_bitstream_filters= NULL;
3182 avcodec_thread_init(st->codec, thread_count);
3184 video_enc = st->codec;
3187 video_enc->codec_tag= video_codec_tag;
3189 if( (video_global_header&1)
3190 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3191 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3192 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3194 if(video_global_header&2){
3195 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3196 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3199 if (video_stream_copy) {
3200 st->stream_copy = 1;
3201 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3202 video_enc->sample_aspect_ratio =
3203 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3208 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3210 if (video_codec_name) {
3211 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3212 codec = avcodec_find_encoder_by_name(video_codec_name);
3213 output_codecs[nb_ocodecs] = codec;
3215 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3216 codec = avcodec_find_encoder(codec_id);
3219 video_enc->codec_id = codec_id;
3221 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3223 if (codec && codec->supported_framerates && !force_fps)
3224 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3225 video_enc->time_base.den = fps.num;
3226 video_enc->time_base.num = fps.den;
3228 video_enc->width = frame_width + frame_padright + frame_padleft;
3229 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3230 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3231 video_enc->pix_fmt = frame_pix_fmt;
3232 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3234 choose_pixel_fmt(st, codec);
3237 video_enc->gop_size = 0;
3238 if (video_qscale || same_quality) {
3239 video_enc->flags |= CODEC_FLAG_QSCALE;
3240 video_enc->global_quality=
3241 st->quality = FF_QP2LAMBDA * video_qscale;
3245 video_enc->intra_matrix = intra_matrix;
3247 video_enc->inter_matrix = inter_matrix;
3249 p= video_rc_override_string;
3252 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3254 fprintf(stderr, "error parsing rc_override\n");
3257 video_enc->rc_override=
3258 av_realloc(video_enc->rc_override,
3259 sizeof(RcOverride)*(i+1));
3260 video_enc->rc_override[i].start_frame= start;
3261 video_enc->rc_override[i].end_frame = end;
3263 video_enc->rc_override[i].qscale= q;
3264 video_enc->rc_override[i].quality_factor= 1.0;
3267 video_enc->rc_override[i].qscale= 0;
3268 video_enc->rc_override[i].quality_factor= -q/100.0;
3273 video_enc->rc_override_count=i;
3274 if (!video_enc->rc_initial_buffer_occupancy)
3275 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3276 video_enc->me_threshold= me_threshold;
3277 video_enc->intra_dc_precision= intra_dc_precision - 8;
3280 video_enc->flags|= CODEC_FLAG_PSNR;
3285 video_enc->flags |= CODEC_FLAG_PASS1;
3287 video_enc->flags |= CODEC_FLAG_PASS2;
3292 if (video_language) {
3293 av_metadata_set2(&st->metadata, "language", video_language, 0);
3294 av_freep(&video_language);
3297 /* reset some key parameters */
3299 av_freep(&video_codec_name);
3300 video_stream_copy = 0;
3301 frame_pix_fmt = PIX_FMT_NONE;
3304 static void new_audio_stream(AVFormatContext *oc)
3307 AVCodecContext *audio_enc;
3308 enum CodecID codec_id;
3310 st = av_new_stream(oc, oc->nb_streams);
3312 fprintf(stderr, "Could not alloc stream\n");
3315 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3317 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3318 audio_bitstream_filters= NULL;
3320 avcodec_thread_init(st->codec, thread_count);
3322 audio_enc = st->codec;
3323 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3326 audio_enc->codec_tag= audio_codec_tag;
3328 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3329 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3330 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3332 if (audio_stream_copy) {
3333 st->stream_copy = 1;
3334 audio_enc->channels = audio_channels;
3335 audio_enc->sample_rate = audio_sample_rate;
3339 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3341 if (audio_codec_name) {
3342 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3343 codec = avcodec_find_encoder_by_name(audio_codec_name);
3344 output_codecs[nb_ocodecs] = codec;
3346 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3347 codec = avcodec_find_encoder(codec_id);
3349 audio_enc->codec_id = codec_id;
3351 if (audio_qscale > QSCALE_NONE) {
3352 audio_enc->flags |= CODEC_FLAG_QSCALE;
3353 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3355 audio_enc->channels = audio_channels;
3356 audio_enc->sample_fmt = audio_sample_fmt;
3357 audio_enc->sample_rate = audio_sample_rate;
3358 audio_enc->channel_layout = channel_layout;
3359 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3360 audio_enc->channel_layout = 0;
3361 choose_sample_fmt(st, codec);
3362 choose_sample_rate(st, codec);
3365 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3366 if (audio_language) {
3367 av_metadata_set2(&st->metadata, "language", audio_language, 0);
3368 av_freep(&audio_language);
3371 /* reset some key parameters */
3373 av_freep(&audio_codec_name);
3374 audio_stream_copy = 0;
3377 static void new_subtitle_stream(AVFormatContext *oc)
3380 AVCodecContext *subtitle_enc;
3382 st = av_new_stream(oc, oc->nb_streams);
3384 fprintf(stderr, "Could not alloc stream\n");
3387 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3389 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3390 subtitle_bitstream_filters= NULL;
3392 subtitle_enc = st->codec;
3393 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3395 if(subtitle_codec_tag)
3396 subtitle_enc->codec_tag= subtitle_codec_tag;
3398 if (subtitle_stream_copy) {
3399 st->stream_copy = 1;
3401 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3402 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3403 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3407 if (subtitle_language) {
3408 av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3409 av_freep(&subtitle_language);
3412 subtitle_disable = 0;
3413 av_freep(&subtitle_codec_name);
3414 subtitle_stream_copy = 0;
3417 static void opt_new_audio_stream(void)
3419 AVFormatContext *oc;
3420 if (nb_output_files <= 0) {
3421 fprintf(stderr, "At least one output file must be specified\n");
3424 oc = output_files[nb_output_files - 1];
3425 new_audio_stream(oc);
3428 static void opt_new_video_stream(void)
3430 AVFormatContext *oc;
3431 if (nb_output_files <= 0) {
3432 fprintf(stderr, "At least one output file must be specified\n");
3435 oc = output_files[nb_output_files - 1];
3436 new_video_stream(oc);
3439 static void opt_new_subtitle_stream(void)
3441 AVFormatContext *oc;
3442 if (nb_output_files <= 0) {
3443 fprintf(stderr, "At least one output file must be specified\n");
3446 oc = output_files[nb_output_files - 1];
3447 new_subtitle_stream(oc);
3450 static void opt_output_file(const char *filename)
3452 AVFormatContext *oc;
3453 int err, use_video, use_audio, use_subtitle;
3454 int input_has_video, input_has_audio, input_has_subtitle;
3455 AVFormatParameters params, *ap = ¶ms;
3456 AVOutputFormat *file_oformat;
3458 if (!strcmp(filename, "-"))
3461 oc = avformat_alloc_context();
3463 print_error(filename, AVERROR(ENOMEM));
3467 if (last_asked_format) {
3468 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3469 if (!file_oformat) {
3470 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3473 last_asked_format = NULL;
3475 file_oformat = av_guess_format(NULL, filename, NULL);
3476 if (!file_oformat) {
3477 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3483 oc->oformat = file_oformat;
3484 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3486 if (!strcmp(file_oformat->name, "ffm") &&
3487 av_strstart(filename, "http:", NULL)) {
3488 /* special case for files sent to ffserver: we get the stream
3489 parameters from ffserver */
3490 int err = read_ffserver_streams(oc, filename);
3492 print_error(filename, err);
3496 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3497 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3498 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3500 /* disable if no corresponding type found and at least one
3502 if (nb_input_files > 0) {
3503 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3504 &input_has_subtitle);
3505 if (!input_has_video)
3507 if (!input_has_audio)
3509 if (!input_has_subtitle)
3513 /* manual disable */
3514 if (audio_disable) {
3517 if (video_disable) {
3520 if (subtitle_disable) {
3525 new_video_stream(oc);
3529 new_audio_stream(oc);
3533 new_subtitle_stream(oc);
3536 oc->timestamp = rec_timestamp;
3538 for(; metadata_count>0; metadata_count--){
3539 av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3540 metadata[metadata_count-1].value, 0);
3542 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3545 output_files[nb_output_files++] = oc;
3547 /* check filename in case of an image number is expected */
3548 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3549 if (!av_filename_number_test(oc->filename)) {
3550 print_error(oc->filename, AVERROR_NUMEXPECTED);
3555 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3556 /* test if it already exists to avoid loosing precious files */
3557 if (!file_overwrite &&
3558 (strchr(filename, ':') == NULL ||
3559 filename[1] == ':' ||
3560 av_strstart(filename, "file:", NULL))) {
3561 if (url_exist(filename)) {
3563 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3565 if (!read_yesno()) {
3566 fprintf(stderr, "Not overwriting - exiting\n");
3571 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3578 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3579 print_error(filename, err);
3584 memset(ap, 0, sizeof(*ap));
3585 if (av_set_parameters(oc, ap) < 0) {
3586 fprintf(stderr, "%s: Invalid encoding parameters\n",
3591 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3592 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3593 oc->loop_output = loop_output;
3594 oc->flags |= AVFMT_FLAG_NONBLOCK;
3596 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3599 /* same option as mencoder */
3600 static void opt_pass(const char *pass_str)
3603 pass = atoi(pass_str);
3604 if (pass != 1 && pass != 2) {
3605 fprintf(stderr, "pass number can be only 1 or 2\n");
3611 static int64_t getutime(void)
3614 struct rusage rusage;
3616 getrusage(RUSAGE_SELF, &rusage);
3617 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3618 #elif HAVE_GETPROCESSTIMES
3620 FILETIME c, e, k, u;
3621 proc = GetCurrentProcess();
3622 GetProcessTimes(proc, &c, &e, &k, &u);
3623 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3625 return av_gettime();
3629 static int64_t getmaxrss(void)
3631 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3632 struct rusage rusage;
3633 getrusage(RUSAGE_SELF, &rusage);
3634 return (int64_t)rusage.ru_maxrss * 1024;
3635 #elif HAVE_GETPROCESSMEMORYINFO
3637 PROCESS_MEMORY_COUNTERS memcounters;
3638 proc = GetCurrentProcess();
3639 memcounters.cb = sizeof(memcounters);
3640 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3641 return memcounters.PeakPagefileUsage;
3647 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3650 const char *p = str;
3657 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3664 static void opt_inter_matrix(const char *arg)
3666 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3667 parse_matrix_coeffs(inter_matrix, arg);
3670 static void opt_intra_matrix(const char *arg)
3672 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3673 parse_matrix_coeffs(intra_matrix, arg);
3677 * Trivial log callback.
3678 * Only suitable for show_help and similar since it lacks prefix handling.
3680 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3682 vfprintf(stdout, fmt, vl);
3685 static void show_usage(void)
3687 printf("Hyper fast Audio and Video encoder\n");
3688 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3692 static void show_help(void)
3694 av_log_set_callback(log_callback_help);
3696 show_help_options(options, "Main options:\n",
3697 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3698 show_help_options(options, "\nAdvanced options:\n",
3699 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3701 show_help_options(options, "\nVideo options:\n",
3702 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3704 show_help_options(options, "\nAdvanced Video options:\n",
3705 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3706 OPT_VIDEO | OPT_EXPERT);
3707 show_help_options(options, "\nAudio options:\n",
3708 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3710 show_help_options(options, "\nAdvanced Audio options:\n",
3711 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3712 OPT_AUDIO | OPT_EXPERT);
3713 show_help_options(options, "\nSubtitle options:\n",
3714 OPT_SUBTITLE | OPT_GRAB,
3716 show_help_options(options, "\nAudio/Video grab options:\n",
3720 av_opt_show(avcodec_opts[0], NULL);
3722 av_opt_show(avformat_opts, NULL);
3724 av_opt_show(sws_opts, NULL);
3727 static void opt_target(const char *arg)
3729 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3730 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3732 if(!strncmp(arg, "pal-", 4)) {
3735 } else if(!strncmp(arg, "ntsc-", 5)) {
3738 } else if(!strncmp(arg, "film-", 5)) {
3743 /* Calculate FR via float to avoid int overflow */
3744 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3747 } else if((fr == 29970) || (fr == 23976)) {
3750 /* Try to determine PAL/NTSC by peeking in the input files */
3751 if(nb_input_files) {
3753 for(j = 0; j < nb_input_files; j++) {
3754 for(i = 0; i < input_files[j]->nb_streams; i++) {
3755 AVCodecContext *c = input_files[j]->streams[i]->codec;
3756 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3758 fr = c->time_base.den * 1000 / c->time_base.num;
3762 } else if((fr == 29970) || (fr == 23976)) {
3772 if(verbose && norm != UNKNOWN)
3773 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3776 if(norm == UNKNOWN) {
3777 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3778 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3779 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3783 if(!strcmp(arg, "vcd")) {
3785 opt_video_codec("mpeg1video");
3786 opt_audio_codec("mp2");
3789 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3790 opt_frame_rate(NULL, frame_rates[norm]);
3791 opt_default("g", norm == PAL ? "15" : "18");
3793 opt_default("b", "1150000");
3794 opt_default("maxrate", "1150000");
3795 opt_default("minrate", "1150000");
3796 opt_default("bufsize", "327680"); // 40*1024*8;
3798 opt_default("ab", "224000");
3799 audio_sample_rate = 44100;
3802 opt_default("packetsize", "2324");
3803 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3805 /* We have to offset the PTS, so that it is consistent with the SCR.
3806 SCR starts at 36000, but the first two packs contain only padding
3807 and the first pack from the other stream, respectively, may also have
3808 been written before.
3809 So the real data starts at SCR 36000+3*1200. */
3810 mux_preload= (36000+3*1200) / 90000.0; //0.44
3811 } else if(!strcmp(arg, "svcd")) {
3813 opt_video_codec("mpeg2video");
3814 opt_audio_codec("mp2");
3817 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3818 opt_frame_rate(NULL, frame_rates[norm]);
3819 opt_default("g", norm == PAL ? "15" : "18");
3821 opt_default("b", "2040000");
3822 opt_default("maxrate", "2516000");
3823 opt_default("minrate", "0"); //1145000;
3824 opt_default("bufsize", "1835008"); //224*1024*8;
3825 opt_default("flags", "+scan_offset");
3828 opt_default("ab", "224000");
3829 audio_sample_rate = 44100;
3831 opt_default("packetsize", "2324");
3833 } else if(!strcmp(arg, "dvd")) {
3835 opt_video_codec("mpeg2video");
3836 opt_audio_codec("ac3");
3839 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3840 opt_frame_rate(NULL, frame_rates[norm]);
3841 opt_default("g", norm == PAL ? "15" : "18");
3843 opt_default("b", "6000000");
3844 opt_default("maxrate", "9000000");
3845 opt_default("minrate", "0"); //1500000;
3846 opt_default("bufsize", "1835008"); //224*1024*8;
3848 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3849 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3851 opt_default("ab", "448000");
3852 audio_sample_rate = 48000;
3854 } else if(!strncmp(arg, "dv", 2)) {
3858 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3859 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3860 (norm == PAL ? "yuv420p" : "yuv411p"));
3861 opt_frame_rate(NULL, frame_rates[norm]);
3863 audio_sample_rate = 48000;
3867 fprintf(stderr, "Unknown target: %s\n", arg);
3872 static void opt_vstats_file (const char *arg)
3874 av_free (vstats_filename);
3875 vstats_filename=av_strdup (arg);
3878 static void opt_vstats (void)
3881 time_t today2 = time(NULL);
3882 struct tm *today = localtime(&today2);
3884 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3886 opt_vstats_file(filename);
3889 static int opt_bsf(const char *opt, const char *arg)
3891 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3892 AVBitStreamFilterContext **bsfp;
3895 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3899 bsfp= *opt == 'v' ? &video_bitstream_filters :
3900 *opt == 'a' ? &audio_bitstream_filters :
3901 &subtitle_bitstream_filters;
3903 bsfp= &(*bsfp)->next;
3910 static int opt_preset(const char *opt, const char *arg)
3913 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3915 const char *base[3]= { getenv("FFMPEG_DATADIR"),
3921 for(i=0; i<3 && !f; i++){
3924 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
3925 f= fopen(filename, "r");
3927 char *codec_name= *opt == 'v' ? video_codec_name :
3928 *opt == 'a' ? audio_codec_name :
3929 subtitle_codec_name;
3930 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
3931 f= fopen(filename, "r");
3935 av_strlcpy(filename, arg, sizeof(filename));
3936 f= fopen(filename, "r");
3940 fprintf(stderr, "File for preset '%s' not found\n", arg);
3945 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3946 if(line[0] == '#' && !e)
3948 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3950 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3953 if(!strcmp(tmp, "acodec")){
3954 opt_audio_codec(tmp2);
3955 }else if(!strcmp(tmp, "vcodec")){
3956 opt_video_codec(tmp2);
3957 }else if(!strcmp(tmp, "scodec")){
3958 opt_subtitle_codec(tmp2);
3959 }else if(opt_default(tmp, tmp2) < 0){
3960 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3970 static const OptionDef options[] = {
3972 #include "cmdutils_common_opts.h"
3973 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3974 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3975 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3976 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3977 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3978 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3979 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3980 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3981 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3982 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3983 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3984 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3985 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
3986 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3987 "add timings for benchmarking" },
3988 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3989 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3990 "dump each input packet" },
3991 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3992 "when dumping packets, also dump the payload" },
3993 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3994 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3995 { "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)", "" },
3996 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3997 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3998 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3999 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4000 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4001 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4002 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4003 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4004 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4005 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4006 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4007 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4008 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4011 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4012 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4013 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4014 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4015 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4016 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4017 { "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" },
4018 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4019 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4020 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4021 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4022 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4023 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4024 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4025 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4026 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4027 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4028 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4029 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4030 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4031 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4032 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4033 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4034 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4035 "use same video quality as source (implies VBR)" },
4036 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4037 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4038 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4039 "deinterlace pictures" },
4040 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4041 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4042 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4043 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4044 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4045 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4046 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4047 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4048 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4049 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4050 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4051 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4054 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4055 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4056 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4057 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4058 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4059 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4060 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4061 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4062 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4063 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4064 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4065 { "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" },
4067 /* subtitle options */
4068 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4069 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4070 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4071 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4072 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4075 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4076 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4077 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4080 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4081 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4083 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4084 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4085 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4087 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4088 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4089 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4090 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4092 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4096 int main(int argc, char **argv)
4101 avcodec_register_all();
4103 avdevice_register_all();
4108 if(isatty(STDIN_FILENO))
4109 url_set_interrupt_cb(decode_interrupt_cb);
4112 for(i=0; i<AVMEDIA_TYPE_NB; i++){
4113 avcodec_opts[i]= avcodec_alloc_context2(i);
4115 avformat_opts = avformat_alloc_context();
4116 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4121 parse_options(argc, argv, options, opt_output_file);
4123 if(nb_output_files <= 0 && nb_input_files == 0) {
4125 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4129 /* file converter / grab */
4130 if (nb_output_files <= 0) {
4131 fprintf(stderr, "At least one output file must be specified\n");
4135 if (nb_input_files == 0) {
4136 fprintf(stderr, "At least one input file must be specified\n");
4141 if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4142 stream_maps, nb_stream_maps) < 0)
4144 ti = getutime() - ti;
4146 int maxrss = getmaxrss() / 1024;
4147 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);