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_pixel_fmt(AVStream *st, AVCodec *codec)
490 if(codec && codec->pix_fmts){
491 const enum PixelFormat *p= codec->pix_fmts;
493 if(*p == st->codec->pix_fmt)
497 && !( st->codec->codec_id==CODEC_ID_MJPEG
498 && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL
499 && ( st->codec->pix_fmt == PIX_FMT_YUV420P
500 || st->codec->pix_fmt == PIX_FMT_YUV422P)))
501 st->codec->pix_fmt = codec->pix_fmts[0];
505 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
511 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
514 /* copy stream format */
515 s->nb_streams = ic->nb_streams;
516 for(i=0;i<ic->nb_streams;i++) {
520 // FIXME: a more elegant solution is needed
521 st = av_mallocz(sizeof(AVStream));
522 memcpy(st, ic->streams[i], sizeof(AVStream));
523 st->codec = avcodec_alloc_context();
525 print_error(filename, AVERROR(ENOMEM));
528 avcodec_copy_context(st->codec, ic->streams[i]->codec);
531 codec = avcodec_find_encoder(st->codec->codec_id);
532 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
533 if (audio_stream_copy) {
536 choose_sample_fmt(st, codec);
537 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
538 if (video_stream_copy) {
541 choose_pixel_fmt(st, codec);
544 if(!st->codec->thread_count)
545 st->codec->thread_count = 1;
546 if(st->codec->thread_count>1)
547 avcodec_thread_init(st->codec, st->codec->thread_count);
549 if(st->codec->flags & CODEC_FLAG_BITEXACT)
554 s->timestamp = av_gettime();
556 av_close_input_file(ic);
561 get_sync_ipts(const AVOutputStream *ost)
563 const AVInputStream *ist = ost->sync_ist;
564 return (double)(ist->pts - start_time)/AV_TIME_BASE;
567 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
571 AVPacket new_pkt= *pkt;
572 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
573 &new_pkt.data, &new_pkt.size,
574 pkt->data, pkt->size,
575 pkt->flags & AV_PKT_FLAG_KEY);
578 new_pkt.destruct= av_destruct_packet;
580 fprintf(stderr, "%s failed for stream %d, codec %s",
581 bsfc->filter->name, pkt->stream_index,
582 avctx->codec ? avctx->codec->name : "copy");
592 ret= av_interleaved_write_frame(s, pkt);
594 print_error("av_interleaved_write_frame()", ret);
599 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
601 static void do_audio_out(AVFormatContext *s,
604 unsigned char *buf, int size)
607 int64_t audio_out_size, audio_buf_size;
608 int64_t allocated_for_size= size;
610 int size_out, frame_bytes, ret;
611 AVCodecContext *enc= ost->st->codec;
612 AVCodecContext *dec= ist->st->codec;
613 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
614 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
615 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
618 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
619 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
620 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
621 audio_buf_size*= osize*enc->channels;
623 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
624 if(coded_bps > 8*osize)
625 audio_out_size= audio_out_size * coded_bps / (8*osize);
626 audio_out_size += FF_MIN_BUFFER_SIZE;
628 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
629 fprintf(stderr, "Buffer sizes too large\n");
633 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
634 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
635 if (!audio_buf || !audio_out){
636 fprintf(stderr, "Out of memory in do_audio_out\n");
640 if (enc->channels != dec->channels)
641 ost->audio_resample = 1;
643 if (ost->audio_resample && !ost->resample) {
644 if (dec->sample_fmt != SAMPLE_FMT_S16)
645 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
646 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
647 enc->sample_rate, dec->sample_rate,
648 enc->sample_fmt, dec->sample_fmt,
650 if (!ost->resample) {
651 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
652 dec->channels, dec->sample_rate,
653 enc->channels, enc->sample_rate);
658 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
659 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
660 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
661 if (ost->reformat_ctx)
662 av_audio_convert_free(ost->reformat_ctx);
663 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
664 dec->sample_fmt, 1, NULL, 0);
665 if (!ost->reformat_ctx) {
666 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
667 avcodec_get_sample_fmt_name(dec->sample_fmt),
668 avcodec_get_sample_fmt_name(enc->sample_fmt));
671 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
674 if(audio_sync_method){
675 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
676 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
677 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
678 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
680 //FIXME resample delay
681 if(fabs(delta) > 50){
682 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
684 byte_delta= FFMAX(byte_delta, -size);
688 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
693 static uint8_t *input_tmp= NULL;
694 input_tmp= av_realloc(input_tmp, byte_delta + size);
696 if(byte_delta > allocated_for_size - size){
697 allocated_for_size= byte_delta + (int64_t)size;
702 memset(input_tmp, 0, byte_delta);
703 memcpy(input_tmp + byte_delta, buf, size);
707 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
709 }else if(audio_sync_method>1){
710 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
711 assert(ost->audio_resample);
713 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
714 // 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));
715 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
719 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
720 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
722 if (ost->audio_resample) {
724 size_out = audio_resample(ost->resample,
725 (short *)buftmp, (short *)buf,
726 size / (ist->st->codec->channels * isize));
727 size_out = size_out * enc->channels * osize;
733 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
734 const void *ibuf[6]= {buftmp};
735 void *obuf[6]= {audio_buf};
736 int istride[6]= {isize};
737 int ostride[6]= {osize};
738 int len= size_out/istride[0];
739 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
740 printf("av_audio_convert() failed\n");
746 size_out = len*osize;
749 /* now encode as many frames as possible */
750 if (enc->frame_size > 1) {
751 /* output resampled raw samples */
752 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
753 fprintf(stderr, "av_fifo_realloc2() failed\n");
756 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
758 frame_bytes = enc->frame_size * osize * enc->channels;
760 while (av_fifo_size(ost->fifo) >= frame_bytes) {
762 av_init_packet(&pkt);
764 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
766 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
768 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
771 fprintf(stderr, "Audio encoding failed\n");
775 pkt.stream_index= ost->index;
778 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
779 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
780 pkt.flags |= AV_PKT_FLAG_KEY;
781 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
783 ost->sync_opts += enc->frame_size;
787 av_init_packet(&pkt);
789 ost->sync_opts += size_out / (osize * enc->channels);
791 /* output a pcm frame */
792 /* determine the size of the coded buffer */
795 size_out = size_out*coded_bps/8;
797 if(size_out > audio_out_size){
798 fprintf(stderr, "Internal error, buffer size too small\n");
802 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
803 ret = avcodec_encode_audio(enc, audio_out, size_out,
806 fprintf(stderr, "Audio encoding failed\n");
810 pkt.stream_index= ost->index;
813 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
814 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
815 pkt.flags |= AV_PKT_FLAG_KEY;
816 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
820 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
824 AVPicture picture_tmp;
827 dec = ist->st->codec;
829 /* deinterlace : must be done before any resize */
830 if (do_deinterlace) {
833 /* create temporary picture */
834 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
835 buf = av_malloc(size);
839 picture2 = &picture_tmp;
840 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
842 if(avpicture_deinterlace(picture2, picture,
843 dec->pix_fmt, dec->width, dec->height) < 0) {
844 /* if error, do not deinterlace */
845 fprintf(stderr, "Deinterlacing failed\n");
854 if (picture != picture2)
855 *picture = *picture2;
859 /* we begin to correct av delay at this threshold */
860 #define AV_DELAY_MAX 0.100
862 static void do_subtitle_out(AVFormatContext *s,
868 static uint8_t *subtitle_out = NULL;
869 int subtitle_out_max_size = 1024 * 1024;
870 int subtitle_out_size, nb, i;
874 if (pts == AV_NOPTS_VALUE) {
875 fprintf(stderr, "Subtitle packets must have a pts\n");
881 enc = ost->st->codec;
884 subtitle_out = av_malloc(subtitle_out_max_size);
887 /* Note: DVB subtitle need one packet to draw them and one other
888 packet to clear them */
889 /* XXX: signal it in the codec context ? */
890 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
895 for(i = 0; i < nb; i++) {
896 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
897 // start_display_time is required to be 0
898 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
899 sub->end_display_time -= sub->start_display_time;
900 sub->start_display_time = 0;
901 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
902 subtitle_out_max_size, sub);
903 if (subtitle_out_size < 0) {
904 fprintf(stderr, "Subtitle encoding failed\n");
908 av_init_packet(&pkt);
909 pkt.stream_index = ost->index;
910 pkt.data = subtitle_out;
911 pkt.size = subtitle_out_size;
912 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
913 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
914 /* XXX: the pts correction is handled here. Maybe handling
915 it in the codec would be better */
917 pkt.pts += 90 * sub->start_display_time;
919 pkt.pts += 90 * sub->end_display_time;
921 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
925 static int bit_buffer_size= 1024*256;
926 static uint8_t *bit_buffer= NULL;
928 static void do_video_out(AVFormatContext *s,
934 int nb_frames, i, ret;
935 int64_t topBand, bottomBand, leftBand, rightBand;
936 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
937 AVFrame picture_crop_temp, picture_pad_temp;
938 AVCodecContext *enc, *dec;
941 avcodec_get_frame_defaults(&picture_crop_temp);
942 avcodec_get_frame_defaults(&picture_pad_temp);
944 enc = ost->st->codec;
945 dec = ist->st->codec;
947 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
949 /* by default, we output a single frame */
954 if(video_sync_method){
955 double vdelta = sync_ipts - ost->sync_opts;
956 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
959 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
963 ost->sync_opts= lrintf(sync_ipts);
964 }else if (vdelta > 1.1)
965 nb_frames = lrintf(vdelta);
966 //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);
970 fprintf(stderr, "*** drop!\n");
971 }else if (nb_frames > 1) {
972 nb_frames_dup += nb_frames - 1;
974 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
977 ost->sync_opts= lrintf(sync_ipts);
979 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
983 if (ost->video_crop) {
984 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
985 fprintf(stderr, "error cropping picture\n");
990 formatted_picture = &picture_crop_temp;
992 formatted_picture = in_picture;
995 final_picture = formatted_picture;
996 padding_src = formatted_picture;
997 resampling_dst = &ost->pict_tmp;
998 if (ost->video_pad) {
999 final_picture = &ost->pict_tmp;
1000 if (ost->video_resample) {
1001 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
1002 fprintf(stderr, "error padding picture\n");
1007 resampling_dst = &picture_pad_temp;
1011 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1012 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1013 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1015 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));
1016 if(!ost->video_resample)
1020 if (ost->video_resample) {
1022 final_picture = &ost->pict_tmp;
1023 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
1024 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
1025 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1027 /* keep bands proportional to the frame size */
1028 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
1029 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1030 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
1031 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
1033 /* sanity check to ensure no bad band sizes sneak in */
1034 assert(topBand <= INT_MAX && topBand >= 0);
1035 assert(bottomBand <= INT_MAX && bottomBand >= 0);
1036 assert(leftBand <= INT_MAX && leftBand >= 0);
1037 assert(rightBand <= INT_MAX && rightBand >= 0);
1039 ost->topBand = topBand;
1040 ost->bottomBand = bottomBand;
1041 ost->leftBand = leftBand;
1042 ost->rightBand = rightBand;
1044 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
1045 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
1046 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1048 /* initialize a new scaler context */
1049 sws_freeContext(ost->img_resample_ctx);
1050 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1051 ost->img_resample_ctx = sws_getContext(
1052 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1053 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1054 ist->st->codec->pix_fmt,
1055 ost->st->codec->width - (ost->padleft + ost->padright),
1056 ost->st->codec->height - (ost->padtop + ost->padbottom),
1057 ost->st->codec->pix_fmt,
1058 sws_flags, NULL, NULL, NULL);
1059 if (ost->img_resample_ctx == NULL) {
1060 fprintf(stderr, "Cannot get resampling context\n");
1064 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1065 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1068 if (ost->video_pad) {
1069 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1070 enc->height, enc->width, enc->pix_fmt,
1071 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1074 /* duplicates frame if needed */
1075 for(i=0;i<nb_frames;i++) {
1077 av_init_packet(&pkt);
1078 pkt.stream_index= ost->index;
1080 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1081 /* raw pictures are written as AVPicture structure to
1082 avoid any copies. We support temorarily the older
1084 AVFrame* old_frame = enc->coded_frame;
1085 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1086 pkt.data= (uint8_t *)final_picture;
1087 pkt.size= sizeof(AVPicture);
1088 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1089 pkt.flags |= AV_PKT_FLAG_KEY;
1091 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1092 enc->coded_frame = old_frame;
1094 AVFrame big_picture;
1096 big_picture= *final_picture;
1097 /* better than nothing: use input picture interlaced
1099 big_picture.interlaced_frame = in_picture->interlaced_frame;
1100 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1101 if(top_field_first == -1)
1102 big_picture.top_field_first = in_picture->top_field_first;
1104 big_picture.top_field_first = top_field_first;
1107 /* handles sameq here. This is not correct because it may
1108 not be a global option */
1110 big_picture.quality = ist->st->quality;
1112 big_picture.quality = ost->st->quality;
1114 big_picture.pict_type = 0;
1115 // big_picture.pts = AV_NOPTS_VALUE;
1116 big_picture.pts= ost->sync_opts;
1117 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1118 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1119 ret = avcodec_encode_video(enc,
1120 bit_buffer, bit_buffer_size,
1123 fprintf(stderr, "Video encoding failed\n");
1128 pkt.data= bit_buffer;
1130 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1131 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1132 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1133 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1134 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1136 if(enc->coded_frame->key_frame)
1137 pkt.flags |= AV_PKT_FLAG_KEY;
1138 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1141 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1142 // enc->frame_number-1, ret, enc->pict_type);
1143 /* if two pass, output log */
1144 if (ost->logfile && enc->stats_out) {
1145 fprintf(ost->logfile, "%s", enc->stats_out);
1150 ost->frame_number++;
1154 static double psnr(double d){
1155 return -10.0*log(d)/log(10.0);
1158 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1161 AVCodecContext *enc;
1163 double ti1, bitrate, avg_bitrate;
1165 /* this is executed just the first time do_video_stats is called */
1167 vstats_file = fopen(vstats_filename, "w");
1174 enc = ost->st->codec;
1175 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1176 frame_number = ost->frame_number;
1177 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1178 if (enc->flags&CODEC_FLAG_PSNR)
1179 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1181 fprintf(vstats_file,"f_size= %6d ", frame_size);
1182 /* compute pts value */
1183 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1187 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1188 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1189 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1190 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1191 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1195 static void print_report(AVFormatContext **output_files,
1196 AVOutputStream **ost_table, int nb_ostreams,
1200 AVOutputStream *ost;
1201 AVFormatContext *oc;
1203 AVCodecContext *enc;
1204 int frame_number, vid, i;
1205 double bitrate, ti1, pts;
1206 static int64_t last_time = -1;
1207 static int qp_histogram[52];
1209 if (!is_last_report) {
1211 /* display the report every 0.5 seconds */
1212 cur_time = av_gettime();
1213 if (last_time == -1) {
1214 last_time = cur_time;
1217 if ((cur_time - last_time) < 500000)
1219 last_time = cur_time;
1223 oc = output_files[0];
1225 total_size = url_fsize(oc->pb);
1226 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1227 total_size= url_ftell(oc->pb);
1232 for(i=0;i<nb_ostreams;i++) {
1234 enc = ost->st->codec;
1235 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1236 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1237 !ost->st->stream_copy ?
1238 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1240 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1241 float t = (av_gettime()-timer_start) / 1000000.0;
1243 frame_number = ost->frame_number;
1244 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1245 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1246 !ost->st->stream_copy ?
1247 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1249 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1252 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1253 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1256 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1258 if (enc->flags&CODEC_FLAG_PSNR){
1260 double error, error_sum=0;
1261 double scale, scale_sum=0;
1262 char type[3]= {'Y','U','V'};
1263 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1266 error= enc->error[j];
1267 scale= enc->width*enc->height*255.0*255.0*frame_number;
1269 error= enc->coded_frame->error[j];
1270 scale= enc->width*enc->height*255.0*255.0;
1275 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1277 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1281 /* compute min output value */
1282 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1283 if ((pts < ti1) && (pts > 0))
1289 if (verbose || is_last_report) {
1290 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1292 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1293 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1294 (double)total_size / 1024, ti1, bitrate);
1296 if (nb_frames_dup || nb_frames_drop)
1297 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1298 nb_frames_dup, nb_frames_drop);
1301 fprintf(stderr, "%s \r", buf);
1306 if (is_last_report && verbose >= 0){
1307 int64_t raw= audio_size + video_size + extra_size;
1308 fprintf(stderr, "\n");
1309 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1313 100.0*(total_size - raw)/raw
1318 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1319 static int output_packet(AVInputStream *ist, int ist_index,
1320 AVOutputStream **ost_table, int nb_ostreams,
1321 const AVPacket *pkt)
1323 AVFormatContext *os;
1324 AVOutputStream *ost;
1328 void *buffer_to_free;
1329 static unsigned int samples_size= 0;
1330 AVSubtitle subtitle, *subtitle_to_free;
1333 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1335 if(ist->next_pts == AV_NOPTS_VALUE)
1336 ist->next_pts= ist->pts;
1340 av_init_packet(&avpkt);
1348 if(pkt->dts != AV_NOPTS_VALUE)
1349 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1351 //while we have more to decode or while the decoder did output something on EOF
1352 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1353 uint8_t *data_buf, *decoded_data_buf;
1354 int data_size, decoded_data_size;
1356 ist->pts= ist->next_pts;
1358 if(avpkt.size && avpkt.size != pkt->size &&
1359 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1360 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1361 ist->showed_multi_packet_warning=1;
1364 /* decode the packet if needed */
1365 decoded_data_buf = NULL; /* fail safe */
1366 decoded_data_size= 0;
1367 data_buf = avpkt.data;
1368 data_size = avpkt.size;
1369 subtitle_to_free = NULL;
1370 if (ist->decoding_needed) {
1371 switch(ist->st->codec->codec_type) {
1372 case AVMEDIA_TYPE_AUDIO:{
1373 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1374 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1376 samples= av_malloc(samples_size);
1378 decoded_data_size= samples_size;
1379 /* XXX: could avoid copy if PCM 16 bits with same
1380 endianness as CPU */
1381 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1388 /* Some bug in mpeg audio decoder gives */
1389 /* decoded_data_size < 0, it seems they are overflows */
1390 if (decoded_data_size <= 0) {
1391 /* no audio frame */
1394 decoded_data_buf = (uint8_t *)samples;
1395 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1396 (ist->st->codec->sample_rate * ist->st->codec->channels);
1398 case AVMEDIA_TYPE_VIDEO:
1399 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1400 /* XXX: allocate picture correctly */
1401 avcodec_get_frame_defaults(&picture);
1403 ret = avcodec_decode_video2(ist->st->codec,
1404 &picture, &got_picture, &avpkt);
1405 ist->st->quality= picture.quality;
1409 /* no picture yet */
1410 goto discard_packet;
1412 if (ist->st->codec->time_base.num != 0) {
1413 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1414 ist->next_pts += ((int64_t)AV_TIME_BASE *
1415 ist->st->codec->time_base.num * ticks) /
1416 ist->st->codec->time_base.den;
1420 case AVMEDIA_TYPE_SUBTITLE:
1421 ret = avcodec_decode_subtitle2(ist->st->codec,
1422 &subtitle, &got_subtitle, &avpkt);
1425 if (!got_subtitle) {
1426 goto discard_packet;
1428 subtitle_to_free = &subtitle;
1435 switch(ist->st->codec->codec_type) {
1436 case AVMEDIA_TYPE_AUDIO:
1437 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1438 ist->st->codec->sample_rate;
1440 case AVMEDIA_TYPE_VIDEO:
1441 if (ist->st->codec->time_base.num != 0) {
1442 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1443 ist->next_pts += ((int64_t)AV_TIME_BASE *
1444 ist->st->codec->time_base.num * ticks) /
1445 ist->st->codec->time_base.den;
1453 buffer_to_free = NULL;
1454 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1455 pre_process_video_frame(ist, (AVPicture *)&picture,
1459 // preprocess audio (volume)
1460 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1461 if (audio_volume != 256) {
1464 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1465 int v = ((*volp) * audio_volume + 128) >> 8;
1466 if (v < -32768) v = -32768;
1467 if (v > 32767) v = 32767;
1473 /* frame rate emulation */
1475 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1476 int64_t now = av_gettime() - ist->start;
1481 /* if output time reached then transcode raw format,
1482 encode packets and output them */
1483 if (start_time == 0 || ist->pts >= start_time)
1484 for(i=0;i<nb_ostreams;i++) {
1488 if (ost->source_index == ist_index) {
1489 os = output_files[ost->file_index];
1491 /* set the input output pts pairs */
1492 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1494 if (ost->encoding_needed) {
1495 assert(ist->decoding_needed);
1496 switch(ost->st->codec->codec_type) {
1497 case AVMEDIA_TYPE_AUDIO:
1498 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1500 case AVMEDIA_TYPE_VIDEO:
1501 do_video_out(os, ost, ist, &picture, &frame_size);
1502 if (vstats_filename && frame_size)
1503 do_video_stats(os, ost, frame_size);
1505 case AVMEDIA_TYPE_SUBTITLE:
1506 do_subtitle_out(os, ost, ist, &subtitle,
1513 AVFrame avframe; //FIXME/XXX remove this
1515 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1517 av_init_packet(&opkt);
1519 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1522 /* no reencoding needed : output the packet directly */
1523 /* force the input stream PTS */
1525 avcodec_get_frame_defaults(&avframe);
1526 ost->st->codec->coded_frame= &avframe;
1527 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1529 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1530 audio_size += data_size;
1531 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1532 video_size += data_size;
1536 opkt.stream_index= ost->index;
1537 if(pkt->pts != AV_NOPTS_VALUE)
1538 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1540 opkt.pts= AV_NOPTS_VALUE;
1542 if (pkt->dts == AV_NOPTS_VALUE)
1543 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1545 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1546 opkt.dts -= ost_tb_start_time;
1548 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1549 opkt.flags= pkt->flags;
1551 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1552 if( ost->st->codec->codec_id != CODEC_ID_H264
1553 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1554 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1556 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1557 opkt.destruct= av_destruct_packet;
1559 opkt.data = data_buf;
1560 opkt.size = data_size;
1563 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1564 ost->st->codec->frame_number++;
1565 ost->frame_number++;
1566 av_free_packet(&opkt);
1570 av_free(buffer_to_free);
1571 /* XXX: allocate the subtitles in the codec ? */
1572 if (subtitle_to_free) {
1573 if (subtitle_to_free->rects != NULL) {
1574 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1575 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1576 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1577 av_freep(&subtitle_to_free->rects[i]);
1579 av_freep(&subtitle_to_free->rects);
1581 subtitle_to_free->num_rects = 0;
1582 subtitle_to_free = NULL;
1589 for(i=0;i<nb_ostreams;i++) {
1591 if (ost->source_index == ist_index) {
1592 AVCodecContext *enc= ost->st->codec;
1593 os = output_files[ost->file_index];
1595 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1597 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1600 if (ost->encoding_needed) {
1604 av_init_packet(&pkt);
1605 pkt.stream_index= ost->index;
1607 switch(ost->st->codec->codec_type) {
1608 case AVMEDIA_TYPE_AUDIO:
1609 fifo_bytes = av_fifo_size(ost->fifo);
1611 /* encode any samples remaining in fifo */
1612 if (fifo_bytes > 0) {
1613 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1614 int fs_tmp = enc->frame_size;
1616 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1617 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1618 enc->frame_size = fifo_bytes / (osize * enc->channels);
1620 int frame_bytes = enc->frame_size*osize*enc->channels;
1621 if (samples_size < frame_bytes)
1623 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1626 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1627 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1628 ost->st->time_base.num, enc->sample_rate);
1629 enc->frame_size = fs_tmp;
1632 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1635 fprintf(stderr, "Audio encoding failed\n");
1639 pkt.flags |= AV_PKT_FLAG_KEY;
1641 case AVMEDIA_TYPE_VIDEO:
1642 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1644 fprintf(stderr, "Video encoding failed\n");
1648 if(enc->coded_frame && enc->coded_frame->key_frame)
1649 pkt.flags |= AV_PKT_FLAG_KEY;
1650 if (ost->logfile && enc->stats_out) {
1651 fprintf(ost->logfile, "%s", enc->stats_out);
1660 pkt.data= bit_buffer;
1662 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1663 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1664 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1676 static void print_sdp(AVFormatContext **avc, int n)
1680 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1681 printf("SDP:\n%s\n", sdp);
1685 static int copy_chapters(int infile, int outfile)
1687 AVFormatContext *is = input_files[infile];
1688 AVFormatContext *os = output_files[outfile];
1691 for (i = 0; i < is->nb_chapters; i++) {
1692 AVChapter *in_ch = is->chapters[i], *out_ch;
1693 AVMetadataTag *t = NULL;
1694 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
1695 AV_TIME_BASE_Q, in_ch->time_base);
1696 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1697 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1700 if (in_ch->end < ts_off)
1702 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1705 out_ch = av_mallocz(sizeof(AVChapter));
1707 return AVERROR(ENOMEM);
1709 out_ch->id = in_ch->id;
1710 out_ch->time_base = in_ch->time_base;
1711 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1712 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1714 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1715 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1718 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1720 return AVERROR(ENOMEM);
1721 os->chapters[os->nb_chapters - 1] = out_ch;
1727 * The following code is the main loop of the file converter
1729 static int av_transcode(AVFormatContext **output_files,
1730 int nb_output_files,
1731 AVFormatContext **input_files,
1733 AVStreamMap *stream_maps, int nb_stream_maps)
1735 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1736 AVFormatContext *is, *os;
1737 AVCodecContext *codec, *icodec;
1738 AVOutputStream *ost, **ost_table = NULL;
1739 AVInputStream *ist, **ist_table = NULL;
1740 AVInputFile *file_table;
1744 uint8_t no_packet[MAX_FILES]={0};
1745 int no_packet_count=0;
1747 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1751 /* input stream init */
1753 for(i=0;i<nb_input_files;i++) {
1754 is = input_files[i];
1755 file_table[i].ist_index = j;
1756 file_table[i].nb_streams = is->nb_streams;
1757 j += is->nb_streams;
1761 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1765 for(i=0;i<nb_istreams;i++) {
1766 ist = av_mallocz(sizeof(AVInputStream));
1772 for(i=0;i<nb_input_files;i++) {
1773 is = input_files[i];
1774 for(k=0;k<is->nb_streams;k++) {
1775 ist = ist_table[j++];
1776 ist->st = is->streams[k];
1777 ist->file_index = i;
1779 ist->discard = 1; /* the stream is discarded by default
1783 ist->start = av_gettime();
1788 /* output stream init */
1790 for(i=0;i<nb_output_files;i++) {
1791 os = output_files[i];
1792 if (!os->nb_streams) {
1793 dump_format(output_files[i], i, output_files[i]->filename, 1);
1794 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1797 nb_ostreams += os->nb_streams;
1799 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1800 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1804 /* Sanity check the mapping args -- do the input files & streams exist? */
1805 for(i=0;i<nb_stream_maps;i++) {
1806 int fi = stream_maps[i].file_index;
1807 int si = stream_maps[i].stream_index;
1809 if (fi < 0 || fi > nb_input_files - 1 ||
1810 si < 0 || si > file_table[fi].nb_streams - 1) {
1811 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1814 fi = stream_maps[i].sync_file_index;
1815 si = stream_maps[i].sync_stream_index;
1816 if (fi < 0 || fi > nb_input_files - 1 ||
1817 si < 0 || si > file_table[fi].nb_streams - 1) {
1818 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1823 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1826 for(i=0;i<nb_ostreams;i++) {
1827 ost = av_mallocz(sizeof(AVOutputStream));
1834 for(k=0;k<nb_output_files;k++) {
1835 os = output_files[k];
1836 for(i=0;i<os->nb_streams;i++,n++) {
1839 ost->file_index = k;
1841 ost->st = os->streams[i];
1842 if (nb_stream_maps > 0) {
1843 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1844 stream_maps[n].stream_index;
1846 /* Sanity check that the stream types match */
1847 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1848 int i= ost->file_index;
1849 dump_format(output_files[i], i, output_files[i]->filename, 1);
1850 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1851 stream_maps[n].file_index, stream_maps[n].stream_index,
1852 ost->file_index, ost->index);
1857 int best_nb_frames=-1;
1858 /* get corresponding input stream index : we select the first one with the right type */
1860 for(j=0;j<nb_istreams;j++) {
1865 AVFormatContext *f= input_files[ ist->file_index ];
1867 for(pi=0; pi<f->nb_programs; pi++){
1868 AVProgram *p= f->programs[pi];
1869 if(p->id == opt_programid)
1870 for(si=0; si<p->nb_stream_indexes; si++){
1871 if(f->streams[ p->stream_index[si] ] == ist->st)
1876 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
1877 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1878 if(best_nb_frames < ist->st->codec_info_nb_frames){
1879 best_nb_frames= ist->st->codec_info_nb_frames;
1880 ost->source_index = j;
1887 if(! opt_programid) {
1888 /* try again and reuse existing stream */
1889 for(j=0;j<nb_istreams;j++) {
1891 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
1892 && ist->st->discard != AVDISCARD_ALL) {
1893 ost->source_index = j;
1899 int i= ost->file_index;
1900 dump_format(output_files[i], i, output_files[i]->filename, 1);
1901 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1902 ost->file_index, ost->index);
1907 ist = ist_table[ost->source_index];
1909 ost->sync_ist = (nb_stream_maps > 0) ?
1910 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1911 stream_maps[n].sync_stream_index] : ist;
1915 /* for each output stream, we compute the right encoding parameters */
1916 for(i=0;i<nb_ostreams;i++) {
1917 AVMetadataTag *t = NULL;
1919 os = output_files[ost->file_index];
1920 ist = ist_table[ost->source_index];
1922 codec = ost->st->codec;
1923 icodec = ist->st->codec;
1925 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
1926 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
1929 ost->st->disposition = ist->st->disposition;
1930 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1931 codec->chroma_sample_location = icodec->chroma_sample_location;
1933 if (ost->st->stream_copy) {
1934 /* if stream_copy is selected, no need to decode or encode */
1935 codec->codec_id = icodec->codec_id;
1936 codec->codec_type = icodec->codec_type;
1938 if(!codec->codec_tag){
1939 if( !os->oformat->codec_tag
1940 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1941 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1942 codec->codec_tag = icodec->codec_tag;
1945 codec->bit_rate = icodec->bit_rate;
1946 codec->extradata= icodec->extradata;
1947 codec->extradata_size= icodec->extradata_size;
1948 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){
1949 codec->time_base = icodec->time_base;
1950 codec->time_base.num *= icodec->ticks_per_frame;
1952 codec->time_base = ist->st->time_base;
1953 switch(codec->codec_type) {
1954 case AVMEDIA_TYPE_AUDIO:
1955 if(audio_volume != 256) {
1956 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1959 codec->channel_layout = icodec->channel_layout;
1960 codec->sample_rate = icodec->sample_rate;
1961 codec->channels = icodec->channels;
1962 codec->frame_size = icodec->frame_size;
1963 codec->block_align= icodec->block_align;
1964 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1965 codec->block_align= 0;
1966 if(codec->codec_id == CODEC_ID_AC3)
1967 codec->block_align= 0;
1969 case AVMEDIA_TYPE_VIDEO:
1970 codec->pix_fmt = icodec->pix_fmt;
1971 codec->width = icodec->width;
1972 codec->height = icodec->height;
1973 codec->has_b_frames = icodec->has_b_frames;
1975 case AVMEDIA_TYPE_SUBTITLE:
1976 codec->width = icodec->width;
1977 codec->height = icodec->height;
1983 switch(codec->codec_type) {
1984 case AVMEDIA_TYPE_AUDIO:
1985 ost->fifo= av_fifo_alloc(1024);
1988 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1989 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1990 icodec->request_channels = codec->channels;
1991 ist->decoding_needed = 1;
1992 ost->encoding_needed = 1;
1994 case AVMEDIA_TYPE_VIDEO:
1995 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1996 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
1999 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2000 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
2001 ost->video_resample = ((codec->width != icodec->width -
2002 (frame_leftBand + frame_rightBand) +
2003 (frame_padleft + frame_padright)) ||
2004 (codec->height != icodec->height -
2005 (frame_topBand + frame_bottomBand) +
2006 (frame_padtop + frame_padbottom)) ||
2007 (codec->pix_fmt != icodec->pix_fmt));
2008 if (ost->video_crop) {
2009 ost->topBand = ost->original_topBand = frame_topBand;
2010 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2011 ost->leftBand = ost->original_leftBand = frame_leftBand;
2012 ost->rightBand = ost->original_rightBand = frame_rightBand;
2014 if (ost->video_pad) {
2015 ost->padtop = frame_padtop;
2016 ost->padleft = frame_padleft;
2017 ost->padbottom = frame_padbottom;
2018 ost->padright = frame_padright;
2019 if (!ost->video_resample) {
2020 avcodec_get_frame_defaults(&ost->pict_tmp);
2021 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2022 codec->width, codec->height))
2026 if (ost->video_resample) {
2027 avcodec_get_frame_defaults(&ost->pict_tmp);
2028 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2029 codec->width, codec->height)) {
2030 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2033 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2034 ost->img_resample_ctx = sws_getContext(
2035 icodec->width - (frame_leftBand + frame_rightBand),
2036 icodec->height - (frame_topBand + frame_bottomBand),
2038 codec->width - (frame_padleft + frame_padright),
2039 codec->height - (frame_padtop + frame_padbottom),
2041 sws_flags, NULL, NULL, NULL);
2042 if (ost->img_resample_ctx == NULL) {
2043 fprintf(stderr, "Cannot get resampling context\n");
2047 ost->original_height = icodec->height;
2048 ost->original_width = icodec->width;
2050 codec->bits_per_raw_sample= 0;
2052 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
2053 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
2054 ost->resample_pix_fmt= icodec->pix_fmt;
2055 ost->encoding_needed = 1;
2056 ist->decoding_needed = 1;
2058 case AVMEDIA_TYPE_SUBTITLE:
2059 ost->encoding_needed = 1;
2060 ist->decoding_needed = 1;
2067 if (ost->encoding_needed &&
2068 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2069 char logfilename[1024];
2072 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2073 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2075 if (codec->flags & CODEC_FLAG_PASS1) {
2076 f = fopen(logfilename, "w");
2078 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2084 size_t logbuffer_size;
2085 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2086 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2089 codec->stats_in = logbuffer;
2093 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2094 int size= codec->width * codec->height;
2095 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2100 bit_buffer = av_malloc(bit_buffer_size);
2102 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2104 ret = AVERROR(ENOMEM);
2108 /* open each encoder */
2109 for(i=0;i<nb_ostreams;i++) {
2111 if (ost->encoding_needed) {
2112 AVCodec *codec = output_codecs[i];
2114 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2116 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2117 ost->st->codec->codec_id, ost->file_index, ost->index);
2118 ret = AVERROR(EINVAL);
2121 if (avcodec_open(ost->st->codec, codec) < 0) {
2122 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2123 ost->file_index, ost->index);
2124 ret = AVERROR(EINVAL);
2127 extra_size += ost->st->codec->extradata_size;
2131 /* open each decoder */
2132 for(i=0;i<nb_istreams;i++) {
2134 if (ist->decoding_needed) {
2135 AVCodec *codec = input_codecs[i];
2137 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2139 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2140 ist->st->codec->codec_id, ist->file_index, ist->index);
2141 ret = AVERROR(EINVAL);
2144 if (avcodec_open(ist->st->codec, codec) < 0) {
2145 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2146 ist->file_index, ist->index);
2147 ret = AVERROR(EINVAL);
2150 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2151 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2156 for(i=0;i<nb_istreams;i++) {
2160 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2161 ist->next_pts = AV_NOPTS_VALUE;
2165 /* set meta data information from input file if required */
2166 for (i=0;i<nb_meta_data_maps;i++) {
2167 AVFormatContext *out_file;
2168 AVFormatContext *in_file;
2169 AVMetadataTag *mtag;
2171 int out_file_index = meta_data_maps[i].out_file;
2172 int in_file_index = meta_data_maps[i].in_file;
2173 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2174 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2175 out_file_index, out_file_index, in_file_index);
2176 ret = AVERROR(EINVAL);
2179 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2180 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2181 in_file_index, out_file_index, in_file_index);
2182 ret = AVERROR(EINVAL);
2186 out_file = output_files[out_file_index];
2187 in_file = input_files[in_file_index];
2191 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2192 av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2193 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2194 in_file->iformat->metadata_conv);
2197 /* copy chapters from the first input file that has them*/
2198 for (i = 0; i < nb_input_files; i++) {
2199 if (!input_files[i]->nb_chapters)
2202 for (j = 0; j < nb_output_files; j++)
2203 if ((ret = copy_chapters(i, j)) < 0)
2207 /* open files and write file headers */
2208 for(i=0;i<nb_output_files;i++) {
2209 os = output_files[i];
2210 if (av_write_header(os) < 0) {
2211 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2212 ret = AVERROR(EINVAL);
2215 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2221 /* dump the file output parameters - cannot be done before in case
2223 for(i=0;i<nb_output_files;i++) {
2224 dump_format(output_files[i], i, output_files[i]->filename, 1);
2227 /* dump the stream mapping */
2229 fprintf(stderr, "Stream mapping:\n");
2230 for(i=0;i<nb_ostreams;i++) {
2232 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2233 ist_table[ost->source_index]->file_index,
2234 ist_table[ost->source_index]->index,
2237 if (ost->sync_ist != ist_table[ost->source_index])
2238 fprintf(stderr, " [sync #%d.%d]",
2239 ost->sync_ist->file_index,
2240 ost->sync_ist->index);
2241 fprintf(stderr, "\n");
2246 fprintf(stderr, "%s\n", error);
2251 print_sdp(output_files, nb_output_files);
2254 if (!using_stdin && verbose >= 0) {
2255 fprintf(stderr, "Press [q] to stop encoding\n");
2256 url_set_interrupt_cb(decode_interrupt_cb);
2260 timer_start = av_gettime();
2262 for(; received_sigterm == 0;) {
2263 int file_index, ist_index;
2271 /* if 'q' pressed, exits */
2275 /* read_key() returns 0 on EOF */
2281 /* select the stream that we must read now by looking at the
2282 smallest output pts */
2284 for(i=0;i<nb_ostreams;i++) {
2287 os = output_files[ost->file_index];
2288 ist = ist_table[ost->source_index];
2289 if(ist->is_past_recording_time || no_packet[ist->file_index])
2291 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2292 ipts = (double)ist->pts;
2293 if (!file_table[ist->file_index].eof_reached){
2294 if(ipts < ipts_min) {
2296 if(input_sync ) file_index = ist->file_index;
2298 if(opts < opts_min) {
2300 if(!input_sync) file_index = ist->file_index;
2303 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2308 /* if none, if is finished */
2309 if (file_index < 0) {
2310 if(no_packet_count){
2312 memset(no_packet, 0, sizeof(no_packet));
2319 /* finish if limit size exhausted */
2320 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2323 /* read a frame from it and output it in the fifo */
2324 is = input_files[file_index];
2325 ret= av_read_frame(is, &pkt);
2326 if(ret == AVERROR(EAGAIN)){
2327 no_packet[file_index]=1;
2332 file_table[file_index].eof_reached = 1;
2340 memset(no_packet, 0, sizeof(no_packet));
2343 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2345 /* the following test is needed in case new streams appear
2346 dynamically in stream : we ignore them */
2347 if (pkt.stream_index >= file_table[file_index].nb_streams)
2348 goto discard_packet;
2349 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2350 ist = ist_table[ist_index];
2352 goto discard_packet;
2354 if (pkt.dts != AV_NOPTS_VALUE)
2355 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2356 if (pkt.pts != AV_NOPTS_VALUE)
2357 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2359 if(input_files_ts_scale[file_index][pkt.stream_index]){
2360 if(pkt.pts != AV_NOPTS_VALUE)
2361 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2362 if(pkt.dts != AV_NOPTS_VALUE)
2363 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2366 // 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);
2367 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2368 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2369 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2370 int64_t delta= pkt_dts - ist->next_pts;
2371 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2372 input_files_ts_offset[ist->file_index]-= delta;
2374 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2375 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2376 if(pkt.pts != AV_NOPTS_VALUE)
2377 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2381 /* finish if recording time exhausted */
2382 if (recording_time != INT64_MAX &&
2383 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2384 ist->is_past_recording_time = 1;
2385 goto discard_packet;
2388 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2389 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2392 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2393 ist->file_index, ist->index);
2396 av_free_packet(&pkt);
2401 av_free_packet(&pkt);
2403 /* dump report by using the output first video and audio streams */
2404 print_report(output_files, ost_table, nb_ostreams, 0);
2407 /* at the end of stream, we must flush the decoder buffers */
2408 for(i=0;i<nb_istreams;i++) {
2410 if (ist->decoding_needed) {
2411 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2417 /* write the trailer if needed and close file */
2418 for(i=0;i<nb_output_files;i++) {
2419 os = output_files[i];
2420 av_write_trailer(os);
2423 /* dump report by using the first video and audio streams */
2424 print_report(output_files, ost_table, nb_ostreams, 1);
2426 /* close each encoder */
2427 for(i=0;i<nb_ostreams;i++) {
2429 if (ost->encoding_needed) {
2430 av_freep(&ost->st->codec->stats_in);
2431 avcodec_close(ost->st->codec);
2435 /* close each decoder */
2436 for(i=0;i<nb_istreams;i++) {
2438 if (ist->decoding_needed) {
2439 avcodec_close(ist->st->codec);
2447 av_freep(&bit_buffer);
2448 av_free(file_table);
2451 for(i=0;i<nb_istreams;i++) {
2458 for(i=0;i<nb_ostreams;i++) {
2462 fclose(ost->logfile);
2463 ost->logfile = NULL;
2465 av_fifo_free(ost->fifo); /* works even if fifo is not
2466 initialized but set to zero */
2467 av_free(ost->pict_tmp.data[0]);
2468 if (ost->video_resample)
2469 sws_freeContext(ost->img_resample_ctx);
2471 audio_resample_close(ost->resample);
2472 if (ost->reformat_ctx)
2473 av_audio_convert_free(ost->reformat_ctx);
2482 static void opt_format(const char *arg)
2484 /* compatibility stuff for pgmyuv */
2485 if (!strcmp(arg, "pgmyuv")) {
2486 pgmyuv_compatibility_hack=1;
2487 // opt_image_format(arg);
2489 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2492 last_asked_format = arg;
2495 static void opt_video_rc_override_string(const char *arg)
2497 video_rc_override_string = arg;
2500 static int opt_me_threshold(const char *opt, const char *arg)
2502 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2506 static int opt_verbose(const char *opt, const char *arg)
2508 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2512 static int opt_frame_rate(const char *opt, const char *arg)
2514 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2515 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2521 static int opt_bitrate(const char *opt, const char *arg)
2523 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2525 opt_default(opt, arg);
2527 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2528 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2533 static void opt_frame_crop_top(const char *arg)
2535 frame_topBand = atoi(arg);
2536 if (frame_topBand < 0) {
2537 fprintf(stderr, "Incorrect top crop size\n");
2540 if ((frame_topBand) >= frame_height){
2541 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2544 frame_height -= frame_topBand;
2547 static void opt_frame_crop_bottom(const char *arg)
2549 frame_bottomBand = atoi(arg);
2550 if (frame_bottomBand < 0) {
2551 fprintf(stderr, "Incorrect bottom crop size\n");
2554 if ((frame_bottomBand) >= frame_height){
2555 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2558 frame_height -= frame_bottomBand;
2561 static void opt_frame_crop_left(const char *arg)
2563 frame_leftBand = atoi(arg);
2564 if (frame_leftBand < 0) {
2565 fprintf(stderr, "Incorrect left crop size\n");
2568 if ((frame_leftBand) >= frame_width){
2569 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2572 frame_width -= frame_leftBand;
2575 static void opt_frame_crop_right(const char *arg)
2577 frame_rightBand = atoi(arg);
2578 if (frame_rightBand < 0) {
2579 fprintf(stderr, "Incorrect right crop size\n");
2582 if ((frame_rightBand) >= frame_width){
2583 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2586 frame_width -= frame_rightBand;
2589 static void opt_frame_size(const char *arg)
2591 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2592 fprintf(stderr, "Incorrect frame size\n");
2597 static void opt_pad_color(const char *arg) {
2598 /* Input is expected to be six hex digits similar to
2599 how colors are expressed in html tags (but without the #) */
2600 int rgb = strtol(arg, NULL, 16);
2604 g = ((rgb >> 8) & 255);
2607 padcolor[0] = RGB_TO_Y(r,g,b);
2608 padcolor[1] = RGB_TO_U(r,g,b,0);
2609 padcolor[2] = RGB_TO_V(r,g,b,0);
2612 static void opt_frame_pad_top(const char *arg)
2614 frame_padtop = atoi(arg);
2615 if (frame_padtop < 0) {
2616 fprintf(stderr, "Incorrect top pad size\n");
2621 static void opt_frame_pad_bottom(const char *arg)
2623 frame_padbottom = atoi(arg);
2624 if (frame_padbottom < 0) {
2625 fprintf(stderr, "Incorrect bottom pad size\n");
2631 static void opt_frame_pad_left(const char *arg)
2633 frame_padleft = atoi(arg);
2634 if (frame_padleft < 0) {
2635 fprintf(stderr, "Incorrect left pad size\n");
2641 static void opt_frame_pad_right(const char *arg)
2643 frame_padright = atoi(arg);
2644 if (frame_padright < 0) {
2645 fprintf(stderr, "Incorrect right pad size\n");
2650 static void opt_frame_pix_fmt(const char *arg)
2652 if (strcmp(arg, "list")) {
2653 frame_pix_fmt = av_get_pix_fmt(arg);
2654 if (frame_pix_fmt == PIX_FMT_NONE) {
2655 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2664 static void opt_frame_aspect_ratio(const char *arg)
2671 p = strchr(arg, ':');
2673 x = strtol(arg, &end, 10);
2675 y = strtol(end+1, &end, 10);
2677 ar = (double)x / (double)y;
2679 ar = strtod(arg, NULL);
2682 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2685 frame_aspect_ratio = ar;
2688 static int opt_metadata(const char *opt, const char *arg)
2690 char *mid= strchr(arg, '=');
2693 fprintf(stderr, "Missing =\n");
2699 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2700 metadata[metadata_count-1].key = av_strdup(arg);
2701 metadata[metadata_count-1].value= av_strdup(mid);
2706 static void opt_qscale(const char *arg)
2708 video_qscale = atof(arg);
2709 if (video_qscale <= 0 ||
2710 video_qscale > 255) {
2711 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2716 static void opt_top_field_first(const char *arg)
2718 top_field_first= atoi(arg);
2721 static int opt_thread_count(const char *opt, const char *arg)
2723 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2726 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2731 static void opt_audio_sample_fmt(const char *arg)
2733 if (strcmp(arg, "list"))
2734 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2736 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2741 static int opt_audio_rate(const char *opt, const char *arg)
2743 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2747 static int opt_audio_channels(const char *opt, const char *arg)
2749 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2753 static void opt_video_channel(const char *arg)
2755 video_channel = strtol(arg, NULL, 0);
2758 static void opt_video_standard(const char *arg)
2760 video_standard = av_strdup(arg);
2763 static void opt_codec(int *pstream_copy, char **pcodec_name,
2764 int codec_type, const char *arg)
2766 av_freep(pcodec_name);
2767 if (!strcmp(arg, "copy")) {
2770 *pcodec_name = av_strdup(arg);
2774 static void opt_audio_codec(const char *arg)
2776 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2779 static void opt_audio_tag(const char *arg)
2782 audio_codec_tag= strtol(arg, &tail, 0);
2785 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2788 static void opt_video_tag(const char *arg)
2791 video_codec_tag= strtol(arg, &tail, 0);
2794 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2797 static void opt_video_codec(const char *arg)
2799 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2802 static void opt_subtitle_codec(const char *arg)
2804 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2807 static void opt_subtitle_tag(const char *arg)
2810 subtitle_codec_tag= strtol(arg, &tail, 0);
2813 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2816 static void opt_map(const char *arg)
2821 m = &stream_maps[nb_stream_maps++];
2823 m->file_index = strtol(arg, &p, 0);
2827 m->stream_index = strtol(p, &p, 0);
2830 m->sync_file_index = strtol(p, &p, 0);
2833 m->sync_stream_index = strtol(p, &p, 0);
2835 m->sync_file_index = m->file_index;
2836 m->sync_stream_index = m->stream_index;
2840 static void opt_map_meta_data(const char *arg)
2845 m = &meta_data_maps[nb_meta_data_maps++];
2847 m->out_file = strtol(arg, &p, 0);
2851 m->in_file = strtol(p, &p, 0);
2854 static void opt_input_ts_scale(const char *arg)
2856 unsigned int stream;
2860 stream = strtol(arg, &p, 0);
2863 scale= strtod(p, &p);
2865 if(stream >= MAX_STREAMS)
2868 input_files_ts_scale[nb_input_files][stream]= scale;
2871 static int opt_recording_time(const char *opt, const char *arg)
2873 recording_time = parse_time_or_die(opt, arg, 1);
2877 static int opt_start_time(const char *opt, const char *arg)
2879 start_time = parse_time_or_die(opt, arg, 1);
2883 static int opt_rec_timestamp(const char *opt, const char *arg)
2885 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2889 static int opt_input_ts_offset(const char *opt, const char *arg)
2891 input_ts_offset = parse_time_or_die(opt, arg, 1);
2895 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2897 const char *codec_string = encoder ? "encoder" : "decoder";
2901 return CODEC_ID_NONE;
2903 avcodec_find_encoder_by_name(name) :
2904 avcodec_find_decoder_by_name(name);
2906 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2909 if(codec->type != type) {
2910 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2916 static void opt_input_file(const char *filename)
2918 AVFormatContext *ic;
2919 AVFormatParameters params, *ap = ¶ms;
2920 AVInputFormat *file_iformat = NULL;
2921 int err, i, ret, rfps, rfps_base;
2924 if (last_asked_format) {
2925 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2926 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2929 last_asked_format = NULL;
2932 if (!strcmp(filename, "-"))
2935 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2936 !strcmp(filename, "/dev/stdin");
2938 /* get default parameters from command line */
2939 ic = avformat_alloc_context();
2941 print_error(filename, AVERROR(ENOMEM));
2945 memset(ap, 0, sizeof(*ap));
2946 ap->prealloced_context = 1;
2947 ap->sample_rate = audio_sample_rate;
2948 ap->channels = audio_channels;
2949 ap->time_base.den = frame_rate.num;
2950 ap->time_base.num = frame_rate.den;
2951 ap->width = frame_width + frame_padleft + frame_padright;
2952 ap->height = frame_height + frame_padtop + frame_padbottom;
2953 ap->pix_fmt = frame_pix_fmt;
2954 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2955 ap->channel = video_channel;
2956 ap->standard = video_standard;
2958 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2960 ic->video_codec_id = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
2961 ic->audio_codec_id = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
2962 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
2963 ic->flags |= AVFMT_FLAG_NONBLOCK;
2965 if(pgmyuv_compatibility_hack)
2966 ic->video_codec_id= CODEC_ID_PGMYUV;
2968 /* open the input file with generic libav function */
2969 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2971 print_error(filename, err);
2977 for(i=0; i<ic->nb_streams; i++){
2978 ic->streams[i]->discard= AVDISCARD_ALL;
2980 for(i=0; i<ic->nb_programs; i++){
2981 AVProgram *p= ic->programs[i];
2982 if(p->id != opt_programid){
2983 p->discard = AVDISCARD_ALL;
2986 for(j=0; j<p->nb_stream_indexes; j++){
2987 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2992 fprintf(stderr, "Specified program id not found\n");
2998 ic->loop_input = loop_input;
3000 /* If not enough info to get the stream parameters, we decode the
3001 first frames to get it. (used in mpeg case for example) */
3002 ret = av_find_stream_info(ic);
3003 if (ret < 0 && verbose >= 0) {
3004 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3008 timestamp = start_time;
3009 /* add the stream start time */
3010 if (ic->start_time != AV_NOPTS_VALUE)
3011 timestamp += ic->start_time;
3013 /* if seeking requested, we execute it */
3014 if (start_time != 0) {
3015 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3017 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3018 filename, (double)timestamp / AV_TIME_BASE);
3020 /* reset seek info */
3024 /* update the current parameters so that they match the one of the input stream */
3025 for(i=0;i<ic->nb_streams;i++) {
3026 AVStream *st = ic->streams[i];
3027 AVCodecContext *enc = st->codec;
3028 avcodec_thread_init(enc, thread_count);
3029 switch(enc->codec_type) {
3030 case AVMEDIA_TYPE_AUDIO:
3031 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3032 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3033 channel_layout = enc->channel_layout;
3034 audio_channels = enc->channels;
3035 audio_sample_rate = enc->sample_rate;
3036 audio_sample_fmt = enc->sample_fmt;
3037 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3039 st->discard= AVDISCARD_ALL;
3041 case AVMEDIA_TYPE_VIDEO:
3042 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3043 frame_height = enc->height;
3044 frame_width = enc->width;
3045 if(ic->streams[i]->sample_aspect_ratio.num)
3046 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3048 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
3049 frame_aspect_ratio *= (float) enc->width / enc->height;
3050 frame_pix_fmt = enc->pix_fmt;
3051 rfps = ic->streams[i]->r_frame_rate.num;
3052 rfps_base = ic->streams[i]->r_frame_rate.den;
3054 enc->flags |= CODEC_FLAG_EMU_EDGE;
3055 frame_height >>= enc->lowres;
3056 frame_width >>= enc->lowres;
3059 enc->debug |= FF_DEBUG_MV;
3061 if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {
3064 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3065 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3067 (float)rfps / rfps_base, rfps, rfps_base);
3069 /* update the current frame rate to match the stream frame rate */
3070 frame_rate.num = rfps;
3071 frame_rate.den = rfps_base;
3073 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3075 st->discard= AVDISCARD_ALL;
3076 else if(video_discard)
3077 st->discard= video_discard;
3079 case AVMEDIA_TYPE_DATA:
3081 case AVMEDIA_TYPE_SUBTITLE:
3082 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3083 if(subtitle_disable)
3084 st->discard = AVDISCARD_ALL;
3086 case AVMEDIA_TYPE_ATTACHMENT:
3087 case AVMEDIA_TYPE_UNKNOWN:
3095 input_files[nb_input_files] = ic;
3096 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3097 /* dump the file content */
3099 dump_format(ic, nb_input_files, filename, 0);
3105 av_freep(&video_codec_name);
3106 av_freep(&audio_codec_name);
3107 av_freep(&subtitle_codec_name);
3110 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3111 int *has_subtitle_ptr)
3113 int has_video, has_audio, has_subtitle, i, j;
3114 AVFormatContext *ic;
3119 for(j=0;j<nb_input_files;j++) {
3120 ic = input_files[j];
3121 for(i=0;i<ic->nb_streams;i++) {
3122 AVCodecContext *enc = ic->streams[i]->codec;
3123 switch(enc->codec_type) {
3124 case AVMEDIA_TYPE_AUDIO:
3127 case AVMEDIA_TYPE_VIDEO:
3130 case AVMEDIA_TYPE_SUBTITLE:
3133 case AVMEDIA_TYPE_DATA:
3134 case AVMEDIA_TYPE_ATTACHMENT:
3135 case AVMEDIA_TYPE_UNKNOWN:
3142 *has_video_ptr = has_video;
3143 *has_audio_ptr = has_audio;
3144 *has_subtitle_ptr = has_subtitle;
3147 static void new_video_stream(AVFormatContext *oc)
3150 AVCodecContext *video_enc;
3151 enum CodecID codec_id;
3153 st = av_new_stream(oc, oc->nb_streams);
3155 fprintf(stderr, "Could not alloc stream\n");
3158 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3159 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3160 video_bitstream_filters= NULL;
3162 avcodec_thread_init(st->codec, thread_count);
3164 video_enc = st->codec;
3167 video_enc->codec_tag= video_codec_tag;
3169 if( (video_global_header&1)
3170 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3171 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3172 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3174 if(video_global_header&2){
3175 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3176 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3179 if (video_stream_copy) {
3180 st->stream_copy = 1;
3181 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3182 video_enc->sample_aspect_ratio =
3183 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3188 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3190 if (video_codec_name) {
3191 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3192 codec = avcodec_find_encoder_by_name(video_codec_name);
3193 output_codecs[nb_ocodecs] = codec;
3195 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3196 codec = avcodec_find_encoder(codec_id);
3199 video_enc->codec_id = codec_id;
3201 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3203 if (codec && codec->supported_framerates && !force_fps)
3204 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3205 video_enc->time_base.den = fps.num;
3206 video_enc->time_base.num = fps.den;
3208 video_enc->width = frame_width + frame_padright + frame_padleft;
3209 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3210 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3211 video_enc->pix_fmt = frame_pix_fmt;
3212 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3214 choose_pixel_fmt(st, codec);
3217 video_enc->gop_size = 0;
3218 if (video_qscale || same_quality) {
3219 video_enc->flags |= CODEC_FLAG_QSCALE;
3220 video_enc->global_quality=
3221 st->quality = FF_QP2LAMBDA * video_qscale;
3225 video_enc->intra_matrix = intra_matrix;
3227 video_enc->inter_matrix = inter_matrix;
3229 p= video_rc_override_string;
3232 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3234 fprintf(stderr, "error parsing rc_override\n");
3237 video_enc->rc_override=
3238 av_realloc(video_enc->rc_override,
3239 sizeof(RcOverride)*(i+1));
3240 video_enc->rc_override[i].start_frame= start;
3241 video_enc->rc_override[i].end_frame = end;
3243 video_enc->rc_override[i].qscale= q;
3244 video_enc->rc_override[i].quality_factor= 1.0;
3247 video_enc->rc_override[i].qscale= 0;
3248 video_enc->rc_override[i].quality_factor= -q/100.0;
3253 video_enc->rc_override_count=i;
3254 if (!video_enc->rc_initial_buffer_occupancy)
3255 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3256 video_enc->me_threshold= me_threshold;
3257 video_enc->intra_dc_precision= intra_dc_precision - 8;
3260 video_enc->flags|= CODEC_FLAG_PSNR;
3265 video_enc->flags |= CODEC_FLAG_PASS1;
3267 video_enc->flags |= CODEC_FLAG_PASS2;
3272 if (video_language) {
3273 av_metadata_set(&st->metadata, "language", video_language);
3274 av_freep(&video_language);
3277 /* reset some key parameters */
3279 av_freep(&video_codec_name);
3280 video_stream_copy = 0;
3281 frame_pix_fmt = PIX_FMT_NONE;
3284 static void new_audio_stream(AVFormatContext *oc)
3287 AVCodecContext *audio_enc;
3288 enum CodecID codec_id;
3290 st = av_new_stream(oc, oc->nb_streams);
3292 fprintf(stderr, "Could not alloc stream\n");
3295 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3297 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3298 audio_bitstream_filters= NULL;
3300 avcodec_thread_init(st->codec, thread_count);
3302 audio_enc = st->codec;
3303 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3306 audio_enc->codec_tag= audio_codec_tag;
3308 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3309 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3310 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3312 if (audio_stream_copy) {
3313 st->stream_copy = 1;
3314 audio_enc->channels = audio_channels;
3318 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3320 if (audio_codec_name) {
3321 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3322 codec = avcodec_find_encoder_by_name(audio_codec_name);
3323 output_codecs[nb_ocodecs] = codec;
3325 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3326 codec = avcodec_find_encoder(codec_id);
3328 audio_enc->codec_id = codec_id;
3330 if (audio_qscale > QSCALE_NONE) {
3331 audio_enc->flags |= CODEC_FLAG_QSCALE;
3332 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3334 audio_enc->channels = audio_channels;
3335 audio_enc->sample_fmt = audio_sample_fmt;
3336 audio_enc->channel_layout = channel_layout;
3337 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3338 audio_enc->channel_layout = 0;
3339 choose_sample_fmt(st, codec);
3342 audio_enc->sample_rate = audio_sample_rate;
3343 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3344 if (audio_language) {
3345 av_metadata_set(&st->metadata, "language", audio_language);
3346 av_freep(&audio_language);
3349 /* reset some key parameters */
3351 av_freep(&audio_codec_name);
3352 audio_stream_copy = 0;
3355 static void new_subtitle_stream(AVFormatContext *oc)
3358 AVCodecContext *subtitle_enc;
3360 st = av_new_stream(oc, oc->nb_streams);
3362 fprintf(stderr, "Could not alloc stream\n");
3365 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3367 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3368 subtitle_bitstream_filters= NULL;
3370 subtitle_enc = st->codec;
3371 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3373 if(subtitle_codec_tag)
3374 subtitle_enc->codec_tag= subtitle_codec_tag;
3376 if (subtitle_stream_copy) {
3377 st->stream_copy = 1;
3379 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3380 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3381 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3385 if (subtitle_language) {
3386 av_metadata_set(&st->metadata, "language", subtitle_language);
3387 av_freep(&subtitle_language);
3390 subtitle_disable = 0;
3391 av_freep(&subtitle_codec_name);
3392 subtitle_stream_copy = 0;
3395 static void opt_new_audio_stream(void)
3397 AVFormatContext *oc;
3398 if (nb_output_files <= 0) {
3399 fprintf(stderr, "At least one output file must be specified\n");
3402 oc = output_files[nb_output_files - 1];
3403 new_audio_stream(oc);
3406 static void opt_new_video_stream(void)
3408 AVFormatContext *oc;
3409 if (nb_output_files <= 0) {
3410 fprintf(stderr, "At least one output file must be specified\n");
3413 oc = output_files[nb_output_files - 1];
3414 new_video_stream(oc);
3417 static void opt_new_subtitle_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_subtitle_stream(oc);
3428 static void opt_output_file(const char *filename)
3430 AVFormatContext *oc;
3431 int use_video, use_audio, use_subtitle;
3432 int input_has_video, input_has_audio, input_has_subtitle;
3433 AVFormatParameters params, *ap = ¶ms;
3434 AVOutputFormat *file_oformat;
3436 if (!strcmp(filename, "-"))
3439 oc = avformat_alloc_context();
3441 print_error(filename, AVERROR(ENOMEM));
3445 if (last_asked_format) {
3446 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3447 if (!file_oformat) {
3448 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3451 last_asked_format = NULL;
3453 file_oformat = av_guess_format(NULL, filename, NULL);
3454 if (!file_oformat) {
3455 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3461 oc->oformat = file_oformat;
3462 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3464 if (!strcmp(file_oformat->name, "ffm") &&
3465 av_strstart(filename, "http:", NULL)) {
3466 /* special case for files sent to ffserver: we get the stream
3467 parameters from ffserver */
3468 int err = read_ffserver_streams(oc, filename);
3470 print_error(filename, err);
3474 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3475 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3476 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3478 /* disable if no corresponding type found and at least one
3480 if (nb_input_files > 0) {
3481 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3482 &input_has_subtitle);
3483 if (!input_has_video)
3485 if (!input_has_audio)
3487 if (!input_has_subtitle)
3491 /* manual disable */
3492 if (audio_disable) {
3495 if (video_disable) {
3498 if (subtitle_disable) {
3503 new_video_stream(oc);
3507 new_audio_stream(oc);
3511 new_subtitle_stream(oc);
3514 oc->timestamp = rec_timestamp;
3516 for(; metadata_count>0; metadata_count--){
3517 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3518 metadata[metadata_count-1].value);
3520 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3523 output_files[nb_output_files++] = oc;
3525 /* check filename in case of an image number is expected */
3526 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3527 if (!av_filename_number_test(oc->filename)) {
3528 print_error(oc->filename, AVERROR_NUMEXPECTED);
3533 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3534 /* test if it already exists to avoid loosing precious files */
3535 if (!file_overwrite &&
3536 (strchr(filename, ':') == NULL ||
3537 filename[1] == ':' ||
3538 av_strstart(filename, "file:", NULL))) {
3539 if (url_exist(filename)) {
3541 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3543 if (!read_yesno()) {
3544 fprintf(stderr, "Not overwriting - exiting\n");
3549 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3556 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3557 fprintf(stderr, "Could not open '%s'\n", filename);
3562 memset(ap, 0, sizeof(*ap));
3563 if (av_set_parameters(oc, ap) < 0) {
3564 fprintf(stderr, "%s: Invalid encoding parameters\n",
3569 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3570 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3571 oc->loop_output = loop_output;
3572 oc->flags |= AVFMT_FLAG_NONBLOCK;
3574 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3577 /* same option as mencoder */
3578 static void opt_pass(const char *pass_str)
3581 pass = atoi(pass_str);
3582 if (pass != 1 && pass != 2) {
3583 fprintf(stderr, "pass number can be only 1 or 2\n");
3589 static int64_t getutime(void)
3592 struct rusage rusage;
3594 getrusage(RUSAGE_SELF, &rusage);
3595 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3596 #elif HAVE_GETPROCESSTIMES
3598 FILETIME c, e, k, u;
3599 proc = GetCurrentProcess();
3600 GetProcessTimes(proc, &c, &e, &k, &u);
3601 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3603 return av_gettime();
3607 static int64_t getmaxrss(void)
3609 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3610 struct rusage rusage;
3611 getrusage(RUSAGE_SELF, &rusage);
3612 return (int64_t)rusage.ru_maxrss * 1024;
3613 #elif HAVE_GETPROCESSMEMORYINFO
3615 PROCESS_MEMORY_COUNTERS memcounters;
3616 proc = GetCurrentProcess();
3617 memcounters.cb = sizeof(memcounters);
3618 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3619 return memcounters.PeakPagefileUsage;
3625 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3628 const char *p = str;
3635 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3642 static void opt_inter_matrix(const char *arg)
3644 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3645 parse_matrix_coeffs(inter_matrix, arg);
3648 static void opt_intra_matrix(const char *arg)
3650 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3651 parse_matrix_coeffs(intra_matrix, arg);
3655 * Trivial log callback.
3656 * Only suitable for show_help and similar since it lacks prefix handling.
3658 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3660 vfprintf(stdout, fmt, vl);
3663 static void show_usage(void)
3665 printf("Hyper fast Audio and Video encoder\n");
3666 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3670 static void show_help(void)
3672 av_log_set_callback(log_callback_help);
3674 show_help_options(options, "Main options:\n",
3675 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3676 show_help_options(options, "\nAdvanced options:\n",
3677 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3679 show_help_options(options, "\nVideo options:\n",
3680 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3682 show_help_options(options, "\nAdvanced Video options:\n",
3683 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3684 OPT_VIDEO | OPT_EXPERT);
3685 show_help_options(options, "\nAudio options:\n",
3686 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3688 show_help_options(options, "\nAdvanced Audio options:\n",
3689 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3690 OPT_AUDIO | OPT_EXPERT);
3691 show_help_options(options, "\nSubtitle options:\n",
3692 OPT_SUBTITLE | OPT_GRAB,
3694 show_help_options(options, "\nAudio/Video grab options:\n",
3698 av_opt_show(avcodec_opts[0], NULL);
3700 av_opt_show(avformat_opts, NULL);
3702 av_opt_show(sws_opts, NULL);
3705 static void opt_target(const char *arg)
3707 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3708 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3710 if(!strncmp(arg, "pal-", 4)) {
3713 } else if(!strncmp(arg, "ntsc-", 5)) {
3716 } else if(!strncmp(arg, "film-", 5)) {
3721 /* Calculate FR via float to avoid int overflow */
3722 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3725 } else if((fr == 29970) || (fr == 23976)) {
3728 /* Try to determine PAL/NTSC by peeking in the input files */
3729 if(nb_input_files) {
3731 for(j = 0; j < nb_input_files; j++) {
3732 for(i = 0; i < input_files[j]->nb_streams; i++) {
3733 AVCodecContext *c = input_files[j]->streams[i]->codec;
3734 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3736 fr = c->time_base.den * 1000 / c->time_base.num;
3740 } else if((fr == 29970) || (fr == 23976)) {
3750 if(verbose && norm != UNKNOWN)
3751 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3754 if(norm == UNKNOWN) {
3755 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3756 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3757 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3761 if(!strcmp(arg, "vcd")) {
3763 opt_video_codec("mpeg1video");
3764 opt_audio_codec("mp2");
3767 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3768 opt_frame_rate(NULL, frame_rates[norm]);
3769 opt_default("g", norm == PAL ? "15" : "18");
3771 opt_default("b", "1150000");
3772 opt_default("maxrate", "1150000");
3773 opt_default("minrate", "1150000");
3774 opt_default("bufsize", "327680"); // 40*1024*8;
3776 opt_default("ab", "224000");
3777 audio_sample_rate = 44100;
3780 opt_default("packetsize", "2324");
3781 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3783 /* We have to offset the PTS, so that it is consistent with the SCR.
3784 SCR starts at 36000, but the first two packs contain only padding
3785 and the first pack from the other stream, respectively, may also have
3786 been written before.
3787 So the real data starts at SCR 36000+3*1200. */
3788 mux_preload= (36000+3*1200) / 90000.0; //0.44
3789 } else if(!strcmp(arg, "svcd")) {
3791 opt_video_codec("mpeg2video");
3792 opt_audio_codec("mp2");
3795 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3796 opt_frame_rate(NULL, frame_rates[norm]);
3797 opt_default("g", norm == PAL ? "15" : "18");
3799 opt_default("b", "2040000");
3800 opt_default("maxrate", "2516000");
3801 opt_default("minrate", "0"); //1145000;
3802 opt_default("bufsize", "1835008"); //224*1024*8;
3803 opt_default("flags", "+scan_offset");
3806 opt_default("ab", "224000");
3807 audio_sample_rate = 44100;
3809 opt_default("packetsize", "2324");
3811 } else if(!strcmp(arg, "dvd")) {
3813 opt_video_codec("mpeg2video");
3814 opt_audio_codec("ac3");
3817 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3818 opt_frame_rate(NULL, frame_rates[norm]);
3819 opt_default("g", norm == PAL ? "15" : "18");
3821 opt_default("b", "6000000");
3822 opt_default("maxrate", "9000000");
3823 opt_default("minrate", "0"); //1500000;
3824 opt_default("bufsize", "1835008"); //224*1024*8;
3826 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3827 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3829 opt_default("ab", "448000");
3830 audio_sample_rate = 48000;
3832 } else if(!strncmp(arg, "dv", 2)) {
3836 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3837 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3838 (norm == PAL ? "yuv420p" : "yuv411p"));
3839 opt_frame_rate(NULL, frame_rates[norm]);
3841 audio_sample_rate = 48000;
3845 fprintf(stderr, "Unknown target: %s\n", arg);
3850 static void opt_vstats_file (const char *arg)
3852 av_free (vstats_filename);
3853 vstats_filename=av_strdup (arg);
3856 static void opt_vstats (void)
3859 time_t today2 = time(NULL);
3860 struct tm *today = localtime(&today2);
3862 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3864 opt_vstats_file(filename);
3867 static int opt_bsf(const char *opt, const char *arg)
3869 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3870 AVBitStreamFilterContext **bsfp;
3873 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3877 bsfp= *opt == 'v' ? &video_bitstream_filters :
3878 *opt == 'a' ? &audio_bitstream_filters :
3879 &subtitle_bitstream_filters;
3881 bsfp= &(*bsfp)->next;
3888 static int opt_preset(const char *opt, const char *arg)
3891 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3893 const char *base[3]= { getenv("FFMPEG_DATADIR"),
3899 for(i=0; i<3 && !f; i++){
3902 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
3903 f= fopen(filename, "r");
3905 char *codec_name= *opt == 'v' ? video_codec_name :
3906 *opt == 'a' ? audio_codec_name :
3907 subtitle_codec_name;
3908 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
3909 f= fopen(filename, "r");
3913 av_strlcpy(filename, arg, sizeof(filename));
3914 f= fopen(filename, "r");
3918 fprintf(stderr, "File for preset '%s' not found\n", arg);
3923 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3924 if(line[0] == '#' && !e)
3926 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3928 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3931 if(!strcmp(tmp, "acodec")){
3932 opt_audio_codec(tmp2);
3933 }else if(!strcmp(tmp, "vcodec")){
3934 opt_video_codec(tmp2);
3935 }else if(!strcmp(tmp, "scodec")){
3936 opt_subtitle_codec(tmp2);
3937 }else if(opt_default(tmp, tmp2) < 0){
3938 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3948 static const OptionDef options[] = {
3950 #include "cmdutils_common_opts.h"
3951 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3952 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3953 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3954 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3955 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3956 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3957 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3958 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3959 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3960 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3961 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3962 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3963 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
3964 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3965 "add timings for benchmarking" },
3966 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3967 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3968 "dump each input packet" },
3969 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3970 "when dumping packets, also dump the payload" },
3971 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3972 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3973 { "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)", "" },
3974 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3975 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3976 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3977 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3978 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3979 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3980 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3981 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3982 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3983 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3984 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3985 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3986 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3989 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3990 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3991 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3992 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3993 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3994 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3995 { "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" },
3996 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3997 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3998 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3999 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4000 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4001 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4002 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4003 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4004 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4005 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4006 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4007 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4008 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4009 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4010 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4011 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4012 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4013 "use same video quality as source (implies VBR)" },
4014 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4015 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4016 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4017 "deinterlace pictures" },
4018 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4019 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4020 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4021 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4022 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4023 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4024 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4025 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4026 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4027 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4028 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4029 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4032 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4033 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4034 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4035 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4036 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4037 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4038 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4039 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4040 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4041 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4042 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4043 { "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" },
4045 /* subtitle options */
4046 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4047 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4048 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4049 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4050 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4053 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4054 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4055 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4058 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4059 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4061 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4062 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4063 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4065 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4066 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4067 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4068 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4070 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4074 int main(int argc, char **argv)
4079 avcodec_register_all();
4081 avdevice_register_all();
4086 if(isatty(STDIN_FILENO))
4087 url_set_interrupt_cb(decode_interrupt_cb);
4090 for(i=0; i<AVMEDIA_TYPE_NB; i++){
4091 avcodec_opts[i]= avcodec_alloc_context2(i);
4093 avformat_opts = avformat_alloc_context();
4094 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4099 parse_options(argc, argv, options, opt_output_file);
4101 if(nb_output_files <= 0 && nb_input_files == 0) {
4103 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4107 /* file converter / grab */
4108 if (nb_output_files <= 0) {
4109 fprintf(stderr, "At least one output file must be specified\n");
4113 if (nb_input_files == 0) {
4114 fprintf(stderr, "At least one input file must be specified\n");
4119 if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4120 stream_maps, nb_stream_maps) < 0)
4122 ti = getutime() - ti;
4124 int maxrss = getmaxrss() / 1024;
4125 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);