#include <ultra64.h>
#include <macros.h>
#include "load.h"
#include "memory.h"
#include "data.h"
#include "seqplayer.h"

Data Structures
struct	SharedDma

Macros
#define	ALIGN16(val) (((val) + 0xF) & ~0xF)

#define	INIT_SOUND(sound)

Functions
void	audio_dma_copy_immediate (u32 devAddr, void *vAddr, u32 nbytes)
	Performs an immediate DMA copy. More...

void	audio_dma_copy_async (u32 devAddr, void vAddr, u32 nbytes, OSMesgQueue queue, OSIoMesg *mesg)
	Performs an asynchronus (normal priority) DMA copy. More...

void	audio_dma_partial_copy_async (u32 devAddr, u8 vAddr, s32 remaining, OSMesgQueue queue, OSIoMesg mesg)
	Performs a partial asynchronous (normal priority) DMA copy. More...

void	decrease_sample_dma_ttls ()

void *	dma_sample_data (u8 devAddr, u32 size, s32 arg2, u8 arg3)

void	func_8031758C (UNUSED s32 arg0)

static void	unused_80317844 (void)

void	func_8031784C (struct AudioBank mem, u8 offset, u32 numInstruments, u32 numDrums)

struct AudioBank *	bank_load_immediate (s32 bankId, s32 arg1)

struct AudioBank *	bank_load_async (s32 bankId, s32 arg1, struct SequencePlayer *seqPlayer)

void *	sequence_dma_immediate (s32 seqId, s32 arg1)

void *	sequence_dma_async (s32 seqId, s32 arg1, struct SequencePlayer *seqPlayer)

u8	get_missing_bank (u32 seqId, s32 nonNullCount, s32 nullCount)

struct AudioBank *	load_banks_immediate (s32 seqId, u8 *arg1)

void	preload_sequence (u32 seqId, u8 preloadMask)

void	load_sequence_internal (u32 player, u32 seqId, s32 loadAsync)

void	load_sequence (u32 player, u32 seqId, s32 loadAsync)

void	audio_init ()

Variables
struct Note *	gNotes

struct SequencePlayer	gSequencePlayers [SEQUENCE_PLAYERS]

struct SequenceChannel	gSequenceChannels [32]

struct SequenceChannelLayer	D_802245D8 [52]

struct SequenceChannel	gSequenceChannelNone

struct AudioListItem	gLayerFreeList

struct NotePool	gNoteFreeLists

OSMesgQueue	gCurrAudioFrameDmaQueue

OSMesg	gCurrAudioFrameDmaMesgBufs [AUDIO_FRAME_DMA_QUEUE_SIZE]

OSIoMesg	gCurrAudioFrameDmaIoMesgBufs [AUDIO_FRAME_DMA_QUEUE_SIZE]

OSMesgQueue	gAudioDmaMesgQueue

OSMesg	gAudioDmaMesg

OSIoMesg	gAudioDmaIoMesg

struct SharedDma	sSampleDmas [0x60]

u32	gSampleDmaNumListItems

u32	sSampleDmaListSize1

u32	sUnused80226B40

u8	sSampleDmaReuseQueue1 [256]

u8	sSampleDmaReuseQueue2 [256]

u8	sSampleDmaReuseQueueTail1

u8	sSampleDmaReuseQueueTail2

u8	sSampleDmaReuseQueueHead1

u8	sSampleDmaReuseQueueHead2

ALSeqFile *	gSeqFileHeader

ALSeqFile *	gAlCtlHeader

ALSeqFile *	gAlTbl

u8 *	gAlBankSets

u16	gSequenceCount

u64	gAudioGlobalsStartMarker

u64	gAudioGlobalsEndMarker

u8	gSoundDataADSR []

u8	gSoundDataRaw []

u8	gMusicData []

u8	gBankSetsData []

Macro Definition Documentation

◆ ALIGN16

#define ALIGN16 ( val ) (((val) + 0xF) & ~0xF)

◆ INIT_SOUND

#define INIT_SOUND ( sound )

Value:

{                                                                                                  \
        struct AudioBankSample **itSample = &sound.sample;                                             \
        if ((*itSample) != 0) {                                                                        \
            /* Making these volatile gives correct codegen further down; it makes                      \
             * lw/addiu/sw's happen in source order, and uses two registers...                         \
             * It looks odd, though, so maybe they should not be volatile.                             \
             * It might also be causing the extra register use.                                        \
             * Presumably sample and sample2 ought to have different types,                            \
             * but that doesn't matter for codegen. */                                                 \
            volatile struct AudioBankSample *sample, *sample2;                                         \
            *itSample = (void *) (memBase + (u32)(*itSample));                                         \
            sample = *itSample;                                                                        \
            sample2 = *itSample;                                                                       \
            if (sample2->loaded == FALSE) {                                                            \
                void *a = sample2->sampleAddr;                                                         \
                void *b = sample->loop;                                                                \
                void *c = sample->book;                                                                \
                sample->sampleAddr = (void *) (offsetBase + (u32) a);                                  \
                sample->loop = (void *) (memBase + (u32) b);                                           \
                sample->book = (void *) (memBase + (u32) c);                                           \
                sample->loaded = TRUE;                                                                 \
            }                                                                                          \
        }                                                                                              \
    }

Function Documentation

◆ audio_dma_copy_async()

void audio_dma_copy_async	(	u32	devAddr,
		void *	vAddr,
		u32	nbytes,
		OSMesgQueue *	queue,
		OSIoMesg *	mesg
	)

Performs an asynchronus (normal priority) DMA copy.

◆ audio_dma_copy_immediate()

void audio_dma_copy_immediate	(	u32	devAddr,
		void *	vAddr,
		u32	nbytes
	)

Performs an immediate DMA copy.

◆ audio_dma_partial_copy_async()

void audio_dma_partial_copy_async	(	u32 *	devAddr,
		u8 **	vAddr,
		s32 *	remaining,
		OSMesgQueue *	queue,
		OSIoMesg *	mesg
	)

Performs a partial asynchronous (normal priority) DMA copy.

This is limited to 0x1000 bytes transfer at once.

◆ audio_init()

void audio_init ( void )

◆ bank_load_async()

struct AudioBank* bank_load_async	(	s32	bankId,
		s32	arg1,
		struct SequencePlayer *	seqPlayer
	)

◆ bank_load_immediate()

struct AudioBank* bank_load_immediate	(	s32	bankId,
		s32	arg1
	)

◆ decrease_sample_dma_ttls()

void decrease_sample_dma_ttls ( void )

◆ dma_sample_data()

void* dma_sample_data	(	u8 *	devAddr,
		u32	size,
		s32	arg2,
		u8 *	arg3
	)

◆ func_8031758C()

void func_8031758C ( UNUSED s32 arg0 )

◆ func_8031784C()

void func_8031784C	(	struct AudioBank *	mem,
		u8 *	offset,
		u32	numInstruments,
		u32	numDrums
	)

◆ get_missing_bank()

u8 get_missing_bank	(	u32	seqId,
		s32 *	nonNullCount,
		s32 *	nullCount
	)

◆ load_banks_immediate()

struct AudioBank* load_banks_immediate	(	s32	seqId,
		u8 *	arg1
	)

◆ load_sequence()

void load_sequence	(	u32	player,
		u32	seqId,
		s32	loadAsync
	)

◆ load_sequence_internal()

void load_sequence_internal	(	u32	player,
		u32	seqId,
		s32	loadAsync
	)

◆ preload_sequence()

void preload_sequence	(	u32	seqId,
		u8	preloadMask
	)

◆ sequence_dma_async()

void* sequence_dma_async	(	s32	seqId,
		s32	arg1,
		struct SequencePlayer *	seqPlayer
	)

◆ sequence_dma_immediate()

void* sequence_dma_immediate	(	s32	seqId,
		s32	arg1
	)

◆ unused_80317844()

static void unused_80317844 ( void )

static

Variable Documentation

◆ D_802245D8

struct SequenceChannelLayer D_802245D8[52]

◆ gAlBankSets

u8* gAlBankSets

◆ gAlCtlHeader

ALSeqFile* gAlCtlHeader

◆ gAlTbl

ALSeqFile* gAlTbl

◆ gAudioDmaIoMesg

OSIoMesg gAudioDmaIoMesg

◆ gAudioDmaMesg

OSMesg gAudioDmaMesg

◆ gAudioDmaMesgQueue

OSMesgQueue gAudioDmaMesgQueue

◆ gAudioGlobalsEndMarker

u64 gAudioGlobalsEndMarker

◆ gAudioGlobalsStartMarker

u64 gAudioGlobalsStartMarker

◆ gBankSetsData

u8 gBankSetsData[]

◆ gCurrAudioFrameDmaIoMesgBufs

OSIoMesg gCurrAudioFrameDmaIoMesgBufs[AUDIO_FRAME_DMA_QUEUE_SIZE]

◆ gCurrAudioFrameDmaMesgBufs

OSMesg gCurrAudioFrameDmaMesgBufs[AUDIO_FRAME_DMA_QUEUE_SIZE]

◆ gCurrAudioFrameDmaQueue

OSMesgQueue gCurrAudioFrameDmaQueue

◆ gLayerFreeList

struct AudioListItem gLayerFreeList

◆ gMusicData

u8 gMusicData[]

◆ gNoteFreeLists

struct NotePool gNoteFreeLists

◆ gNotes

struct Note* gNotes

◆ gSampleDmaNumListItems

u32 gSampleDmaNumListItems

◆ gSeqFileHeader

ALSeqFile* gSeqFileHeader

◆ gSequenceChannelNone

struct SequenceChannel gSequenceChannelNone

◆ gSequenceChannels

struct SequenceChannel gSequenceChannels[32]

◆ gSequenceCount

u16 gSequenceCount

◆ gSequencePlayers

struct SequencePlayer gSequencePlayers[SEQUENCE_PLAYERS]

◆ gSoundDataADSR

u8 gSoundDataADSR[]

◆ gSoundDataRaw

u8 gSoundDataRaw[]

◆ sSampleDmaListSize1

u32 sSampleDmaListSize1

◆ sSampleDmaReuseQueue1

u8 sSampleDmaReuseQueue1[256]

◆ sSampleDmaReuseQueue2

u8 sSampleDmaReuseQueue2[256]

◆ sSampleDmaReuseQueueHead1

u8 sSampleDmaReuseQueueHead1

◆ sSampleDmaReuseQueueHead2

u8 sSampleDmaReuseQueueHead2

◆ sSampleDmaReuseQueueTail1

u8 sSampleDmaReuseQueueTail1

◆ sSampleDmaReuseQueueTail2

u8 sSampleDmaReuseQueueTail2

◆ sSampleDmas

struct SharedDma sSampleDmas[0x60]

◆ sUnused80226B40

u32 sUnused80226B40

Data Structures

Macros

Functions

Variables