ADPCMAudioInfo.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ADPCMAudioInfo.h: Unreal audio ADPCM decompression interface object.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Audio.h"
#include "AudioDecompress.h"
#include "Sound/SoundWave.h"
#include "ContentStreaming.h"
 
#define NUM_ADAPTATION_TABLE 16
#define NUM_ADAPTATION_COEFF 7
 
#define WAVE_FORMAT_LPCM  1
#ifndef WAVE_FORMAT_ADPCM
#define WAVE_FORMAT_ADPCM 2
#endif
 
#if PLATFORM_SUPPORTS_PRAGMA_PACK
#pragma pack(push, 2)
#endif
    struct WaveFormatHeader
    {
        uint16 wFormatTag;      // Format type: 1 = PCM, 2 = ADPCM
        uint16 nChannels;       // Number of channels (i.e. mono, stereo...).
        uint32 nSamplesPerSec;  // Sample rate. 44100 or 22050 or 11025  Hz.
        uint32 nAvgBytesPerSec; // For buffer estimation  = sample rate * BlockAlign.
        uint16 nBlockAlign;     // Block size of data = Channels times BYTES per sample.
        uint16 wBitsPerSample;  // Number of bits per sample of mono data.
        uint16 cbSize;          // The count in bytes of the size of extra information (after cbSize).
    };
#if PLATFORM_SUPPORTS_PRAGMA_PACK
#pragma pack(pop)
#endif
 
namespace ADPCM
{
 
    template <typename T>
    static void GetAdaptationCoefficients(T(& OutAdaptationCoefficient1)[NUM_ADAPTATION_COEFF], T(& OutAdaptationCoefficient2)[NUM_ADAPTATION_COEFF])
    {
        // Magic values as specified by standard
        static T AdaptationCoefficient1[] =
        {
            256, 512, 0, 192, 240, 460, 392
        };
        static T AdaptationCoefficient2[] =
        {
            0, -256, 0,  64, 0, -208, -232
        };
 
        FMemory::Memcpy(&OutAdaptationCoefficient1, AdaptationCoefficient1, sizeof(AdaptationCoefficient1));
        FMemory::Memcpy(&OutAdaptationCoefficient2, AdaptationCoefficient2, sizeof(AdaptationCoefficient2));
    }
 
#if PLATFORM_SUPPORTS_PRAGMA_PACK
#pragma pack(push, 2)
#endif
    struct ADPCMFormatHeader
    {
        WaveFormatHeader    BaseFormat;
        uint16              wSamplesPerBlock;
        uint16              wNumCoef;
        int16               aCoef[2 * NUM_ADAPTATION_COEFF];
        uint32              SamplesPerChannel;  // This is the exact samples per channel for sample precise looping
 
        ADPCMFormatHeader()
        {
            FMemory::Memzero(this, sizeof(ADPCMFormatHeader));
            int16 AdaptationCoefficient1[NUM_ADAPTATION_COEFF];
            int16 AdaptationCoefficient2[NUM_ADAPTATION_COEFF];
            GetAdaptationCoefficients(AdaptationCoefficient1, AdaptationCoefficient2);
 
            // Interlace the coefficients as pairs
            for (int32 Coeff = 0, WriteIndex = 0; Coeff < NUM_ADAPTATION_COEFF; Coeff++)
            {
                aCoef[WriteIndex++] = AdaptationCoefficient1[Coeff];
                aCoef[WriteIndex++] = AdaptationCoefficient2[Coeff];
            }
        }
    };
#if PLATFORM_SUPPORTS_PRAGMA_PACK
#pragma pack(pop)
#endif
 
};
 
class FADPCMAudioInfo : public ICompressedAudioInfo
{
public:
    ADPCMAUDIODECODER_API FADPCMAudioInfo(void);
    ADPCMAUDIODECODER_API virtual ~FADPCMAudioInfo(void);
    // ICompressedAudioInfo Interface
    ADPCMAUDIODECODER_API virtual bool ReadCompressedInfo(const uint8* InSrcBufferData, uint32 InSrcBufferDataSize, struct FSoundQualityInfo* QualityInfo);
    ADPCMAUDIODECODER_API virtual bool ReadCompressedData(uint8* Destination, bool bLooping, uint32 BufferSize);
    ADPCMAUDIODECODER_API virtual void SeekToTime(const float SeekTime);
    ADPCMAUDIODECODER_API virtual void SeekToFrame(const uint32 SeekFrame);
    ADPCMAUDIODECODER_API virtual void ExpandFile(uint8* DstBuffer, struct FSoundQualityInfo* QualityInfo);
    virtual void EnableHalfRate(bool HalfRate) {};
    virtual uint32 GetSourceBufferSize() const { return SrcBufferDataSize; }
    virtual bool UsesVorbisChannelOrdering() const { return false; }
    virtual int GetStreamBufferSize() const;
 
    // Additional overrides for streaming
    virtual bool SupportsStreaming() const override {return true;}
    virtual bool StreamCompressedInfoInternal(const FSoundWaveProxyPtr& InWaveProxy, struct FSoundQualityInfo* QualityInfo) override;
    virtual bool StreamCompressedData(uint8* Destination, bool bLooping, uint32 BufferSize, int32& OutNumBytesStreamed) override;
    virtual int32 GetCurrentChunkIndex() const override
    {
        return CurrentChunkIndex;
    }
    virtual int32 GetCurrentChunkOffset() const override {return CurrentChunkBufferOffset;}
    virtual bool ReleaseStreamChunk(bool bBlockUntilReleased) override;
    // End of ICompressedAudioInfo Interface
 
    uint16 GetFormatTag()
    {
        if (WaveInfo.pFormatTag)
        {
            return *WaveInfo.pFormatTag;
        }
        else
        {
            return 0;
        }
    }
 
    int32 GetNumChannels()
    {
        return NumChannels;
    }
 
private:
 
    // Wrapper function that returns a pointer to the currently used compressed data.
    // If a non-zero chunk is requested, this function also aquires a reference to that chunk
    // until we move on to a different chunk.
    const uint8* GetLoadedChunk(const FSoundWaveProxyPtr& InSoundWave, uint32 ChunkIndex, uint32& OutChunkSize);
 
    int32 NumConsecutiveReadFailiures;
 
    FWaveModInfo WaveInfo;
    const uint8*    SrcBufferData;
    uint32          SrcBufferDataSize;
 
    uint32  UncompressedBlockSize;
    uint32  CompressedBlockSize;
    uint32  BlockSize;
    int32   StreamBufferSize;
    uint32  TotalDecodedSize;
    int32   NumChannels;
    int32   Format;
 
    uint32 PreviouslyRequestedChunkIndex;
 
    uint8*          UncompressedBlockData;          // This holds the current block of compressed data for all channels
    uint32          CurrentUncompressedBlockSampleIndex;    // This is the sample index within the current uncompressed block data
    uint32          CurrentChunkIndex;              // This is the index that is currently being used, needed by streaming engine to make sure it stays loaded and the next chunk gets preloaded
    uint32          CurrentChunkBufferOffset;       // This is this byte offset within the current chunk, used by streaming engine to prioritize a load if more then half way through current chunk
    uint32          CurrentChunkDataSize;           // The size of the current chunk, the first chunk is bigger to accommodate the header info
    uint32          TotalSamplesStreamed;           // The number of samples streamed so far (per channel)
    uint32          TotalSamplesPerChannel;         // Number of samples per channel, used to detect when an audio waveform has ended
    uint32          SamplesPerBlock;                // The number of samples per block
    uint32          FirstChunkSampleDataOffset;     // The size of the header in the first chunk, used to skip over it when looping or starting the sample over
    uint32          FirstChunkSampleDataIndex;
    const uint8*    CurCompressedChunkData;         // A pointer to the current chunk of data
    FAudioChunkHandle CurCompressedChunkHandle;     // Shared reference to the current chunk of data.
    FCriticalSection CurCompressedChunkHandleCriticalSection;
    bool bDecompressorReleased;                     // When the chunk is released, we raise this to true, then early exit on future decodes.
 
    uint32          CurrentCompressedBlockIndex;        // For non disk streaming - the current compressed block in the compressed source data
    uint32          TotalCompressedBlocksPerChannel;    // For non disk streaming - the total number of compressed blocks per channel
    uint8           bNewSeekRequest : 1;                // Whether or not there is a new seek request to be processed 
    uint8           bSeekPendingRead : 1;               // Whether or not a requested seek is pending a read
    uint8           bSeekedFowardToNextChunk : 1;       // If this is true, we have already seeked forward to the next chunk while waiting for the current chunk of audio to load.
 
private:
    void ProcessSeekRequest();
    void SeekToFrameInternal(const uint32 InSeekFrame);
    void ResetSeekState();
 
    std::atomic<uint32> TargetSeekFrame;
 
    FCriticalSection StreamSeekCriticalSection;
};