voice.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include "device.h"
#include "result.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct AXVoice AXVoice;
typedef struct AXVoiceAdpcmLoopData AXVoiceAdpcmLoopData;
typedef struct AXVoiceAdpcm AXVoiceAdpcm;
typedef struct AXVoiceDeviceBusMixData AXVoiceDeviceBusMixData;
typedef struct AXVoiceDeviceMixData AXVoiceDeviceMixData;
typedef struct AXVoiceLink AXVoiceLink;
typedef struct AXVoiceOffsets AXVoiceOffsets;
typedef struct AXVoiceSrc AXVoiceSrc;
typedef struct AXVoiceVeData AXVoiceVeData;
 
typedef uint16_t AXVoiceFormat;
 
typedef uint16_t AXVoiceLoop;
 
typedef uint32_t AXVoiceSrcType;
 
typedef uint32_t AXVoiceState;
 
typedef uint32_t AXVoiceRenderer;
 
typedef int32_t AXVoiceSrcRatioResult;
 
typedef uint32_t AXVoiceType;
 
typedef void(*AXVoiceCallbackFn)(void *);
typedef void(*AXVoiceCallbackExFn)(void *, uint32_t, uint32_t);
 
enum AX_VOICE_FORMAT
{
   AX_VOICE_FORMAT_ADPCM   = 0,
   AX_VOICE_FORMAT_LPCM16  = 10,
   AX_VOICE_FORMAT_LPCM8   = 25,
};
 
enum AX_VOICE_LOOP
{
   AX_VOICE_LOOP_DISABLED  = 0,
   AX_VOICE_LOOP_ENABLED   = 1,
};
 
enum AX_VOICE_RENDERER
{
   AX_VOICE_RENDERER_DSP   = 0,
   AX_VOICE_RENDERER_CPU   = 1,
   AX_VOICE_RENDERER_AUTO  = 2,
};
 
enum AX_VOICE_RATIO_RESULT
{
   AX_VOICE_RATIO_RESULT_SUCCESS                   = 0,
   AX_VOICE_RATIO_RESULT_LESS_THAN_ZERO            = -1,
   AX_VOICE_RATIO_RESULT_GREATER_THAN_SOMETHING    = -2,
};
 
enum AX_VOICE_SRC_TYPE
{
   AX_VOICE_SRC_TYPE_NONE     = 0,
   AX_VOICE_SRC_TYPE_LINEAR   = 1,
   AX_VOICE_SRC_TYPE_UNK0     = 2,
   AX_VOICE_SRC_TYPE_UNK1     = 3,
   AX_VOICE_SRC_TYPE_UNK2     = 4,
};
 
enum AX_VOICE_STATE
{
   AX_VOICE_STATE_STOPPED  = 0,
   AX_VOICE_STATE_PLAYING  = 1,
};
 
enum AX_VOICE_TYPE
{
   // Unknown
   AX_VOICE_TYPE_UNKNOWN
};
 
struct AXVoiceLink
{
   AXVoice *next;
   AXVoice *prev;
};
WUT_CHECK_OFFSET(AXVoiceLink, 0x0, next);
WUT_CHECK_OFFSET(AXVoiceLink, 0x4, prev);
WUT_CHECK_SIZE(AXVoiceLink, 0x8);
 
struct AXVoiceOffsets
{
   AXVoiceFormat dataType;
   AXVoiceLoop loopingEnabled;
   uint32_t loopOffset;
   uint32_t endOffset;
   uint32_t currentOffset;
   const void *data;
};
WUT_CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType);
WUT_CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled);
WUT_CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset);
WUT_CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset);
WUT_CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset);
WUT_CHECK_OFFSET(AXVoiceOffsets, 0x10, data);
WUT_CHECK_SIZE(AXVoiceOffsets, 0x14);
 
struct AXVoice
{
   uint32_t index;
 
   AXVoiceState state;
 
   uint32_t volume;
 
   AXVoiceRenderer renderer;
 
   AXVoiceLink link;
 
   AXVoice *cbNext;
 
   uint32_t priority;
 
   AXVoiceCallbackFn callback;
 
   void *userContext;
 
   uint32_t syncBits;
 
   WUT_UNKNOWN_BYTES(0x8);
 
   AXVoiceOffsets offsets;
 
   AXVoiceCallbackExFn callbackEx;
 
   uint32_t callbackReason;
 
   float unk0;
   float unk1;
};
WUT_CHECK_OFFSET(AXVoice, 0x0, index);
WUT_CHECK_OFFSET(AXVoice, 0x4, state);
WUT_CHECK_OFFSET(AXVoice, 0x8, volume);
WUT_CHECK_OFFSET(AXVoice, 0xc, renderer);
WUT_CHECK_OFFSET(AXVoice, 0x10, link);
WUT_CHECK_OFFSET(AXVoice, 0x18, cbNext);
WUT_CHECK_OFFSET(AXVoice, 0x1c, priority);
WUT_CHECK_OFFSET(AXVoice, 0x20, callback);
WUT_CHECK_OFFSET(AXVoice, 0x24, userContext);
WUT_CHECK_OFFSET(AXVoice, 0x28, syncBits);
WUT_CHECK_OFFSET(AXVoice, 0x34, offsets);
WUT_CHECK_OFFSET(AXVoice, 0x48, callbackEx);
WUT_CHECK_OFFSET(AXVoice, 0x4c, callbackReason);
WUT_CHECK_OFFSET(AXVoice, 0x50, unk0);
WUT_CHECK_OFFSET(AXVoice, 0x54, unk1);
WUT_CHECK_SIZE(AXVoice, 0x58);
 
struct AXVoiceDeviceBusMixData
{
   uint16_t volume;
   int16_t delta;
};
WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume);
WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta);
WUT_CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4);
 
struct AXVoiceDeviceMixData
{
   AXVoiceDeviceBusMixData bus[4];
};
WUT_CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus);
WUT_CHECK_SIZE(AXVoiceDeviceMixData, 0x10);
 
struct AXVoiceVeData
{
   uint16_t volume;
   int16_t delta;
};
WUT_CHECK_OFFSET(AXVoiceVeData, 0x0, volume);
WUT_CHECK_OFFSET(AXVoiceVeData, 0x2, delta);
WUT_CHECK_SIZE(AXVoiceVeData, 0x4);
 
struct AXVoiceAdpcmLoopData
{
   uint16_t predScale;
   int16_t prevSample[2];
};
WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale);
WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample);
WUT_CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6);
 
struct AXVoiceAdpcm
{
   int16_t coefficients[16];
   uint16_t gain;
   uint16_t predScale;
   int16_t prevSample[2];
};
WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients);
WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain);
WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale);
WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample);
WUT_CHECK_SIZE(AXVoiceAdpcm, 0x28);
 
#pragma pack(push, 1)
 
struct AXVoiceSrc
{
   uint32_t ratio;
 
   uint16_t currentOffsetFrac;
   int16_t lastSample[4];
};
WUT_CHECK_OFFSET(AXVoiceSrc, 0x0, ratio);
WUT_CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac);
WUT_CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample);
WUT_CHECK_SIZE(AXVoiceSrc, 0xe);
 
#pragma pack(pop)
 
int32_t
AXVoiceBegin(AXVoice *v);
 
int32_t
AXVoiceEnd(AXVoice *v);
 
AXVoice *
AXAcquireVoice(uint32_t priority,
               AXVoiceCallbackFn callback,
               void *userContext);
 
AXVoice *
AXAcquireVoiceEx(uint32_t priority,
                 AXVoiceCallbackExFn callback,
                 void *userContext);
 
BOOL
AXCheckVoiceOffsets(AXVoiceOffsets *offsets);
 
void
AXFreeVoice(AXVoice *voice);
 
uint32_t
AXGetMaxVoices();
 
uint32_t
AXGetVoiceCurrentOffsetEx(AXVoice *voice,
                          const void *samples);
 
uint32_t
AXGetVoiceLoopCount(AXVoice *voice);
 
void
AXGetVoiceOffsets(AXVoice *voice,
                  AXVoiceOffsets *offsets);
 
BOOL
AXIsVoiceRunning(AXVoice *voice);
 
void
AXSetVoiceAdpcm(AXVoice *voice,
                AXVoiceAdpcm *adpcm);
 
void
AXSetVoiceAdpcmLoop(AXVoice *voice,
                    AXVoiceAdpcmLoopData *loopData);
 
void
AXSetVoiceCurrentOffset(AXVoice *voice,
                        uint32_t offset);
 
AXResult
AXSetVoiceDeviceMix(AXVoice *voice,
                    AXDeviceType type,
                    uint32_t id,
                    AXVoiceDeviceMixData *mixData);
 
void
AXSetVoiceEndOffset(AXVoice *voice,
                    uint32_t offset);
 
void
AXSetVoiceEndOffsetEx(AXVoice *voice,
                      uint32_t offset,
                      const void *samples);
 
AXResult
AXSetVoiceInitialTimeDelay(AXVoice *voice,
                           uint16_t delay);
 
void
AXSetVoiceLoopOffset(AXVoice *voice,
                     uint32_t offset);
 
void
AXSetVoiceLoopOffsetEx(AXVoice *voice,
                       uint32_t offset,
                       const void *samples);
 
void
AXSetVoiceLoop(AXVoice *voice,
               AXVoiceLoop loop);
 
void
AXSetVoiceOffsets(AXVoice *voice,
                  AXVoiceOffsets *offsets);
 
void
AXSetVoicePriority(AXVoice *voice,
                   uint32_t priority);
 
void
AXSetVoiceRmtIIRCoefs(AXVoice *voice,
                      uint16_t filter,
                      ...);
 
void
AXSetVoiceSrc(AXVoice *voice,
              AXVoiceSrc *src);
 
AXVoiceSrcRatioResult
AXSetVoiceSrcRatio(AXVoice *voice,
                   float ratio);
 
void
AXSetVoiceSrcType(AXVoice *voice,
                  AXVoiceSrcType type);
 
void
AXSetVoiceState(AXVoice *voice,
                AXVoiceState state);
 
void
AXSetVoiceType(AXVoice *voice,
               AXVoiceType type);
 
void
AXSetVoiceVe(AXVoice *voice,
             AXVoiceVeData *veData);
 
void
AXSetVoiceVeDelta(AXVoice *voice,
                  int16_t delta);
 
#ifdef __cplusplus
}
#endif