Files
UmaViewer/Assets/Scripts/umamusume/Gallop/DereScript/ACB/hcaAudio/HcaAudioStream.cs
T
2023-01-20 07:13:54 +08:00

349 lines
14 KiB
C#

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using DereTore.Common;
using System.Linq.Expressions;
namespace DereTore.Exchange.Audio.HCA {
public sealed class HcaAudioStream : HcaAudioStreamBase {
public static string NameOf<T>(Expression<Func<T>> e)
{
return ((MemberExpression)e.Body).Member.Name;
}
public HcaAudioStream(Stream sourceStream)
: this(sourceStream, DecodeParams.Default) {
}
public HcaAudioStream(Stream sourceStream, AudioParams audioParams)
: this(sourceStream, DecodeParams.Default, audioParams) {
}
public HcaAudioStream(Stream sourceStream, DecodeParams decodeParams)
: this(sourceStream, decodeParams, AudioParams.Default) {
}
public HcaAudioStream(Stream sourceStream, DecodeParams decodeParams, AudioParams audioParams)
: base(sourceStream, decodeParams) {
var decoder = new HcaDecoder(sourceStream, decodeParams);
_decoder = decoder;
_audioParams = audioParams;
var buffer = new byte[GetTotalAfterDecodingWaveDataSize()];
_memoryCache = new MemoryStream(buffer, true);
_decodedBlocks = new Dictionary<long, long>();
_decodeBuffer = new byte[decoder.GetMinWaveDataBufferSize()];
_hasLoop = decoder.HcaInfo.LoopFlag;
PrepareDecoding();
}
public override long Seek(long offset, SeekOrigin origin) {
if (!EnsureNotDisposed()) {
return 0;
}
switch (origin) {
case SeekOrigin.Begin:
Position = offset;
break;
case SeekOrigin.Current:
Position = Position + offset;
break;
case SeekOrigin.End:
Position = Length - offset;
break;
default:
break;
}
return Position;
}
public override int Read(byte[] buffer, int offset, int count) {
if (!EnsureNotDisposed()) {
return 0;
}
if (!HasMoreData) {
return 0;
}
if (offset < 0 || offset >= buffer.Length) {
throw new ArgumentOutOfRangeException(NameOf(() => offset));
}
if (count < 0) {
throw new ArgumentOutOfRangeException(NameOf(() => count));
}
if (count == 0) {
return 0;
}
var hcaInfo = HcaInfo;
var memoryCache = _memoryCache;
var position = Position;
var read = 0;
if (position < hcaInfo.DataOffset) {
var maxCopy = Math.Min(Math.Min((int)(hcaInfo.DataOffset - position), count), buffer.Length - offset);
if (maxCopy == 0) {
return 0;
}
memoryCache.Seek(position, SeekOrigin.Begin);
memoryCache.Read(buffer, offset, maxCopy);
count -= maxCopy;
offset += maxCopy;
position += maxCopy;
if (count <= 0 || offset >= buffer.Length) {
Position = position;
return maxCopy;
}
read += maxCopy;
}
var audioParams = _audioParams;
var length = Length;
count = HasLoop && audioParams.InfiniteLoop ? Math.Min(count, buffer.Length - offset) : Math.Min((int)(length - position), count);
if (_decodedBlocks.Count < hcaInfo.BlockCount) {
if (HasLoop && audioParams.SimulatedLoopCount > 0) {
EnsureSoundDataDecodedWithLoops(position, count);
} else {
EnsureSoundDataDecoded(position, count);
}
}
var headerSize = _headerSize;
var waveBlockSize = _decoder.GetMinWaveDataBufferSize();
while (count > 0) {
var positionNonLooped = MapPosToNonLoopedWaveStreamPos(position);
memoryCache.Seek(positionNonLooped, SeekOrigin.Begin);
var shouldRead = Math.Min(count, waveBlockSize - ((int)(positionNonLooped - headerSize) % waveBlockSize));
if (shouldRead == 0) {
break;
}
var realRead = memoryCache.Read(buffer, offset, shouldRead);
Debug.Assert(realRead == shouldRead);
count -= realRead;
offset += realRead;
read += realRead;
position += realRead;
}
Position = position;
return read;
}
public override bool CanSeek { get { return true; } }
public override long Length {
get {
if (!EnsureNotDisposed()) {
return 0;
}
if (_length != null) {
return _length.Value;
}
var audioParams = _audioParams;
if (HasLoop && audioParams.InfiniteLoop) {
_length = long.MaxValue;
return _length.Value;
}
var hcaInfo = HcaInfo;
long totalLength = 0;
if (_audioParams.OutputWaveHeader) {
totalLength += _headerSize;
}
var waveDataBlockSize = _decoder.GetMinWaveDataBufferSize();
totalLength += waveDataBlockSize * hcaInfo.BlockCount;
if (HasLoop && audioParams.SimulatedLoopCount > 0) {
var loopedBlockCount = hcaInfo.LoopEnd - hcaInfo.LoopStart + 1;
totalLength += waveDataBlockSize * loopedBlockCount * audioParams.SimulatedLoopCount;
}
_length = totalLength;
return _length.Value;
}
}
public override long Position {
get {
return EnsureNotDisposed() ? _position : 0;
}
set {
EnsureNotDisposed();
if (value < 0 || value > Length) {
throw new ArgumentOutOfRangeException(NameOf(() => value));
}
_position = value;
}
}
public override float LengthInSeconds
{
get
{
return HcaHelper.CalculateLengthInSeconds(HcaInfo, _audioParams.SimulatedLoopCount, _audioParams.InfiniteLoop);
}
}
public override uint LengthInSamples
{
get
{
return HcaHelper.CalculateLengthInSamples(HcaInfo, _audioParams.SimulatedLoopCount, _audioParams.InfiniteLoop);
}
}
protected override void Dispose(bool disposing) {
if (!IsDisposed) {
_memoryCache.Dispose();
}
base.Dispose(disposing);
}
protected override bool HasMoreData
{
get
{
return Position < Length;
}
}
private void EnsureSoundDataDecoded(long waveDataOffset, int byteCount) {
var decoder = _decoder;
var headerSize = _headerSize;
var blockSize = decoder.GetMinWaveDataBufferSize();
var startBlockIndex = (uint)((waveDataOffset - headerSize) / blockSize);
var hcaInfo = HcaInfo;
var endBlockIndex = (uint)((waveDataOffset + byteCount - headerSize) / blockSize);
endBlockIndex = Math.Min(endBlockIndex, hcaInfo.BlockCount - 1);
for (var i = startBlockIndex; i <= endBlockIndex; ++i) {
EnsureDecodeOneBlock(i);
}
}
private void EnsureSoundDataDecodedWithLoops(long waveDataOffset, int byteCount) {
waveDataOffset = MapPosToNonLoopedWaveStreamPos(waveDataOffset);
var decoder = _decoder;
var headerSize = _headerSize;
var waveBlockSize = decoder.GetMinWaveDataBufferSize();
var startBlockIndex = (uint)((waveDataOffset - headerSize) / waveBlockSize);
var waveDataEnd = waveDataOffset + byteCount;
var hcaInfo = HcaInfo;
var audioParams = _audioParams;
var decodedSize = (waveDataOffset - headerSize) / waveBlockSize * waveBlockSize;
// For those before or in the loop range...
if (audioParams.InfiniteLoop || startBlockIndex <= hcaInfo.LoopEnd + (hcaInfo.LoopEnd - hcaInfo.LoopStart + 1) * audioParams.SimulatedLoopCount) {
var blockIndex = startBlockIndex;
var executed = false;
while (true) {
if (executed && blockIndex == startBlockIndex) {
if (audioParams.InfiniteLoop) {
return;
} else {
break;
}
}
if (!audioParams.InfiniteLoop && decodedSize >= waveDataEnd) {
break;
}
EnsureDecodeOneBlock(blockIndex);
decodedSize += waveBlockSize;
++blockIndex;
if (blockIndex > hcaInfo.LoopEnd) {
blockIndex = hcaInfo.LoopStart;
}
executed = true;
}
}
// And those following it.
if (audioParams.InfiniteLoop) {
return;
}
var endBlockIndex = hcaInfo.LoopEnd + (hcaInfo.LoopEnd - hcaInfo.LoopStart + 1) * audioParams.SimulatedLoopCount;
var startOfAfterLoopRegion = endBlockIndex * waveBlockSize;
if (waveDataEnd >= startOfAfterLoopRegion) {
for (var blockIndex = hcaInfo.LoopEnd + 1; blockIndex < hcaInfo.BlockCount && decodedSize < waveDataEnd; ++blockIndex) {
EnsureDecodeOneBlock(blockIndex);
decodedSize += waveBlockSize;
}
}
}
private void EnsureDecodeOneBlock(uint blockIndex) {
var decodedBlocks = _decodedBlocks;
if (decodedBlocks.ContainsKey(blockIndex)) {
return;
}
var decodeBuffer = _decodeBuffer;
var decoder = _decoder;
decoder.DecodeBlock(decodeBuffer, blockIndex);
var positionInOutputStream = _headerSize + decoder.GetMinWaveDataBufferSize() * blockIndex;
var memoryCache = _memoryCache;
memoryCache.Seek(positionInOutputStream, SeekOrigin.Begin);
memoryCache.WriteBytes(decodeBuffer);
decodedBlocks.Add(blockIndex, positionInOutputStream);
}
private long MapPosToNonLoopedWaveStreamPos(long requestedPosition) {
if (!HasLoop) {
return requestedPosition;
}
var hcaInfo = HcaInfo;
var waveBlockSize = _decoder.GetMinWaveDataBufferSize();
var headerSize = _headerSize;
var relativeDataPosition = requestedPosition - headerSize;
var endLoopDataPosition = (hcaInfo.LoopEnd + 1) * waveBlockSize;
if (relativeDataPosition < endLoopDataPosition) {
return requestedPosition;
}
var startLoopDataPosition = hcaInfo.LoopStart * waveBlockSize;
var loopLength = endLoopDataPosition - startLoopDataPosition;
var audioParams = _audioParams;
if (audioParams.InfiniteLoop) {
return headerSize + startLoopDataPosition + (relativeDataPosition - startLoopDataPosition) % loopLength;
}
var extendedLength = endLoopDataPosition + loopLength * audioParams.SimulatedLoopCount;
if (relativeDataPosition < extendedLength) {
return headerSize + startLoopDataPosition + (relativeDataPosition - startLoopDataPosition) % loopLength;
} else {
return headerSize + endLoopDataPosition + (relativeDataPosition - extendedLength);
}
}
private bool HasLoop
{
get
{
return _hasLoop;
}
}
private void PrepareDecoding() {
var decoder = _decoder;
var memoryCache = _memoryCache;
if (_audioParams.OutputWaveHeader) {
var waveHeaderBufferSize = decoder.GetMinWaveHeaderBufferSize();
var waveHeaderBuffer = new byte[waveHeaderBufferSize];
decoder.WriteWaveHeader(waveHeaderBuffer, _audioParams);
memoryCache.WriteBytes(waveHeaderBuffer);
_headerSize = waveHeaderBufferSize;
} else {
_headerSize = 0;
}
memoryCache.Position = 0;
}
private int GetTotalAfterDecodingWaveDataSize() {
var hcaInfo = HcaInfo;
var totalLength = 0;
if (_audioParams.OutputWaveHeader) {
totalLength += _decoder.GetMinWaveHeaderBufferSize();
}
totalLength += _decoder.GetMinWaveDataBufferSize() * (int)hcaInfo.BlockCount;
return totalLength;
}
private readonly AudioParams _audioParams;
private int _headerSize;
private readonly MemoryStream _memoryCache;
private readonly Dictionary<long, long> _decodedBlocks;
private long? _length;
private long _position;
private readonly byte[] _decodeBuffer;
private readonly bool _hasLoop;
}
}