diff options
Diffstat (limited to 'Game/Code/Classes')
25 files changed, 4681 insertions, 2299 deletions
diff --git a/Game/Code/Classes/UAudioConverter.pas b/Game/Code/Classes/UAudioConverter.pas new file mode 100644 index 00000000..aa7918fe --- /dev/null +++ b/Game/Code/Classes/UAudioConverter.pas @@ -0,0 +1,457 @@ +unit UAudioConverter; + +interface + +{$IFDEF FPC} + {$MODE Delphi} +{$ENDIF} + +{$I switches.inc} + +uses + UMusic, + ULog, + {$IFDEF UseSRCResample} + samplerate, + {$ENDIF} + {$IFDEF UseFFMpegResample} + avcodec, + {$ENDIF} + UMediaCore_SDL, + sdl, + SysUtils, + Math; + +type + {* + * Notes: + * - 44.1kHz to 48kHz conversion or vice versa is not supported + * by SDL 1.2 (will be introduced in 1.3). + * No conversion takes place in this cases. + * This is because SDL just converts differences in powers of 2. + * So the result might not be that accurate. + * This IS audible (voice to high/low) and it needs good synchronization + * with the video or the lyrics timer. + * - float<->int16 conversion is not supported (will be part of 1.3) and + * SDL (<1.3) is not capable of handling floats at all. + * -> Using FFMpeg or libsamplerate for resampling is preferred. + * Use SDL for channel and format conversion only. + *} + TAudioConverter_SDL = class(TAudioConverter) + private + cvt: TSDL_AudioCVT; + public + function Init(SrcFormatInfo: TAudioFormatInfo; DstFormatInfo: TAudioFormatInfo): boolean; override; + destructor Destroy(); override; + + function Convert(InputBuffer: PChar; OutputBuffer: PChar; var InputSize: integer): integer; override; + function GetOutputBufferSize(InputSize: integer): integer; override; + function GetRatio(): double; override; + end; + + {$IFDEF UseFFMpegResample} + // Note: FFMpeg seems to be using "kaiser windowed sinc" for resampling, so + // the quality should be good. + TAudioConverter_FFMpeg = class(TAudioConverter) + private + // TODO: use SDL for multi-channel->stereo and format conversion + ResampleContext: PReSampleContext; + Ratio: double; + public + function Init(SrcFormatInfo: TAudioFormatInfo; DstFormatInfo: TAudioFormatInfo): boolean; override; + destructor Destroy(); override; + + function Convert(InputBuffer: PChar; OutputBuffer: PChar; var InputSize: integer): integer; override; + function GetOutputBufferSize(InputSize: integer): integer; override; + function GetRatio(): double; override; + end; + {$ENDIF} + + {$IFDEF UseSRCResample} + TAudioConverter_SRC = class(TAudioConverter) + private + ConverterState: PSRC_STATE; + ConversionData: SRC_DATA; + FormatConverter: TAudioConverter; + public + function Init(SrcFormatInfo: TAudioFormatInfo; DstFormatInfo: TAudioFormatInfo): boolean; override; + destructor Destroy(); override; + + function Convert(InputBuffer: PChar; OutputBuffer: PChar; var InputSize: integer): integer; override; + function GetOutputBufferSize(InputSize: integer): integer; override; + function GetRatio(): double; override; + end; + + // Note: SRC (=libsamplerate) provides several converters with different quality + // speed trade-offs. The SINC-types are slow but offer best quality. + // The SRC_SINC_* converters are too slow for realtime conversion, + // (SRC_SINC_FASTEST is approx. ten times slower than SRC_LINEAR) resulting + // in audible clicks and pops. + // SRC_LINEAR is very fast and should have a better quality than SRC_ZERO_ORDER_HOLD + // because it interpolates the samples. Normal "non-audiophile" users should not + // be able to hear a difference between the SINC_* ones and LINEAR. Especially + // if people sing along with the song. + // But FFMpeg might offer a better quality/speed ratio than SRC_LINEAR. + const + SRC_CONVERTER_TYPE = SRC_LINEAR; + {$ENDIF} + +implementation + +function TAudioConverter_SDL.Init(srcFormatInfo: TAudioFormatInfo; dstFormatInfo: TAudioFormatInfo): boolean; +var + srcFormat: UInt16; + dstFormat: UInt16; +begin + inherited Init(SrcFormatInfo, DstFormatInfo); + + Result := false; + + if (not ConvertAudioFormatToSDL(srcFormatInfo.Format, srcFormat) or + not ConvertAudioFormatToSDL(dstFormatInfo.Format, dstFormat)) then + begin + Log.LogError('Audio-format not supported by SDL', 'TSoftMixerPlaybackStream.InitFormatConversion'); + Exit; + end; + + if (SDL_BuildAudioCVT(@cvt, + srcFormat, srcFormatInfo.Channels, Round(srcFormatInfo.SampleRate), + dstFormat, dstFormatInfo.Channels, Round(dstFormatInfo.SampleRate)) = -1) then + begin + Log.LogError(SDL_GetError(), 'TSoftMixerPlaybackStream.InitFormatConversion'); + Exit; + end; + + Result := true; +end; + +destructor TAudioConverter_SDL.Destroy(); +begin + // nothing to be done here + inherited; +end; + +(* + * Returns the size of the output buffer. This might be bigger than the actual + * size of resampled audio data. + *) +function TAudioConverter_SDL.GetOutputBufferSize(InputSize: integer): integer; +begin + // Note: len_ratio must not be used here. Even if the len_ratio is 1.0, len_mult might be 2. + // Example: 44.1kHz/mono to 22.05kHz/stereo -> len_ratio=1, len_mult=2 + Result := InputSize * cvt.len_mult; +end; + +function TAudioConverter_SDL.GetRatio(): double; +begin + Result := cvt.len_ratio; +end; + +function TAudioConverter_SDL.Convert(InputBuffer: PChar; OutputBuffer: PChar; var InputSize: integer): integer; +begin + Result := -1; + + if (InputSize <= 0) then + begin + // avoid div-by-zero problems + if (InputSize = 0) then + Result := 0; + Exit; + end; + + // OutputBuffer is always bigger than or equal to InputBuffer + Move(InputBuffer[0], OutputBuffer[0], InputSize); + cvt.buf := PUint8(OutputBuffer); + cvt.len := InputSize; + if (SDL_ConvertAudio(@cvt) = -1) then + Exit; + + Result := cvt.len_cvt; +end; + + +{$IFDEF UseFFMpegResample} + +function TAudioConverter_FFMpeg.Init(SrcFormatInfo: TAudioFormatInfo; DstFormatInfo: TAudioFormatInfo): boolean; +begin + inherited Init(SrcFormatInfo, DstFormatInfo); + + Result := false; + + // Note: ffmpeg does not support resampling for more than 2 input channels + + if (srcFormatInfo.Format <> asfS16) then + begin + Log.LogError('Unsupported format', 'TAudioConverter_FFMpeg.Init'); + Exit; + end; + + // TODO: use SDL here + if (srcFormatInfo.Format <> dstFormatInfo.Format) then + begin + Log.LogError('Incompatible formats', 'TAudioConverter_FFMpeg.Init'); + Exit; + end; + + ResampleContext := audio_resample_init( + dstFormatInfo.Channels, srcFormatInfo.Channels, + Round(dstFormatInfo.SampleRate), Round(srcFormatInfo.SampleRate)); + if (ResampleContext = nil) then + begin + Log.LogError('audio_resample_init() failed', 'TAudioConverter_FFMpeg.Init'); + Exit; + end; + + // calculate ratio + Ratio := (dstFormatInfo.Channels / srcFormatInfo.Channels) * + (dstFormatInfo.SampleRate / srcFormatInfo.SampleRate); + + Result := true; +end; + +destructor TAudioConverter_FFMpeg.Destroy(); +begin + if (ResampleContext <> nil) then + audio_resample_close(ResampleContext); + inherited; +end; + +function TAudioConverter_FFMpeg.Convert(InputBuffer: PChar; OutputBuffer: PChar; var InputSize: integer): integer; +var + InputSampleCount: integer; + OutputSampleCount: integer; +begin + Result := -1; + + if (InputSize <= 0) then + begin + // avoid div-by-zero in audio_resample() + if (InputSize = 0) then + Result := 0; + Exit; + end; + + InputSampleCount := InputSize div SrcFormatInfo.FrameSize; + OutputSampleCount := audio_resample( + ResampleContext, PSmallInt(OutputBuffer), PSmallInt(InputBuffer), + InputSampleCount); + if (OutputSampleCount = -1) then + begin + Log.LogError('audio_resample() failed', 'TAudioConverter_FFMpeg.Convert'); + Exit; + end; + Result := OutputSampleCount * DstFormatInfo.FrameSize; +end; + +function TAudioConverter_FFMpeg.GetOutputBufferSize(InputSize: integer): integer; +begin + Result := Ceil(InputSize * GetRatio()); +end; + +function TAudioConverter_FFMpeg.GetRatio(): double; +begin + Result := Ratio; +end; + +{$ENDIF} + + +{$IFDEF UseSRCResample} + +function TAudioConverter_SRC.Init(SrcFormatInfo: TAudioFormatInfo; DstFormatInfo: TAudioFormatInfo): boolean; +var + error: integer; + TempSrcFormatInfo: TAudioFormatInfo; + TempDstFormatInfo: TAudioFormatInfo; +begin + inherited Init(SrcFormatInfo, DstFormatInfo); + + Result := false; + + FormatConverter := nil; + + // SRC does not handle channel or format conversion + if ((SrcFormatInfo.Channels <> DstFormatInfo.Channels) or + not (SrcFormatInfo.Format in [asfS16, asfFloat])) then + begin + // SDL can not convert to float, so we have to convert to SInt16 first + TempSrcFormatInfo := TAudioFormatInfo.Create( + SrcFormatInfo.Channels, SrcFormatInfo.SampleRate, SrcFormatInfo.Format); + TempDstFormatInfo := TAudioFormatInfo.Create( + DstFormatInfo.Channels, SrcFormatInfo.SampleRate, asfS16); + + // init format/channel conversion + FormatConverter := TAudioConverter_SDL.Create(); + if (not FormatConverter.Init(TempSrcFormatInfo, TempDstFormatInfo)) then + begin + Log.LogError('Unsupported input format', 'TAudioConverter_SRC.Init'); + FormatConverter.Free; + // exit after the format-info is freed + end; + + // this info was copied so we do not need it anymore + TempSrcFormatInfo.Free; + TempDstFormatInfo.Free; + + // leave if the format is not supported + if (not assigned(FormatConverter)) then + Exit; + + // adjust our copy of the input audio-format for SRC conversion + Self.SrcFormatInfo.Channels := DstFormatInfo.Channels; + Self.SrcFormatInfo.Format := asfS16; + end; + + if ((DstFormatInfo.Format <> asfS16) and + (DstFormatInfo.Format <> asfFloat)) then + begin + Log.LogError('Unsupported output format', 'TAudioConverter_SRC.Init'); + Exit; + end; + + ConversionData.src_ratio := DstFormatInfo.SampleRate / SrcFormatInfo.SampleRate; + if (src_is_valid_ratio(ConversionData.src_ratio) = 0) then + begin + Log.LogError('Invalid samplerate ratio', 'TAudioConverter_SRC.Init'); + Exit; + end; + + ConverterState := src_new(SRC_CONVERTER_TYPE, DstFormatInfo.Channels, @error); + if (ConverterState = nil) then + begin + Log.LogError('src_new() failed: ' + src_strerror(error), 'TAudioConverter_SRC.Init'); + Exit; + end; + + Result := true; +end; + +destructor TAudioConverter_SRC.Destroy(); +begin + if (ConverterState <> nil) then + src_delete(ConverterState); + FormatConverter.Free; + inherited; +end; + +function TAudioConverter_SRC.Convert(InputBuffer: PChar; OutputBuffer: PChar; var InputSize: integer): integer; +var + FloatInputBuffer: PSingle; + FloatOutputBuffer: PSingle; + TempBuffer: PChar; + TempSize: integer; + NumSamples: integer; + OutputSize: integer; + error: integer; +begin + Result := -1; + + TempBuffer := nil; + + // format conversion with external converter (to correct number of channels and format) + if (assigned(FormatConverter)) then + begin + TempSize := FormatConverter.GetOutputBufferSize(InputSize); + GetMem(TempBuffer, TempSize); + InputSize := FormatConverter.Convert(InputBuffer, TempBuffer, InputSize); + InputBuffer := TempBuffer; + end; + + if (InputSize <= 0) then + begin + // avoid div-by-zero problems + if (InputSize = 0) then + Result := 0; + if (TempBuffer <> nil) then + FreeMem(TempBuffer); + Exit; + end; + + if (SrcFormatInfo.Format = asfFloat) then + begin + FloatInputBuffer := PSingle(InputBuffer); + end else begin + NumSamples := InputSize div AudioSampleSize[SrcFormatInfo.Format]; + GetMem(FloatInputBuffer, NumSamples * SizeOf(Single)); + src_short_to_float_array(PSmallInt(InputBuffer), FloatInputBuffer, NumSamples); + end; + + // calculate approx. output size + OutputSize := Ceil(InputSize * ConversionData.src_ratio); + + if (DstFormatInfo.Format = asfFloat) then + begin + FloatOutputBuffer := PSingle(OutputBuffer); + end else begin + NumSamples := OutputSize div AudioSampleSize[DstFormatInfo.Format]; + GetMem(FloatOutputBuffer, NumSamples * SizeOf(Single)); + end; + + with ConversionData do + begin + data_in := FloatInputBuffer; + input_frames := InputSize div SrcFormatInfo.FrameSize; + data_out := FloatOutputBuffer; + output_frames := OutputSize div DstFormatInfo.FrameSize; + // TODO: set this to 1 at end of file-playback + end_of_input := 0; + end; + + error := src_process(ConverterState, @ConversionData); + if (error <> 0) then + begin + Log.LogError(src_strerror(error), 'TAudioConverter_SRC.Convert'); + if (SrcFormatInfo.Format <> asfFloat) then + FreeMem(FloatInputBuffer); + if (DstFormatInfo.Format <> asfFloat) then + FreeMem(FloatOutputBuffer); + if (TempBuffer <> nil) then + FreeMem(TempBuffer); + Exit; + end; + + if (SrcFormatInfo.Format <> asfFloat) then + FreeMem(FloatInputBuffer); + + if (DstFormatInfo.Format <> asfFloat) then + begin + NumSamples := ConversionData.output_frames_gen * DstFormatInfo.Channels; + src_float_to_short_array(FloatOutputBuffer, PSmallInt(OutputBuffer), NumSamples); + FreeMem(FloatOutputBuffer); + end; + + // free format conversion buffer if used + if (TempBuffer <> nil) then + FreeMem(TempBuffer); + + if (assigned(FormatConverter)) then + InputSize := ConversionData.input_frames_used * FormatConverter.SrcFormatInfo.FrameSize + else + InputSize := ConversionData.input_frames_used * SrcFormatInfo.FrameSize; + + // set result to output size according to SRC + Result := ConversionData.output_frames_gen * DstFormatInfo.FrameSize; +end; + +function TAudioConverter_SRC.GetOutputBufferSize(InputSize: integer): integer; +begin + Result := Ceil(InputSize * GetRatio()); +end; + +function TAudioConverter_SRC.GetRatio(): double; +begin + // if we need additional channel/format conversion, use this ratio + if (assigned(FormatConverter)) then + Result := FormatConverter.GetRatio() + else + Result := 1.0; + + // now the SRC ratio (Note: the format might change from SInt16 to float) + Result := Result * + ConversionData.src_ratio * + (DstFormatInfo.FrameSize / SrcFormatInfo.FrameSize); +end; + +{$ENDIF} + +end.
\ No newline at end of file diff --git a/Game/Code/Classes/UAudioCore_Bass.pas b/Game/Code/Classes/UAudioCore_Bass.pas index 1f754be2..beb2db16 100644 --- a/Game/Code/Classes/UAudioCore_Bass.pas +++ b/Game/Code/Classes/UAudioCore_Bass.pas @@ -16,13 +16,13 @@ uses type TAudioCore_Bass = class - private - constructor Create(); public + constructor Create(); class function GetInstance(): TAudioCore_Bass; function ErrorGetString(): string; overload; function ErrorGetString(errCode: integer): string; overload; function ConvertAudioFormatToBASSFlags(Format: TAudioSampleFormat; out Flags: DWORD): boolean; + function ConvertBASSFlagsToAudioFormat(Flags: DWORD; out Format: TAudioSampleFormat): boolean; end; implementation @@ -41,7 +41,7 @@ end; class function TAudioCore_Bass.GetInstance(): TAudioCore_Bass; begin - if not assigned(Instance) then + if (not Assigned(Instance)) then Instance := TAudioCore_Bass.Create(); Result := Instance; end; @@ -108,4 +108,16 @@ begin Result := true; end; +function TAudioCore_Bass.ConvertBASSFlagsToAudioFormat(Flags: DWORD; out Format: TAudioSampleFormat): boolean; +begin + if ((Flags and BASS_SAMPLE_FLOAT) <> 0) then + Format := asfFloat + else if ((Flags and BASS_SAMPLE_8BITS) <> 0) then + Format := asfU8 + else + Format := asfS16; + + Result := true; +end; + end. diff --git a/Game/Code/Classes/UAudioCore_Portaudio.pas b/Game/Code/Classes/UAudioCore_Portaudio.pas index 90395cb8..bcc8a001 100644 --- a/Game/Code/Classes/UAudioCore_Portaudio.pas +++ b/Game/Code/Classes/UAudioCore_Portaudio.pas @@ -16,9 +16,8 @@ uses type TAudioCore_Portaudio = class - private - constructor Create(); public + constructor Create(); class function GetInstance(): TAudioCore_Portaudio; function GetPreferredApiIndex(): TPaHostApiIndex; function TestDevice(inParams, outParams: PPaStreamParameters; var sampleRate: Double): boolean; diff --git a/Game/Code/Classes/UAudioDecoder_Bass.pas b/Game/Code/Classes/UAudioDecoder_Bass.pas new file mode 100644 index 00000000..dba1fde4 --- /dev/null +++ b/Game/Code/Classes/UAudioDecoder_Bass.pas @@ -0,0 +1,242 @@ +unit UAudioDecoder_Bass; + +interface + +{$IFDEF FPC} + {$MODE Delphi} +{$ENDIF} + +{$I switches.inc} + +implementation + +uses + Classes, + SysUtils, + UMain, + UMusic, + UAudioCore_Bass, + ULog, + bass; + +type + TBassDecodeStream = class(TAudioDecodeStream) + private + Handle: HSTREAM; + FormatInfo : TAudioFormatInfo; + Error: boolean; + public + constructor Create(Handle: HSTREAM); + destructor Destroy(); override; + + procedure Close(); override; + + function GetLength(): real; override; + function GetAudioFormatInfo(): TAudioFormatInfo; override; + function GetPosition: real; override; + procedure SetPosition(Time: real); override; + function GetLoop(): boolean; override; + procedure SetLoop(Enabled: boolean); override; + function IsEOF(): boolean; override; + function IsError(): boolean; override; + + function ReadData(Buffer: PChar; BufSize: integer): integer; override; + end; + +type + TAudioDecoder_Bass = class( TInterfacedObject, IAudioDecoder ) + public + function GetName: string; + + function InitializeDecoder(): boolean; + function FinalizeDecoder(): boolean; + function Open(const Filename: string): TAudioDecodeStream; + end; + +var + BassCore: TAudioCore_Bass; + + +{ TBassDecodeStream } + +constructor TBassDecodeStream.Create(Handle: HSTREAM); +var + ChannelInfo: BASS_CHANNELINFO; + Format: TAudioSampleFormat; +begin + inherited Create(); + Self.Handle := Handle; + + // setup format info + if (not BASS_ChannelGetInfo(Handle, ChannelInfo)) then + begin + raise Exception.Create('Failed to open decode-stream'); + end; + BassCore.ConvertBASSFlagsToAudioFormat(ChannelInfo.flags, Format); + FormatInfo := TAudioFormatInfo.Create(ChannelInfo.chans, ChannelInfo.freq, format); + + Error := false; +end; + +destructor TBassDecodeStream.Destroy(); +begin + Close(); + inherited; +end; + +procedure TBassDecodeStream.Close(); +begin + if (Handle <> 0) then + begin + BASS_StreamFree(Handle); + Handle := 0; + end; + PerformOnClose(); + FreeAndNil(FormatInfo); + Error := false; +end; + +function TBassDecodeStream.GetAudioFormatInfo(): TAudioFormatInfo; +begin + Result := FormatInfo; +end; + +function TBassDecodeStream.GetLength(): real; +var + bytes: QWORD; +begin + bytes := BASS_ChannelGetLength(Handle, BASS_POS_BYTE); + Result := BASS_ChannelBytes2Seconds(Handle, bytes); +end; + +function TBassDecodeStream.GetPosition: real; +var + bytes: QWORD; +begin + bytes := BASS_ChannelGetPosition(Handle, BASS_POS_BYTE); + Result := BASS_ChannelBytes2Seconds(Handle, bytes); +end; + +procedure TBassDecodeStream.SetPosition(Time: real); +var + bytes: QWORD; +begin + bytes := BASS_ChannelSeconds2Bytes(Handle, Time); + BASS_ChannelSetPosition(Handle, bytes, BASS_POS_BYTE); +end; + +function TBassDecodeStream.GetLoop(): boolean; +var + flags: DWORD; +begin + // retrieve channel flags + flags := BASS_ChannelFlags(Handle, 0, 0); + if (flags = DWORD(-1)) then + begin + Log.LogError('BASS_ChannelFlags: ' + BassCore.ErrorGetString(), 'TBassDecodeStream.GetLoop'); + Result := false; + Exit; + end; + Result := (flags and BASS_SAMPLE_LOOP) <> 0; +end; + +procedure TBassDecodeStream.SetLoop(Enabled: boolean); +var + flags: DWORD; +begin + // set/unset loop-flag + if (Enabled) then + flags := BASS_SAMPLE_LOOP + else + flags := 0; + + // set new flag-bits + if (BASS_ChannelFlags(Handle, flags, BASS_SAMPLE_LOOP) = DWORD(-1)) then + begin + Log.LogError('BASS_ChannelFlags: ' + BassCore.ErrorGetString(), 'TBassDecodeStream.SetLoop'); + Exit; + end; +end; + +function TBassDecodeStream.IsEOF(): boolean; +begin + Result := (BASS_ChannelIsActive(Handle) = BASS_ACTIVE_STOPPED); +end; + +function TBassDecodeStream.IsError(): boolean; +begin + Result := Error; +end; + +function TBassDecodeStream.ReadData(Buffer: PChar; BufSize: integer): integer; +begin + Result := BASS_ChannelGetData(Handle, Buffer, BufSize); + // check error state (do not handle EOF as error) + if ((Result = -1) and (BASS_ErrorGetCode() <> BASS_ERROR_ENDED)) then + Error := true + else + Error := false; +end; + + +{ TAudioDecoder_Bass } + +function TAudioDecoder_Bass.GetName: String; +begin + result := 'BASS_Decoder'; +end; + +function TAudioDecoder_Bass.InitializeDecoder(): boolean; +begin + BassCore := TAudioCore_Bass.GetInstance(); + Result := true; +end; + +function TAudioDecoder_Bass.FinalizeDecoder(): boolean; +begin + Result := true; +end; + +function TAudioDecoder_Bass.Open(const Filename: string): TAudioDecodeStream; +var + Stream: HSTREAM; + ChannelInfo: BASS_CHANNELINFO; + FileExt: string; +begin + Result := nil; + + // check if BASS was initialized + // in case the decoder is not used with BASS playback, init the NO_SOUND device + if ((integer(BASS_GetDevice) = -1) and (BASS_ErrorGetCode() = BASS_ERROR_INIT)) then + BASS_Init(0, 44100, 0, 0, nil); + + // TODO: use BASS_STREAM_PRESCAN for accurate seeking in VBR-files? + // disadvantage: seeking will slow down. + Stream := BASS_StreamCreateFile(False, PChar(Filename), 0, 0, BASS_STREAM_DECODE); + if (Stream = 0) then + begin + //Log.LogError(BassCore.ErrorGetString(), 'TAudioDecoder_Bass.Open'); + Exit; + end; + + // check if BASS opened some erroneously recognized file-formats + if BASS_ChannelGetInfo(Stream, channelInfo) then + begin + fileExt := ExtractFileExt(Filename); + // BASS opens FLV-files (maybe others too) although it cannot handle them. + // Setting BASS_CONFIG_VERIFY to the max. value (100000) does not help. + if ((fileExt = '.flv') and (channelInfo.ctype = BASS_CTYPE_STREAM_MP1)) then + begin + BASS_StreamFree(Stream); + Exit; + end; + end; + + Result := TBassDecodeStream.Create(Stream); +end; + + +initialization + MediaManager.Add(TAudioDecoder_Bass.Create); + +end. diff --git a/Game/Code/Classes/UAudioDecoder_FFMpeg.pas b/Game/Code/Classes/UAudioDecoder_FFMpeg.pas index 2a9b7518..a9c5863b 100644 --- a/Game/Code/Classes/UAudioDecoder_FFMpeg.pas +++ b/Game/Code/Classes/UAudioDecoder_FFMpeg.pas @@ -1,15 +1,15 @@ unit UAudioDecoder_FFMpeg; (******************************************************************************* - -This unit is primarily based upon - - http://www.dranger.com/ffmpeg/ffmpegtutorial_all.html - - and tutorial03.c - - http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html - -*******************************************************************************) + * + * This unit is primarily based upon - + * http://www.dranger.com/ffmpeg/ffmpegtutorial_all.html + * + * and tutorial03.c + * + * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html + * + *******************************************************************************) interface @@ -19,682 +19,1032 @@ interface {$I switches.inc} -//{$DEFINE DebugFFMpegDecode} - -uses - Classes, - SysUtils, - UMusic; +{.$DEFINE DebugFFMpegDecode} implementation uses + Classes, + SysUtils, + Math, + UMusic, UIni, UMain, - avcodec, // FFMpeg Audio file decoding + avcodec, avformat, avutil, - avio, // used for url_ferror + avio, mathematics, // used for av_rescale_q rational, + UMediaCore_FFMpeg, SDL, ULog, UCommon, UConfig; -type - PPacketQueue = ^TPacketQueue; - TPacketQueue = class - private - firstPkt, - lastPkt : PAVPacketList; - nbPackets : integer; - size : integer; - mutex : PSDL_Mutex; - cond : PSDL_Cond; - abortRequest: boolean; - - public - constructor Create(); - destructor Destroy(); override; - - function Put(pkt : PAVPacket): integer; - function PutStatus(statusFlag: integer; statusInfo: Pointer): integer; - function Get(var pkt: TAVPacket; block: boolean): integer; - procedure Flush(); - procedure Abort(); - end; - const MAX_AUDIOQ_SIZE = (5 * 16 * 1024); const - STATUS_PACKET: PChar = 'STATUS_PACKET'; -const - PKT_STATUS_FLAG_EOF = 1; - PKT_STATUS_FLAG_FLUSH = 2; - PKT_STATUS_FLAG_ERROR = 3; - -type - PAudioBuffer = ^TAudioBuffer; - // TODO: should (or must?) be aligned at a 2-byte boundary. - // ffmpeg provides a C-macro called DECLARE_ALIGNED for this. - // Records can be aligned with the $PACKRECORDS compiler-directive but - // are already aligned at a 2-byte boundary by default in FPC. - // But what about arrays, are they aligned by a 2-byte boundary too? - // Or maybe we have to define a fake record with only an array in it? - TAudioBuffer = array[0 .. (AVCODEC_MAX_AUDIO_FRAME_SIZE * 3 div 2)-1] of byte; + // TODO: The factor 3/2 might not be necessary as we do not need extra + // space for synchronizing as in the tutorial. + AUDIO_BUFFER_SIZE = (AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) div 2; type TFFMpegDecodeStream = class(TAudioDecodeStream) private - decoderLock : PSDL_Mutex; - parserLock : PSDL_Mutex; - myint: integer; - - EOFState: boolean; // end-of-stream flag - ErrorState: boolean; - - resumeCond : PSDL_Cond; - - quitRequest : boolean; - - seekRequest: boolean; - seekFlags : integer; - seekPos : int64; - seekCond : PSDL_Cond; - - parseThread: PSDL_Thread; - packetQueue: TPacketQueue; - - formatInfo : TAudioFormatInfo; - - // FFMpeg internal data - pFormatCtx : PAVFormatContext; - pCodecCtx : PAVCodecContext; - pCodec : PAVCodec; - ffmpegStreamIndex : Integer; - ffmpegStream : PAVStream; - - audioClock: double; // stream position in seconds - - // state-vars for DecodeFrame - pkt : TAVPacket; - audio_pkt_data : PChar; - audio_pkt_size : integer; - - // state-vars for AudioCallback - audio_buf_index : integer; - audio_buf_size : integer; - audio_buf : TAudioBuffer; - - procedure LockParser(); {$IFDEF HasInline}inline;{$ENDIF} - procedure UnlockParser(); {$IFDEF HasInline}inline;{$ENDIF} - function GetParserMutex(): PSDL_Mutex; {$IFDEF HasInline}inline;{$ENDIF} - - procedure LockDecoder(); {$IFDEF HasInline}inline;{$ENDIF} - procedure UnlockDecoder(); {$IFDEF HasInline}inline;{$ENDIF} - - procedure SetEOF(state: boolean); {$IFDEF HasInline}inline;{$ENDIF} - procedure SetError(state: boolean); {$IFDEF HasInline}inline;{$ENDIF} - - procedure ParseAudio(); - function DecodeFrame(var buffer: TAudioBuffer; bufSize: integer): integer; + StateLock: PSDL_Mutex; + + EOFState: boolean; // end-of-stream flag (locked by StateLock) + ErrorState: boolean; // error flag (locked by StateLock) + + QuitRequest: boolean; // (locked by StateLock) + ParserIdleCond: PSDL_Cond; + + // parser pause/resume data + ParserLocked: boolean; + ParserPauseRequestCount: integer; + ParserUnlockedCond: PSDL_Cond; + ParserResumeCond: PSDL_Cond; + + SeekRequest: boolean; // (locked by StateLock) + SeekFlags: integer; // (locked by StateLock) + SeekPos: double; // stream position to seek for (in secs) (locked by StateLock) + SeekFlush: boolean; // true if the buffers should be flushed after seeking (locked by StateLock) + SeekFinishedCond: PSDL_Cond; + + Loop: boolean; // (locked by StateLock) + + ParseThread: PSDL_Thread; + PacketQueue: TPacketQueue; + + FormatInfo: TAudioFormatInfo; + + // FFMpeg specific data + FormatCtx: PAVFormatContext; + CodecCtx: PAVCodecContext; + Codec: PAVCodec; + + AudioStreamIndex: integer; + AudioStream: PAVStream; + AudioStreamPos: double; // stream position in seconds (locked by DecoderLock) + + // decoder pause/resume data + DecoderLocked: boolean; + DecoderPauseRequestCount: integer; + DecoderUnlockedCond: PSDL_Cond; + DecoderResumeCond: PSDL_Cond; + + // state-vars for DecodeFrame (locked by DecoderLock) + AudioPaket: TAVPacket; + AudioPaketData: PChar; + AudioPaketSize: integer; + AudioPaketSilence: integer; // number of bytes of silence to return + + // state-vars for AudioCallback (locked by DecoderLock) + AudioBufferPos: integer; + AudioBufferSize: integer; + AudioBuffer: PChar; + + Filename: string; + + procedure SetPositionIntern(Time: real; Flush: boolean; Blocking: boolean); + procedure SetEOF(State: boolean); {$IFDEF HasInline}inline;{$ENDIF} + procedure SetError(State: boolean); {$IFDEF HasInline}inline;{$ENDIF} + function IsSeeking(): boolean; + function IsQuit(): boolean; + + procedure Reset(); + + procedure Parse(); + function ParseLoop(): boolean; + procedure PauseParser(); + procedure ResumeParser(); + + function DecodeFrame(Buffer: PChar; BufferSize: integer): integer; + procedure FlushCodecBuffers(); + procedure PauseDecoder(); + procedure ResumeDecoder(); public - constructor Create(pFormatCtx: PAVFormatContext; - pCodecCtx: PAVCodecContext; pCodec: PAVCodec; - ffmpegStreamIndex: Integer; ffmpegStream: PAVStream); + constructor Create(); destructor Destroy(); override; + function Open(const Filename: string): boolean; procedure Close(); override; function GetLength(): real; override; function GetAudioFormatInfo(): TAudioFormatInfo; override; function GetPosition: real; override; procedure SetPosition(Time: real); override; + function GetLoop(): boolean; override; + procedure SetLoop(Enabled: boolean); override; function IsEOF(): boolean; override; function IsError(): boolean; override; - function ReadData(Buffer: PChar; BufSize: integer): integer; override; + function ReadData(Buffer: PChar; BufferSize: integer): integer; override; end; type TAudioDecoder_FFMpeg = class( TInterfacedObject, IAudioDecoder ) - private - class function FindAudioStreamIndex(pFormatCtx : PAVFormatContext): integer; public - function GetName: String; + function GetName: string; function InitializeDecoder(): boolean; function FinalizeDecoder(): boolean; function Open(const Filename: string): TAudioDecodeStream; end; -function DecodeThreadMain(streamPtr: Pointer): integer; cdecl; forward; - var - singleton_AudioDecoderFFMpeg : IAudioDecoder; + FFMpegCore: TMediaCore_FFMpeg; + +function ParseThreadMain(Data: Pointer): integer; cdecl; forward; { TFFMpegDecodeStream } -constructor TFFMpegDecodeStream.Create(pFormatCtx: PAVFormatContext; - pCodecCtx: PAVCodecContext; pCodec: PAVCodec; - ffmpegStreamIndex : Integer; ffmpegStream: PAVStream); -var - sampleFormat: TAudioSampleFormat; +constructor TFFMpegDecodeStream.Create(); begin inherited Create(); - packetQueue := TPacketQueue.Create(); - - audio_pkt_data := nil; - audio_pkt_size := 0; - - audio_buf_index := 0; - audio_buf_size := 0; + StateLock := SDL_CreateMutex(); + ParserUnlockedCond := SDL_CreateCond(); + ParserResumeCond := SDL_CreateCond(); + ParserIdleCond := SDL_CreateCond(); + SeekFinishedCond := SDL_CreateCond(); + DecoderUnlockedCond := SDL_CreateCond(); + DecoderResumeCond := SDL_CreateCond(); + + // according to the documentation of avcodec_decode_audio(2), sample-data + // should be aligned on a 16 byte boundary. Otherwise internal calls + // (e.g. to SSE or Altivec operations) might fail or lack performance on some + // CPUs. Although GetMem() in Delphi and FPC seems to use a 16 byte or higher + // alignment for buffers of this size (alignment depends on the size of the + // requested buffer), we will set the alignment explicitly as the minimum + // alignment used by Delphi and FPC is on an 8 byte boundary. + // + // Note: AudioBuffer was previously defined as a field of type TAudioBuffer + // (array[0..AUDIO_BUFFER_SIZE-1] of byte) and hence statically allocated. + // Fields of records are aligned different to memory allocated with GetMem(), + // aligning depending on the type but will be at least 2 bytes. + // AudioBuffer was not aligned to a 16 byte boundary. The {$ALIGN x} directive + // was not applicable as Delphi in contrast to FPC provides at most 8 byte + // alignment ({$ALIGN 16} is not supported) by this directive. + AudioBuffer := GetAlignedMem(AUDIO_BUFFER_SIZE, 16); + + Reset(); +end; - FillChar(pkt, sizeof(TAVPacket), 0); +procedure TFFMpegDecodeStream.Reset(); +begin + ParseThread := nil; - Self.pFormatCtx := pFormatCtx; - Self.pCodecCtx := pCodecCtx; - Self.pCodec := pCodec; - Self.ffmpegStreamIndex := ffmpegStreamIndex; - Self.ffmpegStream := ffmpegStream; + EOFState := false; + ErrorState := false; + Loop := false; + QuitRequest := false; - case pCodecCtx^.sample_fmt of - SAMPLE_FMT_U8: sampleFormat := asfU8; - SAMPLE_FMT_S16: sampleFormat := asfS16; - SAMPLE_FMT_S24: sampleFormat := asfS24; - SAMPLE_FMT_S32: sampleFormat := asfS32; - SAMPLE_FMT_FLT: sampleFormat := asfFloat; - else sampleFormat := asfS16; // try standard format - end; + AudioPaketData := nil; + AudioPaketSize := 0; + AudioPaketSilence := 0; - formatInfo := TAudioFormatInfo.Create( - pCodecCtx^.channels, - pCodecCtx^.sample_rate, - sampleFormat - ); + AudioBufferPos := 0; + AudioBufferSize := 0; - EOFState := false; - ErrorState := false; - decoderLock := SDL_CreateMutex(); - parserLock := SDL_CreateMutex(); - resumeCond := SDL_CreateCond(); - seekCond := SDL_CreateCond(); + ParserLocked := false; + ParserPauseRequestCount := 0; + DecoderLocked := false; + DecoderPauseRequestCount := 0; - parseThread := SDL_CreateThread(@DecodeThreadMain, Self); + FillChar(AudioPaket, SizeOf(TAVPacket), 0); end; {* * Frees the decode-stream data. - * IMPORTANT: call Close() before freeing the decode-stream to avoid dead-locks. - * This wakes-up every waiting audio-thread waiting in the packet-queue while - * performing a ReadData() request. - * Then assure that no thread uses ReadData anymore (e.g. by stopping the audio-callback). - * Now you can free the decode-stream. *} destructor TFFMpegDecodeStream.Destroy(); begin - // wake-up and terminate threads - // Note: should be called by the caller before Destroy() was called instead - // to wake-up a waiting audio-callback thread in the packet-queue. - // Otherwise dead-locks are possible. Close(); - // Close the codec - if (pCodecCtx <> nil) then + SDL_DestroyMutex(StateLock); + SDL_DestroyCond(ParserUnlockedCond); + SDL_DestroyCond(ParserResumeCond); + SDL_DestroyCond(ParserIdleCond); + SDL_DestroyCond(SeekFinishedCond); + SDL_DestroyCond(DecoderUnlockedCond); + SDL_DestroyCond(DecoderResumeCond); + + FreeAlignedMem(AudioBuffer); + + inherited; +end; + +function TFFMpegDecodeStream.Open(const Filename: string): boolean; +var + SampleFormat: TAudioSampleFormat; + AVResult: integer; +begin + Result := false; + + Close(); + Reset(); + + if (not FileExists(Filename)) then begin - avcodec_close(pCodecCtx); - pCodecCtx := nil; + Log.LogError('Audio-file does not exist: "' + Filename + '"', 'UAudio_FFMpeg'); + Exit; end; - // Close the video file - if (pFormatCtx <> nil) then + Self.Filename := Filename; + + // open audio file + if (av_open_input_file(FormatCtx, PChar(Filename), nil, 0, nil) <> 0) then + begin + Log.LogError('av_open_input_file failed: "' + Filename + '"', 'UAudio_FFMpeg'); + Exit; + end; + + // generate PTS values if they do not exist + FormatCtx^.flags := FormatCtx^.flags or AVFMT_FLAG_GENPTS; + + // retrieve stream information + if (av_find_stream_info(FormatCtx) < 0) then begin - av_close_input_file(pFormatCtx); - pFormatCtx := nil; + Log.LogError('av_find_stream_info failed: "' + Filename + '"', 'UAudio_FFMpeg'); + Close(); + Exit; end; - FreeAndNil(packetQueue); - FreeAndNil(formatInfo); + // FIXME: hack used by ffplay. Maybe should not use url_feof() to test for the end + FormatCtx^.pb.eof_reached := 0; - SDL_DestroyMutex(decoderLock); - decoderLock := nil; - SDL_DestroyMutex(parserLock); - parserLock := nil; - SDL_DestroyCond(resumeCond); - resumeCond := nil; + {$IFDEF DebugFFMpegDecode} + dump_format(FormatCtx, 0, pchar(Filename), 0); + {$ENDIF} - inherited; + AudioStreamIndex := FFMpegCore.FindAudioStreamIndex(FormatCtx); + if (AudioStreamIndex < 0) then + begin + Log.LogError('FindAudioStreamIndex: No Audio-stream found "' + Filename + '"', 'UAudio_FFMpeg'); + Close(); + Exit; + end; + + //Log.LogStatus('AudioStreamIndex is: '+ inttostr(ffmpegStreamID), 'UAudio_FFMpeg'); + + AudioStream := FormatCtx.streams[AudioStreamIndex]; + CodecCtx := AudioStream^.codec; + + // TODO: should we use this or not? Should we allow 5.1 channel audio? + (* + {$IF LIBAVCODEC_VERSION >= 51042000} + if (CodecCtx^.channels > 0) then + CodecCtx^.request_channels := Min(2, CodecCtx^.channels) + else + CodecCtx^.request_channels := 2; + {$IFEND} + *) + + Codec := avcodec_find_decoder(CodecCtx^.codec_id); + if (Codec = nil) then + begin + Log.LogError('Unsupported codec!', 'UAudio_FFMpeg'); + CodecCtx := nil; + Close(); + Exit; + end; + + // set debug options + CodecCtx^.debug_mv := 0; + CodecCtx^.debug := 0; + + // detect bug-workarounds automatically + CodecCtx^.workaround_bugs := FF_BUG_AUTODETECT; + // error resilience strategy (careful/compliant/agressive/very_aggressive) + //CodecCtx^.error_resilience := FF_ER_CAREFUL; //FF_ER_COMPLIANT; + // allow non spec compliant speedup tricks. + //CodecCtx^.flags2 := CodecCtx^.flags2 or CODEC_FLAG2_FAST; + + // Note: avcodec_open() and avcodec_close() are not thread-safe and will + // fail if called concurrently by different threads. + FFMpegCore.LockAVCodec(); + try + AVResult := avcodec_open(CodecCtx, Codec); + finally + FFMpegCore.UnlockAVCodec(); + end; + if (AVResult < 0) then + begin + Log.LogError('avcodec_open failed!', 'UAudio_FFMpeg'); + Close(); + Exit; + end; + + // now initialize the audio-format + + if (not FFMpegCore.ConvertFFMpegToAudioFormat(CodecCtx^.sample_fmt, SampleFormat)) then + begin + // try standard format + SampleFormat := asfS16; + end; + + FormatInfo := TAudioFormatInfo.Create( + CodecCtx^.channels, + CodecCtx^.sample_rate, + SampleFormat + ); + + + PacketQueue := TPacketQueue.Create(); + + // finally start the decode thread + ParseThread := SDL_CreateThread(@ParseThreadMain, Self); + + Result := true; end; procedure TFFMpegDecodeStream.Close(); var - status: integer; + ThreadResult: integer; begin // wake threads waiting for packet-queue data - packetQueue.Abort(); + // Note: normally, there are no waiting threads. If there were waiting + // ones, they would block the audio-callback thread. + if (assigned(PacketQueue)) then + PacketQueue.Abort(); + + // send quit request (to parse-thread etc) + SDL_mutexP(StateLock); + QuitRequest := true; + SDL_CondBroadcast(ParserIdleCond); + SDL_mutexV(StateLock); // abort parse-thread - LockParser(); - quitRequest := true; - SDL_CondBroadcast(resumeCond); - UnlockParser(); - // and wait until it terminates - if (parseThread <> nil) then + if (ParseThread <> nil) then + begin + // and wait until it terminates + SDL_WaitThread(ParseThread, ThreadResult); + ParseThread := nil; + end; + + // Close the codec + if (CodecCtx <> nil) then begin - SDL_WaitThread(parseThread, status); - parseThread := nil; + // avcodec_close() is not thread-safe + FFMpegCore.LockAVCodec(); + try + avcodec_close(CodecCtx); + finally + FFMpegCore.UnlockAVCodec(); + end; + CodecCtx := nil; end; - // NOTE: we cannot free the codecCtx or formatCtx here because - // a formerly waiting thread in the packet-queue might require them - // and crash if it tries to access them. + // Close the video file + if (FormatCtx <> nil) then + begin + av_close_input_file(FormatCtx); + FormatCtx := nil; + end; + + PerformOnClose(); + + FreeAndNil(PacketQueue); + FreeAndNil(FormatInfo); end; -procedure TFFMpegDecodeStream.LockParser(); +function TFFMpegDecodeStream.GetLength(): real; begin - SDL_mutexP(parserLock); + // do not forget to consider the start_time value here + Result := (FormatCtx^.start_time + FormatCtx^.duration) / AV_TIME_BASE; end; -procedure TFFMpegDecodeStream.UnlockParser(); +function TFFMpegDecodeStream.GetAudioFormatInfo(): TAudioFormatInfo; begin - SDL_mutexV(parserLock); + Result := FormatInfo; end; -function TFFMpegDecodeStream.GetParserMutex(): PSDL_Mutex; +function TFFMpegDecodeStream.IsEOF(): boolean; begin - Result := parserLock; + SDL_mutexP(StateLock); + Result := EOFState; + SDL_mutexV(StateLock); end; -procedure TFFMpegDecodeStream.LockDecoder(); +procedure TFFMpegDecodeStream.SetEOF(State: boolean); begin - SDL_mutexP(decoderLock); + SDL_mutexP(StateLock); + EOFState := State; + SDL_mutexV(StateLock); end; -procedure TFFMpegDecodeStream.UnlockDecoder(); +function TFFMpegDecodeStream.IsError(): boolean; begin - SDL_mutexV(decoderLock); + SDL_mutexP(StateLock); + Result := ErrorState; + SDL_mutexV(StateLock); end; -function TFFMpegDecodeStream.GetLength(): real; +procedure TFFMpegDecodeStream.SetError(State: boolean); begin - Result := pFormatCtx^.duration / AV_TIME_BASE; + SDL_mutexP(StateLock); + ErrorState := State; + SDL_mutexV(StateLock); end; -function TFFMpegDecodeStream.GetAudioFormatInfo(): TAudioFormatInfo; +function TFFMpegDecodeStream.IsSeeking(): boolean; begin - Result := formatInfo; + SDL_mutexP(StateLock); + Result := SeekRequest; + SDL_mutexV(StateLock); end; -function TFFMpegDecodeStream.IsEOF(): boolean; +function TFFMpegDecodeStream.IsQuit(): boolean; begin - LockDecoder(); - Result := EOFState; - UnlockDecoder(); + SDL_mutexP(StateLock); + Result := QuitRequest; + SDL_mutexV(StateLock); end; -procedure TFFMpegDecodeStream.SetEOF(state: boolean); +function TFFMpegDecodeStream.GetPosition(): real; +var + BufferSizeSec: double; begin - LockDecoder(); - EOFState := state; - UnlockDecoder(); + PauseDecoder(); + + // ReadData() does not return all of the buffer retrieved by DecodeFrame(). + // Determine the size of the unused part of the decode-buffer. + BufferSizeSec := (AudioBufferSize - AudioBufferPos) / + FormatInfo.BytesPerSec; + + // subtract the size of unused buffer-data from the audio clock. + Result := AudioStreamPos - BufferSizeSec; + + ResumeDecoder(); end; -function TFFMpegDecodeStream.IsError(): boolean; +procedure TFFMpegDecodeStream.SetPosition(Time: real); begin - LockDecoder(); - Result := ErrorState; - UnlockDecoder(); + SetPositionIntern(Time, true, true); end; -procedure TFFMpegDecodeStream.SetError(state: boolean); +function TFFMpegDecodeStream.GetLoop(): boolean; begin - LockDecoder(); - ErrorState := state; - UnlockDecoder(); + SDL_mutexP(StateLock); + Result := Loop; + SDL_mutexV(StateLock); end; -(* -procedure TFFMpegDecodeStream.SetError(state: boolean); +procedure TFFMpegDecodeStream.SetLoop(Enabled: boolean); begin - LockDecoder(); - ErrorState := state; - UnlockDecoder(); + SDL_mutexP(StateLock); + Loop := Enabled; + SDL_mutexV(StateLock); end; -function TFFMpegDecodeStream.IsSeeking(): boolean; + +(******************************************** + * Parser section + ********************************************) + +procedure TFFMpegDecodeStream.PauseParser(); begin - LockDecoder(); - Result := seekRequest; - UnlockDecoder(); + if (SDL_ThreadID() = ParseThread.threadid) then + Exit; + + SDL_mutexP(StateLock); + Inc(ParserPauseRequestCount); + while (ParserLocked) do + SDL_CondWait(ParserUnlockedCond, StateLock); + SDL_mutexV(StateLock); end; -*) -function TFFMpegDecodeStream.GetPosition(): real; +procedure TFFMpegDecodeStream.ResumeParser(); begin - // FIXME: the audio-clock might not be that accurate - // see: tutorial on synching (audio-clock) - Result := audioClock; + if (SDL_ThreadID() = ParseThread.threadid) then + Exit; + + SDL_mutexP(StateLock); + Dec(ParserPauseRequestCount); + SDL_CondSignal(ParserResumeCond); + SDL_mutexV(StateLock); end; -procedure TFFMpegDecodeStream.SetPosition(Time: real); +procedure TFFMpegDecodeStream.SetPositionIntern(Time: real; Flush: boolean; Blocking: boolean); begin - LockParser(); - - seekPos := Trunc(Time * AV_TIME_BASE); + // - Pause the parser first to prevent it from putting obsolete packages + // into the queue after the queue was flushed and before seeking is done. + // Otherwise we will hear fragments of old data, if the stream was seeked + // in stopped mode and resumed afterwards (applies to non-blocking mode only). + // - Pause the decoder to avoid race-condition that might occur otherwise. + // - Last lock the state lock because we are manipulating some shared state-vars. + PauseParser(); + PauseDecoder(); + SDL_mutexP(StateLock); + + // configure seek parameters + SeekPos := Time; + SeekFlush := Flush; + SeekFlags := AVSEEK_FLAG_ANY; + SeekRequest := true; - seekFlags := 0; // Note: the BACKWARD-flag seeks to the first position <= the position // searched for. Otherwise e.g. position 0 might not be seeked correct. // For some reason ffmpeg sometimes doesn't use position 0 but the key-frame // following. In streams with few key-frames (like many flv-files) the next // key-frame after 0 might be 5secs ahead. - if (Time < audioClock) then - seekFlags := AVSEEK_FLAG_BACKWARD; - seekFlags := AVSEEK_FLAG_ANY; - -LockDecoder(); - seekRequest := true; -UnlockDecoder(); - SDL_CondSignal(resumeCond); - (* - while ((not quitRequest) and seekRequest) do - SDL_CondWait(seekCond, GetParserMutex()); - *) - UnlockParser(); + if (Time < AudioStreamPos) then + SeekFlags := SeekFlags or AVSEEK_FLAG_BACKWARD; + + EOFState := false; + ErrorState := false; + + // send a reuse signal in case the parser was stopped (e.g. because of an EOF) + SDL_CondSignal(ParserIdleCond); + + SDL_mutexV(StateLock); + ResumeDecoder(); + ResumeParser(); + + // in blocking mode, wait until seeking is done + if (Blocking) then + begin + SDL_mutexP(StateLock); + while (SeekRequest) do + SDL_CondWait(SeekFinishedCond, StateLock); + SDL_mutexV(StateLock); + end; end; -function DecodeThreadMain(streamPtr: Pointer): integer; cdecl; +function ParseThreadMain(Data: Pointer): integer; cdecl; var - stream: TFFMpegDecodeStream; + Stream: TFFMpegDecodeStream; begin - stream := TFFMpegDecodeStream(streamPtr); - stream.ParseAudio(); - result := 0; + Stream := TFFMpegDecodeStream(Data); + if (Stream <> nil) then + Stream.Parse(); + Result := 0; +end; + +procedure TFFMpegDecodeStream.Parse(); +begin + // reuse thread as long as the stream is not terminated + while (ParseLoop()) do + begin + // wait for reuse or destruction of stream + SDL_mutexP(StateLock); + while (not (SeekRequest or QuitRequest)) do + SDL_CondWait(ParserIdleCond, StateLock); + SDL_mutexV(StateLock); + end; end; -procedure TFFMpegDecodeStream.ParseAudio(); +(** + * Parser main loop. + * Will not return until parsing of the stream is finished. + * Reasons for the parser to return are: + * - the end-of-file is reached + * - an error occured + * - the stream was quited (received a quit-request) + * Returns true if the stream can be resumed or false if the stream has to + * be terminated. + *) +function TFFMpegDecodeStream.ParseLoop(): boolean; var - packet: TAVPacket; - statusPacket: PAVPacket; - seekTarget: int64; - stopParsing: boolean; - pbIOCtx: PByteIOContext; - err: integer; - index: integer; + Packet: TAVPacket; + StatusPacket: PAVPacket; + SeekTarget: int64; + ByteIOCtx: PByteIOContext; + ErrorCode: integer; + StartSilence: double; // duration of silence at start of stream + StartSilencePtr: PDouble; // pointer for the EMPTY status packet + + // Note: pthreads wakes threads waiting on a mutex in the order of their + // priority and not in FIFO order. SDL does not provide any option to + // control priorities. This might (and already did) starve threads waiting + // on the mutex (e.g. SetPosition) making usdx look like it was froozen. + // Instead of simply locking the critical section we set a ParserLocked flag + // instead and give priority to the threads requesting the parser to pause. + procedure LockParser(); + begin + SDL_mutexP(StateLock); + while (ParserPauseRequestCount > 0) do + SDL_CondWait(ParserResumeCond, StateLock); + ParserLocked := true; + SDL_mutexV(StateLock); + end; + + procedure UnlockParser(); + begin + SDL_mutexP(StateLock); + ParserLocked := false; + SDL_CondBroadcast(ParserUnlockedCond); + SDL_mutexV(StateLock); + end; + begin - stopParsing := false; + Result := true; while (true) do begin LockParser(); + try - // wait if end-of-file reached - if (stopParsing) then - begin - // wait for reuse or destruction of stream - while not (seekRequest or quitRequest) do - SDL_CondWait(resumeCond, GetParserMutex()); - end; - - if (quitRequest) then - begin - UnlockParser(); - break; - end; - - // handle seek-request - if (seekRequest) then - begin - // reset status - SetEOF(false); - SetError(false); - stopParsing := false; - - seekTarget := av_rescale_q(seekPos, AV_TIME_BASE_Q, ffmpegStream^.time_base); - err := av_seek_frame(pFormatCtx, ffmpegStreamIndex, seekTarget, seekFlags); - // seeking failed -> retry with the default stream (necessary for flv-videos and some ogg-files) - if (err < 0) then - err := av_seek_frame(pFormatCtx, -1, seekPos, seekFlags); - // check if seeking failed - if (err < 0) then + if (IsQuit()) then begin - Log.LogStatus('Seek Error in "'+pFormatCtx^.filename+'"', 'UAudioDecoder_FFMpeg'); - end - else - begin - packetQueue.Flush(); - packetQueue.PutStatus(PKT_STATUS_FLAG_FLUSH, nil); + Result := false; + Exit; end; - LockDecoder(); - seekRequest := false; - UnlockDecoder(); - SDL_CondSignal(seekCond); - end; - - UnlockParser(); - if (packetQueue.size > MAX_AUDIOQ_SIZE) then - begin - SDL_Delay(10); - continue; - end; - - if (av_read_frame(pFormatCtx, packet) < 0) then - begin - // failed to read a frame, check reason + // handle seek-request (Note: no need to lock SeekRequest here) + if (SeekRequest) then + begin + // first try: seek on the audio stream + SeekTarget := Round(SeekPos / av_q2d(AudioStream^.time_base)); + StartSilence := 0; + if (SeekTarget < AudioStream^.start_time) then + StartSilence := (AudioStream^.start_time - SeekTarget) * av_q2d(AudioStream^.time_base); + ErrorCode := av_seek_frame(FormatCtx, AudioStreamIndex, SeekTarget, SeekFlags); + + if (ErrorCode < 0) then + begin + // second try: seek on the default stream (necessary for flv-videos and some ogg-files) + SeekTarget := Round(SeekPos * AV_TIME_BASE); + StartSilence := 0; + if (SeekTarget < FormatCtx^.start_time) then + StartSilence := (FormatCtx^.start_time - SeekTarget) / AV_TIME_BASE; + ErrorCode := av_seek_frame(FormatCtx, -1, SeekTarget, SeekFlags); + end; - {$IF (LIBAVFORMAT_VERSION_MAJOR >= 52)} - pbIOCtx := pFormatCtx^.pb; - {$ELSE} - pbIOCtx := @pFormatCtx^.pb; - {$IFEND} + // pause decoder and lock state (keep the lock-order to avoid deadlocks). + // Note that the decoder does not block in the packet-queue in seeking state, + // so locking the decoder here does not cause a dead-lock. + PauseDecoder(); + SDL_mutexP(StateLock); + try + if (ErrorCode < 0) then + begin + // seeking failed + ErrorState := true; + Log.LogStatus('Seek Error in "'+FormatCtx^.filename+'"', 'UAudioDecoder_FFMpeg'); + end + else + begin + if (SeekFlush) then + begin + // flush queue (we will send a Flush-Packet when seeking is finished) + PacketQueue.Flush(); + + // flush the decode buffers + AudioBufferSize := 0; + AudioBufferPos := 0; + AudioPaketSize := 0; + AudioPaketSilence := 0; + FlushCodecBuffers(); + + // Set preliminary stream position. The position will be set to + // the correct value as soon as the first packet is decoded. + AudioStreamPos := SeekPos; + end + else + begin + // request avcodec buffer flush + PacketQueue.PutStatus(PKT_STATUS_FLAG_FLUSH, nil); + end; + + // fill the gap between position 0 and start_time with silence + // but not if we are in loop mode + if ((StartSilence > 0) and (not Loop)) then + begin + GetMem(StartSilencePtr, SizeOf(StartSilence)); + StartSilencePtr^ := StartSilence; + PacketQueue.PutStatus(PKT_STATUS_FLAG_EMPTY, StartSilencePtr); + end; + end; + + SeekRequest := false; + SDL_CondBroadcast(SeekFinishedCond); + finally + SDL_mutexV(StateLock); + ResumeDecoder(); + end; + end; - // check for end-of-file (eof is not an error) - if (url_feof(pbIOCtx) <> 0) then + if (PacketQueue.GetSize() > MAX_AUDIOQ_SIZE) then begin - // signal end-of-file - packetQueue.putStatus(PKT_STATUS_FLAG_EOF, nil); - stopParsing := true; - continue; + SDL_Delay(10); + Continue; end; - // check for errors - if (url_ferror(pbIOCtx) <> 0) then + if (av_read_frame(FormatCtx, Packet) < 0) then begin - // an error occured -> abort and wait for repositioning or termination - packetQueue.putStatus(PKT_STATUS_FLAG_ERROR, nil); - stopParsing := true; - continue; + // failed to read a frame, check reason + {$IF (LIBAVFORMAT_VERSION_MAJOR >= 52)} + ByteIOCtx := FormatCtx^.pb; + {$ELSE} + ByteIOCtx := @FormatCtx^.pb; + {$IFEND} + + // check for end-of-file (eof is not an error) + if (url_feof(ByteIOCtx) <> 0) then + begin + if (GetLoop()) then + begin + // rewind stream (but do not flush) + SetPositionIntern(0, false, false); + Continue; + end + else + begin + // signal end-of-file + PacketQueue.PutStatus(PKT_STATUS_FLAG_EOF, nil); + Exit; + end; + end; + + // check for errors + if (url_ferror(ByteIOCtx) <> 0) then + begin + // an error occured -> abort and wait for repositioning or termination + PacketQueue.PutStatus(PKT_STATUS_FLAG_ERROR, nil); + Exit; + end; + + // no error -> wait for user input + SDL_Delay(100); + Continue; end; - // no error -> wait for user input - SDL_Delay(100); - continue; + if (Packet.stream_index = AudioStreamIndex) then + PacketQueue.Put(@Packet) + else + av_free_packet(@Packet); + + finally + UnlockParser(); end; + end; +end; - if (packet.stream_index = ffmpegStreamIndex) then - begin - packetQueue.put(@packet); - end - else - begin - av_free_packet(@packet); + +(******************************************** + * Decoder section + ********************************************) + +procedure TFFMpegDecodeStream.PauseDecoder(); +begin + SDL_mutexP(StateLock); + Inc(DecoderPauseRequestCount); + while (DecoderLocked) do + SDL_CondWait(DecoderUnlockedCond, StateLock); + SDL_mutexV(StateLock); +end; + +procedure TFFMpegDecodeStream.ResumeDecoder(); +begin + SDL_mutexP(StateLock); + Dec(DecoderPauseRequestCount); + SDL_CondSignal(DecoderResumeCond); + SDL_mutexV(StateLock); +end; + +procedure TFFMpegDecodeStream.FlushCodecBuffers(); +begin + // if no flush operation is specified, avcodec_flush_buffers will not do anything. + if (@CodecCtx.codec.flush <> nil) then + begin + // flush buffers used by avcodec_decode_audio, etc. + avcodec_flush_buffers(CodecCtx); + end + else + begin + // we need a Workaround to avoid plopping noise with ogg-vorbis and + // mp3 (in older versions of FFMpeg). + // We will just reopen the codec. + FFMpegCore.LockAVCodec(); + try + avcodec_close(CodecCtx); + avcodec_open(CodecCtx, Codec); + finally + FFMpegCore.UnlockAVCodec(); end; end; end; -function TFFMpegDecodeStream.DecodeFrame(var buffer: TAudioBuffer; bufSize: integer): integer; +function TFFMpegDecodeStream.DecodeFrame(Buffer: PChar; BufferSize: integer): integer; var - len1, - data_size: integer; + PaketDecodedSize: integer; // size of packet data used for decoding + DataSize: integer; // size of output data decoded by FFMpeg + BlockQueue: boolean; + SilenceDuration: double; + {$IFDEF DebugFFMpegDecode} + TmpPos: double; + {$ENDIF} begin - result := -1; + Result := -1; - if EOF then - exit; + if (EOF) then + Exit; while(true) do begin - while (audio_pkt_size > 0) do + // for titles with start_time > 0 we have to generate silence + // until we reach the pts of the first data packet. + if (AudioPaketSilence > 0) then + begin + DataSize := Min(AudioPaketSilence, BufferSize); + FillChar(Buffer[0], DataSize, 0); + Dec(AudioPaketSilence, DataSize); + AudioStreamPos := AudioStreamPos + DataSize / FormatInfo.BytesPerSec; + Result := DataSize; + Exit; + end; + + // read packet data + while (AudioPaketSize > 0) do begin - data_size := bufSize; + DataSize := BufferSize; {$IF LIBAVCODEC_VERSION >= 51030000} // 51.30.0 - len1 := avcodec_decode_audio2(pCodecCtx, @buffer, - data_size, audio_pkt_data, audio_pkt_size); + PaketDecodedSize := avcodec_decode_audio2(CodecCtx, PSmallint(Buffer), + DataSize, AudioPaketData, AudioPaketSize); {$ELSE} - // FIXME: with avcodec_decode_audio a package could contain several frames - // this is not handled yet - len1 := avcodec_decode_audio(pCodecCtx, @buffer, - data_size, audio_pkt_data, audio_pkt_size); + PaketDecodedSize := avcodec_decode_audio(CodecCtx, PSmallint(Buffer), + DataSize, AudioPaketData, AudioPaketSize); {$IFEND} - if(len1 < 0) then + if(PaketDecodedSize < 0) then begin // if error, skip frame {$IFDEF DebugFFMpegDecode} - DebugWriteln( 'Skip audio frame' ); + DebugWriteln('Skip audio frame'); {$ENDIF} - audio_pkt_size := 0; - break; + AudioPaketSize := 0; + Break; end; - Inc(audio_pkt_data, len1); - Dec(audio_pkt_size, len1); - - if (data_size <= 0) then - begin - // no data yet, get more frames - continue; - end; + Inc(AudioPaketData, PaketDecodedSize); + Dec(AudioPaketSize, PaketDecodedSize); - //pts := audioClock; - audioClock := audioClock + data_size / - (1.0 * formatInfo.FrameSize * formatInfo.SampleRate); + // check if avcodec_decode_audio returned data, otherwise fetch more frames + if (DataSize <= 0) then + Continue; + // update stream position by the amount of fetched data + AudioStreamPos := AudioStreamPos + DataSize / FormatInfo.BytesPerSec; + // we have data, return it and come back for more later - result := data_size; - exit; + Result := DataSize; + Exit; end; - if (pkt.data <> nil) then - begin - av_free_packet(@pkt); - end; + // free old packet data + if (AudioPaket.data <> nil) then + av_free_packet(@AudioPaket); - // do not use an aborted queue - if (packetQueue.abortRequest) then - exit; + // do not block queue on seeking (to avoid deadlocks on the DecoderLock) + if (IsSeeking()) then + BlockQueue := false + else + BlockQueue := true; - // request a new packet and block if non available. + // request a new packet and block if none available. // If this fails, the queue was aborted. - if (packetQueue.Get(pkt, true) < 0) then - exit; + if (PacketQueue.Get(AudioPaket, BlockQueue) <= 0) then + Exit; // handle Status-packet - if (PChar(pkt.data) = STATUS_PACKET) then + if (PChar(AudioPaket.data) = STATUS_PACKET) then begin - pkt.data := nil; - audio_pkt_data := nil; - audio_pkt_size := 0; + AudioPaket.data := nil; + AudioPaketData := nil; + AudioPaketSize := 0; - case (pkt.flags) of + case (AudioPaket.flags) of PKT_STATUS_FLAG_FLUSH: begin - avcodec_flush_buffers(pCodecCtx); + // just used if SetPositionIntern was called without the flush flag. + FlushCodecBuffers; end; PKT_STATUS_FLAG_EOF: // end-of-file begin - SetEOF(true); + // ignore EOF while seeking + if (not IsSeeking()) then + SetEOF(true); // buffer contains no data -> result = -1 - exit; + Exit; end; PKT_STATUS_FLAG_ERROR: begin SetError(true); Log.LogStatus('I/O Error', 'TFFMpegDecodeStream.DecodeFrame'); - exit; + Exit; end; + PKT_STATUS_FLAG_EMPTY: + begin + SilenceDuration := PDouble(PacketQueue.GetStatusInfo(AudioPaket))^; + AudioPaketSilence := Round(SilenceDuration * FormatInfo.SampleRate) * FormatInfo.FrameSize; + PacketQueue.FreeStatusInfo(AudioPaket); + end else begin Log.LogStatus('Unknown status', 'TFFMpegDecodeStream.DecodeFrame'); end; end; - continue; + Continue; end; - audio_pkt_data := PChar(pkt.data); - audio_pkt_size := pkt.size; + AudioPaketData := PChar(AudioPaket.data); + AudioPaketSize := AudioPaket.size; - // if available, update the audio clock with pts - if(pkt.pts <> AV_NOPTS_VALUE) then + // if available, update the stream position to the presentation time of this package + if(AudioPaket.pts <> AV_NOPTS_VALUE) then begin - audioClock := av_q2d(ffmpegStream^.time_base) * pkt.pts; + {$IFDEF DebugFFMpegDecode} + TmpPos := AudioStreamPos; + {$ENDIF} + AudioStreamPos := av_q2d(AudioStream^.time_base) * AudioPaket.pts; + {$IFDEF DebugFFMpegDecode} + DebugWriteln('Timestamp: ' + floattostrf(AudioStreamPos, ffFixed, 15, 3) + ' ' + + '(Calc: ' + floattostrf(TmpPos, ffFixed, 15, 3) + '), ' + + 'Diff: ' + floattostrf(AudioStreamPos-TmpPos, ffFixed, 15, 3)); + {$ENDIF} end; end; end; -function TFFMpegDecodeStream.ReadData(Buffer : PChar; BufSize: integer): integer; +function TFFMpegDecodeStream.ReadData(Buffer: PChar; BufferSize: integer): integer; var - nBytesCopy: integer; // number of bytes to copy - nBytesRemain: integer; // number of bytes left (remaining) to read -begin - result := -1; + CopyByteCount: integer; // number of bytes to copy + RemainByteCount: integer; // number of bytes left (remain) to read + BufferPos: integer; - // init number of bytes left to copy to the output buffer - nBytesRemain := BufSize; + // prioritize pause requests + procedure LockDecoder(); + begin + SDL_mutexP(StateLock); + while (DecoderPauseRequestCount > 0) do + SDL_CondWait(DecoderResumeCond, StateLock); + DecoderLocked := true; + SDL_mutexV(StateLock); + end; + + procedure UnlockDecoder(); + begin + SDL_mutexP(StateLock); + DecoderLocked := false; + SDL_CondBroadcast(DecoderUnlockedCond); + SDL_mutexV(StateLock); + end; - // leave if end-of-file was reached previously - if EOF then - exit; +begin + Result := -1; + + // set number of bytes to copy to the output buffer + BufferPos := 0; LockDecoder(); try - if (seekRequest) then - begin - Result := 0; + // leave if end-of-file is reached + if (EOF) then Exit; - end; - finally - UnlockDecoder(); - end; - // copy data to output buffer - while (nBytesRemain > 0) do begin - // check if we need more data - if (audio_buf_index >= audio_buf_size) then + // copy data to output buffer + while (BufferPos < BufferSize) do begin - // we have already sent all our data; get more - audio_buf_size := DecodeFrame(audio_buf, sizeof(TAudioBuffer)); - // check for errors or EOF - if(audio_buf_size < 0) then + // check if we need more data + if (AudioBufferPos >= AudioBufferSize) then begin - // fill decode-buffer with silence - audio_buf_size := 1024; - FillChar(audio_buf, audio_buf_size, #0); + AudioBufferPos := 0; + + // we have already sent all our data; get more + AudioBufferSize := DecodeFrame(AudioBuffer, AUDIO_BUFFER_SIZE); + + // check for errors or EOF + if(AudioBufferSize < 0) then + begin + Result := BufferPos; + Exit; + end; end; - audio_buf_index := 0; - end; - // calc number of new bytes in the decode-buffer - nBytesCopy := audio_buf_size - audio_buf_index; - // resize copy-count if more bytes available than needed (remaining bytes are used the next time) - if (nBytesCopy > nBytesRemain) then - nBytesCopy := nBytesRemain; + // calc number of new bytes in the decode-buffer + CopyByteCount := AudioBufferSize - AudioBufferPos; + // resize copy-count if more bytes available than needed (remaining bytes are used the next time) + RemainByteCount := BufferSize - BufferPos; + if (CopyByteCount > RemainByteCount) then + CopyByteCount := RemainByteCount; - Move(audio_buf[audio_buf_index], Buffer[0], nBytesCopy); + Move(AudioBuffer[AudioBufferPos], Buffer[BufferPos], CopyByteCount); - Dec(nBytesRemain, nBytesCopy); - Inc(Buffer, nBytesCopy); - Inc(audio_buf_index, nBytesCopy); + Inc(BufferPos, CopyByteCount); + Inc(AudioBufferPos, CopyByteCount); + end; + finally + UnlockDecoder(); end; - Result := BufSize; + Result := BufferSize; end; @@ -708,9 +1058,8 @@ end; function TAudioDecoder_FFMpeg.InitializeDecoder: boolean; begin //Log.LogStatus('InitializeDecoder', 'UAudioDecoder_FFMpeg'); - + FFMpegCore := TMediaCore_FFMpeg.GetInstance(); av_register_all(); - Result := true; end; @@ -719,293 +1068,24 @@ begin Result := true; end; -class function TAudioDecoder_FFMpeg.FindAudioStreamIndex(pFormatCtx : PAVFormatContext): integer; -var - i : integer; - streamIndex: integer; - stream : PAVStream; -begin - // find the first audio stream - streamIndex := -1; - - for i := 0 to pFormatCtx^.nb_streams-1 do - begin - //Log.LogStatus('aFormatCtx.streams[i] : ' + inttostr(i), 'UAudio_FFMpeg'); - stream := pFormatCtx^.streams[i]; - - if ( stream.codec^.codec_type = CODEC_TYPE_AUDIO ) then - begin - //Log.LogStatus('Found Audio Stream', 'UAudio_FFMpeg'); - streamIndex := i; - break; - end; - end; - - Result := streamIndex; -end; - function TAudioDecoder_FFMpeg.Open(const Filename: string): TAudioDecodeStream; var - pFormatCtx : PAVFormatContext; - pCodecCtx : PAVCodecContext; - pCodec : PAVCodec; - ffmpegStreamID : Integer; - ffmpegStream : PAVStream; - stream : TFFMpegDecodeStream; + Stream: TFFMpegDecodeStream; begin Result := nil; - if (not FileExists(Filename)) then - begin - Log.LogError('Audio-file does not exist: "' + Filename + '"', 'UAudio_FFMpeg'); - exit; - end; - - // open audio file - if (av_open_input_file(pFormatCtx, PChar(Filename), nil, 0, nil) <> 0) then + Stream := TFFMpegDecodeStream.Create(); + if (not Stream.Open(Filename)) then begin - Log.LogError('av_open_input_file failed: "' + Filename + '"', 'UAudio_FFMpeg'); - exit; - end; - - // TODO: do we need to generate PTS values if they do not exist? - //pFormatCtx^.flags := pFormatCtx^.flags or AVFMT_FLAG_GENPTS; - - // retrieve stream information - if (av_find_stream_info(pFormatCtx) < 0) then - begin - Log.LogError('av_find_stream_info failed: "' + Filename + '"', 'UAudio_FFMpeg'); - av_close_input_file(pFormatCtx); - exit; - end; - - // FIXME: hack used by ffplay. Maybe should not use url_feof() to test for the end - pFormatCtx^.pb.eof_reached := 0; - - {$IFDEF DebugFFMpegDecode} - dump_format(pFormatCtx, 0, pchar(Filename), 0); - {$ENDIF} - - ffmpegStreamID := FindAudioStreamIndex(pFormatCtx); - if (ffmpegStreamID < 0) then - begin - Log.LogError('FindAudioStreamIndex: No Audio-stream found "' + Filename + '"', 'UAudio_FFMpeg'); - av_close_input_file(pFormatCtx); - exit; - end; - - //Log.LogStatus('AudioStreamIndex is: '+ inttostr(ffmpegStreamID), 'UAudio_FFMpeg'); - - ffmpegStream := pFormatCtx.streams[ffmpegStreamID]; - pCodecCtx := ffmpegStream^.codec; - - pCodec := avcodec_find_decoder(pCodecCtx^.codec_id); - if (pCodec = nil) then - begin - Log.LogError('Unsupported codec!', 'UAudio_FFMpeg'); - av_close_input_file(pFormatCtx); - exit; - end; - - // set debug options - pCodecCtx^.debug_mv := 0; - pCodecCtx^.debug := 0; - - // detect bug-workarounds automatically - pCodecCtx^.workaround_bugs := FF_BUG_AUTODETECT; - // error resilience strategy (careful/compliant/agressive/very_aggressive) - //pCodecCtx^.error_resilience := FF_ER_CAREFUL; //FF_ER_COMPLIANT; - // allow non spec compliant speedup tricks. - //pCodecCtx^.flags2 := pCodecCtx^.flags2 or CODEC_FLAG2_FAST; - - // Note: avcodec_open() is not thread-safe! - if (avcodec_open(pCodecCtx, pCodec) < 0) then - begin - Log.LogError('avcodec_open failed!', 'UAudio_FFMpeg'); - exit; - end; - - // TODO: what about pCodecCtx^.start_time? Should we seek to this position here? - // ... - - stream := TFFMpegDecodeStream.Create(pFormatCtx, pCodecCtx, pCodec, - ffmpegStreamID, ffmpegStream); - - Result := stream; -end; - - -{ TPacketQueue } - -constructor TPacketQueue.Create(); -begin - inherited; - - firstPkt := nil; - lastPkt := nil; - nbPackets := 0; - size := 0; - - mutex := SDL_CreateMutex(); - cond := SDL_CreateCond(); -end; - -destructor TPacketQueue.Destroy(); -begin - Flush(); - SDL_DestroyMutex(mutex); - SDL_DestroyCond(cond); - inherited; -end; - -procedure TPacketQueue.Abort(); -begin - SDL_LockMutex(mutex); - - abortRequest := true; - - SDL_CondSignal(cond); - SDL_UnlockMutex(mutex); -end; - -function TPacketQueue.Put(pkt : PAVPacket): integer; -var - pkt1 : PAVPacketList; -begin - result := -1; - - if (pkt = nil) then - exit; - - if (PChar(pkt^.data) <> STATUS_PACKET) then - begin - if (av_dup_packet(pkt) < 0) then - exit; - end; - - pkt1 := av_malloc(sizeof(TAVPacketList)); - if (pkt1 = nil) then - exit; - - pkt1^.pkt := pkt^; - pkt1^.next := nil; - - SDL_LockMutex(Self.mutex); - try - if (Self.lastPkt = nil) then - Self.firstPkt := pkt1 - else - Self.lastPkt^.next := pkt1; - - Self.lastPkt := pkt1; - inc(Self.nbPackets); - - Self.size := Self.size + pkt1^.pkt.size; - SDL_CondSignal(Self.cond); - finally - SDL_UnlockMutex(Self.mutex); - end; - - Result := 0; -end; - -function TPacketQueue.PutStatus(statusFlag: integer; statusInfo: Pointer): integer; -var - pkt: PAVPacket; -begin - // create temp. package - pkt := av_malloc(SizeOf(TAVPacket)); - if (pkt = nil) then - begin - Result := -1; + Stream.Free; Exit; end; - // init package - av_init_packet(pkt^); - pkt^.data := Pointer(STATUS_PACKET); - pkt^.flags := statusFlag; - pkt^.priv := statusInfo; - // put a copy of the package into the queue - Result := Put(pkt); - // data has been copied -> delete temp. package - av_free(pkt); -end; - -function TPacketQueue.Get(var pkt: TAVPacket; block: boolean): integer; -var - pkt1 : PAVPacketList; -begin - Result := -1; - - SDL_LockMutex(Self.mutex); - try - while true do - begin - if (abortRequest) then - exit; - - pkt1 := Self.firstPkt; - if (pkt1 <> nil) then - begin - Self.firstPkt := pkt1^.next; - if (Self.firstPkt = nil) then - Self.lastPkt := nil; - dec(Self.nbPackets); - - Self.size := Self.size - pkt1^.pkt.size; - pkt := pkt1^.pkt; - av_free(pkt1); - - result := 1; - break; - end - else if (not block) then - begin - result := 0; - break; - end - else - begin - SDL_CondWait(Self.cond, Self.mutex); - end; - end; - finally - SDL_UnlockMutex(Self.mutex); - end; -end; - -procedure TPacketQueue.Flush(); -var - pkt, pkt1: PAVPacketList; -begin - SDL_LockMutex(Self.mutex); - pkt := Self.firstPkt; - while(pkt <> nil) do - begin - pkt1 := pkt^.next; - av_free_packet(@pkt^.pkt); - // Note: param must be a pointer to a pointer! - av_freep(@pkt); - pkt := pkt1; - end; - Self.lastPkt := nil; - Self.firstPkt := nil; - Self.nbPackets := 0; - Self.size := 0; - - SDL_UnlockMutex(Self.mutex); + Result := Stream; end; initialization - singleton_AudioDecoderFFMpeg := TAudioDecoder_FFMpeg.create(); - - //writeln( 'UAudioDecoder_FFMpeg - Register Decoder' ); - AudioManager.add( singleton_AudioDecoderFFMpeg ); - -finalization - AudioManager.Remove( singleton_AudioDecoderFFMpeg ); - + MediaManager.Add(TAudioDecoder_FFMpeg.Create); end. diff --git a/Game/Code/Classes/UAudioInput_Bass.pas b/Game/Code/Classes/UAudioInput_Bass.pas index d086a23a..65a4704d 100644 --- a/Game/Code/Classes/UAudioInput_Bass.pas +++ b/Game/Code/Classes/UAudioInput_Bass.pas @@ -57,8 +57,7 @@ type end; var - AudioCore: TAudioCore_Bass; - singleton_AudioInputBass : IAudioInput; + BassCore: TAudioCore_Bass; { Global } @@ -96,9 +95,9 @@ begin begin // get input settings flags := BASS_RecordGetInput(i, PSingle(nil)^); - if (flags = -1) then + if (flags = DWORD(-1)) then begin - Log.LogError('BASS_RecordGetInput: ' + AudioCore.ErrorGetString(), 'TBassInputDevice.GetInputSource'); + Log.LogError('BASS_RecordGetInput: ' + BassCore.ErrorGetString(), 'TBassInputDevice.GetInputSource'); Exit; end; @@ -130,7 +129,7 @@ begin // turn on selected source (turns off the others for single-in devices) if (not BASS_RecordSetInput(SourceIndex, BASS_INPUT_ON, -1)) then begin - Log.LogError('BASS_RecordSetInput: ' + AudioCore.ErrorGetString(), 'TBassInputDevice.Start'); + Log.LogError('BASS_RecordSetInput: ' + BassCore.ErrorGetString(), 'TBassInputDevice.Start'); Exit; end; @@ -143,9 +142,9 @@ begin continue; // get input settings flags := BASS_RecordGetInput(i, PSingle(nil)^); - if (flags = -1) then + if (flags = DWORD(-1)) then begin - Log.LogError('BASS_RecordGetInput: ' + AudioCore.ErrorGetString(), 'TBassInputDevice.GetInputSource'); + Log.LogError('BASS_RecordGetInput: ' + BassCore.ErrorGetString(), 'TBassInputDevice.GetInputSource'); Exit; end; // deselect source if selected @@ -169,11 +168,11 @@ begin if (not BASS_RecordInit(BassDeviceID)) then begin Log.LogError('BASS_RecordInit['+Name+']: ' + - AudioCore.ErrorGetString(), 'TBassInputDevice.Open'); + BassCore.ErrorGetString(), 'TBassInputDevice.Open'); Exit; end; - if (not AudioCore.ConvertAudioFormatToBASSFlags(AudioFormat.Format, FormatFlags)) then + if (not BassCore.ConvertAudioFormatToBASSFlags(AudioFormat.Format, FormatFlags)) then begin Log.LogError('Unhandled sample-format', 'TBassInputDevice.Open'); Exit; @@ -185,7 +184,7 @@ begin @MicrophoneCallback, Self); if (RecordStream = 0) then begin - Log.LogError('BASS_RecordStart: ' + AudioCore.ErrorGetString(), 'TBassInputDevice.Open'); + Log.LogError('BASS_RecordStart: ' + BassCore.ErrorGetString(), 'TBassInputDevice.Open'); BASS_RecordFree; Exit; end; @@ -222,7 +221,7 @@ begin if (not BASS_ChannelPlay(RecordStream, true)) then begin - Log.LogError('BASS_ChannelPlay: ' + AudioCore.ErrorGetString(), 'TBassInputDevice.Start'); + Log.LogError('BASS_ChannelPlay: ' + BassCore.ErrorGetString(), 'TBassInputDevice.Start'); Exit; end; @@ -241,7 +240,7 @@ begin if (not BASS_ChannelStop(RecordStream)) then begin - Log.LogError('BASS_ChannelStop: ' + AudioCore.ErrorGetString(), 'TBassInputDevice.Stop'); + Log.LogError('BASS_ChannelStop: ' + BassCore.ErrorGetString(), 'TBassInputDevice.Stop'); end; // TODO: Do not close the device here (takes too much time). @@ -259,7 +258,7 @@ begin // free data if (not BASS_RecordFree()) then begin - Log.LogError('BASS_RecordFree: ' + AudioCore.ErrorGetString(), 'TBassInputDevice.Close'); + Log.LogError('BASS_RecordFree: ' + BassCore.ErrorGetString(), 'TBassInputDevice.Close'); Result := false; end else @@ -286,9 +285,9 @@ begin Exit; end; - if (BASS_RecordGetInput(SourceIndex, lVolume) = -1) then + if (BASS_RecordGetInput(SourceIndex, lVolume) = DWORD(-1)) then begin - Log.LogError('BASS_RecordGetInput: ' + AudioCore.ErrorGetString() , 'TBassInputDevice.GetVolume'); + Log.LogError('BASS_RecordGetInput: ' + BassCore.ErrorGetString() , 'TBassInputDevice.GetVolume'); Exit; end; Result := lVolume; @@ -315,7 +314,7 @@ begin if (not BASS_RecordSetInput(SourceIndex, 0, Volume)) then begin - Log.LogError('BASS_RecordSetInput: ' + AudioCore.ErrorGetString() , 'TBassInputDevice.SetVolume'); + Log.LogError('BASS_RecordSetInput: ' + BassCore.ErrorGetString() , 'TBassInputDevice.SetVolume'); end; end; @@ -465,7 +464,7 @@ end; function TAudioInput_Bass.InitializeRecord(): boolean; begin - AudioCore := TAudioCore_Bass.GetInstance(); + BassCore := TAudioCore_Bass.GetInstance(); Result := EnumDevices(); end; @@ -477,10 +476,6 @@ end; initialization - singleton_AudioInputBass := TAudioInput_Bass.create(); - AudioManager.add( singleton_AudioInputBass ); - -finalization - AudioManager.Remove( singleton_AudioInputBass ); + MediaManager.Add(TAudioInput_Bass.Create); end. diff --git a/Game/Code/Classes/UAudioInput_Portaudio.pas b/Game/Code/Classes/UAudioInput_Portaudio.pas index 50543e17..9a1c3e99 100644 --- a/Game/Code/Classes/UAudioInput_Portaudio.pas +++ b/Game/Code/Classes/UAudioInput_Portaudio.pas @@ -63,9 +63,6 @@ function MicrophoneTestCallback(input: Pointer; output: Pointer; frameCount: Lon timeInfo: PPaStreamCallbackTimeInfo; statusFlags: TPaStreamCallbackFlags; inputDevice: Pointer): Integer; cdecl; forward; -var - singleton_AudioInputPortaudio : IAudioInput; - { TPortaudioInputDevice } @@ -472,10 +469,6 @@ end; initialization - singleton_AudioInputPortaudio := TAudioInput_Portaudio.create(); - AudioManager.add( singleton_AudioInputPortaudio ); - -finalization - AudioManager.Remove( singleton_AudioInputPortaudio ); + MediaManager.add(TAudioInput_Portaudio.Create); end. diff --git a/Game/Code/Classes/UAudioPlaybackBase.pas b/Game/Code/Classes/UAudioPlaybackBase.pas index 0251b8e8..2337d43f 100644 --- a/Game/Code/Classes/UAudioPlaybackBase.pas +++ b/Game/Code/Classes/UAudioPlaybackBase.pas @@ -16,13 +16,17 @@ type protected OutputDeviceList: TAudioOutputDeviceList; MusicStream: TAudioPlaybackStream; - // open sound or music stream (used by Open() and OpenSound()) - function OpenStream(const Filename: string): TAudioPlaybackStream; virtual; abstract; + function CreatePlaybackStream(): TAudioPlaybackStream; virtual; abstract; procedure ClearOutputDeviceList(); + function GetLatency(): double; virtual; abstract; + + // open sound or music stream (used by Open() and OpenSound()) + function OpenStream(const Filename: string): TAudioPlaybackStream; + function OpenDecodeStream(const Filename: string): TAudioDecodeStream; public - function GetName: String; virtual; abstract; + function GetName: string; virtual; abstract; - function Open(const Filename: string): boolean; // true if succeed + function Open(const Filename: string): boolean; // true if succeed procedure Close; procedure Play; @@ -30,13 +34,15 @@ type procedure Stop; procedure FadeIn(Time: real; TargetVolume: single); + procedure SetSyncSource(SyncSource: TSyncSource); + procedure SetPosition(Time: real); function GetPosition: real; function InitializePlayback: boolean; virtual; abstract; function FinalizePlayback: boolean; virtual; - // function SetOutputDevice(Device: TAudioOutputDevice): boolean; + //function SetOutputDevice(Device: TAudioOutputDevice): boolean; function GetOutputDeviceList(): TAudioOutputDeviceList; procedure SetAppVolume(Volume: single); virtual; abstract; @@ -48,21 +54,24 @@ type function Length: real; // Sounds - function OpenSound(const Filename: String): TAudioPlaybackStream; - procedure PlaySound(stream: TAudioPlaybackStream); - procedure StopSound(stream: TAudioPlaybackStream); + function OpenSound(const Filename: string): TAudioPlaybackStream; + procedure PlaySound(Stream: TAudioPlaybackStream); + procedure StopSound(Stream: TAudioPlaybackStream); // Equalizer - procedure GetFFTData(var data: TFFTData); + procedure GetFFTData(var Data: TFFTData); // Interface for Visualizer - function GetPCMData(var data: TPCMData): Cardinal; + function GetPCMData(var Data: TPCMData): Cardinal; + + function CreateVoiceStream(Channel: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; virtual; abstract; end; implementation uses + ULog, SysUtils; { TAudioPlaybackBase } @@ -71,6 +80,7 @@ function TAudioPlaybackBase.FinalizePlayback: boolean; begin FreeAndNil(MusicStream); ClearOutputDeviceList(); + Result := true; end; function TAudioPlaybackBase.Open(const Filename: string): boolean; @@ -92,8 +102,64 @@ end; procedure TAudioPlaybackBase.Close; begin - if assigned(MusicStream) then - MusicStream.Close(); + FreeAndNil(MusicStream); +end; + +function TAudioPlaybackBase.OpenDecodeStream(const Filename: String): TAudioDecodeStream; +var + i: integer; +begin + for i := 0 to AudioDecoders.Count-1 do + begin + Result := IAudioDecoder(AudioDecoders[i]).Open(Filename); + if (assigned(Result)) then + begin + Log.LogInfo('Using decoder ' + IAudioDecoder(AudioDecoders[i]).GetName() + + ' for "' + Filename + '"', 'TAudioPlaybackBase.OpenDecodeStream'); + Exit; + end; + end; + Result := nil; +end; + +procedure OnClosePlaybackStream(Stream: TAudioProcessingStream); +var + PlaybackStream: TAudioPlaybackStream; + SourceStream: TAudioSourceStream; +begin + PlaybackStream := TAudioPlaybackStream(Stream); + SourceStream := PlaybackStream.GetSourceStream(); + SourceStream.Free; +end; + +function TAudioPlaybackBase.OpenStream(const Filename: string): TAudioPlaybackStream; +var + PlaybackStream: TAudioPlaybackStream; + DecodeStream: TAudioDecodeStream; +begin + Result := nil; + + //Log.LogStatus('Loading Sound: "' + Filename + '"', 'TAudioPlayback_Bass.OpenStream'); + + DecodeStream := OpenDecodeStream(Filename); + if (not assigned(DecodeStream)) then + begin + Log.LogStatus('Could not open "' + Filename + '"', 'TAudioPlayback_Bass.OpenStream'); + Exit; + end; + + // create a matching playback-stream for the decoder + PlaybackStream := CreatePlaybackStream(); + if (not PlaybackStream.Open(DecodeStream)) then + begin + FreeAndNil(PlaybackStream); + FreeAndNil(DecodeStream); + Exit; + end; + + PlaybackStream.AddOnCloseHandler(OnClosePlaybackStream); + + Result := PlaybackStream; end; procedure TAudioPlaybackBase.Play; @@ -136,6 +202,12 @@ begin MusicStream.Position := Time; end; +procedure TAudioPlaybackBase.SetSyncSource(SyncSource: TSyncSource); +begin + if assigned(MusicStream) then + MusicStream.SetSyncSource(SyncSource); +end; + procedure TAudioPlaybackBase.Rewind; begin SetPosition(0); diff --git a/Game/Code/Classes/UAudioPlayback_Bass.pas b/Game/Code/Classes/UAudioPlayback_Bass.pas index 53fbd921..41a91173 100644 --- a/Game/Code/Classes/UAudioPlayback_Bass.pas +++ b/Game/Code/Classes/UAudioPlayback_Bass.pas @@ -13,64 +13,78 @@ implementation uses Classes, SysUtils, + Math, UIni, UMain, UMusic, UAudioPlaybackBase, UAudioCore_Bass, ULog, + sdl, bass; type PHDSP = ^HDSP; type - // Playback-stream decoded internally by BASS TBassPlaybackStream = class(TAudioPlaybackStream) private Handle: HSTREAM; + NeedsRewind: boolean; + PausedSeek: boolean; // true if a seek was performed in pause state + + procedure Reset(); + function IsEOF(): boolean; + protected + function GetLatency(): double; override; + function GetLoop(): boolean; override; + procedure SetLoop(Enabled: boolean); override; + function GetLength(): real; override; + function GetStatus(): TStreamStatus; override; + function GetVolume(): single; override; + procedure SetVolume(Volume: single); override; + function GetPosition: real; override; + procedure SetPosition(Time: real); override; public - constructor Create(stream: HSTREAM); + constructor Create(); destructor Destroy(); override; - procedure Reset(); + function Open(SourceStream: TAudioSourceStream): boolean; override; + procedure Close(); override; procedure Play(); override; procedure Pause(); override; procedure Stop(); override; procedure FadeIn(Time: real; TargetVolume: single); override; - procedure Close(); override; + procedure AddSoundEffect(Effect: TSoundEffect); override; + procedure RemoveSoundEffect(Effect: TSoundEffect); override; - function GetLoop(): boolean; override; - procedure SetLoop(Enabled: boolean); override; - function GetLength(): real; override; - function GetStatus(): TStreamStatus; override; - function GetVolume(): single; override; - procedure SetVolume(volume: single); override; + procedure GetFFTData(var Data: TFFTData); override; + function GetPCMData(var Data: TPCMData): Cardinal; override; - procedure AddSoundEffect(effect: TSoundEffect); override; - procedure RemoveSoundEffect(effect: TSoundEffect); override; + function GetAudioFormatInfo(): TAudioFormatInfo; override; - function GetPosition: real; override; - procedure SetPosition(Time: real); override; + function ReadData(Buffer: PChar; BufferSize: integer): integer; - procedure GetFFTData(var data: TFFTData); override; - function GetPCMData(var data: TPCMData): Cardinal; override; + property EOF: boolean READ IsEOF; end; - // Playback-stream decoded by an external decoder e.g. FFmpeg - TBassExtDecoderPlaybackStream = class(TBassPlaybackStream) +const + MAX_VOICE_DELAY = 0.020; // 20ms + +type + TBassVoiceStream = class(TAudioVoiceStream) private - DecodeStream: TAudioDecodeStream; + Handle: HSTREAM; public - procedure Stop(); override; - procedure Close(); override; - function GetLength(): real; override; - function GetPosition: real; override; - procedure SetPosition(Time: real); override; + function Open(ChannelMap: integer; FormatInfo: TAudioFormatInfo): boolean; override; + procedure Close(); override; - function SetDecodeStream(decodeStream: TAudioDecodeStream): boolean; + procedure WriteData(Buffer: PChar; BufferSize: integer); override; + function ReadData(Buffer: PChar; BufferSize: integer): integer; override; + function IsEOF(): boolean; override; + function IsError(): boolean; override; end; type @@ -78,12 +92,14 @@ type private function EnumDevices(): boolean; protected - function OpenStream(const Filename: string): TAudioPlaybackStream; override; + function GetLatency(): double; override; + function CreatePlaybackStream(): TAudioPlaybackStream; override; public function GetName: String; override; function InitializePlayback(): boolean; override; function FinalizePlayback: boolean; override; procedure SetAppVolume(Volume: single); override; + function CreateVoiceStream(ChannelMap: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; override; end; TBassOutputDevice = class(TAudioOutputDevice) @@ -92,17 +108,107 @@ type end; var - AudioCore: TAudioCore_Bass; - singleton_AudioPlaybackBass : IAudioPlayback; + BassCore: TAudioCore_Bass; { TBassPlaybackStream } -constructor TBassPlaybackStream.Create(stream: HSTREAM); +function PlaybackStreamHandler(handle: HSTREAM; buffer: Pointer; length: DWORD; user: Pointer): DWORD; +{$IFDEF MSWINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF} +var + PlaybackStream: TBassPlaybackStream; + BytesRead: integer; +begin + PlaybackStream := TBassPlaybackStream(user); + if (not assigned (PlaybackStream)) then + begin + Result := BASS_STREAMPROC_END; + Exit; + end; + + BytesRead := PlaybackStream.ReadData(buffer, length); + // check for errors + if (BytesRead < 0) then + Result := BASS_STREAMPROC_END + // check for EOF + else if (PlaybackStream.EOF) then + Result := BytesRead or BASS_STREAMPROC_END + // no error/EOF + else + Result := BytesRead; +end; + +function TBassPlaybackStream.ReadData(Buffer: PChar; BufferSize: integer): integer; +var + AdjustedSize: integer; + RequestedSourceSize, SourceSize: integer; + SkipCount: integer; + SourceFormatInfo: TAudioFormatInfo; + FrameSize: integer; + PadFrame: PChar; + //Info: BASS_INFO; + //Latency: double; +begin + Result := -1; + + if (not assigned(SourceStream)) then + Exit; + + // sanity check + if (BufferSize = 0) then + begin + Result := 0; + Exit; + end; + + SourceFormatInfo := SourceStream.GetAudioFormatInfo(); + FrameSize := SourceFormatInfo.FrameSize; + + // check how much data to fetch to be in synch + AdjustedSize := Synchronize(BufferSize, SourceFormatInfo); + + // skip data if we are too far behind + SkipCount := AdjustedSize - BufferSize; + while (SkipCount > 0) do + begin + RequestedSourceSize := Min(SkipCount, BufferSize); + SourceSize := SourceStream.ReadData(Buffer, RequestedSourceSize); + // if an error or EOF occured stop skipping and handle error/EOF with the next ReadData() + if (SourceSize <= 0) then + break; + Dec(SkipCount, SourceSize); + end; + + // get source data (e.g. from a decoder) + RequestedSourceSize := Min(AdjustedSize, BufferSize); + SourceSize := SourceStream.ReadData(Buffer, RequestedSourceSize); + if (SourceSize < 0) then + Exit; + + // set preliminary result + Result := SourceSize; + + // if we are to far ahead, fill output-buffer with last frame of source data + // Note that AdjustedSize is used instead of SourceSize as the SourceSize might + // be less than expected because of errors etc. + if (AdjustedSize < BufferSize) then + begin + // use either the last frame for padding or fill with zero + if (SourceSize >= FrameSize) then + PadFrame := @Buffer[SourceSize-FrameSize] + else + PadFrame := nil; + + FillBufferWithFrame(@Buffer[SourceSize], BufferSize - SourceSize, + PadFrame, FrameSize); + Result := BufferSize; + end; +end; + +constructor TBassPlaybackStream.Create(); begin - inherited Create(); + inherited; Reset(); - Handle := stream; end; destructor TBassPlaybackStream.Destroy(); @@ -111,32 +217,99 @@ begin inherited; end; -procedure TBassPlaybackStream.Reset(); +function TBassPlaybackStream.Open(SourceStream: TAudioSourceStream): boolean; +var + FormatInfo: TAudioFormatInfo; + FormatFlags: DWORD; begin + Result := false; + + // close previous stream and reset state + Reset(); + + // sanity check if stream is valid + if not assigned(SourceStream) then + Exit; + + Self.SourceStream := SourceStream; + FormatInfo := SourceStream.GetAudioFormatInfo(); + if (not BassCore.ConvertAudioFormatToBASSFlags(FormatInfo.Format, FormatFlags)) then + begin + Log.LogError('Unhandled sample-format', 'TBassPlaybackStream.Open'); + Exit; + end; + + // create matching playback stream + Handle := BASS_StreamCreate(Round(FormatInfo.SampleRate), FormatInfo.Channels, formatFlags, + @PlaybackStreamHandler, Self); + if (Handle = 0) then + begin + Log.LogError('BASS_StreamCreate failed: ' + BassCore.ErrorGetString(BASS_ErrorGetCode()), + 'TBassPlaybackStream.Open'); + Exit; + end; + + Result := true; +end; + +procedure TBassPlaybackStream.Close(); +begin + // stop and free stream if (Handle <> 0) then begin Bass_StreamFree(Handle); + Handle := 0; end; - Handle := 0; + + // Note: PerformOnClose must be called before SourceStream is invalidated + PerformOnClose(); + // unset source-stream + SourceStream := nil; +end; + +procedure TBassPlaybackStream.Reset(); +begin + Close(); + NeedsRewind := false; + PausedSeek := false; end; procedure TBassPlaybackStream.Play(); var - restart: boolean; + NeedsFlush: boolean; begin + if (not assigned(SourceStream)) then + Exit; + + NeedsFlush := true; + if (BASS_ChannelIsActive(Handle) = BASS_ACTIVE_PAUSED) then - restart := false // resume from last position - else - restart := true; // start from the beginning + begin + // only paused (and not seeked while paused) streams are not flushed + if (not PausedSeek) then + NeedsFlush := false; + // paused streams do not need a rewind + NeedsRewind := false; + end; + + // rewind if necessary. Cases that require no rewind are: + // - stream was created and never played + // - stream was paused and is resumed now + // - stream was stopped and set to a new position already + if (NeedsRewind) then + SourceStream.Position := 0; + + NeedsRewind := true; + PausedSeek := false; - BASS_ChannelPlay(Handle, restart); + // start playing and flush buffers on rewind + BASS_ChannelPlay(Handle, NeedsFlush); end; procedure TBassPlaybackStream.FadeIn(Time: real; TargetVolume: single); begin // start stream - BASS_ChannelPlay(Handle, true); - + Play(); // start fade-in: slide from fadeStart- to fadeEnd-volume in FadeInTime BASS_ChannelSlideAttribute(Handle, BASS_ATTRIB_VOL, TargetVolume, Trunc(Time * 1000)); end; @@ -151,9 +324,22 @@ begin BASS_ChannelStop(Handle); end; -procedure TBassPlaybackStream.Close(); +function TBassPlaybackStream.IsEOF(): boolean; begin - Reset(); + if (assigned(SourceStream)) then + Result := SourceStream.EOF + else + Result := true; +end; + +function TBassPlaybackStream.GetLatency(): double; +begin + // TODO: should we consider output latency for synching (needs BASS_DEVICE_LATENCY)? + //if (BASS_GetInfo(Info)) then + // Latency := Info.latency / 1000 + //else + // Latency := 0; + Result := 0; end; function TBassPlaybackStream.GetVolume(): single; @@ -162,7 +348,7 @@ var begin if (not BASS_ChannelGetAttribute(Handle, BASS_ATTRIB_VOL, lVolume)) then begin - Log.LogError('BASS_ChannelGetAttribute: ' + AudioCore.ErrorGetString(), + Log.LogError('BASS_ChannelGetAttribute: ' + BassCore.ErrorGetString(), 'TBassPlaybackStream.GetVolume'); Result := 0; Exit; @@ -170,235 +356,272 @@ begin Result := Round(lVolume); end; -procedure TBassPlaybackStream.SetVolume(volume: single); +procedure TBassPlaybackStream.SetVolume(Volume: single); begin // clamp volume - if volume < 0 then - volume := 0; - if volume > 1.0 then - volume := 1.0; + if Volume < 0 then + Volume := 0; + if Volume > 1.0 then + Volume := 1.0; // set volume - BASS_ChannelSetAttribute(Handle, BASS_ATTRIB_VOL, volume); + BASS_ChannelSetAttribute(Handle, BASS_ATTRIB_VOL, Volume); end; function TBassPlaybackStream.GetPosition: real; var - bytes: QWORD; + BufferPosByte: QWORD; + BufferPosSec: double; begin - bytes := BASS_ChannelGetPosition(Handle, BASS_POS_BYTE); - Result := BASS_ChannelBytes2Seconds(Handle, bytes); + if assigned(SourceStream) then + begin + BufferPosByte := BASS_ChannelGetData(Handle, nil, BASS_DATA_AVAILABLE); + BufferPosSec := BASS_ChannelBytes2Seconds(Handle, BufferPosByte); + // decrease the decoding position by the amount buffered (and hence not played) + // in the BASS playback stream. + Result := SourceStream.Position - BufferPosSec; + end + else + begin + Result := -1; + end; end; procedure TBassPlaybackStream.SetPosition(Time: real); var - bytes: QWORD; + ChannelState: DWORD; begin - bytes := BASS_ChannelSeconds2Bytes(Handle, Time); - BASS_ChannelSetPosition(Handle, bytes, BASS_POS_BYTE); + if assigned(SourceStream) then + begin + ChannelState := BASS_ChannelIsActive(Handle); + if (ChannelState = BASS_ACTIVE_STOPPED) then + begin + // if the stream is stopped, do not rewind when the stream is played next time + NeedsRewind := false + end + else if (ChannelState = BASS_ACTIVE_PAUSED) then + begin + // buffers must be flushed if in paused state but there is no + // BASS_ChannelFlush() function so we have to use BASS_ChannelPlay() called in Play(). + PausedSeek := true; + end; + + // set new position + SourceStream.Position := Time; + end; end; function TBassPlaybackStream.GetLength(): real; -var - bytes: QWORD; begin - bytes := BASS_ChannelGetLength(Handle, BASS_POS_BYTE); - Result := BASS_ChannelBytes2Seconds(Handle, bytes); + if assigned(SourceStream) then + Result := SourceStream.Length + else + Result := -1; end; function TBassPlaybackStream.GetStatus(): TStreamStatus; var - state: DWORD; + State: DWORD; begin - state := BASS_ChannelIsActive(Handle); - case state of - BASS_ACTIVE_PLAYING: - result := ssPlaying; - BASS_ACTIVE_PAUSED: - result := ssPaused; + State := BASS_ChannelIsActive(Handle); + case State of + BASS_ACTIVE_PLAYING, BASS_ACTIVE_STALLED: - result := ssBlocked; + Result := ssPlaying; + BASS_ACTIVE_PAUSED: + Result := ssPaused; BASS_ACTIVE_STOPPED: - result := ssStopped; + Result := ssStopped; else - result := ssUnknown; + begin + Log.LogError('Unknown status', 'TBassPlaybackStream.GetStatus'); + Result := ssStopped; + end; end; end; function TBassPlaybackStream.GetLoop(): boolean; -var - flags: DWORD; begin - // retrieve channel flags - flags := BASS_ChannelFlags(Handle, 0, 0); - if (flags = -1) then - begin - Log.LogError('BASS_ChannelFlags: ' + AudioCore.ErrorGetString(), 'TBassPlaybackStream.GetLoop'); + if assigned(SourceStream) then + Result := SourceStream.Loop + else Result := false; - Exit; - end; - Result := (flags and BASS_SAMPLE_LOOP) <> 0; end; procedure TBassPlaybackStream.SetLoop(Enabled: boolean); -var - flags: DWORD; begin - // set/unset loop-flag - if (Enabled) then - flags := BASS_SAMPLE_LOOP - else - flags := 0; - - // set new flag-bits - if (BASS_ChannelFlags(Handle, flags, BASS_SAMPLE_LOOP) = -1) then - begin - Log.LogError('BASS_ChannelFlags: ' + AudioCore.ErrorGetString(), 'TBassPlaybackStream.SetLoop'); - Exit; - end; + if assigned(SourceStream) then + SourceStream.Loop := Enabled; end; -procedure DSPProcHandler(handle: HDSP; channel: DWORD; buffer: Pointer; length: DWORD; user: Pointer); {$IFDEF MSWINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF} +procedure DSPProcHandler(handle: HDSP; channel: DWORD; buffer: Pointer; length: DWORD; user: Pointer); +{$IFDEF MSWINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF} var - effect: TSoundEffect; + Effect: TSoundEffect; begin - effect := TSoundEffect(user); - if assigned(effect) then - effect.Callback(buffer, length); + Effect := TSoundEffect(user); + if assigned(Effect) then + Effect.Callback(buffer, length); end; -procedure TBassPlaybackStream.AddSoundEffect(effect: TSoundEffect); +procedure TBassPlaybackStream.AddSoundEffect(Effect: TSoundEffect); var - dspHandle: HDSP; + DspHandle: HDSP; begin - if assigned(effect.engineData) then + if assigned(Effect.engineData) then begin Log.LogError('TSoundEffect.engineData already set', 'TBassPlaybackStream.AddSoundEffect'); Exit; end; - dspHandle := BASS_ChannelSetDSP(Handle, @DSPProcHandler, effect, 0); - if (dspHandle = 0) then + DspHandle := BASS_ChannelSetDSP(Handle, @DSPProcHandler, Effect, 0); + if (DspHandle = 0) then begin - Log.LogError(AudioCore.ErrorGetString(), 'TBassPlaybackStream.AddSoundEffect'); + Log.LogError(BassCore.ErrorGetString(), 'TBassPlaybackStream.AddSoundEffect'); Exit; end; - GetMem(effect.engineData, SizeOf(HDSP)); - PHDSP(effect.engineData)^ := dspHandle; + GetMem(Effect.EngineData, SizeOf(HDSP)); + PHDSP(Effect.EngineData)^ := DspHandle; end; -procedure TBassPlaybackStream.RemoveSoundEffect(effect: TSoundEffect); +procedure TBassPlaybackStream.RemoveSoundEffect(Effect: TSoundEffect); begin - if not assigned(effect.EngineData) then + if not assigned(Effect.EngineData) then begin Log.LogError('TSoundEffect.engineData invalid', 'TBassPlaybackStream.RemoveSoundEffect'); Exit; end; - if not BASS_ChannelRemoveDSP(Handle, PHDSP(effect.EngineData)^) then + if not BASS_ChannelRemoveDSP(Handle, PHDSP(Effect.EngineData)^) then begin - Log.LogError(AudioCore.ErrorGetString(), 'TBassPlaybackStream.RemoveSoundEffect'); + Log.LogError(BassCore.ErrorGetString(), 'TBassPlaybackStream.RemoveSoundEffect'); Exit; end; - FreeMem(effect.engineData); - effect.engineData := nil; + FreeMem(Effect.EngineData); + Effect.EngineData := nil; end; -procedure TBassPlaybackStream.GetFFTData(var data: TFFTData); +procedure TBassPlaybackStream.GetFFTData(var Data: TFFTData); begin - // Get Channel Data Mono and 256 Values - BASS_ChannelGetData(Handle, @data, BASS_DATA_FFT512); + // get FFT channel data (Mono, FFT512 -> 256 values) + BASS_ChannelGetData(Handle, @Data, BASS_DATA_FFT512); end; {* * Copies interleaved PCM SInt16 stereo samples into data. * Returns the number of frames *} -function TBassPlaybackStream.GetPCMData(var data: TPCMData): Cardinal; +function TBassPlaybackStream.GetPCMData(var Data: TPCMData): Cardinal; var - info: BASS_CHANNELINFO; + Info: BASS_CHANNELINFO; nBytes: DWORD; begin Result := 0; - FillChar(data, sizeof(TPCMData), 0); + FillChar(Data, SizeOf(TPCMData), 0); // no support for non-stereo files at the moment - BASS_ChannelGetInfo(Handle, info); - if (info.chans <> 2) then + BASS_ChannelGetInfo(Handle, Info); + if (Info.chans <> 2) then Exit; - nBytes := BASS_ChannelGetData(Handle, @data, sizeof(TPCMData)); + nBytes := BASS_ChannelGetData(Handle, @Data, SizeOf(TPCMData)); if(nBytes <= 0) then - result := 0 + Result := 0 else - result := nBytes div sizeof(TPCMStereoSample); + Result := nBytes div SizeOf(TPCMStereoSample); end; +function TBassPlaybackStream.GetAudioFormatInfo(): TAudioFormatInfo; +begin + if assigned(SourceStream) then + Result := SourceStream.GetAudioFormatInfo() + else + Result := nil; +end; -{ TBassExtDecoderPlaybackStream } -procedure TBassExtDecoderPlaybackStream.Stop(); +{ TBassVoiceStream } + +function TBassVoiceStream.Open(ChannelMap: integer; FormatInfo: TAudioFormatInfo): boolean; +var + Flags: DWORD; begin - inherited; - // rewind - if assigned(DecodeStream) then - DecodeStream.Position := 0; + Result := false; + + Close(); + + if (not inherited Open(ChannelMap, FormatInfo)) then + Exit; + + // get channel flags + BassCore.ConvertAudioFormatToBASSFlags(FormatInfo.Format, Flags); + + (* + // distribute the mics equally to both speakers + if ((ChannelMap and CHANNELMAP_LEFT) <> 0) then + Flags := Flags or BASS_SPEAKER_FRONTLEFT; + if ((ChannelMap and CHANNELMAP_RIGHT) <> 0) then + Flags := Flags or BASS_SPEAKER_FRONTRIGHT; + *) + + // create the channel + Handle := BASS_StreamCreate(Round(FormatInfo.SampleRate), 1, Flags, STREAMPROC_PUSH, nil); + + // start the channel + BASS_ChannelPlay(Handle, true); + + Result := true; end; -procedure TBassExtDecoderPlaybackStream.Close(); +procedure TBassVoiceStream.Close(); begin - // wake-up waiting audio-callback threads in the ReadData()-function - if assigned(decodeStream) then - DecodeStream.Close(); - // stop audio-callback on this stream - inherited; - // free decoder-data - FreeAndNil(DecodeStream); + if (Handle <> 0) then + begin + BASS_ChannelStop(Handle); + BASS_StreamFree(Handle); + end; + inherited Close(); end; -function TBassExtDecoderPlaybackStream.GetLength(): real; +procedure TBassVoiceStream.WriteData(Buffer: PChar; BufferSize: integer); +var QueueSize: DWORD; begin - if assigned(DecodeStream) then - result := DecodeStream.Length - else - result := -1; + if ((Handle <> 0) and (BufferSize > 0)) then + begin + // query the queue size (normally 0) + QueueSize := BASS_StreamPutData(Handle, nil, 0); + // flush the buffer if the delay would be too high + if (QueueSize > MAX_VOICE_DELAY * FormatInfo.BytesPerSec) then + BASS_ChannelPlay(Handle, true); + // send new data to playback buffer + BASS_StreamPutData(Handle, Buffer, BufferSize); + end; end; -function TBassExtDecoderPlaybackStream.GetPosition: real; +// Note: we do not need the read-function for the BASS implementation +function TBassVoiceStream.ReadData(Buffer: PChar; BufferSize: integer): integer; begin - if assigned(DecodeStream) then - result := DecodeStream.Position - else - result := -1; + Result := -1; end; -procedure TBassExtDecoderPlaybackStream.SetPosition(Time: real); +function TBassVoiceStream.IsEOF(): boolean; begin - if assigned(DecodeStream) then - DecodeStream.Position := Time; + Result := false; end; -function TBassExtDecoderPlaybackStream.SetDecodeStream(decodeStream: TAudioDecodeStream): boolean; +function TBassVoiceStream.IsError(): boolean; begin - result := false; - - BASS_ChannelStop(Handle); - - if not assigned(decodeStream) then - Exit; - Self.DecodeStream := decodeStream; - - result := true; + Result := false; end; { TAudioPlayback_Bass } -function TAudioPlayback_Bass.GetName: String; +function TAudioPlayback_Bass.GetName: String; begin - result := 'BASS_Playback'; + Result := 'BASS_Playback'; end; function TAudioPlayback_Bass.EnumDevices(): boolean; @@ -408,23 +631,25 @@ var Device: TBassOutputDevice; DeviceInfo: BASS_DEVICEINFO; begin + Result := true; + ClearOutputDeviceList(); // skip "no sound"-device (ID = 0) BassDeviceID := 1; - while true do + while (true) do begin - // Check for device + // check for device if (not BASS_GetDeviceInfo(BassDeviceID, DeviceInfo)) then - break; + Break; - // Set device info + // set device info Device := TBassOutputDevice.Create(); Device.Name := DeviceInfo.name; Device.BassDeviceID := BassDeviceID; - // Add device to list + // add device to list SetLength(OutputDeviceList, BassDeviceID); OutputDeviceList[BassDeviceID-1] := Device; @@ -433,19 +658,17 @@ begin end; function TAudioPlayback_Bass.InitializePlayback(): boolean; -var - Pet: integer; - S: integer; begin result := false; - AudioCore := TAudioCore_Bass.GetInstance(); + BassCore := TAudioCore_Bass.GetInstance(); EnumDevices(); //Log.BenchmarkStart(4); //Log.LogStatus('Initializing Playback Subsystem', 'Music Initialize'); + // TODO: use BASS_DEVICE_LATENCY to determine the latency if not BASS_Init(-1, 44100, 0, 0, nil) then begin Log.LogError('Could not initialize BASS', 'TAudioPlayback_Bass.InitializePlayback'); @@ -469,125 +692,40 @@ begin Result := true; end; -function DecodeStreamHandler(handle: HSTREAM; buffer: Pointer; length: DWORD; user: Pointer): DWORD; {$IFDEF MSWINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF} -var - decodeStream: TAudioDecodeStream; - bytes: integer; +function TAudioPlayback_Bass.CreatePlaybackStream(): TAudioPlaybackStream; begin - decodeStream := TAudioDecodeStream(user); - bytes := decodeStream.ReadData(buffer, length); - // handle errors - if (bytes < 0) then - Result := BASS_STREAMPROC_END - // handle EOF - else if (DecodeStream.EOF) then - Result := bytes or BASS_STREAMPROC_END - else - Result := bytes; + Result := TBassPlaybackStream.Create(); +end; + +procedure TAudioPlayback_Bass.SetAppVolume(Volume: single); +begin + // set volume for this application (ranges from 0..10000 since BASS 2.4) + BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, Round(Volume*10000)); end; -function TAudioPlayback_Bass.OpenStream(const Filename: string): TAudioPlaybackStream; +function TAudioPlayback_Bass.CreateVoiceStream(ChannelMap: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; var - stream: HSTREAM; - playbackStream: TBassExtDecoderPlaybackStream; - decodeStream: TAudioDecodeStream; - formatInfo: TAudioFormatInfo; - formatFlags: DWORD; - channelInfo: BASS_CHANNELINFO; - fileExt: string; + VoiceStream: TAudioVoiceStream; begin Result := nil; - //Log.LogStatus('Loading Sound: "' + Filename + '"', 'LoadSoundFromFile'); - // TODO: use BASS_STREAM_PRESCAN for accurate seeking in VBR-files? - // disadvantage: seeking will slow down. - stream := BASS_StreamCreateFile(False, PChar(Filename), 0, 0, 0); - - // check if BASS opened some erroneously recognized file-formats - if (stream <> 0) then + VoiceStream := TBassVoiceStream.Create(); + if (not VoiceStream.Open(ChannelMap, FormatInfo)) then begin - if BASS_ChannelGetInfo(stream, channelInfo) then - begin - fileExt := ExtractFileExt(Filename); - // BASS opens FLV-files (maybe others too) although it cannot handle them. - // Setting BASS_CONFIG_VERIFY to the max. value (100000) does not help. - if ((fileExt = '.flv') and (channelInfo.ctype = BASS_CTYPE_STREAM_MP1)) then - begin - BASS_StreamFree(stream); - stream := 0; - end; - end; + VoiceStream.Free; + Exit; end; - // Check if BASS can handle the format or try another decoder otherwise - if (stream <> 0) then - begin - Result := TBassPlaybackStream.Create(stream); - end - else - begin - if (AudioDecoder = nil) then - begin - Log.LogError('Failed to open "' + Filename + '", ' + - AudioCore.ErrorGetString(), 'TAudioPlayback_Bass.Load'); - Exit; - end; - - decodeStream := AudioDecoder.Open(Filename); - if not assigned(decodeStream) then - begin - Log.LogStatus('Sound not found "' + Filename + '"', 'TAudioPlayback_Bass.Load'); - Exit; - end; - - formatInfo := decodeStream.GetAudioFormatInfo(); - if (not AudioCore.ConvertAudioFormatToBASSFlags(formatInfo.Format, formatFlags)) then - begin - Log.LogError('Unhandled sample-format in "' + Filename + '"', 'TAudioPlayback_Bass.Load'); - FreeAndNil(decodeStream); - Exit; - end; - - stream := BASS_StreamCreate(Round(formatInfo.SampleRate), formatInfo.Channels, formatFlags, - @DecodeStreamHandler, decodeStream); - if (stream = 0) then - begin - Log.LogError('Failed to open "' + Filename + '", ' + - AudioCore.ErrorGetString(BASS_ErrorGetCode()), 'TAudioPlayback_Bass.Load'); - FreeAndNil(decodeStream); - Exit; - end; - - playbackStream := TBassExtDecoderPlaybackStream.Create(stream); - if (not assigned(playbackStream)) then - begin - FreeAndNil(decodeStream); - Exit; - end; - - if (not playbackStream.SetDecodeStream(decodeStream)) then - begin - FreeAndNil(playbackStream); - FreeAndNil(decodeStream); - Exit; - end; - - Result := playbackStream; - end; + Result := VoiceStream; end; -procedure TAudioPlayback_Bass.SetAppVolume(Volume: single); +function TAudioPlayback_Bass.GetLatency(): double; begin - // Sets Volume only for this Application (now ranges from 0..10000) - BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, Round(Volume*10000)); + Result := 0; end; initialization - singleton_AudioPlaybackBass := TAudioPlayback_Bass.create(); - AudioManager.add( singleton_AudioPlaybackBass ); - -finalization - AudioManager.Remove( singleton_AudioPlaybackBass ); + MediaManager.Add(TAudioPlayback_Bass.Create); end. diff --git a/Game/Code/Classes/UAudioPlayback_Portaudio.pas b/Game/Code/Classes/UAudioPlayback_Portaudio.pas index b27fa83c..c3717ba6 100644 --- a/Game/Code/Classes/UAudioPlayback_Portaudio.pas +++ b/Game/Code/Classes/UAudioPlayback_Portaudio.pas @@ -29,6 +29,7 @@ type private paStream: PPaStream; AudioCore: TAudioCore_Portaudio; + Latency: double; function OpenDevice(deviceIndex: TPaDeviceIndex): boolean; function EnumDevices(): boolean; protected @@ -36,6 +37,7 @@ type function StartAudioPlaybackEngine(): boolean; override; procedure StopAudioPlaybackEngine(); override; function FinalizeAudioPlaybackEngine(): boolean; override; + function GetLatency(): double; override; public function GetName: String; override; end; @@ -45,9 +47,6 @@ type PaDeviceIndex: TPaDeviceIndex; end; -var - singleton_AudioPlaybackPortaudio : IAudioPlayback; - { TAudioPlayback_Portaudio } @@ -55,63 +54,74 @@ function PortaudioAudioCallback(input: Pointer; output: Pointer; frameCount: Lon timeInfo: PPaStreamCallbackTimeInfo; statusFlags: TPaStreamCallbackFlags; userData: Pointer): Integer; cdecl; var - engine: TAudioPlayback_Portaudio; + Engine: TAudioPlayback_Portaudio; begin - engine := TAudioPlayback_Portaudio(userData); - engine.AudioCallback(output, frameCount * engine.FormatInfo.FrameSize); - result := paContinue; + Engine := TAudioPlayback_Portaudio(userData); + // update latency + Engine.Latency := timeInfo.outputBufferDacTime - timeInfo.currentTime; + // call superclass callback + Engine.AudioCallback(output, frameCount * Engine.FormatInfo.FrameSize); + Result := paContinue; end; function TAudioPlayback_Portaudio.GetName: String; begin - result := 'Portaudio_Playback'; + Result := 'Portaudio_Playback'; end; function TAudioPlayback_Portaudio.OpenDevice(deviceIndex: TPaDeviceIndex): boolean; var - deviceInfo : PPaDeviceInfo; - sampleRate : double; - outParams : TPaStreamParameters; + DeviceInfo : PPaDeviceInfo; + SampleRate : double; + OutParams : TPaStreamParameters; + StreamInfo : PPaStreamInfo; err : TPaError; begin Result := false; - deviceInfo := Pa_GetDeviceInfo(deviceIndex); + DeviceInfo := Pa_GetDeviceInfo(deviceIndex); - Log.LogInfo('Audio-Output Device: ' + deviceInfo^.name, 'TAudioPlayback_Portaudio.OpenDevice'); + Log.LogInfo('Audio-Output Device: ' + DeviceInfo^.name, 'TAudioPlayback_Portaudio.OpenDevice'); - sampleRate := deviceInfo^.defaultSampleRate; + SampleRate := DeviceInfo^.defaultSampleRate; - with outParams do + with OutParams do begin device := deviceIndex; channelCount := 2; sampleFormat := paInt16; - suggestedLatency := deviceInfo^.defaultLowOutputLatency; + suggestedLatency := DeviceInfo^.defaultLowOutputLatency; hostApiSpecificStreamInfo := nil; end; // check souncard and adjust sample-rate - if not AudioCore.TestDevice(nil, @outParams, sampleRate) then + if not AudioCore.TestDevice(nil, @OutParams, SampleRate) then begin Log.LogStatus('TestDevice failed!', 'TAudioPlayback_Portaudio.OpenDevice'); - exit; + Exit; end; // open output stream - err := Pa_OpenStream(paStream, nil, @outParams, sampleRate, + err := Pa_OpenStream(paStream, nil, @OutParams, SampleRate, paFramesPerBufferUnspecified, paNoFlag, @PortaudioAudioCallback, Self); if(err <> paNoError) then begin Log.LogStatus(Pa_GetErrorText(err), 'TAudioPlayback_Portaudio.OpenDevice'); paStream := nil; - exit; + Exit; end; - + + // get estimated latency (will be updated with real latency in the callback) + StreamInfo := Pa_GetStreamInfo(paStream); + if (StreamInfo <> nil) then + Latency := StreamInfo^.outputLatency + else + Latency := 0; + FormatInfo := TAudioFormatInfo.Create( - outParams.channelCount, - sampleRate, + OutParams.channelCount, + SampleRate, asfS16 // FIXME: is paInt16 system-dependant or -independant? ); @@ -131,7 +141,7 @@ var err: TPaError; errMsg: string; paDevice: TPortaudioOutputDevice; - inputParams: TPaStreamParameters; + outputParams: TPaStreamParameters; stream: PPaStream; streamInfo: PPaStreamInfo; sampleRate: double; @@ -140,6 +150,7 @@ var cbWorks: boolean; begin Result := false; + (* // choose the best available Audio-API paApiIndex := AudioCore.GetPreferredApiIndex(); @@ -190,10 +201,10 @@ begin // TODO: correct too low latencies (what is a too low latency, maybe < 10ms?) latency := deviceInfo^.defaultLowInputLatency; - // setup desired input parameters - // TODO: retry with input-latency set to 20ms (defaultLowInputLatency might + // setup desired output parameters + // TODO: retry with input-latency set to 20ms (defaultLowOutputLatency might // not be set correctly in OSS) - with inputParams do + with outputParams do begin device := deviceIndex; channelCount := channelCnt; @@ -203,24 +214,24 @@ begin end; // check if mic-callback works (might not be called on some devices) - if (not TAudioCore_Portaudio.TestDevice(@inputParams, nil, sampleRate)) then + if (not TAudioCore_Portaudio.TestDevice(nil, @outputParams, sampleRate)) then begin // ignore device if callback did not work Log.LogError('Device "'+paDevice.Name+'" does not respond', - 'TAudioInput_Portaudio.InitializeRecord'); + 'TAudioPlayback_Portaudio.InitializeRecord'); paDevice.Free(); continue; end; // open device for further info - err := Pa_OpenStream(stream, @inputParams, nil, sampleRate, + err := Pa_OpenStream(stream, nil, @outputParams, sampleRate, paFramesPerBufferUnspecified, paNoFlag, @MicrophoneTestCallback, nil); if(err <> paNoError) then begin // unable to open device -> skip errMsg := Pa_GetErrorText(err); Log.LogError('Device error: "'+ deviceName +'" ('+ errMsg +')', - 'TAudioInput_Portaudio.InitializeRecord'); + 'TAudioPlayback_Portaudio.InitializeRecord'); paDevice.Free(); continue; end; @@ -237,7 +248,7 @@ begin sampleRate := streamInfo^.sampleRate; end; end; - + // create audio-format info and resize capture-buffer array paDevice.AudioFormat := TAudioFormatInfo.Create( channelCnt, @@ -246,11 +257,11 @@ begin ); SetLength(paDevice.CaptureChannel, paDevice.AudioFormat.Channels); - Log.LogStatus('InputDevice "'+paDevice.Name+'"@' + + Log.LogStatus('OutputDevice "'+paDevice.Name+'"@' + IntToStr(paDevice.AudioFormat.Channels)+'x'+ FloatToStr(paDevice.AudioFormat.SampleRate)+'Hz ('+ - FloatTostr(inputParams.suggestedLatency)+'sec)' , - 'Portaudio.InitializeRecord'); + FloatTostr(outputParams.suggestedLatency)+'sec)' , + 'TAudioInput_Portaudio.InitializeRecord'); // close test-stream Pa_CloseStream(stream); @@ -262,9 +273,9 @@ begin SetLength(OutputDeviceList, SC); Log.LogStatus('#Output-Devices: ' + inttostr(SC), 'Portaudio'); +*) Result := true; - *) end; function TAudioPlayback_Portaudio.InitializeAudioPlaybackEngine(): boolean; @@ -274,7 +285,7 @@ var paOutDevice : TPaDeviceIndex; err: TPaError; begin - result := false; + Result := false; AudioCore := TAudioCore_Portaudio.GetInstance(); @@ -304,14 +315,14 @@ begin Exit; end; - result := true; + Result := true; end; function TAudioPlayback_Portaudio.StartAudioPlaybackEngine(): boolean; var err: TPaError; begin - result := false; + Result := false; if (paStream = nil) then Exit; @@ -320,10 +331,10 @@ begin if(err <> paNoError) then begin Log.LogStatus('Pa_StartStream: '+Pa_GetErrorText(err), 'UAudioPlayback_Portaudio'); - exit; + Exit; end; - result := true; + Result := true; end; procedure TAudioPlayback_Portaudio.StopAudioPlaybackEngine(); @@ -338,13 +349,13 @@ begin Result := true; end; +function TAudioPlayback_Portaudio.GetLatency(): double; +begin + Result := Latency; +end; -initialization - singleton_AudioPlaybackPortaudio := TAudioPlayback_Portaudio.create(); - AudioManager.add( singleton_AudioPlaybackPortaudio ); - -finalization - AudioManager.Remove( singleton_AudioPlaybackPortaudio ); +initialization + MediaManager.Add(TAudioPlayback_Portaudio.Create); end. diff --git a/Game/Code/Classes/UAudioPlayback_SDL.pas b/Game/Code/Classes/UAudioPlayback_SDL.pas index 14990855..deef91e8 100644 --- a/Game/Code/Classes/UAudioPlayback_SDL.pas +++ b/Game/Code/Classes/UAudioPlayback_SDL.pas @@ -26,34 +26,33 @@ uses type TAudioPlayback_SDL = class(TAudioPlayback_SoftMixer) private + Latency: double; function EnumDevices(): boolean; protected function InitializeAudioPlaybackEngine(): boolean; override; function StartAudioPlaybackEngine(): boolean; override; procedure StopAudioPlaybackEngine(); override; function FinalizeAudioPlaybackEngine(): boolean; override; + function GetLatency(): double; override; public function GetName: String; override; procedure MixBuffers(dst, src: PChar; size: Cardinal; volume: Single); override; end; -var - singleton_AudioPlaybackSDL : IAudioPlayback; - { TAudioPlayback_SDL } procedure SDLAudioCallback(userdata: Pointer; stream: PChar; len: integer); cdecl; var - engine: TAudioPlayback_SDL; + Engine: TAudioPlayback_SDL; begin - engine := TAudioPlayback_SDL(userdata); - engine.AudioCallback(stream, len); + Engine := TAudioPlayback_SDL(userdata); + Engine.AudioCallback(stream, len); end; function TAudioPlayback_SDL.GetName: String; begin - result := 'SDL_Playback'; + Result := 'SDL_Playback'; end; function TAudioPlayback_SDL.EnumDevices(): boolean; @@ -68,28 +67,29 @@ end; function TAudioPlayback_SDL.InitializeAudioPlaybackEngine(): boolean; var - desiredAudioSpec, obtainedAudioSpec: TSDL_AudioSpec; + DesiredAudioSpec, ObtainedAudioSpec: TSDL_AudioSpec; SampleBufferSize: integer; begin - result := false; + Result := false; EnumDevices(); if (SDL_InitSubSystem(SDL_INIT_AUDIO) = -1) then begin Log.LogError('SDL_InitSubSystem failed!', 'TAudioPlayback_SDL.InitializeAudioPlaybackEngine'); - exit; + Exit; end; SampleBufferSize := IAudioOutputBufferSizeVals[Ini.AudioOutputBufferSizeIndex]; if (SampleBufferSize <= 0) then begin - // Automatic setting defaults to 1024 samples - SampleBufferSize := 1024; + // Automatic setting default + // FIXME: too much glitches with 1024 samples + SampleBufferSize := 2048; //1024; end; - FillChar(desiredAudioSpec, sizeof(desiredAudioSpec), 0); - with desiredAudioSpec do + FillChar(DesiredAudioSpec, SizeOf(DesiredAudioSpec), 0); + with DesiredAudioSpec do begin freq := 44100; format := AUDIO_S16SYS; @@ -99,27 +99,36 @@ begin userdata := Self; end; - if(SDL_OpenAudio(@desiredAudioSpec, @obtainedAudioSpec) = -1) then + // Note: always use the "obtained" parameter, otherwise SDL might try to convert + // the samples itself if the desired format is not available. This might lead + // to problems if for example ALSA does not support 44100Hz and proposes 48000Hz. + // Without the obtained parameter, SDL would try to convert 44.1kHz to 48kHz with + // its crappy (non working) converter resulting in a wrong (too high) pitch. + if(SDL_OpenAudio(@DesiredAudioSpec, @ObtainedAudioSpec) = -1) then begin Log.LogStatus('SDL_OpenAudio: ' + SDL_GetError(), 'TAudioPlayback_SDL.InitializeAudioPlaybackEngine'); - exit; + Exit; end; FormatInfo := TAudioFormatInfo.Create( - obtainedAudioSpec.channels, - obtainedAudioSpec.freq, + ObtainedAudioSpec.channels, + ObtainedAudioSpec.freq, asfS16 ); + // Note: SDL does not provide info of the internal buffer state. + // So we use the average buffer-size. + Latency := (ObtainedAudioSpec.samples/2) / FormatInfo.SampleRate; + Log.LogStatus('Opened audio device', 'TAudioPlayback_SDL.InitializeAudioPlaybackEngine'); - result := true; + Result := true; end; function TAudioPlayback_SDL.StartAudioPlaybackEngine(): boolean; begin SDL_PauseAudio(0); - result := true; + Result := true; end; procedure TAudioPlayback_SDL.StopAudioPlaybackEngine(); @@ -134,6 +143,11 @@ begin Result := true; end; +function TAudioPlayback_SDL.GetLatency(): double; +begin + Result := Latency; +end; + procedure TAudioPlayback_SDL.MixBuffers(dst, src: PChar; size: Cardinal; volume: Single); begin SDL_MixAudio(PUInt8(dst), PUInt8(src), size, Round(volume * SDL_MIX_MAXVOLUME)); @@ -141,10 +155,6 @@ end; initialization - singleton_AudioPlaybackSDL := TAudioPlayback_SDL.create(); - AudioManager.add( singleton_AudioPlaybackSDL ); - -finalization - AudioManager.Remove( singleton_AudioPlaybackSDL ); + MediaManager.add(TAudioPlayback_SDL.Create); end. diff --git a/Game/Code/Classes/UAudioPlayback_SoftMixer.pas b/Game/Code/Classes/UAudioPlayback_SoftMixer.pas index 714e19ae..31d0412b 100644 --- a/Game/Code/Classes/UAudioPlayback_SoftMixer.pas +++ b/Game/Code/Classes/UAudioPlayback_SoftMixer.pas @@ -13,6 +13,7 @@ uses Classes, SysUtils, sdl, + URingBuffer, UMusic, UAudioPlaybackBase; @@ -23,86 +24,90 @@ type private Engine: TAudioPlayback_SoftMixer; - DecodeStream: TAudioDecodeStream; - SampleBuffer : PChar; + SampleBuffer: PChar; + SampleBufferSize: integer; SampleBufferCount: integer; // number of available bytes in SampleBuffer - SampleBufferPos : cardinal; - BytesAvail: integer; - cvt: TSDL_AudioCVT; + SampleBufferPos: cardinal; - Status: TStreamStatus; - Loop: boolean; + SourceBuffer: PChar; + SourceBufferSize: integer; + SourceBufferCount: integer; // number of available bytes in SourceBuffer + Converter: TAudioConverter; + Status: TStreamStatus; InternalLock: PSDL_Mutex; - SoundEffects: TList; - - _volume: single; + fVolume: single; FadeInStartTime, FadeInTime: cardinal; FadeInStartVolume, FadeInTargetVolume: single; + NeedsRewind: boolean; + procedure Reset(); - class function ConvertAudioFormatToSDL(Format: TAudioSampleFormat; out SDLFormat: UInt16): boolean; + procedure ApplySoundEffects(Buffer: PChar; BufferSize: integer); function InitFormatConversion(): boolean; + procedure FlushBuffers(); - procedure Lock(); {$IFDEF HasInline}inline;{$ENDIF} - procedure Unlock(); {$IFDEF HasInline}inline;{$ENDIF} + procedure LockSampleBuffer(); {$IFDEF HasInline}inline;{$ENDIF} + procedure UnlockSampleBuffer(); {$IFDEF HasInline}inline;{$ENDIF} + protected + function GetLatency(): double; override; + function GetStatus(): TStreamStatus; override; + function GetVolume(): single; override; + procedure SetVolume(Volume: single); override; + function GetLength(): real; override; + function GetLoop(): boolean; override; + procedure SetLoop(Enabled: boolean); override; + function GetPosition: real; override; + procedure SetPosition(Time: real); override; public constructor Create(Engine: TAudioPlayback_SoftMixer); destructor Destroy(); override; - function SetDecodeStream(decodeStream: TAudioDecodeStream): boolean; + function Open(SourceStream: TAudioSourceStream): boolean; override; + procedure Close(); override; procedure Play(); override; procedure Pause(); override; procedure Stop(); override; procedure FadeIn(Time: real; TargetVolume: single); override; - procedure Close(); override; + function GetAudioFormatInfo(): TAudioFormatInfo; override; - function GetLength(): real; override; - function GetStatus(): TStreamStatus; override; - function GetVolume(): single; override; - procedure SetVolume(Volume: single); override; - function GetLoop(): boolean; override; - procedure SetLoop(Enabled: boolean); override; - function GetPosition: real; override; - procedure SetPosition(Time: real); override; + function ReadData(Buffer: PChar; BufferSize: integer): integer; - function ReadData(Buffer: PChar; BufSize: integer): integer; + function GetPCMData(var Data: TPCMData): Cardinal; override; + procedure GetFFTData(var Data: TFFTData); override; - function GetPCMData(var data: TPCMData): Cardinal; override; - procedure GetFFTData(var data: TFFTData); override; - - procedure AddSoundEffect(effect: TSoundEffect); override; - procedure RemoveSoundEffect(effect: TSoundEffect); override; + procedure AddSoundEffect(Effect: TSoundEffect); override; + procedure RemoveSoundEffect(Effect: TSoundEffect); override; end; TAudioMixerStream = class private Engine: TAudioPlayback_SoftMixer; - activeStreams: TList; - mixerBuffer: PChar; - internalLock: PSDL_Mutex; + ActiveStreams: TList; + MixerBuffer: PChar; + InternalLock: PSDL_Mutex; - appVolume: single; + AppVolume: single; procedure Lock(); {$IFDEF HasInline}inline;{$ENDIF} procedure Unlock(); {$IFDEF HasInline}inline;{$ENDIF} function GetVolume(): single; - procedure SetVolume(volume: single); + procedure SetVolume(Volume: single); public constructor Create(Engine: TAudioPlayback_SoftMixer); destructor Destroy(); override; - procedure AddStream(stream: TAudioPlaybackStream); - procedure RemoveStream(stream: TAudioPlaybackStream); - function ReadData(Buffer: PChar; BufSize: integer): integer; + procedure AddStream(Stream: TAudioPlaybackStream); + procedure RemoveStream(Stream: TAudioPlaybackStream); + function ReadData(Buffer: PChar; BufferSize: integer): integer; - property Volume: single READ GetVolume WRITE SetVolume; + property Volume: single read GetVolume write SetVolume; end; TAudioPlayback_SoftMixer = class(TAudioPlaybackBase) @@ -115,9 +120,9 @@ type function StartAudioPlaybackEngine(): boolean; virtual; abstract; procedure StopAudioPlaybackEngine(); virtual; abstract; function FinalizeAudioPlaybackEngine(): boolean; virtual; abstract; - procedure AudioCallback(buffer: PChar; size: integer); {$IFDEF HasInline}inline;{$ENDIF} + procedure AudioCallback(Buffer: PChar; Size: integer); {$IFDEF HasInline}inline;{$ENDIF} - function OpenStream(const Filename: String): TAudioPlaybackStream; override; + function CreatePlaybackStream(): TAudioPlaybackStream; override; public function GetName: String; override; abstract; function InitializePlayback(): boolean; override; @@ -125,20 +130,46 @@ type procedure SetAppVolume(Volume: single); override; + function CreateVoiceStream(ChannelMap: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; override; + function GetMixer(): TAudioMixerStream; {$IFDEF HasInline}inline;{$ENDIF} function GetAudioFormatInfo(): TAudioFormatInfo; - procedure MixBuffers(dst, src: PChar; size: Cardinal; volume: Single); virtual; + procedure MixBuffers(DstBuffer, SrcBuffer: PChar; Size: Cardinal; Volume: Single); virtual; + end; + +type + TGenericVoiceStream = class(TAudioVoiceStream) + private + VoiceBuffer: TRingBuffer; + BufferLock: PSDL_Mutex; + PlaybackStream: TGenericPlaybackStream; + Engine: TAudioPlayback_SoftMixer; + public + constructor Create(Engine: TAudioPlayback_SoftMixer); + + function Open(ChannelMap: integer; FormatInfo: TAudioFormatInfo): boolean; override; + procedure Close(); override; + procedure WriteData(Buffer: PChar; BufferSize: integer); override; + function ReadData(Buffer: PChar; BufferSize: integer): integer; override; + function IsEOF(): boolean; override; + function IsError(): boolean; override; end; +const + SOURCE_BUFFER_FRAMES = 4096; + +const + MAX_VOICE_DELAY = 0.500; // 20ms + implementation uses Math, - //samplerate, - UFFT, ULog, UIni, + UFFT, + UAudioConverter, UMain; { TAudioMixerStream } @@ -149,123 +180,123 @@ begin Self.Engine := Engine; - activeStreams := TList.Create; - internalLock := SDL_CreateMutex(); - appVolume := 1.0; + ActiveStreams := TList.Create; + InternalLock := SDL_CreateMutex(); + AppVolume := 1.0; end; destructor TAudioMixerStream.Destroy(); begin - if assigned(mixerBuffer) then - Freemem(mixerBuffer); - activeStreams.Free; - SDL_DestroyMutex(internalLock); + if assigned(MixerBuffer) then + Freemem(MixerBuffer); + ActiveStreams.Free; + SDL_DestroyMutex(InternalLock); inherited; end; procedure TAudioMixerStream.Lock(); begin - SDL_mutexP(internalLock); + SDL_mutexP(InternalLock); end; procedure TAudioMixerStream.Unlock(); begin - SDL_mutexV(internalLock); + SDL_mutexV(InternalLock); end; function TAudioMixerStream.GetVolume(): single; begin Lock(); - result := appVolume; + Result := AppVolume; Unlock(); end; -procedure TAudioMixerStream.SetVolume(volume: single); +procedure TAudioMixerStream.SetVolume(Volume: single); begin Lock(); - appVolume := volume; + AppVolume := Volume; Unlock(); end; -procedure TAudioMixerStream.AddStream(stream: TAudioPlaybackStream); +procedure TAudioMixerStream.AddStream(Stream: TAudioPlaybackStream); begin - if not assigned(stream) then + if not assigned(Stream) then Exit; Lock(); // check if stream is already in list to avoid duplicates - if (activeStreams.IndexOf(Pointer(stream)) = -1) then - activeStreams.Add(Pointer(stream)); + if (ActiveStreams.IndexOf(Pointer(Stream)) = -1) then + ActiveStreams.Add(Pointer(Stream)); Unlock(); end; (* - * Sets the entry of stream in the activeStreams-List to nil - * but does not remove it from the list (count is not changed!). + * Sets the entry of stream in the ActiveStreams-List to nil + * but does not remove it from the list (Count is not changed!). * Otherwise iterations over the elements might fail due to a - * changed count-property. - * Call activeStreams.Pack() to remove the nil-pointers - * or check for nil-pointers when accessing activeStreams. + * changed Count-property. + * Call ActiveStreams.Pack() to remove the nil-pointers + * or check for nil-pointers when accessing ActiveStreams. *) -procedure TAudioMixerStream.RemoveStream(stream: TAudioPlaybackStream); +procedure TAudioMixerStream.RemoveStream(Stream: TAudioPlaybackStream); var - index: integer; + Index: integer; begin Lock(); - index := activeStreams.IndexOf(Pointer(stream)); - if (index <> -1) then + Index := activeStreams.IndexOf(Pointer(Stream)); + if (Index <> -1) then begin // remove entry but do not decrease count-property - activeStreams[index] := nil; + ActiveStreams[Index] := nil; end; Unlock(); end; -function TAudioMixerStream.ReadData(Buffer: PChar; BufSize: integer): integer; +function TAudioMixerStream.ReadData(Buffer: PChar; BufferSize: integer): integer; var i: integer; - size: integer; - stream: TGenericPlaybackStream; - needsPacking: boolean; + Size: integer; + Stream: TGenericPlaybackStream; + NeedsPacking: boolean; begin - result := BufSize; + Result := BufferSize; // zero target-buffer (silence) - FillChar(Buffer^, BufSize, 0); + FillChar(Buffer^, BufferSize, 0); // resize mixer-buffer if necessary - ReallocMem(mixerBuffer, BufSize); - if not assigned(mixerBuffer) then + ReallocMem(MixerBuffer, BufferSize); + if not assigned(MixerBuffer) then Exit; Lock(); - needsPacking := false; + NeedsPacking := false; // mix streams to one stream - for i := 0 to activeStreams.Count-1 do + for i := 0 to ActiveStreams.Count-1 do begin - if (activeStreams[i] = nil) then + if (ActiveStreams[i] = nil) then begin - needsPacking := true; + NeedsPacking := true; continue; end; - stream := TGenericPlaybackStream(activeStreams[i]); + Stream := TGenericPlaybackStream(ActiveStreams[i]); // fetch data from current stream - size := stream.ReadData(mixerBuffer, BufSize); - if (size > 0) then + Size := Stream.ReadData(MixerBuffer, BufferSize); + if (Size > 0) then begin // mix stream-data with mixer-buffer // Note: use Self.appVolume instead of Self.Volume to prevent recursive locking - Engine.MixBuffers(Buffer, mixerBuffer, size, appVolume * stream.Volume); + Engine.MixBuffers(Buffer, MixerBuffer, Size, AppVolume * Stream.Volume); end; end; // remove nil-pointers from list - if (needsPacking) then + if (NeedsPacking) then begin - activeStreams.Pack(); + ActiveStreams.Pack(); end; Unlock(); @@ -278,7 +309,7 @@ constructor TGenericPlaybackStream.Create(Engine: TAudioPlayback_SoftMixer); begin inherited Create(); Self.Engine := Engine; - internalLock := SDL_CreateMutex(); + InternalLock := SDL_CreateMutex(); SoundEffects := TList.Create; Status := ssStopped; Reset(); @@ -287,342 +318,419 @@ end; destructor TGenericPlaybackStream.Destroy(); begin Close(); - SDL_DestroyMutex(internalLock); + SDL_DestroyMutex(InternalLock); FreeAndNil(SoundEffects); inherited; end; procedure TGenericPlaybackStream.Reset(); begin - // wake-up sleeping audio-callback threads in the ReadData()-function - if assigned(decodeStream) then - decodeStream.Close(); - - // stop audio-callback on this stream - Stop(); - - // reset and/or free data - - Loop := false; + SourceStream := nil; - // TODO: use DecodeStream.Unref() instead of Free(); - FreeAndNil(DecodeStream); + FreeAndNil(Converter); FreeMem(SampleBuffer); SampleBuffer := nil; SampleBufferPos := 0; - BytesAvail := 0; - - _volume := 0; - SoundEffects.Clear; - FadeInTime := 0; -end; + SampleBufferSize := 0; + SampleBufferCount := 0; -procedure TGenericPlaybackStream.Lock(); -begin - SDL_mutexP(internalLock); -end; + FreeMem(SourceBuffer); + SourceBuffer := nil; + SourceBufferSize := 0; + SourceBufferCount := 0; -procedure TGenericPlaybackStream.Unlock(); -begin - SDL_mutexV(internalLock); -end; + NeedsRewind := false; -class function TGenericPlaybackStream.ConvertAudioFormatToSDL(Format: TAudioSampleFormat; out SDLFormat: UInt16): boolean; -begin - case Format of - asfU8: SDLFormat := AUDIO_U8; - asfS8: SDLFormat := AUDIO_S8; - asfU16LSB: SDLFormat := AUDIO_U16LSB; - asfS16LSB: SDLFormat := AUDIO_S16LSB; - asfU16MSB: SDLFormat := AUDIO_U16MSB; - asfS16MSB: SDLFormat := AUDIO_S16MSB; - asfU16: SDLFormat := AUDIO_U16; - asfS16: SDLFormat := AUDIO_S16; - else begin - Result := false; - Exit; - end; - end; - Result := true; + fVolume := 0; + SoundEffects.Clear; + FadeInTime := 0; end; -function TGenericPlaybackStream.InitFormatConversion(): boolean; -var - srcFormat: UInt16; - dstFormat: UInt16; - srcFormatInfo: TAudioFormatInfo; - dstFormatInfo: TAudioFormatInfo; +function TGenericPlaybackStream.Open(SourceStream: TAudioSourceStream): boolean; begin Result := false; - srcFormatInfo := DecodeStream.GetAudioFormatInfo(); - dstFormatInfo := Engine.GetAudioFormatInfo(); + Close(); - if (not ConvertAudioFormatToSDL(srcFormatInfo.Format, srcFormat) or - not ConvertAudioFormatToSDL(dstFormatInfo.Format, dstFormat)) then - begin - Log.LogError('Audio-format not supported by SDL', 'TSoftMixerPlaybackStream.InitFormatConversion'); + if (not assigned(SourceStream)) then Exit; - end; + Self.SourceStream := SourceStream; - if (SDL_BuildAudioCVT(@cvt, - srcFormat, srcFormatInfo.Channels, Round(srcFormatInfo.SampleRate), - dstFormat, dstFormatInfo.Channels, Round(dstFormatInfo.SampleRate)) = -1) then + if (not InitFormatConversion()) then begin - Log.LogError(SDL_GetError(), 'TSoftMixerPlaybackStream.InitFormatConversion'); + // reset decode-stream so it will not be freed on destruction + Self.SourceStream := nil; Exit; end; + SourceBufferSize := SOURCE_BUFFER_FRAMES * SourceStream.GetAudioFormatInfo().FrameSize; + GetMem(SourceBuffer, SourceBufferSize); + fVolume := 1.0; + Result := true; end; -function TGenericPlaybackStream.SetDecodeStream(decodeStream: TAudioDecodeStream): boolean; +procedure TGenericPlaybackStream.Close(); begin - result := false; + // stop audio-callback on this stream + Stop(); + // Note: PerformOnClose must be called before SourceStream is invalidated + PerformOnClose(); + // and free data Reset(); +end; - if not assigned(decodeStream) then - Exit; - Self.DecodeStream := decodeStream; - if not InitFormatConversion() then - Exit; - - _volume := 1.0; +procedure TGenericPlaybackStream.LockSampleBuffer(); +begin + SDL_mutexP(InternalLock); +end; - result := true; +procedure TGenericPlaybackStream.UnlockSampleBuffer(); +begin + SDL_mutexV(InternalLock); end; -procedure TGenericPlaybackStream.Close(); +function TGenericPlaybackStream.InitFormatConversion(): boolean; +var + SrcFormatInfo: TAudioFormatInfo; + DstFormatInfo: TAudioFormatInfo; begin - Reset(); + Result := false; + + SrcFormatInfo := SourceStream.GetAudioFormatInfo(); + DstFormatInfo := GetAudioFormatInfo(); + + // TODO: selection should not be done here, use a factory (TAudioConverterFactory) instead + {$IF Defined(UseFFMpegResample)} + Converter := TAudioConverter_FFMpeg.Create(); + {$ELSEIF Defined(UseSRCResample)} + Converter := TAudioConverter_SRC.Create(); + {$ELSE} + Converter := TAudioConverter_SDL.Create(); + {$IFEND} + + Result := Converter.Init(SrcFormatInfo, DstFormatInfo); end; procedure TGenericPlaybackStream.Play(); var - mixer: TAudioMixerStream; + Mixer: TAudioMixerStream; begin - if (status = ssPlaying) then - begin - // rewind - if assigned(DecodeStream) then - DecodeStream.Position := 0; - end; - status := ssPlaying; - - mixer := Engine.GetMixer(); - if (mixer <> nil) then - mixer.AddStream(Self); + // only paused streams are not flushed + if (Status = ssPaused) then + NeedsRewind := false; + + // rewind if necessary. Cases that require no rewind are: + // - stream was created and never played + // - stream was paused and is resumed now + // - stream was stopped and set to a new position already + if (NeedsRewind) then + SetPosition(0); + + // update status + Status := ssPlaying; + + NeedsRewind := true; + + // add this stream to the mixer + Mixer := Engine.GetMixer(); + if (Mixer <> nil) then + Mixer.AddStream(Self); end; procedure TGenericPlaybackStream.FadeIn(Time: real; TargetVolume: single); begin FadeInTime := Trunc(Time * 1000); FadeInStartTime := SDL_GetTicks(); - FadeInStartVolume := _volume; + FadeInStartVolume := fVolume; FadeInTargetVolume := TargetVolume; Play(); end; procedure TGenericPlaybackStream.Pause(); var - mixer: TAudioMixerStream; + Mixer: TAudioMixerStream; begin - status := ssPaused; + if (Status <> ssPlaying) then + Exit; + + Status := ssPaused; - mixer := Engine.GetMixer(); - if (mixer <> nil) then - mixer.RemoveStream(Self); + Mixer := Engine.GetMixer(); + if (Mixer <> nil) then + Mixer.RemoveStream(Self); end; procedure TGenericPlaybackStream.Stop(); var - mixer: TAudioMixerStream; + Mixer: TAudioMixerStream; begin - if (status = ssStopped) then + if (Status = ssStopped) then Exit; - status := ssStopped; - - mixer := Engine.GetMixer(); - if (mixer <> nil) then - mixer.RemoveStream(Self); + Status := ssStopped; - // rewind (note: DecodeStream might be closed already, but this is not a problem) - if assigned(DecodeStream) then - DecodeStream.Position := 0; + Mixer := Engine.GetMixer(); + if (Mixer <> nil) then + Mixer.RemoveStream(Self); end; function TGenericPlaybackStream.GetLoop(): boolean; begin - result := Loop; + if assigned(SourceStream) then + Result := SourceStream.Loop + else + Result := false; end; procedure TGenericPlaybackStream.SetLoop(Enabled: boolean); begin - Loop := Enabled; + if assigned(SourceStream) then + SourceStream.Loop := Enabled; end; function TGenericPlaybackStream.GetLength(): real; begin - if assigned(DecodeStream) then - result := DecodeStream.Length + if assigned(SourceStream) then + Result := SourceStream.Length else - result := -1; + Result := -1; +end; + +function TGenericPlaybackStream.GetLatency(): double; +begin + Result := Engine.GetLatency(); end; function TGenericPlaybackStream.GetStatus(): TStreamStatus; begin - result := status; + Result := Status; end; -{* - * Note: 44.1kHz to 48kHz conversion or vice versa is not supported - * by SDL at the moment. No conversion takes place in this cases. - * This is because SDL just converts differences in powers of 2. - * So the result might not be that accurate. Although this is not - * audible in most cases it needs synchronization with the video - * or the lyrics timer. - * Using libsamplerate might give better results. - *} -function TGenericPlaybackStream.ReadData(Buffer: PChar; BufSize: integer): integer; -var - decodeBufSize: integer; - sampleBufSize: integer; - nBytesDecoded: integer; - frameSize: integer; - remFrameBytes: integer; - copyCnt: integer; - BytesNeeded: integer; - i: integer; +function TGenericPlaybackStream.GetAudioFormatInfo(): TAudioFormatInfo; begin - Result := -1; + Result := Engine.GetAudioFormatInfo(); +end; - BytesNeeded := BufSize; +procedure TGenericPlaybackStream.FlushBuffers(); +begin + SampleBufferCount := 0; + SampleBufferPos := 0; + SourceBufferCount := 0; +end; - // copy remaining data from the last call to the result-buffer - if (BytesAvail > 0) then +procedure TGenericPlaybackStream.ApplySoundEffects(Buffer: PChar; BufferSize: integer); +var + i: integer; +begin + for i := 0 to SoundEffects.Count-1 do begin - copyCnt := Min(BufSize, BytesAvail); - Move(SampleBuffer[SampleBufferPos], Buffer[0], copyCnt); - Dec(BytesAvail, copyCnt); - Dec(BytesNeeded, copyCnt); - if (BytesNeeded = 0) then + if (SoundEffects[i] <> nil) then begin - // Result-Buffer is full -> no need to decode more data. - // The sample-buffer might even contain some data for the next call - Inc(SampleBufferPos, copyCnt); - Result := BufSize; - Exit; + TSoundEffect(SoundEffects[i]).Callback(Buffer, BufferSize); end; end; +end; - if not assigned(DecodeStream) then - Exit; +function TGenericPlaybackStream.ReadData(Buffer: PChar; BufferSize: integer): integer; +var + ConversionInputCount: integer; + ConversionOutputSize: integer; // max. number of converted data (= buffer size) + ConversionOutputCount: integer; // actual number of converted data + SourceSize: integer; + RequestedSourceSize: integer; + NeededSampleBufferSize: integer; + BytesNeeded, BytesAvail: integer; + SourceFormatInfo, OutputFormatInfo: TAudioFormatInfo; + SourceFrameSize, OutputFrameSize: integer; + SkipOutputCount: integer; // number of output-data bytes to skip + SkipSourceCount: integer; // number of source-data bytes to skip + FillCount: integer; // number of bytes to fill with padding data + CopyCount: integer; + PadFrame: PChar; + i: integer; +begin + Result := -1; - // calc number of bytes to decode - decodeBufSize := Ceil(BufSize / cvt.len_ratio); - // assure that the decode-size is a multiple of the frame size - frameSize := DecodeStream.GetAudioFormatInfo().FrameSize; - remFrameBytes := decodeBufSize mod frameSize; - if (remFrameBytes > 0) then - decodeBufSize := decodeBufSize + (frameSize - remFrameBytes); + // sanity check for the source-stream + if (not assigned(SourceStream)) then + Exit; + + SkipOutputCount := 0; + SkipSourceCount := 0; + FillCount := 0; + + SourceFormatInfo := SourceStream.GetAudioFormatInfo(); + SourceFrameSize := SourceFormatInfo.FrameSize; + OutputFormatInfo := GetAudioFormatInfo(); + OutputFrameSize := OutputFormatInfo.FrameSize; + + // synchronize (adjust buffer size) + BytesNeeded := Synchronize(BufferSize, OutputFormatInfo); + if (BytesNeeded > BufferSize) then + begin + SkipOutputCount := BytesNeeded - BufferSize; + BytesNeeded := BufferSize; + end + else if (BytesNeeded < BufferSize) then + begin + FillCount := BufferSize - BytesNeeded; + end; - Lock(); + // lock access to sample-buffer + LockSampleBuffer(); try - // calc buffer size - sampleBufSize := decodeBufSize * cvt.len_mult; - - // resize buffer if necessary. - // The required buffer-size will be smaller than the result-buffer - // in most cases (if the decoded signal is mono or has a lesser bitrate). - // If the output-rate is 44.1kHz and the decode-rate is 48kHz or 96kHz it - // will be ~1.09 or ~2.18 times bigger. Those extra memory consumption - // should be reasonable. If not we should call TDecodeStream.ReadData() - // multiple times. - // Note: we do not decrease the buffer by the count of bytes used from - // the previous call of this function (bytesAvail). Otherwise the - // buffer will be reallocated each time this function is called just to - // add or remove a few bytes from the buffer. - // By not doing this the buffer's size should be rather stable and it - // will not be reallocated/resized at all if the BufSize params does not - // change in consecutive calls. - ReallocMem(SampleBuffer, sampleBufSize); - if not assigned(SampleBuffer) then - Exit; - // decode data - nBytesDecoded := DecodeStream.ReadData(SampleBuffer, decodeBufSize); - if (nBytesDecoded = -1) then - Exit; + // skip sample-buffer data + SampleBufferPos := SampleBufferPos + SkipOutputCount; + // size of available bytes in SampleBuffer after skipping + SampleBufferCount := SampleBufferCount - SampleBufferPos; + // update byte skip-count + SkipOutputCount := -SampleBufferCount; - // end-of-file reached -> stop playback - if (DecodeStream.EOF) then + // now that we skipped all buffered data from the last pass, we have to skip + // data directly after fetching it from the source-stream. + if (SkipOutputCount > 0) then begin - Stop(); + SampleBufferCount := 0; + // convert skip-count to source-format units and resize to a multiple of + // the source frame-size. + SkipSourceCount := Round((SkipOutputCount * OutputFormatInfo.GetRatio(SourceFormatInfo)) / + SourceFrameSize) * SourceFrameSize; + SkipOutputCount := 0; end; - // resample decoded data - cvt.buf := PUint8(SampleBuffer); - cvt.len := nBytesDecoded; - if (SDL_ConvertAudio(@cvt) = -1) then - Exit; + // copy data to front of buffer + if ((SampleBufferCount > 0) and (SampleBufferPos > 0)) then + Move(SampleBuffer[SampleBufferPos], SampleBuffer[0], SampleBufferCount); + SampleBufferPos := 0; - SampleBufferCount := cvt.len_cvt; + // resize buffer to a reasonable size + if (BufferSize > SampleBufferCount) then + begin + // Note: use BufferSize instead of BytesNeeded to minimize the need for resizing + SampleBufferSize := BufferSize; + ReallocMem(SampleBuffer, SampleBufferSize); + if (not assigned(SampleBuffer)) then + Exit; + end; - // apply effects - for i := 0 to SoundEffects.Count-1 do + // fill sample-buffer (fetch and convert one block of source data per loop) + while (SampleBufferCount < BytesNeeded) do begin - if (SoundEffects[i] <> nil) then + // move remaining source data from the previous pass to front of buffer + if (SourceBufferCount > 0) then + begin + Move(SourceBuffer[SourceBufferSize-SourceBufferCount], + SourceBuffer[0], + SourceBufferCount); + end; + + SourceSize := SourceStream.ReadData( + @SourceBuffer[SourceBufferCount], SourceBufferSize-SourceBufferCount); + // break on error (-1) or if no data is available (0), e.g. while seeking + if (SourceSize <= 0) then + begin + // if we do not have data -> exit + if (SourceBufferCount = 0) then + begin + FlushBuffers(); + Exit; + end; + // if we have some data, stop retrieving data from the source stream + // and use the data we have so far + Break; + end; + + SourceBufferCount := SourceBufferCount + SourceSize; + + // end-of-file reached -> stop playback + if (SourceStream.EOF) then begin - TSoundEffect(SoundEffects[i]).Callback(SampleBuffer, SampleBufferCount); + if (Loop) then + SourceStream.Position := 0 + else + Stop(); end; + + if (SkipSourceCount > 0) then + begin + // skip data and update source buffer count + SourceBufferCount := SourceBufferCount - SkipSourceCount; + SkipSourceCount := -SourceBufferCount; + // continue with next pass if we skipped all data + if (SourceBufferCount <= 0) then + begin + SourceBufferCount := 0; + Continue; + end; + end; + + // calc buffer size (might be bigger than actual resampled byte count) + ConversionOutputSize := Converter.GetOutputBufferSize(SourceBufferCount); + NeededSampleBufferSize := SampleBufferCount + ConversionOutputSize; + + // resize buffer if necessary + if (SampleBufferSize < NeededSampleBufferSize) then + begin + SampleBufferSize := NeededSampleBufferSize; + ReallocMem(SampleBuffer, SampleBufferSize); + if (not assigned(SampleBuffer)) then + begin + FlushBuffers(); + Exit; + end; + end; + + // resample source data (Note: ConversionInputCount might be adjusted by Convert()) + ConversionInputCount := SourceBufferCount; + ConversionOutputCount := Converter.Convert( + SourceBuffer, @SampleBuffer[SampleBufferCount], ConversionInputCount); + if (ConversionOutputCount = -1) then + begin + FlushBuffers(); + Exit; + end; + + // adjust sample- and source-buffer count by the number of converted bytes + SampleBufferCount := SampleBufferCount + ConversionOutputCount; + SourceBufferCount := SourceBufferCount - ConversionInputCount; end; - finally - Unlock(); - end; - BytesAvail := SampleBufferCount; - SampleBufferPos := 0; + // apply effects + ApplySoundEffects(SampleBuffer, SampleBufferCount); - // copy data to result buffer - copyCnt := Min(BytesNeeded, BytesAvail); - Move(SampleBuffer[0], Buffer[BufSize - BytesNeeded], copyCnt); - Dec(BytesAvail, copyCnt); - Dec(BytesNeeded, copyCnt); - Inc(SampleBufferPos, copyCnt); + // copy data to result buffer + CopyCount := Min(BytesNeeded, SampleBufferCount); + Move(SampleBuffer[0], Buffer[BufferSize - BytesNeeded], CopyCount); + Dec(BytesNeeded, CopyCount); + SampleBufferPos := CopyCount; - Result := BufSize - BytesNeeded; -end; + // release buffer lock + finally + UnlockSampleBuffer(); + end; -(* TODO: libsamplerate support -function TGenericPlaybackStream.ReadData(Buffer: PChar; BufSize: integer): integer; -var - convState: PSRC_STATE; - convData: SRC_DATA; - error: integer; -begin - // Note: needs mono->stereo conversion, multi-channel->stereo, etc. - // maybe we should use SDL for the channel-conversion stuff - // and use libsamplerate afterwards for the frequency-conversion - - //convState := src_new(SRC_SINC_MEDIUM_QUALITY, 2, @error); - //src_short_to_float_array(input, output, len); - convData. - if (src_process(convState, @convData) <> 0) then + // pad the buffer with the last frame if we are to fast + if (FillCount > 0) then begin - Log.LogError(src_strerror(src_error(convState)), 'TSoftMixerPlaybackStream.ReadData'); - Exit; + if (CopyCount >= OutputFrameSize) then + PadFrame := @Buffer[CopyCount-OutputFrameSize] + else + PadFrame := nil; + FillBufferWithFrame(@Buffer[CopyCount], FillCount, + PadFrame, OutputFrameSize); end; - src_float_to_short_array(); - //src_delete(convState); + + // BytesNeeded now contains the number of remaining bytes we were not able to fetch + Result := BufferSize - BytesNeeded; end; -*) -function TGenericPlaybackStream.GetPCMData(var data: TPCMData): Cardinal; +function TGenericPlaybackStream.GetPCMData(var Data: TPCMData): Cardinal; var - nBytes: integer; + ByteCount: integer; begin Result := 0; @@ -634,23 +742,23 @@ begin end; // zero memory - FillChar(data, SizeOf(data), 0); + FillChar(Data, SizeOf(Data), 0); // TODO: At the moment just the first samples of the SampleBuffer // are returned, even if there is newer data in the upper samples. - Lock(); - nBytes := Min(SizeOf(data), SampleBufferCount); - if (nBytes > 0) then + LockSampleBuffer(); + ByteCount := Min(SizeOf(Data), SampleBufferCount); + if (ByteCount > 0) then begin - Move(SampleBuffer[0], data, nBytes); + Move(SampleBuffer[0], Data, ByteCount); end; - Unlock(); + UnlockSampleBuffer(); - Result := nBytes div SizeOf(TPCMStereoSample); + Result := ByteCount div SizeOf(TPCMStereoSample); end; -procedure TGenericPlaybackStream.GetFFTData(var data: TFFTData); +procedure TGenericPlaybackStream.GetFFTData(var Data: TFFTData); var i: integer; Frames: integer; @@ -658,16 +766,14 @@ var AudioFormat: TAudioFormatInfo; begin // only works with SInt16 and Float values at the moment - AudioFormat := Engine.GetAudioFormatInfo(); + AudioFormat := GetAudioFormatInfo(); DataIn := AllocMem(FFTSize * SizeOf(Single)); if (DataIn = nil) then Exit; - Lock(); + LockSampleBuffer(); // TODO: We just use the first Frames frames, the others are ignored. - // This is OK for the equalizer display but not if we want to use - // this function for voice-analysis someday (I don't think we want). Frames := Min(FFTSize, SampleBufferCount div AudioFormat.FrameSize); // use only first channel and convert data to float-values case AudioFormat.Format of @@ -682,56 +788,84 @@ begin DataIn[i] := PSingle(@SampleBuffer[i*AudioFormat.FrameSize])^; end; end; - Unlock(); + UnlockSampleBuffer(); WindowFunc(fwfHanning, FFTSize, DataIn); - PowerSpectrum(FFTSize, DataIn, @data); + PowerSpectrum(FFTSize, DataIn, @Data); FreeMem(DataIn); // resize data to a 0..1 range for i := 0 to High(TFFTData) do begin - data[i] := Sqrt(data[i]) / 100; + Data[i] := Sqrt(Data[i]) / 100; end; end; -procedure TGenericPlaybackStream.AddSoundEffect(effect: TSoundEffect); +procedure TGenericPlaybackStream.AddSoundEffect(Effect: TSoundEffect); begin - if (not assigned(effect)) then + if (not assigned(Effect)) then Exit; - Lock(); + + LockSampleBuffer(); // check if effect is already in list to avoid duplicates - if (SoundEffects.IndexOf(Pointer(effect)) = -1) then - SoundEffects.Add(Pointer(effect)); - Unlock(); + if (SoundEffects.IndexOf(Pointer(Effect)) = -1) then + SoundEffects.Add(Pointer(Effect)); + UnlockSampleBuffer(); end; -procedure TGenericPlaybackStream.RemoveSoundEffect(effect: TSoundEffect); +procedure TGenericPlaybackStream.RemoveSoundEffect(Effect: TSoundEffect); begin - Lock(); - SoundEffects.Remove(effect); - Unlock(); + LockSampleBuffer(); + SoundEffects.Remove(Effect); + UnlockSampleBuffer(); end; function TGenericPlaybackStream.GetPosition: real; +var + BufferedTime: double; begin - if assigned(DecodeStream) then - result := DecodeStream.Position + if assigned(SourceStream) then + begin + LockSampleBuffer(); + + // calc the time of source data that is buffered (in the SampleBuffer and SourceBuffer) + // but not yet outputed + BufferedTime := (SampleBufferCount - SampleBufferPos) / Engine.FormatInfo.BytesPerSec + + SourceBufferCount / SourceStream.GetAudioFormatInfo().BytesPerSec; + // and subtract it from the source position + Result := SourceStream.Position - BufferedTime; + + UnlockSampleBuffer(); + end else - result := -1; + begin + Result := -1; + end; end; procedure TGenericPlaybackStream.SetPosition(Time: real); begin - if assigned(DecodeStream) then - DecodeStream.Position := Time; + if assigned(SourceStream) then + begin + LockSampleBuffer(); + + SourceStream.Position := Time; + if (Status = ssStopped) then + NeedsRewind := false; + // do not use outdated data + FlushBuffers(); + + AvgSyncDiff := -1; + + UnlockSampleBuffer(); + end; end; function TGenericPlaybackStream.GetVolume(): single; var FadeAmount: Single; begin - Lock(); + LockSampleBuffer(); // adjust volume if fading is enabled if (FadeInTime > 0) then begin @@ -741,32 +875,131 @@ begin begin // target reached -> stop fading FadeInTime := 0; - _volume := FadeInTargetVolume; + fVolume := FadeInTargetVolume; end else begin // fading in progress - _volume := FadeAmount*FadeInTargetVolume + (1-FadeAmount)*FadeInStartVolume; + fVolume := FadeAmount*FadeInTargetVolume + (1-FadeAmount)*FadeInStartVolume; end; end; // return current volume - Result := _volume; - Unlock(); + Result := fVolume; + UnlockSampleBuffer(); end; -procedure TGenericPlaybackStream.SetVolume(volume: single); +procedure TGenericPlaybackStream.SetVolume(Volume: single); begin - Lock(); + LockSampleBuffer(); // stop fading FadeInTime := 0; // clamp volume - if (volume > 1.0) then - _volume := 1.0 - else if (volume < 0) then - _volume := 0 + if (Volume > 1.0) then + fVolume := 1.0 + else if (Volume < 0) then + fVolume := 0 else - _volume := volume; - Unlock(); + fVolume := Volume; + UnlockSampleBuffer(); +end; + + +{ TGenericVoiceStream } + +constructor TGenericVoiceStream.Create(Engine: TAudioPlayback_SoftMixer); +begin + inherited Create(); + Self.Engine := Engine; +end; + +function TGenericVoiceStream.Open(ChannelMap: integer; FormatInfo: TAudioFormatInfo): boolean; +var + BufferSize: integer; +begin + Result := false; + + Close(); + + if (not inherited Open(ChannelMap, FormatInfo)) then + Exit; + + // Note: + // - use Self.FormatInfo instead of FormatInfo as the latter one might have a + // channel size of 2. + // - the buffer-size must be a multiple of the FrameSize + BufferSize := (Ceil(MAX_VOICE_DELAY * Self.FormatInfo.BytesPerSec) div Self.FormatInfo.FrameSize) * + Self.FormatInfo.FrameSize; + VoiceBuffer := TRingBuffer.Create(BufferSize); + + BufferLock := SDL_CreateMutex(); + + + // create a matching playback stream for the voice-stream + PlaybackStream := TGenericPlaybackStream.Create(Engine); + // link voice- and playback-stream + if (not PlaybackStream.Open(Self)) then + begin + PlaybackStream.Free; + Exit; + end; + + // start voice passthrough + PlaybackStream.Play(); + + Result := true; +end; + +procedure TGenericVoiceStream.Close(); +begin + // stop and free the playback stream + FreeAndNil(PlaybackStream); + + // free data + FreeAndNil(VoiceBuffer); + if (BufferLock <> nil) then + SDL_DestroyMutex(BufferLock); + + inherited Close(); +end; + +procedure TGenericVoiceStream.WriteData(Buffer: PChar; BufferSize: integer); +begin + // lock access to buffer + SDL_mutexP(BufferLock); + try + if (VoiceBuffer = nil) then + Exit; + VoiceBuffer.Write(Buffer, BufferSize); + finally + SDL_mutexV(BufferLock); + end; +end; + +function TGenericVoiceStream.ReadData(Buffer: PChar; BufferSize: integer): integer; +begin + Result := -1; + + // lock access to buffer + SDL_mutexP(BufferLock); + try + if (VoiceBuffer = nil) then + Exit; + Result := VoiceBuffer.Read(Buffer, BufferSize); + finally + SDL_mutexV(BufferLock); + end; +end; + +function TGenericVoiceStream.IsEOF(): boolean; +begin + SDL_mutexP(BufferLock); + Result := (VoiceBuffer = nil); + SDL_mutexV(BufferLock); +end; + +function TGenericVoiceStream.IsError(): boolean; +begin + Result := false; end; @@ -774,7 +1007,7 @@ end; function TAudioPlayback_SoftMixer.InitializePlayback: boolean; begin - result := false; + Result := false; //Log.LogStatus('InitializePlayback', 'UAudioPlayback_SoftMixer'); @@ -786,7 +1019,7 @@ begin if(not StartAudioPlaybackEngine()) then Exit; - result := true; + Result := true; end; function TAudioPlayback_SoftMixer.FinalizePlayback: boolean; @@ -802,9 +1035,9 @@ begin Result := true; end; -procedure TAudioPlayback_SoftMixer.AudioCallback(buffer: PChar; size: integer); +procedure TAudioPlayback_SoftMixer.AudioCallback(Buffer: PChar; Size: integer); begin - MixerStream.ReadData(buffer, size); + MixerStream.ReadData(Buffer, Size); end; function TAudioPlayback_SoftMixer.GetMixer(): TAudioMixerStream; @@ -817,38 +1050,26 @@ begin Result := FormatInfo; end; -function TAudioPlayback_SoftMixer.OpenStream(const Filename: String): TAudioPlaybackStream; +function TAudioPlayback_SoftMixer.CreatePlaybackStream(): TAudioPlaybackStream; +begin + Result := TGenericPlaybackStream.Create(Self); +end; + +function TAudioPlayback_SoftMixer.CreateVoiceStream(ChannelMap: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; var - decodeStream: TAudioDecodeStream; - playbackStream: TGenericPlaybackStream; + VoiceStream: TGenericVoiceStream; begin Result := nil; - if (AudioDecoder = nil) then - Exit; - - decodeStream := AudioDecoder.Open(Filename); - if not assigned(decodeStream) then + // create a voice stream + VoiceStream := TGenericVoiceStream.Create(Self); + if (not VoiceStream.Open(ChannelMap, FormatInfo)) then begin - Log.LogStatus('LoadSoundFromFile: Sound not found "' + Filename + '"', 'UAudioPlayback_SoftMixer'); + VoiceStream.Free; Exit; end; - playbackStream := TGenericPlaybackStream.Create(Self); - if (not assigned(playbackStream)) then - begin - FreeAndNil(decodeStream); - Exit; - end; - - if (not playbackStream.SetDecodeStream(decodeStream)) then - begin - FreeAndNil(playbackStream); - FreeAndNil(decodeStream); - Exit; - end; - - result := playbackStream; + Result := VoiceStream; end; procedure TAudioPlayback_SoftMixer.SetAppVolume(Volume: single); @@ -857,47 +1078,46 @@ begin MixerStream.Volume := Volume; end; -procedure TAudioPlayback_SoftMixer.MixBuffers(dst, src: PChar; size: Cardinal; volume: Single); +procedure TAudioPlayback_SoftMixer.MixBuffers(DstBuffer, SrcBuffer: PChar; Size: Cardinal; Volume: Single); var SampleIndex: Cardinal; SampleInt: Integer; SampleFlt: Single; begin - - // TODO: optimize this code, e.g. with assembler (MMX) - SampleIndex := 0; case FormatInfo.Format of asfS16: begin - while (SampleIndex < size) do + while (SampleIndex < Size) do begin // apply volume and sum with previous mixer value - SampleInt := PSmallInt(@dst[SampleIndex])^ + Round(PSmallInt(@src[SampleIndex])^ * volume); + SampleInt := PSmallInt(@DstBuffer[SampleIndex])^ + + Round(PSmallInt(@SrcBuffer[SampleIndex])^ * Volume); // clip result if (SampleInt > High(SmallInt)) then SampleInt := High(SmallInt) else if (SampleInt < Low(SmallInt)) then SampleInt := Low(SmallInt); // assign result - PSmallInt(@dst[SampleIndex])^ := SampleInt; + PSmallInt(@DstBuffer[SampleIndex])^ := SampleInt; // increase index by one sample Inc(SampleIndex, SizeOf(SmallInt)); end; end; asfFloat: begin - while (SampleIndex < size) do + while (SampleIndex < Size) do begin // apply volume and sum with previous mixer value - SampleFlt := PSingle(@dst[SampleIndex])^ + PSingle(@src[SampleIndex])^ * volume; + SampleFlt := PSingle(@DstBuffer[SampleIndex])^ + + PSingle(@SrcBuffer[SampleIndex])^ * Volume; // clip result if (SampleFlt > 1.0) then SampleFlt := 1.0 else if (SampleFlt < -1.0) then SampleFlt := -1.0; // assign result - PSingle(@dst[SampleIndex])^ := SampleFlt; + PSingle(@DstBuffer[SampleIndex])^ := SampleFlt; // increase index by one sample Inc(SampleIndex, SizeOf(Single)); end; diff --git a/Game/Code/Classes/UCommon.pas b/Game/Code/Classes/UCommon.pas index 3c32a804..1b0a6e6c 100644 --- a/Game/Code/Classes/UCommon.pas +++ b/Game/Code/Classes/UCommon.pas @@ -81,6 +81,9 @@ function IsControlChar(ch: WideChar): boolean; // A stable alternative to TList.Sort() (use TList.Sort() if applicable, see below) procedure MergeSort(List: TList; CompareFunc: TListSortCompare); +function GetAlignedMem(Size: cardinal; Alignment: integer): Pointer; +procedure FreeAlignedMem(P: Pointer); + implementation @@ -733,7 +736,7 @@ begin RightSize := BlockSize - LeftSize; MidPos := StartPos + LeftSize; - // sort left and right halves of this block by recursive calls of this function + // sort left and right halves of this block by recursive calls of this function if (LeftSize >= 2) then _MergeSort(InList, OutList, TempList, StartPos, LeftSize, CompareFunc) else @@ -798,6 +801,62 @@ begin end; +type + // stores the unaligned pointer of data allocated by GetAlignedMem() + PMemAlignHeader = ^TMemAlignHeader; + TMemAlignHeader = Pointer; + +(** + * Use this function to assure that allocated memory is aligned on a specific + * byte boundary. + * Alignment must be a power of 2. + * + * Important: Memory allocated with GetAlignedMem() MUST be freed with + * FreeAlignedMem(), FreeMem() will cause a segmentation fault. + * + * Hint: If you do not need dynamic memory, consider to allocate memory + * statically and use the {$ALIGN x} compiler directive. Note that delphi + * supports an alignment "x" of up to 8 bytes only whereas FPC supports + * alignments on 16 and 32 byte boundaries too. + *) +function GetAlignedMem(Size: cardinal; Alignment: integer): Pointer; +var + OrigPtr: Pointer; +const + MIN_ALIGNMENT = 16; +begin + // Delphi and FPC (tested with 2.2.0) align memory blocks allocated with + // GetMem() at least on 8 byte boundaries. Delphi uses a minimal alignment + // of either 8 or 16 bytes depending on the size of the requested block + // (see System.GetMinimumBlockAlignment). As we do not want to change the + // boundary for the worse, we align at least on MIN_ALIGN. + if (Alignment < MIN_ALIGNMENT) then + Alignment := MIN_ALIGNMENT; + + // allocate unaligned memory + GetMem(OrigPtr, SizeOf(TMemAlignHeader) + Size + Alignment); + if (OrigPtr = nil) then + begin + Result := nil; + Exit; + end; + + // reserve space for the header + Result := Pointer(PtrUInt(OrigPtr) + SizeOf(TMemAlignHeader)); + // align memory + Result := Pointer(PtrUInt(Result) + Alignment - PtrUInt(Result) mod Alignment); + + // set header with info on old pointer for FreeMem + PMemAlignHeader(PtrUInt(Result) - SizeOf(TMemAlignHeader))^ := OrigPtr; +end; + +procedure FreeAlignedMem(P: Pointer); +begin + if (P <> nil) then + FreeMem(PMemAlignHeader(PtrUInt(P) - SizeOf(TMemAlignHeader))^); +end; + + initialization InitConsoleOutput(); diff --git a/Game/Code/Classes/UConfig.pas b/Game/Code/Classes/UConfig.pas index 46ba2e74..58aa704c 100644 --- a/Game/Code/Classes/UConfig.pas +++ b/Game/Code/Classes/UConfig.pas @@ -164,6 +164,12 @@ const (PORTAUDIO_VERSION_RELEASE * VERSION_RELEASE); {$ENDIF} + {$IFDEF HaveLibsamplerate} + LIBSAMPLERATE_VERSION = (LIBSAMPLERATE_VERSION_MAJOR * VERSION_MAJOR) + + (LIBSAMPLERATE_VERSION_MINOR * VERSION_MINOR) + + (LIBSAMPLERATE_VERSION_RELEASE * VERSION_RELEASE); + {$ENDIF} + function USDXVersionStr(): string; function USDXShortVersionStr(): string; diff --git a/Game/Code/Classes/UGraphic.pas b/Game/Code/Classes/UGraphic.pas index cc876b65..ae145955 100644 --- a/Game/Code/Classes/UGraphic.pas +++ b/Game/Code/Classes/UGraphic.pas @@ -18,6 +18,7 @@ uses SysUtils, ULyrics, UImage, + UMusic, UScreenLoading, UScreenWelcome, UScreenMain, @@ -454,13 +455,15 @@ begin Log.LogBenchmark('--> Loading Fonts', 2); } + // Note: do not initialize video modules earlier. They might depend on some + // SDL video functions or OpenGL extensions initialized in InitializeScreen() + InitializeVideo(); + //Log.BenchmarkStart(2); Log.LogStatus('TDisplay.Create', 'UGraphic.Initialize3D'); Display := TDisplay.Create; - Log.LogStatus('SDL_EnableUnicode', 'UGraphic.Initialize3D'); - SDL_EnableUnicode(1); //Log.BenchmarkEnd(2); Log.LogBenchmark('====> Creating Display', 2); //Log.LogStatus('Loading Screens', 'Initialize3D'); @@ -551,9 +554,14 @@ begin SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 5); - SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); // Z-Buffer depth SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); + // VSYNC works for windows only at the moment. SDL_GL_SWAP_CONTROL under + // linux uses GLX_MESA_swap_control which is not supported by nvidea cards. + // Maybe use glXSwapIntervalSGI(1) from the GLX_SGI_swap_control extension instead. + //SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1); // VSYNC (currently Windows only) + // If there is a resolution in Parameters, use it, else use the Ini value I := Params.Resolution; if (I <> -1) then diff --git a/Game/Code/Classes/UMain.pas b/Game/Code/Classes/UMain.pas index 46d86447..d045ee34 100644 --- a/Game/Code/Classes/UMain.pas +++ b/Game/Code/Classes/UMain.pas @@ -10,7 +10,6 @@ interface uses SDL, - UGraphic, UMusic, URecord, UTime, @@ -21,8 +20,7 @@ uses ULyrics, UScreenSing, USong, - gl, - UThemes; + gl; type PPLayerNote = ^TPlayerNote; @@ -138,9 +136,11 @@ uses UConfig, UCore, UCommon, + UGraphic, UGraphicClasses, UPluginDefs, - UPlatform; + UPlatform, + UThemes; @@ -167,6 +167,7 @@ begin // Initialize SDL // Without SDL_INIT_TIMER SDL_GetTicks() might return strange values SDL_Init(SDL_INIT_VIDEO or SDL_INIT_TIMER); + SDL_EnableUnicode(1); USTime := TTime.Create; VideoBGTimer := TRelativeTimer.Create; @@ -353,7 +354,7 @@ begin // call an uninitialize routine for every initialize step // or at least use the corresponding Free-Methods - FinalizeSound(); + FinalizeMedia(); TTF_Quit(); SDL_Quit(); diff --git a/Game/Code/Classes/UMediaCore_FFMpeg.pas b/Game/Code/Classes/UMediaCore_FFMpeg.pas new file mode 100644 index 00000000..b914f6be --- /dev/null +++ b/Game/Code/Classes/UMediaCore_FFMpeg.pas @@ -0,0 +1,405 @@ +unit UMediaCore_FFMpeg; + +interface + +{$IFDEF FPC} + {$MODE Delphi} +{$ENDIF} + +{$I switches.inc} + +uses + UMusic, + avcodec, + avformat, + avutil, + ULog, + sdl; + +type + PPacketQueue = ^TPacketQueue; + TPacketQueue = class + private + FirstListEntry: PAVPacketList; + LastListEntry: PAVPacketList; + PacketCount: integer; + Mutex: PSDL_Mutex; + Condition: PSDL_Cond; + Size: integer; + AbortRequest: boolean; + public + constructor Create(); + destructor Destroy(); override; + + function Put(Packet : PAVPacket): integer; + function PutStatus(StatusFlag: integer; StatusInfo: Pointer): integer; + procedure FreeStatusInfo(var Packet: TAVPacket); + function GetStatusInfo(var Packet: TAVPacket): Pointer; + function Get(var Packet: TAVPacket; Blocking: boolean): integer; + function GetSize(): integer; + procedure Flush(); + procedure Abort(); + function IsAborted(): boolean; + end; + +const + STATUS_PACKET: PChar = 'STATUS_PACKET'; +const + PKT_STATUS_FLAG_EOF = 1; // signal end-of-file + PKT_STATUS_FLAG_FLUSH = 2; // request the decoder to flush its avcodec decode buffers + PKT_STATUS_FLAG_ERROR = 3; // signal an error state + PKT_STATUS_FLAG_EMPTY = 4; // request the decoder to output empty data (silence or black frames) + +type + TMediaCore_FFMpeg = class + private + AVCodecLock: PSDL_Mutex; + public + constructor Create(); + destructor Destroy(); override; + class function GetInstance(): TMediaCore_FFMpeg; + + function GetErrorString(ErrorNum: integer): string; + function FindStreamIDs(FormatCtx: PAVFormatContext; out FirstVideoStream, FirstAudioStream: integer ): boolean; + function FindAudioStreamIndex(FormatCtx: PAVFormatContext): integer; + function ConvertFFMpegToAudioFormat(FFMpegFormat: TSampleFormat; out Format: TAudioSampleFormat): boolean; + procedure LockAVCodec(); + procedure UnlockAVCodec(); + end; + +implementation + +uses + SysUtils; + +var + Instance: TMediaCore_FFMpeg; + +constructor TMediaCore_FFMpeg.Create(); +begin + inherited; + AVCodecLock := SDL_CreateMutex(); +end; + +destructor TMediaCore_FFMpeg.Destroy(); +begin + SDL_DestroyMutex(AVCodecLock); + inherited; +end; + +class function TMediaCore_FFMpeg.GetInstance(): TMediaCore_FFMpeg; +begin + if (not Assigned(Instance)) then + Instance := TMediaCore_FFMpeg.Create(); + Result := Instance; +end; + +procedure TMediaCore_FFMpeg.LockAVCodec(); +begin + SDL_mutexP(AVCodecLock); +end; + +procedure TMediaCore_FFMpeg.UnlockAVCodec(); +begin + SDL_mutexV(AVCodecLock); +end; + +function TMediaCore_FFMpeg.GetErrorString(ErrorNum: integer): string; +begin + case ErrorNum of + AVERROR_IO: Result := 'AVERROR_IO'; + AVERROR_NUMEXPECTED: Result := 'AVERROR_NUMEXPECTED'; + AVERROR_INVALIDDATA: Result := 'AVERROR_INVALIDDATA'; + AVERROR_NOMEM: Result := 'AVERROR_NOMEM'; + AVERROR_NOFMT: Result := 'AVERROR_NOFMT'; + AVERROR_NOTSUPP: Result := 'AVERROR_NOTSUPP'; + AVERROR_NOENT: Result := 'AVERROR_NOENT'; + AVERROR_PATCHWELCOME: Result := 'AVERROR_PATCHWELCOME'; + else Result := 'AVERROR_#'+inttostr(ErrorNum); + end; +end; + +{ + @param(FormatCtx is a PAVFormatContext returned from av_open_input_file ) + @param(FirstVideoStream is an OUT value of type integer, this is the index of the video stream) + @param(FirstAudioStream is an OUT value of type integer, this is the index of the audio stream) + @returns(@true on success, @false otherwise) +} +function TMediaCore_FFMpeg.FindStreamIDs(FormatCtx: PAVFormatContext; out FirstVideoStream, FirstAudioStream: integer): boolean; +var + i: integer; + Stream: PAVStream; +begin + // find the first video stream + FirstAudioStream := -1; + FirstVideoStream := -1; + + for i := 0 to FormatCtx.nb_streams-1 do + begin + Stream := FormatCtx.streams[i]; + + if (Stream.codec.codec_type = CODEC_TYPE_VIDEO) and + (FirstVideoStream < 0) then + begin + FirstVideoStream := i; + end; + + if (Stream.codec.codec_type = CODEC_TYPE_AUDIO) and + (FirstAudioStream < 0) then + begin + FirstAudioStream := i; + end; + end; + + // return true if either an audio- or video-stream was found + Result := (FirstAudioStream > -1) or + (FirstVideoStream > -1) ; +end; + +function TMediaCore_FFMpeg.FindAudioStreamIndex(FormatCtx: PAVFormatContext): integer; +var + i: integer; + StreamIndex: integer; + Stream: PAVStream; +begin + // find the first audio stream + StreamIndex := -1; + + for i := 0 to FormatCtx^.nb_streams-1 do + begin + Stream := FormatCtx^.streams[i]; + + if (Stream.codec^.codec_type = CODEC_TYPE_AUDIO) then + begin + StreamIndex := i; + Break; + end; + end; + + Result := StreamIndex; +end; + +function TMediaCore_FFMpeg.ConvertFFMpegToAudioFormat(FFMpegFormat: TSampleFormat; out Format: TAudioSampleFormat): boolean; +begin + case FFMpegFormat of + SAMPLE_FMT_U8: Format := asfU8; + SAMPLE_FMT_S16: Format := asfS16; + SAMPLE_FMT_S24: Format := asfS24; + SAMPLE_FMT_S32: Format := asfS32; + SAMPLE_FMT_FLT: Format := asfFloat; + else begin + Result := false; + Exit; + end; + end; + Result := true; +end; + +{ TPacketQueue } + +constructor TPacketQueue.Create(); +begin + inherited; + + FirstListEntry := nil; + LastListEntry := nil; + PacketCount := 0; + Size := 0; + + Mutex := SDL_CreateMutex(); + Condition := SDL_CreateCond(); +end; + +destructor TPacketQueue.Destroy(); +begin + Flush(); + SDL_DestroyMutex(Mutex); + SDL_DestroyCond(Condition); + inherited; +end; + +procedure TPacketQueue.Abort(); +begin + SDL_LockMutex(Mutex); + + AbortRequest := true; + + SDL_CondBroadcast(Condition); + SDL_UnlockMutex(Mutex); +end; + +function TPacketQueue.IsAborted(): boolean; +begin + SDL_LockMutex(Mutex); + Result := AbortRequest; + SDL_UnlockMutex(Mutex); +end; + +function TPacketQueue.Put(Packet : PAVPacket): integer; +var + CurrentListEntry : PAVPacketList; +begin + Result := -1; + + if (Packet = nil) then + Exit; + + if (PChar(Packet^.data) <> STATUS_PACKET) then + begin + if (av_dup_packet(Packet) < 0) then + Exit; + end; + + CurrentListEntry := av_malloc(SizeOf(TAVPacketList)); + if (CurrentListEntry = nil) then + Exit; + + CurrentListEntry^.pkt := Packet^; + CurrentListEntry^.next := nil; + + SDL_LockMutex(Mutex); + try + if (LastListEntry = nil) then + FirstListEntry := CurrentListEntry + else + LastListEntry^.next := CurrentListEntry; + + LastListEntry := CurrentListEntry; + Inc(PacketCount); + + Size := Size + CurrentListEntry^.pkt.size; + SDL_CondSignal(Condition); + finally + SDL_UnlockMutex(Mutex); + end; + + Result := 0; +end; + +(** + * Adds a status packet (EOF, Flush, etc.) to the end of the queue. + * StatusInfo can be used to pass additional information to the decoder. + * Only assign nil or a valid pointer to data allocated with Getmem() to + * StatusInfo because the pointer will be disposed with Freemem() on a call + * to Flush(). If the packet is removed from the queue it is the decoder's + * responsibility to free the StatusInfo data with FreeStatusInfo(). + *) +function TPacketQueue.PutStatus(StatusFlag: integer; StatusInfo: Pointer): integer; +var + TempPacket: PAVPacket; +begin + // create temp. package + TempPacket := av_malloc(SizeOf(TAVPacket)); + if (TempPacket = nil) then + begin + Result := -1; + Exit; + end; + // init package + av_init_packet(TempPacket^); + TempPacket^.data := Pointer(STATUS_PACKET); + TempPacket^.flags := StatusFlag; + TempPacket^.priv := StatusInfo; + // put a copy of the package into the queue + Result := Put(TempPacket); + // data has been copied -> delete temp. package + av_free(TempPacket); +end; + +procedure TPacketQueue.FreeStatusInfo(var Packet: TAVPacket); +begin + if (Packet.priv <> nil) then + FreeMem(Packet.priv); +end; + +function TPacketQueue.GetStatusInfo(var Packet: TAVPacket): Pointer; +begin + Result := Packet.priv; +end; + +function TPacketQueue.Get(var Packet: TAVPacket; Blocking: boolean): integer; +var + CurrentListEntry: PAVPacketList; +const + WAIT_TIMEOUT = 10; // timeout in ms +begin + Result := -1; + + SDL_LockMutex(Mutex); + try + while (true) do + begin + if (AbortRequest) then + Exit; + + CurrentListEntry := FirstListEntry; + if (CurrentListEntry <> nil) then + begin + FirstListEntry := CurrentListEntry^.next; + if (FirstListEntry = nil) then + LastListEntry := nil; + Dec(PacketCount); + + Size := Size - CurrentListEntry^.pkt.size; + Packet := CurrentListEntry^.pkt; + av_free(CurrentListEntry); + + Result := 1; + Break; + end + else if (not Blocking) then + begin + Result := 0; + Break; + end + else + begin + // block until a new package arrives, + // but do not wait till infinity to avoid deadlocks + if (SDL_CondWaitTimeout(Condition, Mutex, WAIT_TIMEOUT) = SDL_MUTEX_TIMEDOUT) then + begin + Result := 0; + Break; + end; + end; + end; + finally + SDL_UnlockMutex(Mutex); + end; +end; + +function TPacketQueue.GetSize(): integer; +begin + SDL_LockMutex(Mutex); + Result := Size; + SDL_UnlockMutex(Mutex); +end; + +procedure TPacketQueue.Flush(); +var + CurrentListEntry, TempListEntry: PAVPacketList; +begin + SDL_LockMutex(Mutex); + + CurrentListEntry := FirstListEntry; + while(CurrentListEntry <> nil) do + begin + TempListEntry := CurrentListEntry^.next; + // free status data + if (PChar(CurrentListEntry^.pkt.data) = STATUS_PACKET) then + FreeStatusInfo(CurrentListEntry^.pkt); + // free packet data + av_free_packet(@CurrentListEntry^.pkt); + // Note: param must be a pointer to a pointer! + av_freep(@CurrentListEntry); + CurrentListEntry := TempListEntry; + end; + LastListEntry := nil; + FirstListEntry := nil; + PacketCount := 0; + Size := 0; + + SDL_UnlockMutex(Mutex); +end; + +end. diff --git a/Game/Code/Classes/UMediaCore_SDL.pas b/Game/Code/Classes/UMediaCore_SDL.pas new file mode 100644 index 00000000..252f72a0 --- /dev/null +++ b/Game/Code/Classes/UMediaCore_SDL.pas @@ -0,0 +1,38 @@ +unit UMediaCore_SDL; + +interface + +{$IFDEF FPC} + {$MODE Delphi} +{$ENDIF} + +{$I switches.inc} + +uses + UMusic, + sdl; + +function ConvertAudioFormatToSDL(Format: TAudioSampleFormat; out SDLFormat: UInt16): boolean; + +implementation + +function ConvertAudioFormatToSDL(Format: TAudioSampleFormat; out SDLFormat: UInt16): boolean; +begin + case Format of + asfU8: SDLFormat := AUDIO_U8; + asfS8: SDLFormat := AUDIO_S8; + asfU16LSB: SDLFormat := AUDIO_U16LSB; + asfS16LSB: SDLFormat := AUDIO_S16LSB; + asfU16MSB: SDLFormat := AUDIO_U16MSB; + asfS16MSB: SDLFormat := AUDIO_S16MSB; + asfU16: SDLFormat := AUDIO_U16; + asfS16: SDLFormat := AUDIO_S16; + else begin + Result := false; + Exit; + end; + end; + Result := true; +end; + +end. diff --git a/Game/Code/Classes/UMedia_dummy.pas b/Game/Code/Classes/UMedia_dummy.pas index 62a94aef..438b89ab 100644 --- a/Game/Code/Classes/UMedia_dummy.pas +++ b/Game/Code/Classes/UMedia_dummy.pas @@ -1,14 +1,4 @@ unit UMedia_dummy; -{< ############################################################################# -# FFmpeg support for UltraStar deluxe # -# # -# Created by b1indy # -# based on 'An ffmpeg and SDL Tutorial' (http://www.dranger.com/ffmpeg/) # -# # -# http://www.mail-archive.com/fpc-pascal@lists.freepascal.org/msg09949.html # -# http://www.nabble.com/file/p11795857/mpegpas01.zip # -# # -############################################################################## } interface @@ -25,18 +15,16 @@ uses math, UMusic; -var - singleton_dummy : IVideoPlayback; - type TMedia_dummy = class( TInterfacedObject, IVideoPlayback, IVideoVisualization, IAudioPlayback, IAudioInput ) private DummyOutputDeviceList: TAudioOutputDeviceList; public - constructor create(); + constructor Create(); function GetName: string; - procedure init(); + function Init(): boolean; + function Finalize(): boolean; function Open(const aFileName : string): boolean; // true if succeed procedure Close; @@ -48,6 +36,8 @@ type procedure SetPosition(Time: real); function GetPosition: real; + procedure SetSyncSource(SyncSource: TSyncSource); + procedure GetFrame(Time: Extended); procedure DrawGL(Screen: integer); @@ -74,157 +64,180 @@ type function Length: real; function OpenSound(const Filename: string): TAudioPlaybackStream; + procedure CloseSound(var PlaybackStream: TAudioPlaybackStream); procedure PlaySound(stream: TAudioPlaybackStream); procedure StopSound(stream: TAudioPlaybackStream); + + function CreateVoiceStream(Channel: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; + procedure CloseVoiceStream(var VoiceStream: TAudioVoiceStream); end; -function Tmedia_dummy.GetName: string; +function TMedia_dummy.GetName: string; begin - result := 'dummy'; + Result := 'dummy'; end; -procedure Tmedia_dummy.GetFrame(Time: Extended); +procedure TMedia_dummy.GetFrame(Time: Extended); begin end; -procedure Tmedia_dummy.DrawGL(Screen: integer); +procedure TMedia_dummy.DrawGL(Screen: integer); begin end; -constructor Tmedia_dummy.create(); +constructor TMedia_dummy.Create(); begin inherited; end; -procedure Tmedia_dummy.init(); +function TMedia_dummy.Init(): boolean; +begin + Result := true; +end; + +function TMedia_dummy.Finalize(): boolean; begin + Result := true; end; -function Tmedia_dummy.Open(const aFileName : string): boolean; // true if succeed +function TMedia_dummy.Open(const aFileName : string): boolean; // true if succeed begin - result := false; + Result := false; end; -procedure Tmedia_dummy.Close; +procedure TMedia_dummy.Close; begin end; -procedure Tmedia_dummy.Play; +procedure TMedia_dummy.Play; begin end; -procedure Tmedia_dummy.Pause; +procedure TMedia_dummy.Pause; begin end; -procedure Tmedia_dummy.Stop; +procedure TMedia_dummy.Stop; begin end; -procedure Tmedia_dummy.SetPosition(Time: real); +procedure TMedia_dummy.SetPosition(Time: real); begin end; -function Tmedia_dummy.GetPosition: real; +function TMedia_dummy.GetPosition: real; +begin + Result := 0; +end; + +procedure TMedia_dummy.SetSyncSource(SyncSource: TSyncSource); begin - result := 0; end; // IAudioInput -function Tmedia_dummy.InitializeRecord: boolean; +function TMedia_dummy.InitializeRecord: boolean; begin - result := true; + Result := true; end; -function Tmedia_dummy.FinalizeRecord: boolean; +function TMedia_dummy.FinalizeRecord: boolean; begin - result := true; + Result := true; end; -procedure Tmedia_dummy.CaptureStart; +procedure TMedia_dummy.CaptureStart; begin end; -procedure Tmedia_dummy.CaptureStop; +procedure TMedia_dummy.CaptureStop; begin end; -procedure Tmedia_dummy.GetFFTData(var data: TFFTData); +procedure TMedia_dummy.GetFFTData(var data: TFFTData); begin end; -function Tmedia_dummy.GetPCMData(var data: TPCMData): Cardinal; +function TMedia_dummy.GetPCMData(var data: TPCMData): Cardinal; begin - result := 0; + Result := 0; end; // IAudioPlayback -function Tmedia_dummy.InitializePlayback: boolean; +function TMedia_dummy.InitializePlayback: boolean; begin SetLength(DummyOutputDeviceList, 1); DummyOutputDeviceList[0] := TAudioOutputDevice.Create(); DummyOutputDeviceList[0].Name := '[Dummy Device]'; - result := true; + Result := true; end; -function Tmedia_dummy.FinalizePlayback: boolean; +function TMedia_dummy.FinalizePlayback: boolean; begin - result := true; + Result := true; end; -function Tmedia_dummy.GetOutputDeviceList(): TAudioOutputDeviceList; +function TMedia_dummy.GetOutputDeviceList(): TAudioOutputDeviceList; begin Result := DummyOutputDeviceList; end; -procedure Tmedia_dummy.SetAppVolume(Volume: single); +procedure TMedia_dummy.SetAppVolume(Volume: single); begin end; -procedure Tmedia_dummy.SetVolume(Volume: single); +procedure TMedia_dummy.SetVolume(Volume: single); begin end; -procedure Tmedia_dummy.SetLoop(Enabled: boolean); +procedure TMedia_dummy.SetLoop(Enabled: boolean); begin end; -procedure Tmedia_dummy.FadeIn(Time: real; TargetVolume: single); +procedure TMedia_dummy.FadeIn(Time: real; TargetVolume: single); begin end; -procedure Tmedia_dummy.Rewind; +procedure TMedia_dummy.Rewind; begin end; -function Tmedia_dummy.Finished: boolean; +function TMedia_dummy.Finished: boolean; begin - result := false; + Result := false; end; -function Tmedia_dummy.Length: real; +function TMedia_dummy.Length: real; begin Result := 60; end; -function Tmedia_dummy.OpenSound(const Filename: string): TAudioPlaybackStream; +function TMedia_dummy.OpenSound(const Filename: string): TAudioPlaybackStream; begin - result := nil; + Result := nil; end; -procedure Tmedia_dummy.PlaySound(stream: TAudioPlaybackStream); +procedure TMedia_dummy.CloseSound(var PlaybackStream: TAudioPlaybackStream); begin end; -procedure Tmedia_dummy.StopSound(stream: TAudioPlaybackStream); +procedure TMedia_dummy.PlaySound(stream: TAudioPlaybackStream); begin end; -initialization - singleton_dummy := Tmedia_dummy.create(); - AudioManager.add( singleton_dummy ); +procedure TMedia_dummy.StopSound(stream: TAudioPlaybackStream); +begin +end; + +function TMedia_dummy.CreateVoiceStream(Channel: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; +begin + Result := nil; +end; -finalization - AudioManager.Remove( singleton_dummy ); +procedure TMedia_dummy.CloseVoiceStream(var VoiceStream: TAudioVoiceStream); +begin +end; + +initialization + MediaManager.Add(TMedia_dummy.Create); end. diff --git a/Game/Code/Classes/UMusic.pas b/Game/Code/Classes/UMusic.pas index 35c67ae1..38f7d53a 100644 --- a/Game/Code/Classes/UMusic.pas +++ b/Game/Code/Classes/UMusic.pas @@ -68,6 +68,9 @@ type TLineState = class private Timer: TRelativeTimer; // keeps track of the current time + + function GetCurrentTime(): real; + procedure SetCurrentTime(Time: real); public OldBeat: integer; // previous discovered beat CurrentBeat: integer; @@ -95,11 +98,11 @@ type constructor Create(); procedure Pause(); procedure Resume(); - function GetCurrentTime(): real; - procedure SetCurrentTime(Time: real); - // current song time used as base-timer for lyrics etc. - property CurrentTime: real READ GetCurrentTime WRITE SetCurrentTime; + (** + * current song time used as base-timer for lyrics etc. + *) + property CurrentTime: real read GetCurrentTime write SetCurrentTime; end; @@ -114,10 +117,10 @@ type TPCMData = array[0..511] of TPCMStereoSample; type - TStreamStatus = (ssStopped, ssPlaying, ssPaused, ssBlocked, ssUnknown); + TStreamStatus = (ssStopped, ssPlaying, ssPaused); const StreamStatusStr: array[TStreamStatus] of string = - ('Stopped', 'Playing', 'Paused', 'Blocked', 'Unknown'); + ('Stopped', 'Playing', 'Paused'); type TAudioSampleFormat = ( @@ -142,15 +145,39 @@ const 4 // asfFloat ); +const + CHANNELMAP_LEFT = 1; + CHANNELMAP_RIGHT = 2; + CHANNELMAP_FRONT = CHANNELMAP_LEFT or CHANNELMAP_RIGHT; + type TAudioFormatInfo = class + private + fSampleRate : double; + fChannels : byte; + fFormat : TAudioSampleFormat; + fFrameSize : integer; + + procedure SetChannels(Channels: byte); + procedure SetFormat(Format: TAudioSampleFormat); + procedure UpdateFrameSize(); + function GetBytesPerSec(): double; public - Channels : byte; - SampleRate : double; - Format : TAudioSampleFormat; - FrameSize : integer; // calculated on construction - constructor Create(Channels: byte; SampleRate: double; Format: TAudioSampleFormat); + function Copy(): TAudioFormatInfo; + + (** + * Returns the inverse ratio of the size of data in this format to its + * size in a given target format. + * Example: SrcSize*SrcInfo.GetRatio(TgtInfo) = TgtSize + *) + function GetRatio(TargetInfo: TAudioFormatInfo): double; + + property SampleRate: double read fSampleRate write fSampleRate; + property Channels: byte read fChannels write SetChannels; + property Format: TAudioSampleFormat read fFormat write SetFormat; + property FrameSize: integer read fFrameSize; + property BytesPerSec: double read GetBytesPerSec; end; type @@ -166,22 +193,89 @@ type end; type + TSyncSource = class + function GetClock(): real; virtual; abstract; + end; + + TAudioProcessingStream = class; + TOnCloseHandler = procedure(Stream: TAudioProcessingStream); + TAudioProcessingStream = class + protected + OnCloseHandlers: array of TOnCloseHandler; + + function GetLength(): real; virtual; abstract; + function GetPosition(): real; virtual; abstract; + procedure SetPosition(Time: real); virtual; abstract; + function GetLoop(): boolean; virtual; abstract; + procedure SetLoop(Enabled: boolean); virtual; abstract; + + procedure PerformOnClose(); + public + function GetAudioFormatInfo(): TAudioFormatInfo; virtual; abstract; + procedure Close(); virtual; abstract; + + (** + * Adds a new OnClose action handler. + * The handlers are performed in the order they were added. + * If not stated explicitely, member-variables might have been invalidated + * already. So do not use any member (variable/method/...) if you are not + * sure it is valid. + *) + procedure AddOnCloseHandler(Handler: TOnCloseHandler); + + property Length: real read GetLength; + property Position: real read GetPosition write SetPosition; + property Loop: boolean read GetLoop write SetLoop; + end; + + TAudioSourceStream = class(TAudioProcessingStream) + protected + function IsEOF(): boolean; virtual; abstract; + function IsError(): boolean; virtual; abstract; public - procedure Close(); virtual; abstract; + function ReadData(Buffer: PChar; BufferSize: integer): integer; virtual; abstract; + + property EOF: boolean read IsEOF; + property Error: boolean read IsError; end; + (* + * State-Chart for playback-stream state transitions + * []: Transition, (): State + * + * /---[Play/FadeIn]--->-\ /-------[Pause]----->-\ + * -[Create]->(Stop) (Play) (Pause) + * \\-<-[Stop/EOF*/Error]-/ \-<---[Play/FadeIn]--// + * \-<------------[Stop/EOF*/Error]--------------/ + * + * *: if not looped, otherwise stream is repeated + * Note: SetPosition() does not change the state. + *) + TAudioPlaybackStream = class(TAudioProcessingStream) protected - function GetPosition: real; virtual; abstract; - procedure SetPosition(Time: real); virtual; abstract; - function GetLength(): real; virtual; abstract; + SyncSource: TSyncSource; + AvgSyncDiff: double; + SourceStream: TAudioSourceStream; + + function GetLatency(): double; virtual; abstract; function GetStatus(): TStreamStatus; virtual; abstract; function GetVolume(): single; virtual; abstract; procedure SetVolume(Volume: single); virtual; abstract; - function GetLoop(): boolean; virtual; abstract; - procedure SetLoop(Enabled: boolean); virtual; abstract; - public + function Synchronize(BufferSize: integer; FormatInfo: TAudioFormatInfo): integer; + procedure FillBufferWithFrame(Buffer: PChar; BufferSize: integer; Frame: PChar; FrameSize: integer); + public + (** + * Opens a SourceStream for playback. + * Note that the caller (not the TAudioPlaybackStream) is responsible to + * free the SourceStream after the Playback-Stream is closed. + * You may use an OnClose-handler to achieve this. GetSourceStream() + * guarantees to deliver this method's SourceStream parameter to + * the OnClose-handler. Freeing SourceStream at OnClose is allowed. + *) + function Open(SourceStream: TAudioSourceStream): boolean; virtual; abstract; + procedure Play(); virtual; abstract; procedure Pause(); virtual; abstract; procedure Stop(); virtual; abstract; @@ -190,38 +284,40 @@ type procedure GetFFTData(var data: TFFTData); virtual; abstract; function GetPCMData(var data: TPCMData): Cardinal; virtual; abstract; - procedure AddSoundEffect(effect: TSoundEffect); virtual; abstract; - procedure RemoveSoundEffect(effect: TSoundEffect); virtual; abstract; + procedure AddSoundEffect(Effect: TSoundEffect); virtual; abstract; + procedure RemoveSoundEffect(Effect: TSoundEffect); virtual; abstract; + + procedure SetSyncSource(SyncSource: TSyncSource); + function GetSourceStream(): TAudioSourceStream; - property Length: real READ GetLength; - property Position: real READ GetPosition WRITE SetPosition; - property Status: TStreamStatus READ GetStatus; - property Volume: single READ GetVolume WRITE SetVolume; - property Loop: boolean READ GetLoop WRITE SetLoop; + property Status: TStreamStatus read GetStatus; + property Volume: single read GetVolume write SetVolume; end; - TAudioDecodeStream = class(TAudioProcessingStream) + TAudioDecodeStream = class(TAudioSourceStream) + end; + + TAudioVoiceStream = class(TAudioSourceStream) protected - function GetLength(): real; virtual; abstract; - function GetPosition(): real; virtual; abstract; - procedure SetPosition(Time: real); virtual; abstract; - function IsEOF(): boolean; virtual; abstract; - function IsError(): boolean; virtual; abstract; + FormatInfo: TAudioFormatInfo; + ChannelMap: integer; public - function ReadData(Buffer: PChar; BufSize: integer): integer; virtual; abstract; - function GetAudioFormatInfo(): TAudioFormatInfo; virtual; abstract; + destructor Destroy; override; + + function Open(ChannelMap: integer; FormatInfo: TAudioFormatInfo): boolean; virtual; + procedure Close(); override; + + procedure WriteData(Buffer: PChar; BufferSize: integer); virtual; abstract; + function GetAudioFormatInfo(): TAudioFormatInfo; override; - property Length: real READ GetLength; - property Position: real READ GetPosition WRITE SetPosition; - property EOF: boolean READ IsEOF; + function GetLength(): real; override; + function GetPosition(): real; override; + procedure SetPosition(Time: real); override; + function GetLoop(): boolean; override; + procedure SetLoop(Enabled: boolean); override; end; type - TAudioVoiceStream = class(TAudioProcessingStream) - public - function ReadData(Buffer: PChar; BufSize: integer): integer; virtual; abstract; - function GetAudioFormatInfo(): TAudioFormatInfo; virtual; abstract; - end; // soundcard output-devices information TAudioOutputDevice = class public @@ -234,7 +330,7 @@ type ['{63A5EBC3-3F4D-4F23-8DFB-B5165FCE33DD}'] function GetName: String; - function Open(const Filename: string): boolean; // true if succeed + function Open(const Filename: string): boolean; // true if succeed procedure Close; procedure Play; @@ -242,14 +338,15 @@ type procedure Stop; procedure SetPosition(Time: real); - function GetPosition: real; + function GetPosition: real; - property Position : real READ GetPosition WRITE SetPosition; + property Position: real read GetPosition write SetPosition; end; IVideoPlayback = Interface( IGenericPlayback ) ['{3574C40C-28AE-4201-B3D1-3D1F0759B131}'] - procedure init(); + function Init(): boolean; + function Finalize: boolean; procedure GetFrame(Time: Extended); // WANT TO RENAME THESE TO BE MORE GENERIC procedure DrawGL(Screen: integer); // WANT TO RENAME THESE TO BE MORE GENERIC @@ -266,25 +363,36 @@ type function FinalizePlayback: boolean; function GetOutputDeviceList(): TAudioOutputDeviceList; + procedure SetAppVolume(Volume: single); procedure SetVolume(Volume: single); procedure SetLoop(Enabled: boolean); + procedure FadeIn(Time: real; TargetVolume: single); + procedure SetSyncSource(SyncSource: TSyncSource); procedure Rewind; function Finished: boolean; function Length: real; // Sounds + // TODO: + // add a TMediaDummyPlaybackStream implementation that will + // be used by the TSoundLib whenever OpenSound() fails, so checking for + // nil-pointers is not neccessary anymore. + // PlaySound/StopSound will be removed then, OpenSound will be renamed to + // CreateSound. function OpenSound(const Filename: String): TAudioPlaybackStream; - procedure PlaySound(stream: TAudioPlaybackStream); - procedure StopSound(stream: TAudioPlaybackStream); + procedure PlaySound(Stream: TAudioPlaybackStream); + procedure StopSound(Stream: TAudioPlaybackStream); // Equalizer - procedure GetFFTData(var data: TFFTData); + procedure GetFFTData(var Data: TFFTData); // Interface for Visualizer - function GetPCMData(var data: TPCMData): Cardinal; + function GetPCMData(var Data: TPCMData): Cardinal; + + function CreateVoiceStream(ChannelMap: integer; FormatInfo: TAudioFormatInfo): TAudioVoiceStream; end; IGenericDecoder = Interface @@ -318,108 +426,200 @@ type end; type + TAudioConverter = class + protected + fSrcFormatInfo: TAudioFormatInfo; + fDstFormatInfo: TAudioFormatInfo; + public + function Init(SrcFormatInfo: TAudioFormatInfo; DstFormatInfo: TAudioFormatInfo): boolean; virtual; + destructor Destroy(); override; + + (** + * Converts the InputBuffer and stores the result in OutputBuffer. + * If the result is not -1, InputSize will be set to the actual number of + * input-buffer bytes used. + * Returns the number of bytes written to the output-buffer or -1 if an error occured. + *) + function Convert(InputBuffer: PChar; OutputBuffer: PChar; var InputSize: integer): integer; virtual; abstract; + + (** + * Destination/Source size ratio + *) + function GetRatio(): double; virtual; abstract; + + function GetOutputBufferSize(InputSize: integer): integer; virtual; abstract; + property SrcFormatInfo: TAudioFormatInfo read fSrcFormatInfo; + property DstFormatInfo: TAudioFormatInfo read fDstFormatInfo; + end; + +(* TODO +const + SOUNDID_START = 0; + SOUNDID_BACK = 1; + SOUNDID_SWOOSH = 2; + SOUNDID_CHANGE = 3; + SOUNDID_OPTION = 4; + SOUNDID_CLICK = 5; + LAST_SOUNDID = SOUNDID_CLICK; + + BaseSoundFilenames: array[0..LAST_SOUNDID] of string = ( + '%SOUNDPATH%/Common start.mp3', // Start + '%SOUNDPATH%/Common back.mp3', // Back + '%SOUNDPATH%/menu swoosh.mp3', // Swoosh + '%SOUNDPATH%/select music change music 50.mp3', // Change + '%SOUNDPATH%/option change col.mp3', // Option + '%SOUNDPATH%/rimshot022b.mp3' // Click + { + '%SOUNDPATH%/bassdrumhard076b.mp3', // Drum (unused) + '%SOUNDPATH%/hihatclosed068b.mp3', // Hihat (unused) + '%SOUNDPATH%/claps050b.mp3', // Clap (unused) + '%SOUNDPATH%/Shuffle.mp3' // Shuffle (unused) + } + ); +*) + +type TSoundLibrary = class + private + // TODO + //Sounds: array of TAudioPlaybackStream; public + // TODO: move sounds to the private section + // and provide IDs instead. Start: TAudioPlaybackStream; Back: TAudioPlaybackStream; Swoosh: TAudioPlaybackStream; Change: TAudioPlaybackStream; Option: TAudioPlaybackStream; Click: TAudioPlaybackStream; - Drum: TAudioPlaybackStream; - Hihat: TAudioPlaybackStream; - Clap: TAudioPlaybackStream; - Shuffle: TAudioPlaybackStream; + BGMusic: TAudioPlaybackStream; constructor Create(); destructor Destroy(); override; procedure LoadSounds(); procedure UnloadSounds(); - end; -var // TODO : JB --- THESE SHOULD NOT BE GLOBAL - // czesci z nutami; - Lines: array of TLines; - - // LineState - LineState: TLineState; + // TODO + //function AddSound(Filename: string): integer; + //procedure RemoveSound(ID: integer); + //function GetSound(ID: integer): TAudioPlaybackStream; + //property Sound[ID: integer]: TAudioPlaybackStream read GetSound; default; + end; +var + // TODO: JB --- THESE SHOULD NOT BE GLOBAL + Lines: array of TLines; + LineState: TLineState; SoundLib: TSoundLibrary; procedure InitializeSound; -procedure FinalizeSound; +procedure InitializeVideo; +procedure FinalizeMedia; function Visualization(): IVideoPlayback; function VideoPlayback(): IVideoPlayback; function AudioPlayback(): IAudioPlayback; function AudioInput(): IAudioInput; -function AudioDecoder(): IAudioDecoder; +function AudioDecoders(): TInterfaceList; -function AudioManager: TInterfaceList; +function MediaManager: TInterfaceList; +procedure DumpMediaInterfaces(); implementation uses sysutils, + math, UMain, UCommandLine, URecord, ULog; var - singleton_VideoPlayback : IVideoPlayback = nil; - singleton_Visualization : IVideoPlayback = nil; - singleton_AudioPlayback : IAudioPlayback = nil; - singleton_AudioInput : IAudioInput = nil; - singleton_AudioDecoder : IAudioDecoder = nil; - - singleton_AudioManager : TInterfaceList = nil; + DefaultVideoPlayback : IVideoPlayback; + DefaultVisualization : IVideoPlayback; + DefaultAudioPlayback : IAudioPlayback; + DefaultAudioInput : IAudioInput; + AudioDecoderList : TInterfaceList; + MediaInterfaceList : TInterfaceList; constructor TAudioFormatInfo.Create(Channels: byte; SampleRate: double; Format: TAudioSampleFormat); begin inherited Create(); - Self.Channels := Channels; - Self.SampleRate := SampleRate; - Self.Format := Format; - Self.FrameSize := AudioSampleSize[Format] * Channels; + fChannels := Channels; + fSampleRate := SampleRate; + fFormat := Format; + UpdateFrameSize(); +end; + +procedure TAudioFormatInfo.SetChannels(Channels: byte); +begin + fChannels := Channels; + UpdateFrameSize(); +end; + +procedure TAudioFormatInfo.SetFormat(Format: TAudioSampleFormat); +begin + fFormat := Format; + UpdateFrameSize(); +end; + +function TAudioFormatInfo.GetBytesPerSec(): double; +begin + Result := FrameSize * SampleRate; +end; + +procedure TAudioFormatInfo.UpdateFrameSize(); +begin + fFrameSize := AudioSampleSize[fFormat] * fChannels; +end; + +function TAudioFormatInfo.Copy(): TAudioFormatInfo; +begin + Result := TAudioFormatInfo.Create(Self.Channels, Self.SampleRate, Self.Format); end; -function AudioManager: TInterfaceList; +function TAudioFormatInfo.GetRatio(TargetInfo: TAudioFormatInfo): double; begin - if singleton_AudioManager = nil then - singleton_AudioManager := TInterfaceList.Create(); - - Result := singleton_AudioManager; -end; //CompressionPluginManager + Result := (TargetInfo.FrameSize / Self.FrameSize) * + (TargetInfo.SampleRate / Self.SampleRate) +end; +function MediaManager: TInterfaceList; +begin + if (not assigned(MediaInterfaceList)) then + MediaInterfaceList := TInterfaceList.Create(); + Result := MediaInterfaceList; +end; + function VideoPlayback(): IVideoPlayback; begin - result := singleton_VideoPlayback; + Result := DefaultVideoPlayback; end; function Visualization(): IVideoPlayback; begin - result := singleton_Visualization; + Result := DefaultVisualization; end; function AudioPlayback(): IAudioPlayback; begin - result := singleton_AudioPlayback; + Result := DefaultAudioPlayback; end; function AudioInput(): IAudioInput; begin - result := singleton_AudioInput; + Result := DefaultAudioInput; end; -function AudioDecoder(): IAudioDecoder; +function AudioDecoders(): TInterfaceList; begin - result := singleton_AudioDecoder; + Result := AudioDecoderList; end; procedure FilterInterfaceList(const IID: TGUID; InList, OutList: TInterfaceList); @@ -442,129 +642,169 @@ begin end; end; -procedure AssignSingletonObjects(); +procedure InitializeSound; var - lTmpInterface : IInterface; - iCount : Integer; + i: integer; + InterfaceList: TInterfaceList; + CurrentAudioDecoder: IAudioDecoder; + CurrentAudioPlayback: IAudioPlayback; + CurrentAudioInput: IAudioInput; begin - lTmpInterface := nil; + // create a temporary list for interface enumeration + InterfaceList := TInterfaceList.Create(); - for iCount := 0 to AudioManager.Count - 1 do + // initialize all audio-decoders first + FilterInterfaceList(IAudioDecoder, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do begin - if assigned( AudioManager[iCount] ) then + CurrentAudioDecoder := IAudioDecoder(InterfaceList[i]); + if (not CurrentAudioDecoder.InitializeDecoder()) then begin - // if this interface is a Playback, then set it as the default used - - if ( AudioManager[iCount].QueryInterface( IAudioPlayback, lTmpInterface ) = 0 ) AND - ( true ) then //not assigned( singleton_AudioPlayback ) ) then - begin - singleton_AudioPlayback := IAudioPlayback( lTmpInterface ); - end; - - // if this interface is a Input, then set it as the default used - if ( AudioManager[iCount].QueryInterface( IAudioInput, lTmpInterface ) = 0 ) AND - ( true ) then //not assigned( singleton_AudioInput ) ) then - begin - singleton_AudioInput := IAudioInput( lTmpInterface ); - end; - - // if this interface is a Decoder, then set it as the default used - if ( AudioManager[iCount].QueryInterface( IAudioDecoder, lTmpInterface ) = 0 ) AND - ( true ) then //not assigned( singleton_AudioDecoder ) ) then - begin - singleton_AudioDecoder := IAudioDecoder( lTmpInterface ); - end; - - // if this interface is a Input, then set it as the default used - if ( AudioManager[iCount].QueryInterface( IVideoPlayback, lTmpInterface ) = 0 ) AND - ( true ) then //not assigned( singleton_VideoPlayback ) ) then - begin - singleton_VideoPlayback := IVideoPlayback( lTmpInterface ); - end; - - if ( AudioManager[iCount].QueryInterface( IVideoVisualization, lTmpInterface ) = 0 ) AND - ( true ) then //not assigned( singleton_Visualization ) ) then - begin - singleton_Visualization := IVideoPlayback( lTmpInterface ); - end; - + Log.LogError('Initialize failed, Removing - '+ CurrentAudioDecoder.GetName); + MediaManager.Remove(CurrentAudioDecoder); end; end; -end; -procedure InitializeSound; -begin - singleton_AudioPlayback := nil; - singleton_AudioInput := nil; - singleton_AudioDecoder := nil; - singleton_VideoPlayback := nil; - singleton_Visualization := nil; - - AssignSingletonObjects(); + // create and setup decoder-list (see AudioDecoders()) + AudioDecoderList := TInterfaceList.Create; + FilterInterfaceList(IAudioDecoder, MediaManager, AudioDecoders); - if VideoPlayback <> nil then + // find and initialize playback interface + DefaultAudioPlayback := nil; + FilterInterfaceList(IAudioPlayback, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do begin + CurrentAudioPlayback := IAudioPlayback(InterfaceList[i]); + if (CurrentAudioPlayback.InitializePlayback()) then + begin + DefaultAudioPlayback := CurrentAudioPlayback; + break; + end; + Log.LogError('Initialize failed, Removing - '+ CurrentAudioPlayback.GetName); + MediaManager.Remove(CurrentAudioPlayback); end; - if AudioDecoder <> nil then + // find and initialize input interface + DefaultAudioInput := nil; + FilterInterfaceList(IAudioInput, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do begin - while not AudioDecoder.InitializeDecoder do + CurrentAudioInput := IAudioInput(InterfaceList[i]); + if (CurrentAudioInput.InitializeRecord()) then begin - Log.LogError('Initialize failed, Removing - '+ AudioDecoder.GetName); - AudioManager.remove( AudioDecoder ); - singleton_AudioDecoder := nil; - AssignSingletonObjects(); + DefaultAudioInput := CurrentAudioInput; + break; end; + Log.LogError('Initialize failed, Removing - '+ CurrentAudioInput.GetName); + MediaManager.Remove(CurrentAudioInput); end; - if AudioPlayback <> nil then + InterfaceList.Free; + + // Update input-device list with registered devices + AudioInputProcessor.UpdateInputDeviceConfig(); + + // Load in-game sounds + SoundLib := TSoundLibrary.Create; + AudioPlayback.PlaySound(SoundLib.BGMusic); +end; + +procedure InitializeVideo(); +var + i: integer; + InterfaceList: TInterfaceList; + VideoInterface: IVideoPlayback; + VisualInterface: IVideoVisualization; +begin + InterfaceList := TInterfaceList.Create; + + // initialize and set video-playback singleton + DefaultVideoPlayback := nil; + FilterInterfaceList(IVideoPlayback, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do begin - while not AudioPlayback.InitializePlayback do + VideoInterface := IVideoPlayback(InterfaceList[i]); + if (VideoInterface.Init()) then begin - Log.LogError('Initialize failed, Removing - '+ AudioPlayback.GetName); - AudioManager.remove( AudioPlayback ); - singleton_AudioPlayback := nil; - AssignSingletonObjects(); + DefaultVideoPlayback := VideoInterface; + break; end; + Log.LogError('Initialize failed, Removing - '+ VideoInterface.GetName); + MediaManager.Remove(VideoInterface); end; - if AudioInput <> nil then + // initialize and set visualization singleton + DefaultVisualization := nil; + FilterInterfaceList(IVideoVisualization, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do begin - while not AudioInput.InitializeRecord do + VisualInterface := IVideoVisualization(InterfaceList[i]); + if (VisualInterface.Init()) then begin - Log.LogError('Initialize failed, Removing - '+ AudioInput.GetName); - AudioManager.remove( AudioInput ); - singleton_AudioInput := nil; - AssignSingletonObjects(); - end; + DefaultVisualization := VisualInterface; + break; + end; + Log.LogError('Initialize failed, Removing - '+ VisualInterface.GetName); + MediaManager.Remove(VisualInterface); end; - // Update input-device list with registered devices - AudioInputProcessor.UpdateInputDeviceConfig(); - // Load in-game sounds - SoundLib := TSoundLibrary.Create; + InterfaceList.Free; + // now that we have all interfaces, we can dump them + // TODO: move this to another place if FindCmdLineSwitch( cMediaInterfaces ) then begin - writeln( '' ); - writeln( '--------------------------------------------------------------' ); - writeln( ' In-use Media Interfaces ' ); - writeln( '--------------------------------------------------------------' ); - writeln( 'Registered Audio Playback Interface : ' + AudioPlayback.GetName ); - writeln( 'Registered Audio Input Interface : ' + AudioInput.GetName ); - writeln( 'Registered Video Playback Interface : ' + VideoPlayback.GetName ); - writeln( 'Registered Visualization Interface : ' + Visualization.GetName ); - writeln( '--------------------------------------------------------------' ); - writeln( '' ); - + DumpMediaInterfaces(); halt; end; end; -procedure FinalizeSound; +procedure UnloadMediaModules; var i: integer; - AudioIntfList: TInterfaceList; + InterfaceList: TInterfaceList; +begin + FreeAndNil(AudioDecoderList); + DefaultAudioPlayback := nil; + DefaultAudioInput := nil; + DefaultVideoPlayback := nil; + DefaultVisualization := nil; + + // create temporary interface list + InterfaceList := TInterfaceList.Create(); + + // finalize audio playback interfaces (should be done before the decoders) + FilterInterfaceList(IAudioPlayback, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do + IAudioPlayback(InterfaceList[i]).FinalizePlayback(); + + // finalize audio input interfaces + FilterInterfaceList(IAudioInput, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do + IAudioInput(InterfaceList[i]).FinalizeRecord(); + + // finalize audio decoder interfaces + FilterInterfaceList(IAudioDecoder, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do + IAudioDecoder(InterfaceList[i]).FinalizeDecoder(); + + // finalize video interfaces + FilterInterfaceList(IVideoPlayback, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do + IVideoPlayback(InterfaceList[i]).Finalize(); + + // finalize audio decoder interfaces + FilterInterfaceList(IVideoVisualization, MediaManager, InterfaceList); + for i := 0 to InterfaceList.Count-1 do + IVideoVisualization(InterfaceList[i]).Finalize(); + + InterfaceList.Free; + + // finally free interfaces (by removing all references to them) + FreeAndNil(MediaInterfaceList); +end; + +procedure FinalizeMedia; begin // stop, close and free sounds SoundLib.Free; @@ -577,35 +817,30 @@ begin if (AudioInput <> nil) then AudioInput.CaptureStop; - singleton_AudioPlayback := nil; - singleton_AudioDecoder := nil; - singleton_AudioInput := nil; - - // create temporary interface list - AudioIntfList := TInterfaceList.Create(); - - // finalize audio playback interfaces (should be done before the decoders) - FilterInterfaceList(IAudioPlayback, AudioManager, AudioIntfList); - for i := 0 to AudioIntfList.Count-1 do - IAudioPlayback(AudioIntfList[i]).FinalizePlayback(); + if (VideoPlayback <> nil) then + VideoPlayback.Close; - // finalize audio input interfaces - FilterInterfaceList(IAudioInput, AudioManager, AudioIntfList); - for i := 0 to AudioIntfList.Count-1 do - IAudioInput(AudioIntfList[i]).FinalizeRecord(); + if (Visualization <> nil) then + Visualization.Close; - // finalize audio decoder interfaces - FilterInterfaceList(IAudioDecoder, AudioManager, AudioIntfList); - for i := 0 to AudioIntfList.Count-1 do - IAudioDecoder(AudioIntfList[i]).FinalizeDecoder(); - - AudioIntfList.Free; + UnloadMediaModules(); +end; - // free audio interfaces - while (AudioManager.Count > 0) do - AudioManager.Delete(0); +procedure DumpMediaInterfaces(); +begin + writeln( '' ); + writeln( '--------------------------------------------------------------' ); + writeln( ' In-use Media Interfaces ' ); + writeln( '--------------------------------------------------------------' ); + writeln( 'Registered Audio Playback Interface : ' + AudioPlayback.GetName ); + writeln( 'Registered Audio Input Interface : ' + AudioInput.GetName ); + writeln( 'Registered Video Playback Interface : ' + VideoPlayback.GetName ); + writeln( 'Registered Visualization Interface : ' + Visualization.GetName ); + writeln( '--------------------------------------------------------------' ); + writeln( '' ); end; + { TSoundLibrary } constructor TSoundLibrary.Create(); @@ -634,11 +869,8 @@ begin Option := AudioPlayback.OpenSound(SoundPath + 'option change col.mp3'); Click := AudioPlayback.OpenSound(SoundPath + 'rimshot022b.mp3'); - //Drum := AudioPlayback.OpenSound(SoundPath + 'bassdrumhard076b.mp3'); - //Hihat := AudioPlayback.OpenSound(SoundPath + 'hihatclosed068b.mp3'); - //Clap := AudioPlayback.OpenSound(SoundPath + 'claps050b.mp3'); - - //Shuffle := AudioPlayback.OpenSound(SoundPath + 'Shuffle.mp3'); + //BGMusic := AudioPlayback.OpenSound(SoundPath + '18982__bebeto__Loop010_ambient.mp3'); + //BGMusic.SetLoop(true); //Log.BenchmarkEnd(4); //Log.LogBenchmark('--> Loading Sounds', 4); @@ -646,19 +878,26 @@ end; procedure TSoundLibrary.UnloadSounds(); begin - Start.Free; - Back.Free; - Swoosh.Free; - Change.Free; - Option.Free; - Click.Free; - - //Drum.Free; - //Hihat.Free; - //Clap.Free; + FreeAndNil(Start); + FreeAndNil(Back); + FreeAndNil(Swoosh); + FreeAndNil(Change); + FreeAndNil(Option); + FreeAndNil(Click); + FreeAndNil(BGMusic); +end; - //Shuffle.Free; +(* TODO +function TSoundLibrary.GetSound(ID: integer): TAudioPlaybackStream; +begin + if ((ID >= 0) and (ID < Length(Sounds))) then + Result := Sounds[ID] + else + Result := nil; end; +*) + +{ TVoiceRemoval } procedure TVoiceRemoval.Callback(Buffer: PChar; BufSize: integer); var @@ -687,7 +926,9 @@ end; constructor TLineState.Create(); begin - Timer := TRelativeTimer.Create(); + // create a triggered timer, so we can Pause() it, set the time + // and Resume() it afterwards for better synching. + Timer := TRelativeTimer.Create(true); end; procedure TLineState.Pause(); @@ -702,7 +943,9 @@ end; procedure TLineState.SetCurrentTime(Time: real); begin - Timer.SetTime(Time); + // do not start the timer (if not started already), + // after setting the current time + Timer.SetTime(Time, false); end; function TLineState.GetCurrentTime(): real; @@ -711,14 +954,206 @@ begin end; -initialization +{ TAudioConverter } + +function TAudioConverter.Init(SrcFormatInfo: TAudioFormatInfo; DstFormatInfo: TAudioFormatInfo): boolean; +begin + fSrcFormatInfo := SrcFormatInfo.Copy(); + fDstFormatInfo := DstFormatInfo.Copy(); + Result := true; +end; + +destructor TAudioConverter.Destroy(); +begin + FreeAndNil(fSrcFormatInfo); + FreeAndNil(fDstFormatInfo); +end; + + +{ TAudioProcessingStream } + +procedure TAudioProcessingStream.AddOnCloseHandler(Handler: TOnCloseHandler); +begin + if (@Handler <> nil) then + begin + SetLength(OnCloseHandlers, System.Length(OnCloseHandlers)+1); + OnCloseHandlers[High(OnCloseHandlers)] := @Handler; + end; +end; + +procedure TAudioProcessingStream.PerformOnClose(); +var i: integer; +begin + for i := 0 to High(OnCloseHandlers) do + begin + OnCloseHandlers[i](Self); + end; +end; + + +{ TAudioPlaybackStream } + +function TAudioPlaybackStream.GetSourceStream(): TAudioSourceStream; +begin + Result := SourceStream; +end; + +procedure TAudioPlaybackStream.SetSyncSource(SyncSource: TSyncSource); +begin + Self.SyncSource := SyncSource; + AvgSyncDiff := -1; +end; + +(* + * Results an adjusted size of the input buffer size to keep the stream in sync + * with the SyncSource. If no SyncSource was assigned to this stream, the + * input buffer size will be returned, so this method will have no effect. + * + * These are the possible cases: + * - Result > BufferSize: stream is behind the sync-source (stream is too slow), + * (Result-BufferSize) bytes of the buffer must be skipped. + * - Result = BufferSize: stream is in sync, + * there is nothing to do. + * - Result < BufferSize: stream is ahead of the sync-source (stream is too fast), + * (BufferSize-Result) bytes of the buffer must be padded. + *) +function TAudioPlaybackStream.Synchronize(BufferSize: integer; FormatInfo: TAudioFormatInfo): integer; +var + TimeDiff: double; + TimeCorrectionFactor: double; +const + AVG_HISTORY_FACTOR = 0.9; + SYNC_THRESHOLD = 0.045; + MAX_SYNC_DIFF_TIME = 0.002; +begin + Result := BufferSize; + + if (not assigned(SyncSource)) then + Exit; + + if (BufferSize <= 0) then + Exit; + + // difference between sync-source and stream position + // (negative if the music-stream's position is ahead of the master clock) + TimeDiff := SyncSource.GetClock() - (Position - GetLatency()); + + // calculate average time difference (some sort of weighted mean). + // The bigger AVG_HISTORY_FACTOR is, the smoother is the average diff. + // This means that older diffs are weighted more with a higher history factor + // than with a lower. Do not use a too low history factor. FFMpeg produces + // very instable timestamps (pts) for ogg due to some bugs. They may differ + // +-50ms from the real stream position. Without filtering those glitches we + // would synch without any need, resulting in ugly plopping sounds. + if (AvgSyncDiff = -1) then + AvgSyncDiff := TimeDiff + else + AvgSyncDiff := TimeDiff * (1-AVG_HISTORY_FACTOR) + + AvgSyncDiff * AVG_HISTORY_FACTOR; + + // check if sync needed + if (Abs(AvgSyncDiff) >= SYNC_THRESHOLD) then + begin + // TODO: use SetPosition if diff is too large (>5s) + if (TimeDiff < 1) then + TimeCorrectionFactor := Sign(TimeDiff)*TimeDiff*TimeDiff + else + TimeCorrectionFactor := TimeDiff; + + // calculate adapted buffer size + // reduce size of data to fetch if music is ahead, increase otherwise + Result := BufferSize + Round(TimeCorrectionFactor * FormatInfo.SampleRate) * FormatInfo.FrameSize; + if (Result < 0) then + Result := 0; + + // reset average + AvgSyncDiff := -1; + end; + + (* + DebugWriteln('Diff: ' + floattostrf(TimeDiff, ffFixed, 15, 3) + + '| SyS: ' + floattostrf(SyncSource.GetClock(), ffFixed, 15, 3) + + '| Pos: ' + floattostrf(Position, ffFixed, 15, 3) + + '| Avg: ' + floattostrf(AvgSyncDiff, ffFixed, 15, 3)); + *) +end; + +(* + * Fills a buffer with copies of the given frame or with 0 if frame. + *) +procedure TAudioPlaybackStream.FillBufferWithFrame(Buffer: PChar; BufferSize: integer; Frame: PChar; FrameSize: integer); +var + i: integer; + FrameCopyCount: integer; +begin + // the buffer must at least contain place for one copy of the frame. + if ((Buffer = nil) or (BufferSize <= 0) or (BufferSize < FrameSize)) then + Exit; + + // no valid frame -> fill with 0 + if ((Frame = nil) or (FrameSize <= 0)) then + begin + FillChar(Buffer[0], BufferSize, 0); + Exit; + end; + + // number of frames to copy + FrameCopyCount := BufferSize div FrameSize; + // insert as many copies of frame into the buffer as possible + for i := 0 to FrameCopyCount-1 do + Move(Frame[0], Buffer[i*FrameSize], FrameSize); +end; + +{ TAudioVoiceStream } + +function TAudioVoiceStream.Open(ChannelMap: integer; FormatInfo: TAudioFormatInfo): boolean; +begin + Self.ChannelMap := ChannelMap; + Self.FormatInfo := FormatInfo.Copy(); + // a voice stream is always mono, reassure the the format is correct + Self.FormatInfo.Channels := 1; + Result := true; +end; + +destructor TAudioVoiceStream.Destroy; +begin + Close(); + inherited; +end; + +procedure TAudioVoiceStream.Close(); +begin + PerformOnClose(); + FreeAndNil(FormatInfo); +end; + +function TAudioVoiceStream.GetAudioFormatInfo(): TAudioFormatInfo; +begin + Result := FormatInfo; +end; + +function TAudioVoiceStream.GetLength(): real; +begin + Result := -1; +end; + +function TAudioVoiceStream.GetPosition(): real; +begin + Result := -1; +end; + +procedure TAudioVoiceStream.SetPosition(Time: real); begin - singleton_AudioManager := TInterfaceList.Create(); +end; +function TAudioVoiceStream.GetLoop(): boolean; +begin + Result := false; +end; + +procedure TAudioVoiceStream.SetLoop(Enabled: boolean); +begin end; -finalization - singleton_AudioManager.clear; - FreeAndNil( singleton_AudioManager ); end. diff --git a/Game/Code/Classes/URecord.pas b/Game/Code/Classes/URecord.pas index 6d24e0f4..87aa6ea3 100644 --- a/Game/Code/Classes/URecord.pas +++ b/Game/Code/Classes/URecord.pas @@ -8,6 +8,8 @@ interface {$I switches.inc} +{.$DEFINE VOICE_PASSTHROUGH} + uses Classes, Math, SysUtils, @@ -22,7 +24,7 @@ const type TCaptureBuffer = class private - BufferNew: TMemoryStream; // buffer for newest samples + VoiceStream: TAudioVoiceStream; // stream for voice passthrough function GetToneString: string; // converts a tone to its string represenatation; public @@ -33,6 +35,7 @@ type AudioFormat: TAudioFormatInfo; // pitch detection + // TODO: remove ToneValid, set Tone/ToneAbs=-1 if invalid instead ToneValid: boolean; // true if Tone contains a valid value (otherwise it contains noise) Tone: integer; // tone relative to one octave (e.g. C2=C3=C4). Range: 0-11 ToneAbs: integer; // absolute (full range) tone (e.g. C2<>C3). Range: 0..NumHalftones-1 @@ -43,7 +46,9 @@ type procedure Clear; - procedure ProcessNewBuffer; + procedure BoostBuffer(Buffer: PChar; Size: Cardinal); + procedure ProcessNewBuffer(Buffer: PChar; BufferSize: integer); + // use to analyze sound from buffers to get new pitch procedure AnalyzeBuffer; // we call it to analyze sound by checking Autocorrelation @@ -95,11 +100,12 @@ type DeviceList: array of TAudioInputDevice; constructor Create; + destructor Destroy; override; procedure UpdateInputDeviceConfig; // handle microphone input - procedure HandleMicrophoneData(Buffer: Pointer; Size: Cardinal; + procedure HandleMicrophoneData(Buffer: PChar; Size: Cardinal; InputDevice: TAudioInputDevice); end; @@ -118,8 +124,8 @@ type end; - SmallIntArray = array [0..maxInt shr 1-1] of smallInt; - PSmallIntArray = ^SmallIntArray; + TSmallIntArray = array [0..(MaxInt div SizeOf(SmallInt))-1] of SmallInt; + PSmallIntArray = ^TSmallIntArray; function AudioInputProcessor(): TAudioInputProcessor; @@ -133,9 +139,9 @@ var singleton_AudioInputProcessor : TAudioInputProcessor = nil; -// FIXME: Race-Conditions between Callback-thread and main-thread -// on BufferArray (maybe BufferNew also). -// Use SDL-mutexes to solve this problem. +// FIXME: +// Race-Conditions between Callback-thread and main-thread on BufferArray. +// Use mutexes to solve this problem. { Global } @@ -161,20 +167,41 @@ begin end; procedure TAudioInputDevice.LinkCaptureBuffer(ChannelIndex: integer; Sound: TCaptureBuffer); +var + DeviceCfg: PInputDeviceConfig; + OldSound: TCaptureBuffer; begin // check bounds if ((ChannelIndex < 0) or (ChannelIndex > High(CaptureChannel))) then Exit; - // reset audio-format of old capture-buffer - if (CaptureChannel[ChannelIndex] <> nil) then - CaptureChannel[ChannelIndex].AudioFormat := nil; + // reset previously assigned (old) capture-buffer + OldSound := CaptureChannel[ChannelIndex]; + if (OldSound <> nil) then + begin + // close voice stream + FreeAndNil(OldSound.VoiceStream); + // free old audio-format info + FreeAndNil(OldSound.AudioFormat); + end; // set audio-format of new capture-buffer if (Sound <> nil) then - Sound.AudioFormat := AudioFormat; + begin + // copy the input-device audio-format ... + Sound.AudioFormat := AudioFormat.Copy; + // and adjust it because capture buffers are always mono + Sound.AudioFormat.Channels := 1; + DeviceCfg := @Ini.InputDeviceConfig[CfgIndex]; +// TODO: make this an ini-var, e.g. VoicePassthrough, VoiceRepeat or LiveVoice +{$IFDEF VOICE_PASSTHROUGH} + // create a voice-stream for passthrough + // TODO: map odd players to the left and even players to the right speaker + Sound.VoiceStream := AudioPlayback.CreateVoiceStream(CHANNELMAP_FRONT, AudioFormat); +{$ENDIF} + end; - // replace old with new buffer + // replace old with new buffer (Note: Sound might be nil) CaptureChannel[ChannelIndex] := Sound; end; @@ -183,65 +210,72 @@ end; constructor TCaptureBuffer.Create; begin inherited; - BufferNew := TMemoryStream.Create; BufferLong := TMemoryStream.Create; AnalysisBufferSize := Min(4*1024, Length(BufferArray)); end; destructor TCaptureBuffer.Destroy; begin - AudioFormat := nil; - FreeAndNil(BufferNew); FreeAndNil(BufferLong); + FreeAndNil(VoiceStream); + FreeAndNil(AudioFormat); inherited; end; procedure TCaptureBuffer.Clear; begin - if assigned(BufferNew) then - BufferNew.Clear; if assigned(BufferLong) then BufferLong.Clear; FillChar(BufferArray[0], Length(BufferArray) * SizeOf(SmallInt), 0); end; -procedure TCaptureBuffer.ProcessNewBuffer; +procedure TCaptureBuffer.ProcessNewBuffer(Buffer: PChar; BufferSize: integer); var - SkipCount: integer; - NumSamples: integer; - SampleIndex: integer; + BufferOffset: integer; + SampleCount: integer; + i: integer; begin + // apply software boost + //BoostBuffer(Buffer, Size); + + // voice passthrough (send data to playback-device) + if (assigned(VoiceStream)) then + VoiceStream.WriteData(Buffer, BufferSize); + + // we assume that samples are in S16Int format + // TODO: support float too + if (AudioFormat.Format <> asfS16) then + Exit; + // process BufferArray - SkipCount := 0; - NumSamples := BufferNew.Size div 2; + BufferOffset := 0; + + SampleCount := BufferSize div SizeOf(SmallInt); // check if we have more new samples than we can store - if (NumSamples > Length(BufferArray)) then + if (SampleCount > Length(BufferArray)) then begin // discard the oldest of the new samples - SkipCount := NumSamples - Length(BufferArray); - NumSamples := Length(BufferArray); + BufferOffset := (SampleCount - Length(BufferArray)) * SizeOf(SmallInt); + SampleCount := Length(BufferArray); end; // move old samples to the beginning of the array (if necessary) - // TODO: should be a ring-buffer instead - for SampleIndex := NumSamples to High(BufferArray) do - BufferArray[SampleIndex-NumSamples] := BufferArray[SampleIndex]; + for i := 0 to High(BufferArray)-SampleCount do + BufferArray[i] := BufferArray[i+SampleCount]; - // skip samples if necessary - BufferNew.Seek(2*SkipCount, soBeginning); - // copy samples - BufferNew.ReadBuffer(BufferArray[Length(BufferArray)-NumSamples], 2*NumSamples); + // copy samples to analysis buffer + Move(Buffer[BufferOffset], BufferArray[Length(BufferArray)-SampleCount], + SampleCount * SizeOf(SmallInt)); - // save capture-data to BufferLong if neccessary + // save capture-data to BufferLong if enabled if (Ini.SavePlayback = 1) then begin // this is just for debugging (approx 15MB per player for a 3min song!!!) // For an in-game replay-mode we need to compress data so we do not // waste that much memory. Maybe ogg-vorbis with voice-preset in fast-mode? // Or we could use a faster but not that efficient lossless compression. - BufferNew.Seek(0, soBeginning); - BufferLong.CopyFrom(BufferNew, BufferNew.Size); + BufferLong.WriteBuffer(Buffer, BufferSize); end; end; @@ -371,19 +405,71 @@ begin Result := '-'; end; +procedure TCaptureBuffer.BoostBuffer(Buffer: PChar; Size: Cardinal); +var + i: integer; + Value: Longint; + SampleCount: integer; + SampleBuffer: PSmallIntArray; // buffer handled as array of samples + Boost: byte; +begin + // TODO: set boost per device + { + case Ini.MicBoost of + 0: Boost := 1; + 1: Boost := 2; + 2: Boost := 4; + 3: Boost := 8; + else Boost := 1; + end; + } + Boost := 1; + + // at the moment we will boost SInt16 data only + if (AudioFormat.Format = asfS16) then + begin + // interpret buffer as buffer of bytes + SampleBuffer := PSmallIntArray(Buffer); + SampleCount := Size div AudioFormat.FrameSize; + + // boost buffer + for i := 0 to SampleCount-1 do + begin + Value := SampleBuffer^[i] * Boost; + + // TODO : JB - This will clip the audio... cant we reduce the "Boost" if the data clips ?? + if Value > High(Smallint) then + Value := High(Smallint); + + if Value < Low(Smallint) then + Value := Low(Smallint); + + SampleBuffer^[i] := Value; + end; + end; +end; + { TAudioInputProcessor } constructor TAudioInputProcessor.Create; var - i: integer; + i: integer; begin inherited; SetLength(Sound, 6 {max players});//Ini.Players+1); for i := 0 to High(Sound) do - begin Sound[i] := TCaptureBuffer.Create; - end; +end; + +destructor TAudioInputProcessor.Destroy; +var + i: integer; +begin + for i := 0 to High(Sound) do + Sound[i].Free; + SetLength(Sound, 0); + inherited; end; // updates InputDeviceConfig with current input-device information @@ -459,7 +545,7 @@ begin end; {* - * Handle captured microphone input data. + * Handles captured microphone input data. * Params: * Buffer - buffer of signed 16bit interleaved stereo PCM-samples. * Interleaved means that a right-channel sample follows a left- @@ -467,86 +553,48 @@ end; * Length - number of bytes in Buffer * Input - Soundcard-Input used for capture *} -procedure TAudioInputProcessor.HandleMicrophoneData(Buffer: Pointer; Size: Cardinal; InputDevice: TAudioInputDevice); +procedure TAudioInputProcessor.HandleMicrophoneData(Buffer: PChar; Size: Cardinal; InputDevice: TAudioInputDevice); var - Value: integer; - ChannelBuffer: PChar; // buffer handled as array of bytes (offset relative to channel) - SampleBuffer: PSmallIntArray; // buffer handled as array of samples - Boost: byte; + MultiChannelBuffer: PChar; // buffer handled as array of bytes (offset relative to channel) + SingleChannelBuffer: PChar; // temporary buffer for new samples per channel + SingleChannelBufferSize: integer; ChannelIndex: integer; CaptureChannel: TCaptureBuffer; AudioFormat: TAudioFormatInfo; - FrameSize: integer; - NumSamples: integer; - NumFrames: integer; // number of frames (stereo: 2xsamples) + SampleSize: integer; + SampleCount: integer; + SamplesPerChannel: integer; i: integer; begin - // set boost - case Ini.MicBoost of - 0: Boost := 1; - 1: Boost := 2; - 2: Boost := 4; - 3: Boost := 8; - else Boost := 1; - end; - AudioFormat := InputDevice.AudioFormat; + SampleSize := AudioSampleSize[AudioFormat.Format]; + SampleCount := Size div SampleSize; + SamplesPerChannel := Size div AudioFormat.FrameSize; - // FIXME: At the moment we assume a SInt16 format - // TODO: use SDL_AudioConvert to convert to SInt16 but do NOT change the - // samplerate (SDL does not convert 44.1kHz to 48kHz so we might get wrong - // results in the analysis phase otherwise) - if (AudioFormat.Format <> asfS16) then - begin - // this only occurs if a developer choosed an unsupported input sample-format - Log.CriticalError('TAudioInputProcessor.HandleMicrophoneData: Wrong sample-format'); - Exit; - end; - - // interpret buffer as buffer of bytes - SampleBuffer := Buffer; - - NumSamples := Size div SizeOf(Smallint); - - // boost buffer - // TODO: remove this senseless stuff - adjust the threshold instead - for i := 0 to NumSamples-1 do - begin - Value := SampleBuffer^[i] * Boost; - - // TODO : JB - This will clip the audio... cant we reduce the "Boost" if the data clips ?? - if Value > High(Smallint) then - Value := High(Smallint); - - if Value < Low(Smallint) then - Value := Low(Smallint); - - SampleBuffer^[i] := Value; - end; - - // samples per channel - FrameSize := AudioFormat.Channels * SizeOf(SmallInt); - NumFrames := Size div FrameSize; + SingleChannelBufferSize := SamplesPerChannel * SampleSize; + GetMem(SingleChannelBuffer, SingleChannelBufferSize); // process channels for ChannelIndex := 0 to High(InputDevice.CaptureChannel) do begin CaptureChannel := InputDevice.CaptureChannel[ChannelIndex]; + // check if a capture buffer was assigned, otherwise there is nothing to do if (CaptureChannel <> nil) then begin // set offset according to channel index - ChannelBuffer := @PChar(Buffer)[ChannelIndex * SizeOf(SmallInt)]; - - // TODO: remove BufferNew and write to BufferArray directly - - CaptureChannel.BufferNew.Clear; - for i := 0 to NumFrames-1 do + MultiChannelBuffer := @Buffer[ChannelIndex * SampleSize]; + // seperate channel-data from interleaved multi-channel (e.g. stereo) data + for i := 0 to SamplesPerChannel-1 do begin - CaptureChannel.BufferNew.Write(ChannelBuffer[i*FrameSize], SizeOf(SmallInt)); + Move(MultiChannelBuffer[i*AudioFormat.FrameSize], + SingleChannelBuffer[i*SampleSize], + SampleSize); end; - CaptureChannel.ProcessNewBuffer(); + CaptureChannel.ProcessNewBuffer(SingleChannelBuffer, SingleChannelBufferSize); end; end; + + FreeMem(SingleChannelBuffer); end; @@ -559,6 +607,7 @@ begin for i := 0 to High(AudioInputProcessor.DeviceList) do AudioInputProcessor.DeviceList[i].Free(); AudioInputProcessor.DeviceList := nil; + Result := true; end; {* @@ -625,14 +674,22 @@ end; procedure TAudioInputBase.CaptureStop; var DeviceIndex: integer; + ChannelIndex: integer; Device: TAudioInputDevice; + DeviceCfg: PInputDeviceConfig; begin for DeviceIndex := 0 to High(AudioInputProcessor.DeviceList) do begin Device := AudioInputProcessor.DeviceList[DeviceIndex]; if not assigned(Device) then continue; + Device.Stop(); + + // disconnect capture buffers + DeviceCfg := @Ini.InputDeviceConfig[Device.CfgIndex]; + for ChannelIndex := 0 to High(DeviceCfg.ChannelToPlayerMap) do + Device.LinkCaptureBuffer(ChannelIndex, nil); end; Started := false; diff --git a/Game/Code/Classes/URingBuffer.pas b/Game/Code/Classes/URingBuffer.pas new file mode 100644 index 00000000..ce51e209 --- /dev/null +++ b/Game/Code/Classes/URingBuffer.pas @@ -0,0 +1,128 @@ +unit URingBuffer; + +interface + +{$IFDEF FPC} + {$MODE Delphi} +{$ENDIF} + +{$I switches.inc} + +uses + SysUtils; + +type + TRingBuffer = class + private + RingBuffer: PChar; + BufferCount: integer; + BufferSize: integer; + WritePos: integer; + ReadPos: integer; + public + constructor Create(Size: integer); + destructor Destroy; override; + function Read(Buffer: PChar; Count: integer): integer; + function Write(Buffer: PChar; Count: integer): integer; + procedure Flush(); + end; + +implementation + +uses + Math; + +constructor TRingBuffer.Create(Size: integer); +begin + BufferSize := Size; + + GetMem(RingBuffer, Size); + if (RingBuffer = nil) then + raise Exception.Create('No memory'); +end; + +destructor TRingBuffer.Destroy; +begin + FreeMem(RingBuffer); +end; + +function TRingBuffer.Read(Buffer: PChar; Count: integer): integer; +var + PartCount: integer; +begin + // adjust output count + if (Count > BufferCount) then + begin + //DebugWriteln('Read too much: ' + inttostr(count) +',count:'+ inttostr(BufferCount) + '/size:' + inttostr(BufferSize)); + Count := BufferCount; + end; + + // check if there is something to do + if (Count <= 0) then + begin + Result := Count; + Exit; + end; + + // copy data to output buffer + + // first step: copy from the area between the read-position and the end of the buffer + PartCount := Min(Count, BufferSize - ReadPos); + Move(RingBuffer[ReadPos], Buffer[0], PartCount); + + // second step: if we need more data, copy from the beginning of the buffer + if (PartCount < Count) then + Move(RingBuffer[0], Buffer[0], Count-PartCount); + + // mark the copied part of the buffer as free + BufferCount := BufferCount - Count; + ReadPos := (ReadPos + Count) mod BufferSize; + + Result := Count; +end; + +function TRingBuffer.Write(Buffer: PChar; Count: integer): integer; +var + PartCount: integer; +begin + // check for a reasonable request + if (Count <= 0) then + begin + Result := Count; + Exit; + end; + + // skip input data if the input buffer is bigger than the ring-buffer + if (Count > BufferSize) then + begin + //DebugWriteln('Write skip data:' + inttostr(count) +',count:'+ inttostr(BufferCount) + '/size:' + inttostr(BufferSize)); + Buffer := @Buffer[Count - BufferSize]; + Count := BufferSize; + end; + + // first step: copy to the area between the write-position and the end of the buffer + PartCount := Min(Count, BufferSize - WritePos); + Move(Buffer[0], RingBuffer[WritePos], PartCount); + + // second step: copy data to front of buffer + if (PartCount < Count) then + Move(Buffer[PartCount], RingBuffer[0], Count-PartCount); + + // update info + BufferCount := Min(BufferCount + Count, BufferSize); + WritePos := (WritePos + Count) mod BufferSize; + // if the buffer is full, we have to reposition the read-position + if (BufferCount = BufferSize) then + ReadPos := WritePos; + + Result := Count; +end; + +procedure TRingBuffer.Flush(); +begin + ReadPos := 0; + WritePos := 0; + BufferCount := 0; +end; + +end.
\ No newline at end of file diff --git a/Game/Code/Classes/UTime.pas b/Game/Code/Classes/UTime.pas index 2acca35c..f8ae91c4 100644 --- a/Game/Code/Classes/UTime.pas +++ b/Game/Code/Classes/UTime.pas @@ -20,12 +20,15 @@ type AbsoluteTime: int64; // system-clock reference time for calculation of CurrentTime RelativeTimeOffset: real; Paused: boolean; + TriggerMode: boolean; public - constructor Create; + constructor Create(TriggerMode: boolean = false); procedure Pause(); procedure Resume(); function GetTime(): real; - procedure SetTime(Time: real); + function GetAndResetTime(): real; + procedure SetTime(Time: real; Trigger: boolean = true); + procedure Reset(); end; procedure CountSkipTimeSet; @@ -98,11 +101,18 @@ end; * TRelativeTimer **} -constructor TRelativeTimer.Create; +(* + * Creates a new timer. + * If TriggerMode is false (default), the timer + * will immediately begin with counting. + * If TriggerMode is true, it will wait until Get/SetTime() or Pause() is called + * for the first time. + *) +constructor TRelativeTimer.Create(TriggerMode: boolean); begin - inherited; - RelativeTimeOffset := 0; - AbsoluteTime := SDL_GetTicks(); + inherited Create(); + Self.TriggerMode := TriggerMode; + Reset(); Paused := false; end; @@ -118,19 +128,58 @@ begin Paused := false; end; +(* + * Returns the counter of the timer. + * If in TriggerMode it will return 0 and start the counter on the first call. + *) function TRelativeTimer.GetTime: real; begin + // initialize absolute time on first call in triggered mode + if (TriggerMode and (AbsoluteTime = 0)) then + begin + AbsoluteTime := SDL_GetTicks(); + Result := RelativeTimeOffset; + Exit; + end; + if Paused then Result := RelativeTimeOffset else Result := RelativeTimeOffset + (SDL_GetTicks() - AbsoluteTime) / cSDLCorrectionRatio; end; -procedure TRelativeTimer.SetTime(Time: real); +(* + * Returns the counter of the timer and resets the counter to 0 afterwards. + * Note: In TriggerMode the counter will not be stopped as with Reset(). + *) +function TRelativeTimer.GetAndResetTime(): real; +begin + Result := GetTime(); + SetTime(0); +end; + +(* + * Sets the timer to the given time. This will trigger in TriggerMode if + * Trigger is set to true. Otherwise the counter's state will not change. + *) +procedure TRelativeTimer.SetTime(Time: real; Trigger: boolean); begin RelativeTimeOffset := Time; - AbsoluteTime := SDL_GetTicks(); + if ((not TriggerMode) or Trigger) then + AbsoluteTime := SDL_GetTicks(); end; +(* + * Resets the counter of the timer to 0. + * If in TriggerMode the timer will not start counting until it is triggered again. + *) +procedure TRelativeTimer.Reset(); +begin + RelativeTimeOffset := 0; + if (TriggerMode) then + AbsoluteTime := 0 + else + AbsoluteTime := SDL_GetTicks(); +end; end. diff --git a/Game/Code/Classes/UVideo.pas b/Game/Code/Classes/UVideo.pas index bef77728..9b55aa35 100644 --- a/Game/Code/Classes/UVideo.pas +++ b/Game/Code/Classes/UVideo.pas @@ -12,10 +12,11 @@ unit UVideo; -//{$define DebugDisplay} // uncomment if u want to see the debug stuff -//{$define DebugFrames} -//{$define VideoBenchmark} -//{$define Info} +// uncomment if you want to see the debug stuff +{.$define DebugDisplay} +{.$define DebugFrames} +{.$define VideoBenchmark} +{.$define Info} interface @@ -25,12 +26,10 @@ interface {$I switches.inc} -(* - TODO: look into av_read_play -*) - -// use BGR-format for accelerated colorspace conversion with swscale -{.$DEFINE PIXEL_FMT_BGR} +// use BGR-format for accelerated colorspace conversion with swscale +{$IFDEF UseSWScale} + {$DEFINE PIXEL_FMT_BGR} +{$ENDIF} implementation @@ -45,6 +44,7 @@ uses {$IFDEF UseSWScale} swscale, {$ENDIF} + UMediaCore_FFMpeg, math, gl, glext, @@ -66,7 +66,7 @@ const {$ENDIF} type - TVideoPlayback_ffmpeg = class( TInterfacedObject, IVideoPlayback ) + TVideoPlayback_FFMpeg = class( TInterfacedObject, IVideoPlayback ) private fVideoOpened, fVideoPaused: Boolean; @@ -95,14 +95,16 @@ type EOF: boolean; Loop: boolean; + Initialized: boolean; + procedure Reset(); function DecodeFrame(var AVPacket: TAVPacket; out pts: double): boolean; - function FindStreamIDs( const aFormatCtx : PAVFormatContext; out aFirstVideoStream, aFirstAudioStream : integer ): boolean; - procedure SynchronizeVideo(pFrame: PAVFrame; var pts: double); + procedure SynchronizeVideo(Frame: PAVFrame; var pts: double); public - constructor Create(); function GetName: String; - procedure Init(); + + function Init(): boolean; + function Finalize: boolean; function Open(const aFileName : string): boolean; // true if succeed procedure Close; @@ -116,53 +118,36 @@ type procedure GetFrame(Time: Extended); procedure DrawGL(Screen: integer); - end; var - singleton_VideoFFMpeg : IVideoPlayback; - - - -function FFMpegErrorString(Errnum: integer): string; -begin - case Errnum of - AVERROR_IO: Result := 'AVERROR_IO'; - AVERROR_NUMEXPECTED: Result := 'AVERROR_NUMEXPECTED'; - AVERROR_INVALIDDATA: Result := 'AVERROR_INVALIDDATA'; - AVERROR_NOMEM: Result := 'AVERROR_NOMEM'; - AVERROR_NOFMT: Result := 'AVERROR_NOFMT'; - AVERROR_NOTSUPP: Result := 'AVERROR_NOTSUPP'; - AVERROR_NOENT: Result := 'AVERROR_NOENT'; - AVERROR_PATCHWELCOME: Result := 'AVERROR_PATCHWELCOME'; - else Result := 'AVERROR_#'+inttostr(Errnum); - end; -end; + FFMpegCore: TMediaCore_FFMpeg; + // These are called whenever we allocate a frame buffer. // We use this to store the global_pts in a frame at the time it is allocated. -function PtsGetBuffer(pCodecCtx: PAVCodecContext; pFrame: PAVFrame): integer; cdecl; +function PtsGetBuffer(CodecCtx: PAVCodecContext; Frame: PAVFrame): integer; cdecl; var pts: Pint64; VideoPktPts: Pint64; begin - Result := avcodec_default_get_buffer(pCodecCtx, pFrame); - VideoPktPts := pCodecCtx^.opaque; + Result := avcodec_default_get_buffer(CodecCtx, Frame); + VideoPktPts := CodecCtx^.opaque; if (VideoPktPts <> nil) then begin // Note: we must copy the pts instead of passing a pointer, because the packet // (and with it the pts) might change before a frame is returned by av_decode_video. pts := av_malloc(sizeof(int64)); pts^ := VideoPktPts^; - pFrame^.opaque := pts; + Frame^.opaque := pts; end; end; -procedure PtsReleaseBuffer(pCodecCtx: PAVCodecContext; pFrame: PAVFrame); cdecl; +procedure PtsReleaseBuffer(CodecCtx: PAVCodecContext; Frame: PAVFrame); cdecl; begin - if (pFrame <> nil) then - av_freep(@pFrame^.opaque); - avcodec_default_release_buffer(pCodecCtx, pFrame); + if (Frame <> nil) then + av_freep(@Frame^.opaque); + avcodec_default_release_buffer(CodecCtx, Frame); end; @@ -170,53 +155,258 @@ end; * TVideoPlayback_ffmpeg *------------------------------------------------------------------------------} -function TVideoPlayback_ffmpeg.GetName: String; +function TVideoPlayback_FFMpeg.GetName: String; begin result := 'FFMpeg_Video'; end; -{ - @param(aFormatCtx is a PAVFormatContext returned from av_open_input_file ) - @param(aFirstVideoStream is an OUT value of type integer, this is the index of the video stream) - @param(aFirstAudioStream is an OUT value of type integer, this is the index of the audio stream) - @returns(@true on success, @false otherwise) -} -function TVideoPlayback_ffmpeg.FindStreamIDs(const aFormatCtx: PAVFormatContext; out aFirstVideoStream, aFirstAudioStream: integer): boolean; +function TVideoPlayback_FFMpeg.Init(): boolean; +begin + Result := true; + + if (Initialized) then + Exit; + Initialized := true; + + FFMpegCore := TMediaCore_FFMpeg.GetInstance(); + + Reset(); + av_register_all(); + glGenTextures(1, PGLuint(@fVideoTex)); +end; + +function TVideoPlayback_FFMpeg.Finalize(): boolean; +begin + Close(); + glDeleteTextures(1, PGLuint(@fVideoTex)); + Result := true; +end; + +procedure TVideoPlayback_FFMpeg.Reset(); +begin + // close previously opened video + Close(); + + fVideoOpened := False; + fVideoPaused := False; + VideoTimeBase := 0; + VideoTime := 0; + VideoStream := nil; + VideoStreamIndex := -1; + + EOF := false; + + // TODO: do we really want this by default? + Loop := true; + fLoopTime := 0; +end; + +function TVideoPlayback_FFMpeg.Open(const aFileName : string): boolean; // true if succeed var - i : integer; - st : PAVStream; + errnum: Integer; + AudioStreamIndex: integer; begin - // Find the first video stream - aFirstAudioStream := -1; - aFirstVideoStream := -1; + Result := false; - {$IFDEF DebugDisplay} - debugwriteln('aFormatCtx.nb_streams : ' + inttostr(aFormatCtx.nb_streams)); - {$ENDIF} + Reset(); - for i := 0 to aFormatCtx.nb_streams-1 do + errnum := av_open_input_file(VideoFormatContext, PChar(aFileName), nil, 0, nil); + if (errnum <> 0) then begin - st := aFormatCtx.streams[i]; + Log.LogError('Failed to open file "'+aFileName+'" ('+FFMpegCore.GetErrorString(errnum)+')'); + Exit; + end; - if (st.codec.codec_type = CODEC_TYPE_VIDEO) and - (aFirstVideoStream < 0) then - begin - aFirstVideoStream := i; - end; + // update video info + if (av_find_stream_info(VideoFormatContext) < 0) then + begin + Log.LogError('No stream info found', 'TVideoPlayback_ffmpeg.Open'); + Close(); + Exit; + end; + Log.LogInfo('VideoStreamIndex : ' + inttostr(VideoStreamIndex), 'TVideoPlayback_ffmpeg.Open'); - if (st.codec.codec_type = CODEC_TYPE_AUDIO) and - (aFirstAudioStream < 0) then - begin - aFirstAudioStream := i; + // find video stream + FFMpegCore.FindStreamIDs(VideoFormatContext, VideoStreamIndex, AudioStreamIndex); + if (VideoStreamIndex < 0) then + begin + Log.LogError('No video stream found', 'TVideoPlayback_ffmpeg.Open'); + Close(); + Exit; + end; + + VideoStream := VideoFormatContext^.streams[VideoStreamIndex]; + VideoCodecContext := VideoStream^.codec; + + VideoCodec := avcodec_find_decoder(VideoCodecContext^.codec_id); + if (VideoCodec = nil) then + begin + Log.LogError('No matching codec found', 'TVideoPlayback_ffmpeg.Open'); + Close(); + Exit; + end; + + // set debug options + VideoCodecContext^.debug_mv := 0; + VideoCodecContext^.debug := 0; + + // detect bug-workarounds automatically + VideoCodecContext^.workaround_bugs := FF_BUG_AUTODETECT; + // error resilience strategy (careful/compliant/agressive/very_aggressive) + //VideoCodecContext^.error_resilience := FF_ER_CAREFUL; //FF_ER_COMPLIANT; + // allow non spec compliant speedup tricks. + //VideoCodecContext^.flags2 := VideoCodecContext^.flags2 or CODEC_FLAG2_FAST; + + // Note: avcodec_open() and avcodec_close() are not thread-safe and will + // fail if called concurrently by different threads. + FFMpegCore.LockAVCodec(); + try + errnum := avcodec_open(VideoCodecContext, VideoCodec); + finally + FFMpegCore.UnlockAVCodec(); + end; + if (errnum < 0) then + begin + Log.LogError('No matching codec found', 'TVideoPlayback_ffmpeg.Open'); + Close(); + Exit; + end; + + // register custom callbacks for pts-determination + VideoCodecContext^.get_buffer := PtsGetBuffer; + VideoCodecContext^.release_buffer := PtsReleaseBuffer; + + {$ifdef DebugDisplay} + DebugWriteln('Found a matching Codec: '+ VideoCodecContext^.Codec.Name + sLineBreak + + sLineBreak + + ' Width = '+inttostr(VideoCodecContext^.width) + + ', Height='+inttostr(VideoCodecContext^.height) + sLineBreak + + ' Aspect : '+inttostr(VideoCodecContext^.sample_aspect_ratio.num) + '/' + + inttostr(VideoCodecContext^.sample_aspect_ratio.den) + sLineBreak + + ' Framerate : '+inttostr(VideoCodecContext^.time_base.num) + '/' + + inttostr(VideoCodecContext^.time_base.den)); + {$endif} + + // allocate space for decoded frame and rgb frame + AVFrame := avcodec_alloc_frame(); + AVFrameRGB := avcodec_alloc_frame(); + FrameBuffer := av_malloc(avpicture_get_size(PIXEL_FMT_FFMPEG, + VideoCodecContext^.width, VideoCodecContext^.height)); + + if ((AVFrame = nil) or (AVFrameRGB = nil) or (FrameBuffer = nil)) then + begin + Log.LogError('Failed to allocate buffers', 'TVideoPlayback_ffmpeg.Open'); + Close(); + Exit; + end; + + // TODO: pad data for OpenGL to GL_UNPACK_ALIGNMENT + // (otherwise video will be distorted if width/height is not a multiple of the alignment) + errnum := avpicture_fill(PAVPicture(AVFrameRGB), FrameBuffer, PIXEL_FMT_FFMPEG, + VideoCodecContext^.width, VideoCodecContext^.height); + if (errnum < 0) then + begin + Log.LogError('avpicture_fill failed: ' + FFMpegCore.GetErrorString(errnum), 'TVideoPlayback_ffmpeg.Open'); + Close(); + Exit; + end; + + // calculate some information for video display + VideoAspect := av_q2d(VideoCodecContext^.sample_aspect_ratio); + if (VideoAspect = 0) then + VideoAspect := VideoCodecContext^.width / + VideoCodecContext^.height + else + VideoAspect := VideoAspect * VideoCodecContext^.width / + VideoCodecContext^.height; + + VideoTimeBase := 1/av_q2d(VideoStream^.r_frame_rate); + + // hack to get reasonable timebase (for divx and others) + if (VideoTimeBase < 0.02) then // 0.02 <-> 50 fps + begin + VideoTimeBase := av_q2d(VideoStream^.r_frame_rate); + while (VideoTimeBase > 50) do + VideoTimeBase := VideoTimeBase/10; + VideoTimeBase := 1/VideoTimeBase; + end; + + Log.LogInfo('VideoTimeBase: ' + floattostr(VideoTimeBase), 'TVideoPlayback_ffmpeg.Open'); + Log.LogInfo('Framerate: '+inttostr(floor(1/VideoTimeBase))+'fps', 'TVideoPlayback_ffmpeg.Open'); + + {$IFDEF UseSWScale} + // if available get a SWScale-context -> faster than the deprecated img_convert(). + // SWScale has accelerated support for PIX_FMT_RGB32/PIX_FMT_BGR24/PIX_FMT_BGR565/PIX_FMT_BGR555. + // Note: PIX_FMT_RGB32 is a BGR- and not an RGB-format (maybe a bug)!!! + // The BGR565-formats (GL_UNSIGNED_SHORT_5_6_5) is way too slow because of its + // bad OpenGL support. The BGR formats have MMX(2) implementations but no speed-up + // could be observed in comparison to the RGB versions. + SoftwareScaleContext := sws_getContext( + VideoCodecContext^.width, VideoCodecContext^.height, + integer(VideoCodecContext^.pix_fmt), + VideoCodecContext^.width, VideoCodecContext^.height, + integer(PIXEL_FMT_FFMPEG), + SWS_FAST_BILINEAR, nil, nil, nil); + if (SoftwareScaleContext = nil) then + begin + Log.LogError('Failed to get swscale context', 'TVideoPlayback_ffmpeg.Open'); + Close(); + Exit; + end; + {$ENDIF} + + TexWidth := Round(Power(2, Ceil(Log2(VideoCodecContext^.width)))); + TexHeight := Round(Power(2, Ceil(Log2(VideoCodecContext^.height)))); + + // we retrieve a texture just once with glTexImage2D and update it with glTexSubImage2D later. + // Benefits: glTexSubImage2D is faster and supports non-power-of-two widths/height. + glBindTexture(GL_TEXTURE_2D, fVideoTex); + glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE); + glTexImage2D(GL_TEXTURE_2D, 0, 3, TexWidth, TexHeight, 0, + PIXEL_FMT_OPENGL, GL_UNSIGNED_BYTE, nil); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + + + fVideoOpened := True; + + Result := true; +end; + +procedure TVideoPlayback_FFMpeg.Close; +begin + if (FrameBuffer <> nil) then + av_free(FrameBuffer); + if (AVFrameRGB <> nil) then + av_free(AVFrameRGB); + if (AVFrame <> nil) then + av_free(AVFrame); + + AVFrame := nil; + AVFrameRGB := nil; + FrameBuffer := nil; + + if (VideoCodecContext <> nil) then + begin + // avcodec_close() is not thread-safe + FFMpegCore.LockAVCodec(); + try + avcodec_close(VideoCodecContext); + finally + FFMpegCore.UnlockAVCodec(); end; end; - // return true if either an audio- or video-stream was found - result := (aFirstAudioStream > -1) or - (aFirstVideoStream > -1) ; + if (VideoFormatContext <> nil) then + av_close_input_file(VideoFormatContext); + + VideoCodecContext := nil; + VideoFormatContext := nil; + + fVideoOpened := False; end; -procedure TVideoPlayback_ffmpeg.SynchronizeVideo(pFrame: PAVFrame; var pts: double); +procedure TVideoPlayback_FFMpeg.SynchronizeVideo(Frame: PAVFrame; var pts: double); var FrameDelay: double; begin @@ -232,11 +422,11 @@ begin // update the video clock FrameDelay := av_q2d(VideoCodecContext^.time_base); // if we are repeating a frame, adjust clock accordingly - FrameDelay := FrameDelay + pFrame^.repeat_pict * (FrameDelay * 0.5); + FrameDelay := FrameDelay + Frame^.repeat_pict * (FrameDelay * 0.5); VideoTime := VideoTime + FrameDelay; end; -function TVideoPlayback_ffmpeg.DecodeFrame(var AVPacket: TAVPacket; out pts: double): boolean; +function TVideoPlayback_FFMpeg.DecodeFrame(var AVPacket: TAVPacket; out pts: double): boolean; var FrameFinished: Integer; VideoPktPts: int64; @@ -330,7 +520,7 @@ begin Result := true; end; -procedure TVideoPlayback_ffmpeg.GetFrame(Time: Extended); +procedure TVideoPlayback_FFMpeg.GetFrame(Time: Extended); var AVPacket: TAVPacket; errnum: Integer; @@ -429,7 +619,7 @@ begin {$ELSE} errnum := img_convert(PAVPicture(AVFrameRGB), PIXEL_FMT_FFMPEG, PAVPicture(AVFrame), VideoCodecContext^.pix_fmt, - VideoCodecContext^.width, VideoCodecContext^.height); + VideoCodecContext^.width, VideoCodecContext^.height); {$ENDIF} if (errnum < 0) then @@ -464,7 +654,7 @@ begin {$ENDIF} end; -procedure TVideoPlayback_ffmpeg.DrawGL(Screen: integer); +procedure TVideoPlayback_FFMpeg.DrawGL(Screen: integer); var TexVideoRightPos, TexVideoLowerPos: Single; ScreenLeftPos, ScreenRightPos: Single; @@ -488,6 +678,10 @@ begin Log.BenchmarkStart(15); {$ENDIF} + // TODO: add a SetAspectCorrectionMode() function so we can switch + // aspect correction. The screens video backgrounds look very ugly with aspect + // correction because of the white bars at the top and bottom. + ScreenAspect := ScreenW / ScreenH; RenderAspect := RenderW / RenderH; ScaledVideoWidth := RenderW; @@ -574,250 +768,20 @@ begin {$ENDIF} end; -constructor TVideoPlayback_ffmpeg.Create(); -begin - inherited; - Reset(); - av_register_all(); -end; - -procedure TVideoPlayback_ffmpeg.Init(); -begin - glGenTextures(1, PGLuint(@fVideoTex)); -end; - -procedure TVideoPlayback_ffmpeg.Reset(); -begin - // close previously opened video - Close(); - - fVideoOpened := False; - fVideoPaused := False; - VideoTimeBase := 0; - VideoTime := 0; - VideoStream := nil; - VideoFormatContext := nil; - VideoCodecContext := nil; - VideoStreamIndex := -1; - - AVFrame := nil; - AVFrameRGB := nil; - FrameBuffer := nil; - - EOF := false; - - // TODO: do we really want this by default? - Loop := true; - fLoopTime := 0; -end; - -function TVideoPlayback_ffmpeg.Open(const aFileName : string): boolean; // true if succeed -var - errnum: Integer; - err: GLenum; - AudioStreamIndex: integer; - - procedure CleanOnError(); - begin - if (VideoCodecContext <> nil) then - avcodec_close(VideoCodecContext); - if (VideoFormatContext <> nil) then - av_close_input_file(VideoFormatContext); - av_free(AVFrameRGB); - av_free(AVFrame); - av_free(FrameBuffer); - end; - -begin - Result := false; - - Reset(); - - errnum := av_open_input_file(VideoFormatContext, pchar( aFileName ), nil, 0, nil); - if (errnum <> 0) then - begin - Log.LogError('Failed to open file "'+aFileName+'" ('+FFMpegErrorString(errnum)+')'); - Exit; - end; - - // update video info - if (av_find_stream_info(VideoFormatContext) < 0) then - begin - Log.LogError('No stream info found', 'TVideoPlayback_ffmpeg.Open'); - CleanOnError(); - Exit; - end; - Log.LogInfo('VideoStreamIndex : ' + inttostr(VideoStreamIndex), 'TVideoPlayback_ffmpeg.Open'); - - // find video stream - FindStreamIDs(VideoFormatContext, VideoStreamIndex, AudioStreamIndex); - if (VideoStreamIndex < 0) then - begin - Log.LogError('No video stream found', 'TVideoPlayback_ffmpeg.Open'); - CleanOnError(); - Exit; - end; - - VideoStream := VideoFormatContext^.streams[VideoStreamIndex]; - VideoCodecContext := VideoStream^.codec; - - VideoCodec := avcodec_find_decoder(VideoCodecContext^.codec_id); - if (VideoCodec = nil) then - begin - Log.LogError('No matching codec found', 'TVideoPlayback_ffmpeg.Open'); - CleanOnError(); - Exit; - end; - - // set debug options - VideoCodecContext^.debug_mv := 0; - VideoCodecContext^.debug := 0; - - // detect bug-workarounds automatically - VideoCodecContext^.workaround_bugs := FF_BUG_AUTODETECT; - // error resilience strategy (careful/compliant/agressive/very_aggressive) - //VideoCodecContext^.error_resilience := FF_ER_CAREFUL; //FF_ER_COMPLIANT; - // allow non spec compliant speedup tricks. - //VideoCodecContext^.flags2 := VideoCodecContext^.flags2 or CODEC_FLAG2_FAST; - - errnum := avcodec_open(VideoCodecContext, VideoCodec); - if (errnum < 0) then - begin - Log.LogError('No matching codec found', 'TVideoPlayback_ffmpeg.Open'); - CleanOnError(); - Exit; - end; - - // register custom callbacks for pts-determination - VideoCodecContext^.get_buffer := PtsGetBuffer; - VideoCodecContext^.release_buffer := PtsReleaseBuffer; - - {$ifdef DebugDisplay} - DebugWriteln('Found a matching Codec: '+ VideoCodecContext^.Codec.Name + sLineBreak + - sLineBreak + - ' Width = '+inttostr(VideoCodecContext^.width) + - ', Height='+inttostr(VideoCodecContext^.height) + sLineBreak + - ' Aspect : '+inttostr(VideoCodecContext^.sample_aspect_ratio.num) + '/' + - inttostr(VideoCodecContext^.sample_aspect_ratio.den) + sLineBreak + - ' Framerate : '+inttostr(VideoCodecContext^.time_base.num) + '/' + - inttostr(VideoCodecContext^.time_base.den)); - {$endif} - - // allocate space for decoded frame and rgb frame - AVFrame := avcodec_alloc_frame(); - AVFrameRGB := avcodec_alloc_frame(); - FrameBuffer := av_malloc(avpicture_get_size(PIXEL_FMT_FFMPEG, - VideoCodecContext^.width, VideoCodecContext^.height)); - - if ((AVFrame = nil) or (AVFrameRGB = nil) or (FrameBuffer = nil)) then - begin - Log.LogError('Failed to allocate buffers', 'TVideoPlayback_ffmpeg.Open'); - CleanOnError(); - Exit; - end; - - // TODO: pad data for OpenGL to GL_UNPACK_ALIGNMENT - // (otherwise video will be distorted if width/height is not a multiple of the alignment) - errnum := avpicture_fill(PAVPicture(AVFrameRGB), FrameBuffer, PIXEL_FMT_FFMPEG, - VideoCodecContext^.width, VideoCodecContext^.height); - if (errnum < 0) then - begin - Log.LogError('avpicture_fill failed: ' + FFMpegErrorString(errnum), 'TVideoPlayback_ffmpeg.Open'); - CleanOnError(); - Exit; - end; - - // calculate some information for video display - VideoAspect := av_q2d(VideoCodecContext^.sample_aspect_ratio); - if (VideoAspect = 0) then - VideoAspect := VideoCodecContext^.width / - VideoCodecContext^.height - else - VideoAspect := VideoAspect * VideoCodecContext^.width / - VideoCodecContext^.height; - - VideoTimeBase := 1/av_q2d(VideoStream^.r_frame_rate); - - // hack to get reasonable timebase (for divx and others) - if (VideoTimeBase < 0.02) then // 0.02 <-> 50 fps - begin - VideoTimeBase := av_q2d(VideoStream^.r_frame_rate); - while (VideoTimeBase > 50) do - VideoTimeBase := VideoTimeBase/10; - VideoTimeBase := 1/VideoTimeBase; - end; - - Log.LogInfo('VideoTimeBase: ' + floattostr(VideoTimeBase), 'TVideoPlayback_ffmpeg.Open'); - Log.LogInfo('Framerate: '+inttostr(floor(1/VideoTimeBase))+'fps', 'TVideoPlayback_ffmpeg.Open'); - - {$IFDEF UseSWScale} - // if available get a SWScale-context -> faster than the deprecated img_convert(). - // SWScale has accelerated support for PIX_FMT_RGB32/PIX_FMT_BGR24/PIX_FMT_BGR565/PIX_FMT_BGR555. - // Note: PIX_FMT_RGB32 is a BGR- and not an RGB-format (maybe a bug)!!! - // The BGR565-formats (GL_UNSIGNED_SHORT_5_6_5) is way too slow because of its - // bad OpenGL support. The BGR formats have MMX(2) implementations but no speed-up - // could be observed in comparison to the RGB versions. - SoftwareScaleContext := sws_getContext( - VideoCodecContext^.width, VideoCodecContext^.height, - integer(VideoCodecContext^.pix_fmt), - VideoCodecContext^.width, VideoCodecContext^.height, - integer(PIXEL_FMT_FFMPEG), - SWS_FAST_BILINEAR, nil, nil, nil); - if (SoftwareScaleContext = nil) then - begin - Log.LogError('Failed to get swscale context', 'TVideoPlayback_ffmpeg.Open'); - CleanOnError(); - Exit; - end; - {$ENDIF} - - TexWidth := Round(Power(2, Ceil(Log2(VideoCodecContext^.width)))); - TexHeight := Round(Power(2, Ceil(Log2(VideoCodecContext^.height)))); - - // we retrieve a texture just once with glTexImage2D and update it with glTexSubImage2D later. - // Benefits: glTexSubImage2D is faster and supports non-power-of-two widths/height. - glBindTexture(GL_TEXTURE_2D, fVideoTex); - glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE); - glTexImage2D(GL_TEXTURE_2D, 0, 3, TexWidth, TexHeight, 0, - PIXEL_FMT_OPENGL, GL_UNSIGNED_BYTE, nil); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - - - fVideoOpened := True; - - Result := true; -end; - -procedure TVideoPlayback_ffmpeg.Close; -begin - if fVideoOpened then - begin - av_free(FrameBuffer); - av_free(AVFrameRGB); - av_free(AVFrame); - - avcodec_close(VideoCodecContext); - av_close_input_file(VideoFormatContext); - - fVideoOpened := False; - end; -end; - -procedure TVideoPlayback_ffmpeg.Play; +procedure TVideoPlayback_FFMpeg.Play; begin end; -procedure TVideoPlayback_ffmpeg.Pause; +procedure TVideoPlayback_FFMpeg.Pause; begin fVideoPaused := not fVideoPaused; end; -procedure TVideoPlayback_ffmpeg.Stop; +procedure TVideoPlayback_FFMpeg.Stop; begin end; -procedure TVideoPlayback_ffmpeg.SetPosition(Time: real); +procedure TVideoPlayback_FFMpeg.SetPosition(Time: real); var SeekFlags: integer; begin @@ -838,20 +802,19 @@ begin if (av_seek_frame(VideoFormatContext, VideoStreamIndex, Floor(Time/VideoTimeBase), SeekFlags) < 0) then begin Log.LogError('av_seek_frame() failed', 'TVideoPlayback_ffmpeg.SetPosition'); + Exit; end; + + avcodec_flush_buffers(VideoCodecContext); end; -function TVideoPlayback_ffmpeg.GetPosition: real; +function TVideoPlayback_FFMpeg.GetPosition: real; begin // TODO: return video-position in seconds - result := VideoTime; + Result := VideoTime; end; initialization - singleton_VideoFFMpeg := TVideoPlayback_ffmpeg.create(); - AudioManager.add( singleton_VideoFFMpeg ); - -finalization - AudioManager.Remove( singleton_VideoFFMpeg ); + MediaManager.Add(TVideoPlayback_FFMpeg.Create); end. diff --git a/Game/Code/Classes/UVisualizer.pas b/Game/Code/Classes/UVisualizer.pas index d778eff7..6864b6b9 100644 --- a/Game/Code/Classes/UVisualizer.pas +++ b/Game/Code/Classes/UVisualizer.pas @@ -1,13 +1,15 @@ -{############################################################################ -# Visualizer support for UltraStar deluxe # -# # -# Created by hennymcc # -# Slight modifications by Jay Binks # -# based on UVideo.pas # -#############################################################################} - unit UVisualizer; +(* TODO: + * - fix video/visualizer switching + * - use GL_EXT_framebuffer_object for rendering to a separate framebuffer, + * this will prevent plugins from messing up our render-context + * (-> no stack corruption anymore, no need for Save/RestoreOpenGLState()). + * - create a generic (C-compatible) interface for visualization plugins + * - create a visualization plugin manager + * - write a plugin for projectM in C/C++ (so we need no wrapper anymore) + *) + interface {$IFDEF FPC} @@ -35,27 +37,6 @@ uses UConfig, ULog; -(* - * TODO: - * - fix video/visualizer switching and initialisation - * - use GL_EXT_framebuffer_object for rendering to a separate framebuffer, - * this will prevent plugins from messing up our render-context - * (-> no stack corruption anymore, no need for Save/RestoreOpenGLState()). - * - create a generic (C-compatible) interface for visualization plugins - * - create a visualization plugin manager - * - write a plugin for projectM in C/C++ (so we need no wrapper anymore) - *) - -var - singleton_VideoProjectM : IVideoPlayback; - -var - ProjectMPath : string; - - // FIXME: dirty fix needed because the init method is not - // called yet. - inited: boolean; - {$IF PROJECTM_VERSION < 1000000} // < 1.0 const meshX = 32; @@ -67,15 +48,16 @@ const type TVideoPlayback_ProjectM = class( TInterfacedObject, IVideoPlayback, IVideoVisualization ) private - pm : TProjectM; + pm: TProjectM; + ProjectMPath : string; + Initialized: boolean; - VisualizerStarted , - VisualizerPaused : Boolean; + VisualizerStarted: boolean; + VisualizerPaused: boolean; - VisualTex : glUint; - PCMData : TPCMData; - - RndPCMcount : integer; + VisualTex: GLuint; + PCMData: TPCMData; + RndPCMcount: integer; projMatrix: array[0..3, 0..3] of GLdouble; texMatrix: array[0..3, 0..3] of GLdouble; @@ -91,31 +73,38 @@ type procedure RestoreOpenGLState(); public - procedure Init(); - function GetName: String; + function GetName: String; + + function Init(): boolean; + function Finalize(): boolean; - function Open(const aFileName : string): boolean; // true if succeed - procedure Close; + function Open(const aFileName : string): boolean; // true if succeed + procedure Close; - procedure Play; - procedure Pause; - procedure Stop; + procedure Play; + procedure Pause; + procedure Stop; - procedure SetPosition(Time: real); - function GetPosition: real; + procedure SetPosition(Time: real); + function GetPosition: real; - procedure GetFrame(Time: Extended); - procedure DrawGL(Screen: integer); + procedure GetFrame(Time: Extended); + procedure DrawGL(Screen: integer); end; -procedure TVideoPlayback_ProjectM.Init(); +function TVideoPlayback_ProjectM.GetName: String; begin - // FIXME: dirty fix needed because the init method is not - // called yet. - if (inited) then + result := 'ProjectM'; +end; + +function TVideoPlayback_ProjectM.Init(): boolean; +begin + Result := true; + + if (Initialized) then Exit; - inited := true; + Initialized := true; RndPCMcount := 0; @@ -133,20 +122,23 @@ begin {$ENDIF} end; -function TVideoPlayback_ProjectM.GetName: String; +function TVideoPlayback_ProjectM.Finalize(): boolean; begin - result := 'ProjectM'; + VisualizerStop(); + {$IFDEF UseTexture} + glDeleteTextures(1, PglUint(@VisualTex)); + {$ENDIF} + Result := true; end; - function TVideoPlayback_ProjectM.Open(const aFileName : string): boolean; // true if succeed begin - VisualizerStart(); - result := true; + result := false; end; procedure TVideoPlayback_ProjectM.Close; begin + VisualizerStop(); end; procedure TVideoPlayback_ProjectM.Play; @@ -232,18 +224,21 @@ begin if VisualizerStarted then Exit; - // FIXME: dirty fix needed because the init method is not - // called yet. - if (not inited) then - Init(); - - {$IF PROJECTM_VERSION >= 1000000} // >= 1.0 - pm := TProjectM.Create(ProjectMPath + 'config.inp'); - {$ELSE} - pm := TProjectM.Create( - meshX, meshY, fps, textureSize, ScreenW, ScreenH, - ProjectMPath + 'presets', ProjectMPath + 'fonts'); - {$IFEND} + try + {$IF PROJECTM_VERSION >= 1000000} // >= 1.0 + pm := TProjectM.Create(ProjectMPath + 'config.inp'); + {$ELSE} + pm := TProjectM.Create( + meshX, meshY, fps, textureSize, ScreenW, ScreenH, + ProjectMPath + 'presets', ProjectMPath + 'fonts'); + {$IFEND} + except on E: Exception do + begin + // Create() might fail if the config-file is not found + Log.LogError('TProjectM.Create: ' + E.Message, 'TVideoPlayback_ProjectM.VisualizerStart'); + Exit; + end; + end; VisualizerStarted := True; @@ -260,7 +255,7 @@ begin if VisualizerStarted then begin VisualizerStarted := False; - pm.Free(); + FreeAndNil(pm); end; end; @@ -380,10 +375,6 @@ end; initialization - singleton_VideoProjectM := TVideoPlayback_ProjectM.create(); - AudioManager.add( singleton_VideoProjectM ); - -finalization - AudioManager.Remove( singleton_VideoProjectM ); + MediaManager.Add(TVideoPlayback_ProjectM.Create); end. |