From 72607d12e4d59e0e53388892c25c34e3960b8980 Mon Sep 17 00:00:00 2001 From: n64 Date: Mon, 30 Aug 2021 22:16:55 +0200 Subject: [PATCH] Implement new pc mixer code for shindou's audio --- src/audio/internal.h | 5 + src/audio/port_eu.c | 2 +- src/audio/port_sh.c | 30 ++++ src/pc/mixer.c | 362 ++++++++++++++++++++++++++++++++++++++++--- src/pc/mixer.h | 86 ++++++++-- 5 files changed, 449 insertions(+), 36 deletions(-) diff --git a/src/audio/internal.h b/src/audio/internal.h index 0924e07..aab33fa 100644 --- a/src/audio/internal.h +++ b/src/audio/internal.h @@ -173,11 +173,16 @@ struct AdpcmBook struct AudioBankSample { #ifdef VERSION_SH +#if !IS_BIG_ENDIAN + u32 size : 24; +#endif /* 0x00 */ u32 codec : 4; /* 0x00 */ u32 medium : 2; /* 0x00 */ u32 bit1 : 1; /* 0x00 */ u32 isPatched : 1; +#if IS_BIG_ENDIAN /* 0x01 */ u32 size : 24; +#endif #else u8 unused; u8 loaded; diff --git a/src/audio/port_eu.c b/src/audio/port_eu.c index bae4190..d607f77 100644 --- a/src/audio/port_eu.c +++ b/src/audio/port_eu.c @@ -140,7 +140,7 @@ void create_next_audio_buffer(s16 *samples, u32 num_samples) { gAudioFrameCount++; decrease_sample_dma_ttls(); if (osRecvMesg(OSMesgQueues[2], &msg, 0) != -1) { - gAudioResetPresetIdToLoad = (u8) (s32) msg; + gAudioResetPresetIdToLoad = (u8) (intptr_t) msg; gAudioResetStatus = 5; } diff --git a/src/audio/port_sh.c b/src/audio/port_sh.c index 8c657b6..66cbc3b 100644 --- a/src/audio/port_sh.c +++ b/src/audio/port_sh.c @@ -23,6 +23,7 @@ void func_8031D690(s32 playerIndex, s32 numFrames); void seq_player_fade_to_zero_volume(s32 arg0, s32 numFrames); void func_802ad7ec(u32 arg0); +#ifdef TARGET_N64 struct SPTask *create_next_audio_frame_task(void) { u32 samplesRemainingInAI; s32 writtenCmds; @@ -145,6 +146,35 @@ struct SPTask *create_next_audio_frame_task(void) { return NULL; } } +#else +struct SPTask *create_next_audio_frame_task(void) { + return NULL; +} +void create_next_audio_buffer(s16 *samples, u32 num_samples) { + s32 writtenCmds; + OSMesg msg; + gAudioFrameCount++; + decrease_sample_dma_ttls(); + if (osRecvMesg(D_SH_80350F88, &msg, 0) != -1) { + gAudioResetPresetIdToLoad = (u8) (intptr_t) msg; + if (gAudioResetStatus == 0) { + gAudioResetStatus = 5; + } + } + + if (gAudioResetStatus != 0) { + audio_reset_session(); + gAudioResetStatus = 0; + } + while (osRecvMesg(D_SH_80350F68, &msg, OS_MESG_NOBLOCK) != -1) { + func_802ad7ec((u32) msg); + } + synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples); + gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); + gAudioRandom = gAudioRandom + writtenCmds / 8; + gCurrAudioFrameDmaCount = 0; +} +#endif void eu_process_audio_cmd(struct EuAudioCmd *cmd) { s32 i; diff --git a/src/pc/mixer.c b/src/pc/mixer.c index 282aef9..62d2cbb 100644 --- a/src/pc/mixer.c +++ b/src/pc/mixer.c @@ -3,6 +3,8 @@ #include #include +#include "mixer.h" + #ifdef __SSE4_1__ #include #define HAS_SSE41 1 @@ -22,15 +24,33 @@ #define LOADLH(l, h) _mm_castpd_si128(_mm_loadh_pd(_mm_load_sd((const double *)(l)), (const double *)(h))) #endif +#define ROUND_UP_64(v) (((v) + 63) & ~63) #define ROUND_UP_32(v) (((v) + 31) & ~31) #define ROUND_UP_16(v) (((v) + 15) & ~15) #define ROUND_UP_8(v) (((v) + 7) & ~7) +#define ROUND_DOWN_16(v) ((v) & ~0xf) + +#ifdef NEW_AUDIO_UCODE +#define BUF_SIZE 2880 +#define BUF_U8(a) (rspa.buf.as_u8 + ((a) - 0x450)) +#define BUF_S16(a) (rspa.buf.as_s16 + ((a) - 0x450) / sizeof(int16_t)) +#else +#define BUF_SIZE 2512 +#define BUF_U8(a) (rspa.buf.as_u8 + (a)) +#define BUF_S16(a) (rspa.buf.as_s16 + (a) / sizeof(int16_t)) +#endif static struct { uint16_t in; uint16_t out; uint16_t nbytes; +#ifdef NEW_AUDIO_UCODE + uint16_t vol[2]; + uint16_t rate[2]; + uint16_t vol_wet; + uint16_t rate_wet; +#else int16_t vol[2]; uint16_t dry_right; @@ -42,13 +62,20 @@ static struct { int16_t vol_dry; int16_t vol_wet; +#endif ADPCM_STATE *adpcm_loop_state; int16_t adpcm_table[8][2][8]; + +#ifdef NEW_AUDIO_UCODE + uint16_t filter_count; + int16_t filter[8]; +#endif + union { - int16_t as_s16[2512 / sizeof(int16_t)]; - uint8_t as_u8[2512]; + int16_t as_s16[BUF_SIZE / sizeof(int16_t)]; + uint8_t as_u8[BUF_SIZE]; } buf; } rspa; @@ -107,33 +134,46 @@ static inline int32_t clamp32(int64_t v) { void aClearBufferImpl(uint16_t addr, int nbytes) { nbytes = ROUND_UP_16(nbytes); - memset(rspa.buf.as_u8 + addr, 0, nbytes); + memset(BUF_U8(addr), 0, nbytes); } +#ifdef NEW_AUDIO_UCODE +void aLoadBufferImpl(const void *source_addr, uint16_t dest_addr, uint16_t nbytes) { + memcpy(BUF_U8(dest_addr), source_addr, ROUND_DOWN_16(nbytes)); +} + +void aSaveBufferImpl(uint16_t source_addr, int16_t *dest_addr, uint16_t nbytes) { + memcpy(dest_addr, BUF_S16(source_addr), ROUND_DOWN_16(nbytes)); +} +#else void aLoadBufferImpl(const void *source_addr) { - memcpy(rspa.buf.as_u8 + rspa.in, source_addr, ROUND_UP_8(rspa.nbytes)); + memcpy(BUF_U8(rspa.in), source_addr, ROUND_UP_8(rspa.nbytes)); } void aSaveBufferImpl(int16_t *dest_addr) { - memcpy(dest_addr, rspa.buf.as_s16 + rspa.out / sizeof(int16_t), ROUND_UP_8(rspa.nbytes)); + memcpy(dest_addr, BUF_S16(rspa.out), ROUND_UP_8(rspa.nbytes)); } +#endif void aLoadADPCMImpl(int num_entries_times_16, const int16_t *book_source_addr) { memcpy(rspa.adpcm_table, book_source_addr, num_entries_times_16); } void aSetBufferImpl(uint8_t flags, uint16_t in, uint16_t out, uint16_t nbytes) { +#ifndef NEW_AUDIO_UCODE if (flags & A_AUX) { rspa.dry_right = in; rspa.wet_left = out; rspa.wet_right = nbytes; - } else { - rspa.in = in; - rspa.out = out; - rspa.nbytes = nbytes; + return; } +#endif + rspa.in = in; + rspa.out = out; + rspa.nbytes = nbytes; } +#ifndef NEW_AUDIO_UCODE void aSetVolumeImpl(uint8_t flags, int16_t v, int16_t t, int16_t r) { if (flags & A_AUX) { rspa.vol_dry = v; @@ -154,12 +194,40 @@ void aSetVolumeImpl(uint8_t flags, int16_t v, int16_t t, int16_t r) { } } } +#endif +#ifdef NEW_AUDIO_UCODE +void aInterleaveImpl(uint16_t dest, uint16_t left, uint16_t right, uint16_t c) { + int count = ROUND_UP_8(c) / sizeof(int16_t) / 4; + int16_t *l = BUF_S16(left); + int16_t *r = BUF_S16(right); + int16_t *d = BUF_S16(dest); + while (count > 0) { + int16_t l0 = *l++; + int16_t l1 = *l++; + int16_t l2 = *l++; + int16_t l3 = *l++; + int16_t r0 = *r++; + int16_t r1 = *r++; + int16_t r2 = *r++; + int16_t r3 = *r++; + *d++ = l0; + *d++ = r0; + *d++ = l1; + *d++ = r1; + *d++ = l2; + *d++ = r2; + *d++ = l3; + *d++ = r3; + --count; + } +} +#else void aInterleaveImpl(uint16_t left, uint16_t right) { int count = ROUND_UP_16(rspa.nbytes) / sizeof(int16_t) / 8; - int16_t *l = rspa.buf.as_s16 + left / sizeof(int16_t); - int16_t *r = rspa.buf.as_s16 + right / sizeof(int16_t); - int16_t *d = rspa.buf.as_s16 + rspa.out / sizeof(int16_t); + int16_t *l = BUF_S16(left); + int16_t *r = BUF_S16(right); + int16_t *d = BUF_S16(rspa.out); while (count > 0) { int16_t l0 = *l++; int16_t l1 = *l++; @@ -196,10 +264,11 @@ void aInterleaveImpl(uint16_t left, uint16_t right) { --count; } } +#endif void aDMEMMoveImpl(uint16_t in_addr, uint16_t out_addr, int nbytes) { nbytes = ROUND_UP_16(nbytes); - memmove(rspa.buf.as_u8 + out_addr, rspa.buf.as_u8 + in_addr, nbytes); + memmove(BUF_U8(out_addr), BUF_U8(in_addr), nbytes); } void aSetLoopImpl(ADPCM_STATE *adpcm_loop_state) { @@ -224,8 +293,8 @@ void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state) { const int16x8_t mask = vdupq_n_s16((int16_t)0xf000); const int16x8_t table_prefix = vld1q_s16(table_prefix_data); #endif - uint8_t *in = rspa.buf.as_u8 + rspa.in; - int16_t *out = rspa.buf.as_s16 + rspa.out / sizeof(int16_t); + uint8_t *in = BUF_U8(rspa.in); + int16_t *out = BUF_S16(rspa.out); int nbytes = ROUND_UP_32(rspa.nbytes); if (flags & A_INIT) { memset(out, 0, 16 * sizeof(int16_t)); @@ -376,9 +445,9 @@ void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state) { void aResampleImpl(uint8_t flags, uint16_t pitch, RESAMPLE_STATE state) { int16_t tmp[16]; - int16_t *in_initial = rspa.buf.as_s16 + rspa.in / sizeof(int16_t); + int16_t *in_initial = BUF_S16(rspa.in); int16_t *in = in_initial; - int16_t *out = rspa.buf.as_s16 + rspa.out / sizeof(int16_t); + int16_t *out = BUF_S16(rspa.out); int nbytes = ROUND_UP_16(rspa.nbytes); uint32_t pitch_accumulator; int i; @@ -422,11 +491,9 @@ void aResampleImpl(uint8_t flags, uint16_t pitch, RESAMPLE_STATE state) { tbl_entries[i] = _mm_castpd_si128(_mm_loadh_pd(_mm_load_sd( (const double *)resample_table[_mm_extract_epi16(tbl_positions, 2 * i)]), (const double *)resample_table[_mm_extract_epi16(tbl_positions, 2 * i + 1)])); - samples[i] = _mm_castpd_si128(_mm_loadh_pd(_mm_load_sd( (const double *)&in[_mm_extract_epi16(in_positions, 2 * i)]), (const double *)&in[_mm_extract_epi16(in_positions, 2 * i + 1)])); - samples[i] = _mm_mulhrs_epi16(samples[i], tbl_entries[i]); }*/ tbl_entries[0] = LOADLH(resample_table[_mm_extract_epi16(tbl_positions, 0)], resample_table[_mm_extract_epi16(tbl_positions, 1)]); @@ -526,11 +593,57 @@ void aResampleImpl(uint8_t flags, uint16_t pitch, RESAMPLE_STATE state) { memcpy(state + 8, in, 8 * sizeof(int16_t)); } +#ifdef NEW_AUDIO_UCODE +void aEnvSetup1Impl(uint8_t initial_vol_wet, uint16_t rate_wet, uint16_t rate_left, uint16_t rate_right) { + rspa.vol_wet = (uint16_t)(initial_vol_wet << 8); + rspa.rate_wet = rate_wet; + rspa.rate[0] = rate_left; + rspa.rate[1] = rate_right; +} +void aEnvSetup2Impl(uint16_t initial_vol_left, uint16_t initial_vol_right) { + rspa.vol[0] = initial_vol_left; + rspa.vol[1] = initial_vol_right; +} + +void aEnvMixerImpl(uint16_t in_addr, uint16_t n_samples, bool swap_reverb, + bool neg_left, bool neg_right, + uint16_t dry_left_addr, uint16_t dry_right_addr, + uint16_t wet_left_addr, uint16_t wet_right_addr) +{ + int16_t *in = BUF_S16(in_addr); + int16_t *dry[2] = {BUF_S16(dry_left_addr), BUF_S16(dry_right_addr)}; + int16_t *wet[2] = {BUF_S16(wet_left_addr), BUF_S16(wet_right_addr)}; + int16_t negs[2] = {neg_left ? -1 : 0, neg_right ? -1 : 0}; + int swapped[2] = {swap_reverb ? 1 : 0, swap_reverb ? 0 : 1}; + int n = ROUND_UP_16(n_samples); + + uint16_t vols[2] = {rspa.vol[0], rspa.vol[1]}; + uint16_t rates[2] = {rspa.rate[0], rspa.rate[1]}; + uint16_t vol_wet = rspa.vol_wet; + uint16_t rate_wet = rspa.rate_wet; + + do { + for (int i = 0; i < 8; i++) { + int16_t samples[2] = {*in, *in}; in++; + for (int j = 0; j < 2; j++) { + samples[j] = (samples[j] * vols[j] >> 16) ^ negs[j]; + *dry[j] = clamp16(*dry[j] + samples[j]); dry[j]++; + *wet[j] = clamp16(*wet[j] + (samples[swapped[j]] * vol_wet >> 16)); wet[j]++; + } + } + vols[0] += rates[0]; + vols[1] += rates[1]; + vol_wet += rate_wet; + + n -= 8; + } while (n > 0); +} +#else void aEnvMixerImpl(uint8_t flags, ENVMIX_STATE state) { - int16_t *in = rspa.buf.as_s16 + rspa.in / sizeof(int16_t); - int16_t *dry[2] = {rspa.buf.as_s16 + rspa.out / sizeof(int16_t), rspa.buf.as_s16 + rspa.dry_right / sizeof(int16_t)}; - int16_t *wet[2] = {rspa.buf.as_s16 + rspa.wet_left / sizeof(int16_t), rspa.buf.as_s16 + rspa.wet_right / sizeof(int16_t)}; + int16_t *in = BUF_S16(rspa.in); + int16_t *dry[2] = {BUF_S16(rspa.out), BUF_S16(rspa.dry_right)}; + int16_t *wet[2] = {BUF_S16(rspa.wet_left), BUF_S16(rspa.wet_right)}; int nbytes = ROUND_UP_16(rspa.nbytes); #if HAS_SSE41 @@ -786,11 +899,17 @@ void aEnvMixerImpl(uint8_t flags, ENVMIX_STATE state) { state[39] = vol_wet; #endif } +#endif +#ifdef NEW_AUDIO_UCODE +void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr, uint16_t count) { + int nbytes = ROUND_UP_32(ROUND_DOWN_16(count)); +#else void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr) { int nbytes = ROUND_UP_32(rspa.nbytes); - int16_t *in = rspa.buf.as_s16 + in_addr / sizeof(int16_t); - int16_t *out = rspa.buf.as_s16 + out_addr / sizeof(int16_t); +#endif + int16_t *in = BUF_S16(in_addr); + int16_t *out = BUF_S16(out_addr); #if HAS_SSE41 __m128i gain_vec = _mm_set1_epi16(gain); #elif !HAS_NEON @@ -869,3 +988,198 @@ void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr) { nbytes -= 16 * sizeof(int16_t); } } + +#ifdef NEW_AUDIO_UCODE +void aS8DecImpl(uint8_t flags, ADPCM_STATE state) { + uint8_t *in = BUF_U8(rspa.in); + int16_t *out = BUF_S16(rspa.out); + int nbytes = ROUND_UP_32(rspa.nbytes); + if (flags & A_INIT) { + memset(out, 0, 16 * sizeof(int16_t)); + } else if (flags & A_LOOP) { + memcpy(out, rspa.adpcm_loop_state, 16 * sizeof(int16_t)); + } else { + memcpy(out, state, 16 * sizeof(int16_t)); + } + out += 16; + + while (nbytes > 0) { + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + + nbytes -= 16 * sizeof(int16_t); + } + + memcpy(state, out - 16, 16 * sizeof(int16_t)); +} + +void aAddMixerImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count) { + int16_t *in = BUF_S16(in_addr); + int16_t *out = BUF_S16(out_addr); + int nbytes = ROUND_UP_64(ROUND_DOWN_16(count)); + + do { + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + + nbytes -= 16 * sizeof(int16_t); + } while (nbytes > 0); +} + +void aDuplicateImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count) { + uint8_t *in = BUF_U8(in_addr); + uint8_t *out = BUF_U8(out_addr); + + uint8_t tmp[128]; + memcpy(tmp, in, 128); + do { + memcpy(out, tmp, 128); + out += 128; + } while (count-- > 0); +} + +void aDMEMMove2Impl(uint8_t t, uint16_t in_addr, uint16_t out_addr, uint16_t count) { + uint8_t *in = BUF_U8(in_addr); + uint8_t *out = BUF_U8(out_addr); + int nbytes = ROUND_UP_32(count); + + do { + memmove(out, in, nbytes); + in += nbytes; + out += nbytes; + } while (t-- > 0); +} + +void aResampleZohImpl(uint16_t pitch, uint16_t start_fract) { + int16_t *in = BUF_S16(rspa.in); + int16_t *out = BUF_S16(rspa.out); + int nbytes = ROUND_UP_8(rspa.nbytes); + uint32_t pos = start_fract; + uint32_t pitch_add = pitch << 2; + + do { + *out++ = in[pos >> 17]; pos += pitch_add; + *out++ = in[pos >> 17]; pos += pitch_add; + *out++ = in[pos >> 17]; pos += pitch_add; + *out++ = in[pos >> 17]; pos += pitch_add; + + nbytes -= 4 * sizeof(int16_t); + } while (nbytes > 0); +} + +void aDownsampleHalfImpl(uint16_t n_samples, uint16_t in_addr, uint16_t out_addr) { + int16_t *in = BUF_S16(in_addr); + int16_t *out = BUF_S16(out_addr); + int n = ROUND_UP_8(n_samples); + + do { + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + + n -= 8; + } while (n > 0); +} + +void aFilterImpl(uint8_t flags, uint16_t count_or_buf, int16_t state_or_filter[8]) { + if (flags > A_INIT) { + rspa.filter_count = ROUND_UP_16(count_or_buf); + memcpy(rspa.filter, state_or_filter, sizeof(rspa.filter)); + } else { + int16_t tmp[16]; + int count = rspa.filter_count; + int16_t *buf = BUF_S16(count_or_buf); + + if (flags == A_INIT) { + memset(tmp, 0, 8 * sizeof(int16_t)); + } else { + memcpy(tmp, state_or_filter, 8 * sizeof(int16_t)); + } + + do { + memcpy(tmp + 8, buf, 8 * sizeof(int16_t)); + for (int i = 0; i < 8; i++) { + int64_t sample = 0x4000; // round term + int16_t in = tmp[8 + i]; + for (int j = 1; j <= 8; j++) { + sample += in * tmp[8 + i - j]; + } + buf[i] = clamp16((int32_t)(sample >> 15)); + } + memcpy(tmp, tmp + 8, 8 * sizeof(int16_t)); + + buf += 8; + count -= 8 * sizeof(int16_t); + } while (count > 0); + + memcpy(state_or_filter, tmp, 8 * sizeof(int16_t)); + } +} + +void aHiLoGainImpl(uint8_t g, uint16_t count, uint16_t addr) { + int16_t *samples = BUF_S16(addr); + int nbytes = ROUND_UP_32(count); + + do { + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + + nbytes -= 8; + } while (nbytes > 0); +} + +void aUnknown25Impl(uint8_t f, uint16_t count, uint16_t out_addr, uint16_t in_addr) { + int nbytes = ROUND_UP_64(count); + int16_t *in = BUF_S16(in_addr + f); + int16_t *out = BUF_S16(out_addr); + int16_t tbl[32]; + + memcpy(tbl, in, 32 * sizeof(int16_t)); + do { + for (int i = 0; i < 32; i++) { + out[i] = clamp16(out[i] * tbl[i]); + } + out += 32; + nbytes -= 32 * sizeof(int16_t); + } while (nbytes > 0); +} +#endif diff --git a/src/pc/mixer.h b/src/pc/mixer.h index 6b55c4f..5debc7f 100644 --- a/src/pc/mixer.h +++ b/src/pc/mixer.h @@ -1,9 +1,14 @@ #ifndef MIXER_H #define MIXER_H +#include #include #include +#ifdef VERSION_SH +#define NEW_AUDIO_UCODE +#endif + #undef aSegment #undef aClearBuffer #undef aSetBuffer @@ -19,35 +24,94 @@ #undef aSetLoop #undef aLoadADPCM #undef aADPCMdec +#undef aS8Dec +#undef aAddMixer +#undef aDuplicate +#undef aDMEMMove2 +#undef aResampleZoh +#undef aDownsampleHalf +#undef aEnvSetup1 +#undef aEnvSetup2 +#undef aFilter +#undef aHiLoGain +#undef aUnknown25 void aClearBufferImpl(uint16_t addr, int nbytes); -void aLoadBufferImpl(const void *source_addr); -void aSaveBufferImpl(int16_t *dest_addr); void aLoadADPCMImpl(int num_entries_times_16, const int16_t *book_source_addr); void aSetBufferImpl(uint8_t flags, uint16_t in, uint16_t out, uint16_t nbytes); -void aSetVolumeImpl(uint8_t flags, int16_t v, int16_t t, int16_t r); -void aInterleaveImpl(uint16_t left, uint16_t right); void aDMEMMoveImpl(uint16_t in_addr, uint16_t out_addr, int nbytes); void aSetLoopImpl(ADPCM_STATE *adpcm_loop_state); void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state); void aResampleImpl(uint8_t flags, uint16_t pitch, RESAMPLE_STATE state); -void aEnvMixerImpl(uint8_t flags, ENVMIX_STATE state); + +#ifndef NEW_AUDIO_UCODE +void aSetVolumeImpl(uint8_t flags, int16_t v, int16_t t, int16_t r); +void aLoadBufferImpl(const void *source_addr); +void aSaveBufferImpl(int16_t *dest_addr); +void aInterleaveImpl(uint16_t left, uint16_t right); void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr); +void aEnvMixerImpl(uint8_t flags, ENVMIX_STATE state); +#else +void aLoadBufferImpl(const void *source_addr, uint16_t dest_addr, uint16_t nbytes); +void aSaveBufferImpl(uint16_t source_addr, int16_t *dest_addr, uint16_t nbytes); +void aInterleaveImpl(uint16_t dest, uint16_t left, uint16_t right, uint16_t c); +void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aEnvSetup1Impl(uint8_t initial_vol_wet, uint16_t rate_wet, uint16_t rate_left, uint16_t rate_right); +void aEnvSetup2Impl(uint16_t initial_vol_left, uint16_t initial_vol_right); +void aEnvMixerImpl(uint16_t in_addr, uint16_t n_samples, bool swap_reverb, + bool neg_left, bool neg_right, + uint16_t dry_left_addr, uint16_t dry_right_addr, + uint16_t wet_left_addr, uint16_t wet_right_addr); +void aS8DecImpl(uint8_t flags, ADPCM_STATE state); +void aAddMixerImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aDuplicateImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aDMEMMove2Impl(uint8_t t, uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aResampleZohImpl(uint16_t pitch, uint16_t start_fract); +void aDownsampleHalfImpl(uint16_t n_samples, uint16_t in_addr, uint16_t out_addr); +void aFilterImpl(uint8_t flags, uint16_t count_or_buf, int16_t state_or_filter[8]); +void aHiLoGainImpl(uint8_t g, uint16_t count, uint16_t addr); +void aUnknown25Impl(uint8_t f, uint16_t count, uint16_t out_addr, uint16_t in_addr); +#endif #define aSegment(pkt, s, b) do { } while(0) #define aClearBuffer(pkt, d, c) aClearBufferImpl(d, c) -#define aLoadBuffer(pkt, s) aLoadBufferImpl(s) -#define aSaveBuffer(pkt, s) aSaveBufferImpl(s) #define aLoadADPCM(pkt, c, d) aLoadADPCMImpl(c, d) #define aSetBuffer(pkt, f, i, o, c) aSetBufferImpl(f, i, o, c) -#define aSetVolume(pkt, f, v, t, r) aSetVolumeImpl(f, v, t, r) -#define aSetVolume32(pkt, f, v, tr) aSetVolume(pkt, f, v, (int16_t)((tr) >> 16), (int16_t)(tr)) -#define aInterleave(pkt, l, r) aInterleaveImpl(l, r) #define aDMEMMove(pkt, i, o, c) aDMEMMoveImpl(i, o, c) #define aSetLoop(pkt, a) aSetLoopImpl(a) #define aADPCMdec(pkt, f, s) aADPCMdecImpl(f, s) #define aResample(pkt, f, p, s) aResampleImpl(f, p, s) -#define aEnvMixer(pkt, f, s) aEnvMixerImpl(f, s) + +#ifndef NEW_AUDIO_UCODE +#define aSetVolume(pkt, f, v, t, r) aSetVolumeImpl(f, v, t, r) +#define aSetVolume32(pkt, f, v, tr) aSetVolume(pkt, f, v, (int16_t)((tr) >> 16), (int16_t)(tr)) +#define aLoadBuffer(pkt, s) aLoadBufferImpl(s) +#define aSaveBuffer(pkt, s) aSaveBufferImpl(s) +#define aInterleave(pkt, l, r) aInterleaveImpl(l, r) #define aMix(pkt, f, g, i, o) aMixImpl(g, i, o) +#define aEnvMixer(pkt, f, s) aEnvMixerImpl(f, s) +#else +#define aLoadBuffer(pkt, s, d, c) aLoadBufferImpl(s, d, c) +#define aSaveBuffer(pkt, s, d, c) aSaveBufferImpl(s, d, c) +#define aInterleave(pkt, o, l, r, c) aInterleaveImpl(o, l, r, c) +#define aMix(pkt, g, i, o, c) aMixImpl(g, i, o, c) +#define aEnvSetup1(pkt, initialVolReverb, rampReverb, rampLeft, rampRight) \ + aEnvSetup1Impl(initialVolReverb, rampReverb, rampLeft, rampRight) +#define aEnvSetup2(pkt, initialVolLeft, initialVolRight) \ + aEnvSetup2Impl(initialVolLeft, initialVolRight) +#define aEnvMixer(pkt, inBuf, nSamples, swapReverb, negLeft, negRight, \ + dryLeft, dryRight, wetLeft, wetRight) \ + aEnvMixerImpl(inBuf, nSamples, swapReverb, negLeft, negRight, \ + dryLeft, dryRight, wetLeft, wetRight) +#define aS8Dec(pkt, f, s) aS8DecImpl(f, s) +#define aAddMixer(pkt, s, d, c) aAddMixerImpl(s, d, c) +#define aDuplicate(pkt, s, d, c) aDuplicateImpl(s, d, c) +#define aDMEMMove2(pkt, t, i, o, c) aDMEMMove2Impl(t, i, o, c) +#define aResampleZoh(pkt, pitch, startFract) aResampleZohImpl(pitch, startFract) +#define aDownsampleHalf(pkt, nSamples, i, o) aDownsampleHalfImpl(nSamples, i, o) +#define aFilter(pkt, f, countOrBuf, addr) aFilterImpl(f, countOrBuf, addr) +#define aHiLoGain(pkt, g, buflen, i) aHiLoGainImpl(g, buflen, i) +#define aUnknown25(pkt, f, c, o, i) aUnknown25Impl(f, c, o, i) +#endif #endif