/**
* Copyright (C) 2023 saybur
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
**/
#ifdef ENABLE_AUDIO_OUTPUT
#include
#include
#include
#include
#include
#include
#include "audio.h"
#include "BlueSCSI_audio.h"
#include "BlueSCSI_config.h"
#include "BlueSCSI_log.h"
#include "BlueSCSI_platform.h"
extern SdFs SD;
// Table with the number of '1' bits for each index.
// Used for SP/DIF parity calculations.
// Placed in SRAM5 for the second core to use with reduced contention.
const uint8_t snd_parity[256] __attribute__((aligned(256), section(".scratch_y.snd_parity"))) = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, };
/*
* Precomputed biphase-mark patterns for data. For an 8-bit value this has
* 16-bits in MSB-first order for the correct high/low transitions to
* represent the data, given an output clocking rate twice the bitrate (so the
* bits '11' or '00' reflect a zero and '10' or '01' represent a one). Each
* value below starts with a '1' and will need to be inverted if the last bit
* of the previous mask was also a '1'. These values can be written to an
* appropriately configured SPI peripheral to blast biphase data at a
* receiver.
*
* To facilitate fast lookups this table should be put in SRAM with low
* contention, aligned to an apppropriate boundry.
*/
const uint16_t biphase[256] __attribute__((aligned(512), section(".scratch_y.biphase"))) = {
0xCCCC, 0xB333, 0xD333, 0xACCC, 0xCB33, 0xB4CC, 0xD4CC, 0xAB33,
0xCD33, 0xB2CC, 0xD2CC, 0xAD33, 0xCACC, 0xB533, 0xD533, 0xAACC,
0xCCB3, 0xB34C, 0xD34C, 0xACB3, 0xCB4C, 0xB4B3, 0xD4B3, 0xAB4C,
0xCD4C, 0xB2B3, 0xD2B3, 0xAD4C, 0xCAB3, 0xB54C, 0xD54C, 0xAAB3,
0xCCD3, 0xB32C, 0xD32C, 0xACD3, 0xCB2C, 0xB4D3, 0xD4D3, 0xAB2C,
0xCD2C, 0xB2D3, 0xD2D3, 0xAD2C, 0xCAD3, 0xB52C, 0xD52C, 0xAAD3,
0xCCAC, 0xB353, 0xD353, 0xACAC, 0xCB53, 0xB4AC, 0xD4AC, 0xAB53,
0xCD53, 0xB2AC, 0xD2AC, 0xAD53, 0xCAAC, 0xB553, 0xD553, 0xAAAC,
0xCCCB, 0xB334, 0xD334, 0xACCB, 0xCB34, 0xB4CB, 0xD4CB, 0xAB34,
0xCD34, 0xB2CB, 0xD2CB, 0xAD34, 0xCACB, 0xB534, 0xD534, 0xAACB,
0xCCB4, 0xB34B, 0xD34B, 0xACB4, 0xCB4B, 0xB4B4, 0xD4B4, 0xAB4B,
0xCD4B, 0xB2B4, 0xD2B4, 0xAD4B, 0xCAB4, 0xB54B, 0xD54B, 0xAAB4,
0xCCD4, 0xB32B, 0xD32B, 0xACD4, 0xCB2B, 0xB4D4, 0xD4D4, 0xAB2B,
0xCD2B, 0xB2D4, 0xD2D4, 0xAD2B, 0xCAD4, 0xB52B, 0xD52B, 0xAAD4,
0xCCAB, 0xB354, 0xD354, 0xACAB, 0xCB54, 0xB4AB, 0xD4AB, 0xAB54,
0xCD54, 0xB2AB, 0xD2AB, 0xAD54, 0xCAAB, 0xB554, 0xD554, 0xAAAB,
0xCCCD, 0xB332, 0xD332, 0xACCD, 0xCB32, 0xB4CD, 0xD4CD, 0xAB32,
0xCD32, 0xB2CD, 0xD2CD, 0xAD32, 0xCACD, 0xB532, 0xD532, 0xAACD,
0xCCB2, 0xB34D, 0xD34D, 0xACB2, 0xCB4D, 0xB4B2, 0xD4B2, 0xAB4D,
0xCD4D, 0xB2B2, 0xD2B2, 0xAD4D, 0xCAB2, 0xB54D, 0xD54D, 0xAAB2,
0xCCD2, 0xB32D, 0xD32D, 0xACD2, 0xCB2D, 0xB4D2, 0xD4D2, 0xAB2D,
0xCD2D, 0xB2D2, 0xD2D2, 0xAD2D, 0xCAD2, 0xB52D, 0xD52D, 0xAAD2,
0xCCAD, 0xB352, 0xD352, 0xACAD, 0xCB52, 0xB4AD, 0xD4AD, 0xAB52,
0xCD52, 0xB2AD, 0xD2AD, 0xAD52, 0xCAAD, 0xB552, 0xD552, 0xAAAD,
0xCCCA, 0xB335, 0xD335, 0xACCA, 0xCB35, 0xB4CA, 0xD4CA, 0xAB35,
0xCD35, 0xB2CA, 0xD2CA, 0xAD35, 0xCACA, 0xB535, 0xD535, 0xAACA,
0xCCB5, 0xB34A, 0xD34A, 0xACB5, 0xCB4A, 0xB4B5, 0xD4B5, 0xAB4A,
0xCD4A, 0xB2B5, 0xD2B5, 0xAD4A, 0xCAB5, 0xB54A, 0xD54A, 0xAAB5,
0xCCD5, 0xB32A, 0xD32A, 0xACD5, 0xCB2A, 0xB4D5, 0xD4D5, 0xAB2A,
0xCD2A, 0xB2D5, 0xD2D5, 0xAD2A, 0xCAD5, 0xB52A, 0xD52A, 0xAAD5,
0xCCAA, 0xB355, 0xD355, 0xACAA, 0xCB55, 0xB4AA, 0xD4AA, 0xAB55,
0xCD55, 0xB2AA, 0xD2AA, 0xAD55, 0xCAAA, 0xB555, 0xD555, 0xAAAA };
/*
* Biphase frame headers for SP/DIF, including the special bit framing
* errors used to detect (sub)frame start conditions. See above table
* for details.
*/
const uint16_t x_preamble = 0xE2CC;
const uint16_t y_preamble = 0xE4CC;
const uint16_t z_preamble = 0xE8CC;
// DMA configuration info
static dma_channel_config snd_dma_a_cfg;
static dma_channel_config snd_dma_b_cfg;
// some chonky buffers to store audio samples
static uint8_t sample_buf_a[AUDIO_BUFFER_SIZE];
static uint8_t sample_buf_b[AUDIO_BUFFER_SIZE];
// tracking for the state of the above buffers
enum bufstate { STALE, FILLING, READY };
static volatile bufstate sbufst_a = STALE;
static volatile bufstate sbufst_b = STALE;
enum bufselect { A, B };
static bufselect sbufsel = A;
static uint16_t sbufpos = 0;
static uint8_t sbufswap = 0;
// buffers for storing biphase patterns
#define SAMPLE_CHUNK_SIZE 1024 // ~5.8ms
#define WIRE_BUFFER_SIZE (SAMPLE_CHUNK_SIZE * 2)
static uint16_t wire_buf_a[WIRE_BUFFER_SIZE];
static uint16_t wire_buf_b[WIRE_BUFFER_SIZE];
// tracking for audio playback
static uint8_t audio_owner; // SCSI ID or 0xFF when idle
static volatile bool audio_paused = false;
static ImageBackingStore* audio_file;
static uint64_t fpos;
static uint32_t fleft;
// historical playback status information
static audio_status_code audio_last_status[8] = {ASC_NO_STATUS};
// volume information for targets
static volatile uint16_t volumes[8] = {
DEFAULT_VOLUME_LEVEL, DEFAULT_VOLUME_LEVEL, DEFAULT_VOLUME_LEVEL, DEFAULT_VOLUME_LEVEL,
DEFAULT_VOLUME_LEVEL, DEFAULT_VOLUME_LEVEL, DEFAULT_VOLUME_LEVEL, DEFAULT_VOLUME_LEVEL
};
static volatile uint16_t channels[8] = {
AUDIO_CHANNEL_ENABLE_MASK, AUDIO_CHANNEL_ENABLE_MASK, AUDIO_CHANNEL_ENABLE_MASK, AUDIO_CHANNEL_ENABLE_MASK,
AUDIO_CHANNEL_ENABLE_MASK, AUDIO_CHANNEL_ENABLE_MASK, AUDIO_CHANNEL_ENABLE_MASK, AUDIO_CHANNEL_ENABLE_MASK
};
// mechanism for cleanly stopping DMA units
static volatile bool audio_stopping = false;
// trackers for the below function call
static uint16_t sfcnt = 0; // sub-frame count; 2 per frame, 192 frames/block
static uint8_t invert = 0; // biphase encode help: set if last wire bit was '1'
/*
* Translates 16-bit stereo sound samples to biphase wire patterns for the
* SPI peripheral. Produces 8 patterns (128 bits, or 1 SP/DIF frame) per pair
* of input samples. Provided length is the total number of sample bytes present,
* _twice_ the number of samples (little-endian order assumed)
*
* This function operates with side-effects and is not safe to call from both
* cores. It must also be called in the same order data is intended to be
* output.
*/
static void snd_encode(uint8_t* samples, uint16_t* wire_patterns, uint16_t len, uint8_t swap) {
uint16_t wvol = volumes[audio_owner & 7];
uint8_t lvol = ((wvol >> 8) + (wvol & 0xFF)) >> 1; // average of both values
// limit maximum volume; with my DACs I've had persistent issues
// with signal clipping when sending data in the highest bit position
lvol = lvol >> 2;
uint8_t rvol = lvol;
// enable or disable based on the channel information for both output
// ports, where the high byte and mask control the right channel, and
// the low control the left channel
uint16_t chn = channels[audio_owner & 7] & AUDIO_CHANNEL_ENABLE_MASK;
if (!(chn >> 8)) rvol = 0;
if (!(chn & 0xFF)) lvol = 0;
uint16_t widx = 0;
for (uint16_t i = 0; i < len; i += 2) {
uint32_t sample = 0;
uint8_t parity = 0;
if (samples != NULL) {
int32_t rsamp;
if (swap) {
rsamp = (int16_t)(samples[i + 1] + (samples[i] << 8));
} else {
rsamp = (int16_t)(samples[i] + (samples[i + 1] << 8));
}
// linear scale to requested audio value
if (i & 2) {
rsamp *= rvol;
} else {
rsamp *= lvol;
}
// use 20 bits of value only, which allows ignoring the lowest 8
// bits during biphase conversion (after including sample shift)
sample = ((uint32_t)rsamp) & 0xFFFFF0;
// determine parity, simplified to one lookup via XOR
parity = ((sample >> 16) ^ (sample >> 8)) ^ sample;
parity = snd_parity[parity];
// shift sample into the correct bit positions of the sub-frame.
sample = sample << 4;
}
// if needed, establish even parity with P bit
if (parity % 2) sample |= 0x80000000;
// translate sample into biphase encoding
// first is low 8 bits: preamble and 4 least-significant bits of
// 24-bit audio, pre-encoded as all '0' due to 16-bit samples
uint16_t wp;
if (sfcnt == 0) {
wp = z_preamble; // left channel, block start
} else if (sfcnt % 2) {
wp = y_preamble; // right channel
} else {
wp = x_preamble; // left channel, not block start
}
if (invert) wp = ~wp;
invert = wp & 1;
wire_patterns[widx++] = wp;
// next 8 bits
wp = biphase[(uint8_t) (sample >> 8)];
if (invert) wp = ~wp;
invert = wp & 1;
wire_patterns[widx++] = wp;
// next 8 again, all audio data
wp = biphase[(uint8_t) (sample >> 16)];
if (invert) wp = ~wp;
invert = wp & 1;
wire_patterns[widx++] = wp;
// final 8, low 4 audio data and high 4 control bits
wp = biphase[(uint8_t) (sample >> 24)];
if (invert) wp = ~wp;
invert = wp & 1;
wire_patterns[widx++] = wp;
// increment subframe counter for next pass
sfcnt++;
if (sfcnt == 384) sfcnt = 0; // if true, block complete
}
}
// functions for passing to Core1
static void snd_process_a() {
if (sbufsel == A) {
if (sbufst_a == READY) {
snd_encode(sample_buf_a + sbufpos, wire_buf_a, SAMPLE_CHUNK_SIZE, sbufswap);
sbufpos += SAMPLE_CHUNK_SIZE;
if (sbufpos >= AUDIO_BUFFER_SIZE) {
sbufsel = B;
sbufpos = 0;
sbufst_a = STALE;
}
} else {
snd_encode(NULL, wire_buf_a, SAMPLE_CHUNK_SIZE, sbufswap);
}
} else {
if (sbufst_b == READY) {
snd_encode(sample_buf_b + sbufpos, wire_buf_a, SAMPLE_CHUNK_SIZE, sbufswap);
sbufpos += SAMPLE_CHUNK_SIZE;
if (sbufpos >= AUDIO_BUFFER_SIZE) {
sbufsel = A;
sbufpos = 0;
sbufst_b = STALE;
}
} else {
snd_encode(NULL, wire_buf_a, SAMPLE_CHUNK_SIZE, sbufswap);
}
}
}
static void snd_process_b() {
// clone of above for the other wire buffer
if (sbufsel == A) {
if (sbufst_a == READY) {
snd_encode(sample_buf_a + sbufpos, wire_buf_b, SAMPLE_CHUNK_SIZE, sbufswap);
sbufpos += SAMPLE_CHUNK_SIZE;
if (sbufpos >= AUDIO_BUFFER_SIZE) {
sbufsel = B;
sbufpos = 0;
sbufst_a = STALE;
}
} else {
snd_encode(NULL, wire_buf_b, SAMPLE_CHUNK_SIZE, sbufswap);
}
} else {
if (sbufst_b == READY) {
snd_encode(sample_buf_b + sbufpos, wire_buf_b, SAMPLE_CHUNK_SIZE, sbufswap);
sbufpos += SAMPLE_CHUNK_SIZE;
if (sbufpos >= AUDIO_BUFFER_SIZE) {
sbufsel = A;
sbufpos = 0;
sbufst_b = STALE;
}
} else {
snd_encode(NULL, wire_buf_b, SAMPLE_CHUNK_SIZE, sbufswap);
}
}
}
// Allows execution on Core1 via function pointers. Each function can take
// no parameters and should return nothing, operating via side-effects only.
static void core1_handler() {
while (1) {
void (*function)() = (void (*)()) multicore_fifo_pop_blocking();
(*function)();
}
}
/* ------------------------------------------------------------------------ */
/* ---------- VISIBLE FUNCTIONS ------------------------------------------- */
/* ------------------------------------------------------------------------ */
void audio_dma_irq() {
if (dma_hw->intr & (1 << SOUND_DMA_CHA)) {
dma_hw->ints0 = (1 << SOUND_DMA_CHA);
multicore_fifo_push_blocking((uintptr_t) &snd_process_a);
if (audio_stopping) {
channel_config_set_chain_to(&snd_dma_a_cfg, SOUND_DMA_CHA);
}
dma_channel_configure(SOUND_DMA_CHA,
&snd_dma_a_cfg,
&(spi_get_hw(AUDIO_SPI)->dr),
&wire_buf_a,
WIRE_BUFFER_SIZE,
false);
} else if (dma_hw->intr & (1 << SOUND_DMA_CHB)) {
dma_hw->ints0 = (1 << SOUND_DMA_CHB);
multicore_fifo_push_blocking((uintptr_t) &snd_process_b);
if (audio_stopping) {
channel_config_set_chain_to(&snd_dma_b_cfg, SOUND_DMA_CHB);
}
dma_channel_configure(SOUND_DMA_CHB,
&snd_dma_b_cfg,
&(spi_get_hw(AUDIO_SPI)->dr),
&wire_buf_b,
WIRE_BUFFER_SIZE,
false);
}
}
bool audio_is_active() {
return audio_owner != 0xFF;
}
bool audio_is_playing(uint8_t id) {
return audio_owner == (id & 7);
}
void audio_setup() {
// setup SPI to blast SP/DIF data over the TX pin
spi_set_baudrate(AUDIO_SPI, 5644800); // will be slightly wrong, ~0.03% slow
hw_write_masked(&spi_get_hw(AUDIO_SPI)->cr0,
0x1F, // TI mode with 16 bits
SPI_SSPCR0_DSS_BITS | SPI_SSPCR0_FRF_BITS);
spi_get_hw(AUDIO_SPI)->dmacr = SPI_SSPDMACR_TXDMAE_BITS;
hw_set_bits(&spi_get_hw(AUDIO_SPI)->cr1, SPI_SSPCR1_SSE_BITS);
dma_channel_claim(SOUND_DMA_CHA);
dma_channel_claim(SOUND_DMA_CHB);
log("Starting Core1 for audio");
multicore_launch_core1(core1_handler);
}
void audio_poll() {
if (!audio_is_active()) return;
if (audio_paused) return;
if (fleft == 0 && sbufst_a == STALE && sbufst_b == STALE) {
// out of data and ready to stop
audio_stop(audio_owner);
return;
} else if (fleft == 0) {
// out of data to read but still working on remainder
return;
} else if (!audio_file->isOpen()) {
// closed elsewhere, maybe disk ejected?
debuglog("------ Playback stop due to closed file");
audio_stop(audio_owner);
return;
}
// are new audio samples needed from the memory card?
uint8_t* audiobuf;
if (sbufst_a == STALE) {
sbufst_a = FILLING;
audiobuf = sample_buf_a;
} else if (sbufst_b == STALE) {
sbufst_b = FILLING;
audiobuf = sample_buf_b;
} else {
// no data needed this time
return;
}
platform_set_sd_callback(NULL, NULL);
uint16_t toRead = AUDIO_BUFFER_SIZE;
if (fleft < toRead) toRead = fleft;
if (audio_file->position() != fpos) {
// should be uncommon due to SCSI command restrictions on devices
// playing audio; if this is showing up in logs a different approach
// will be needed to avoid seek performance issues on FAT32 vols
debuglog("------ Audio seek required on ", audio_owner);
if (!audio_file->seek(fpos)) {
log("Audio error, unable to seek to ", fpos, ", ID:", audio_owner);
}
}
if (audio_file->read(audiobuf, toRead) != toRead) {
log("Audio sample data underrun");
}
fpos += toRead;
fleft -= toRead;
if (sbufst_a == FILLING) {
sbufst_a = READY;
} else if (sbufst_b == FILLING) {
sbufst_b = READY;
}
}
bool audio_play(uint8_t owner, ImageBackingStore* img, uint64_t start, uint64_t end, bool swap) {
// stop any existing playback first
if (audio_is_active()) audio_stop(audio_owner);
// debuglog("Request to play ('", file, "':", start, ":", end, ")");
// verify audio file is present and inputs are (somewhat) sane
if (owner == 0xFF) {
log("Illegal audio owner");
return false;
}
if (start >= end) {
log("Invalid range for audio (", start, ":", end, ")");
return false;
}
platform_set_sd_callback(NULL, NULL);
audio_file = img;
if (!audio_file->isOpen()) {
log("File not open for audio playback, ", owner);
return false;
}
uint64_t len = audio_file->size();
if (start > len) {
log("File playback request start (", start, ":", len, ") outside file bounds");
return false;
}
// truncate playback end to end of file
// we will not consider this to be an error at the moment
if (end > len) {
debuglog("------ Truncate audio play request end ", end, " to file size ", len);
end = len;
}
fleft = end - start;
if (fleft <= 2 * AUDIO_BUFFER_SIZE) {
log("File playback request (", start, ":", end, ") too short");
return false;
}
// read in initial sample buffers
if (!audio_file->seek(start)) {
log("Sample file failed start seek to ", start);
return false;
}
if (audio_file->read(sample_buf_a, AUDIO_BUFFER_SIZE) != AUDIO_BUFFER_SIZE) {
log("File playback start returned fewer bytes than allowed");
return false;
}
if (audio_file->read(sample_buf_b, AUDIO_BUFFER_SIZE) != AUDIO_BUFFER_SIZE) {
log("File playback start returned fewer bytes than allowed");
return false;
}
// prepare initial tracking state
fpos = audio_file->position();
fleft -= AUDIO_BUFFER_SIZE * 2;
sbufsel = A;
sbufpos = 0;
sbufswap = swap;
sbufst_a = READY;
sbufst_b = READY;
audio_owner = owner & 7;
audio_last_status[audio_owner] = ASC_PLAYING;
audio_paused = false;
// prepare the wire buffers
for (uint16_t i = 0; i < WIRE_BUFFER_SIZE; i++) {
wire_buf_a[i] = 0;
wire_buf_b[i] = 0;
}
sfcnt = 0;
invert = 0;
// setup the two DMA units to hand-off to each other
// to maintain a stable bitstream these need to run without interruption
snd_dma_a_cfg = dma_channel_get_default_config(SOUND_DMA_CHA);
channel_config_set_transfer_data_size(&snd_dma_a_cfg, DMA_SIZE_16);
channel_config_set_dreq(&snd_dma_a_cfg, spi_get_dreq(AUDIO_SPI, true));
channel_config_set_read_increment(&snd_dma_a_cfg, true);
channel_config_set_chain_to(&snd_dma_a_cfg, SOUND_DMA_CHB);
// version of pico-sdk lacks channel_config_set_high_priority()
snd_dma_a_cfg.ctrl |= DMA_CH0_CTRL_TRIG_HIGH_PRIORITY_BITS;
dma_channel_configure(SOUND_DMA_CHA, &snd_dma_a_cfg, &(spi_get_hw(AUDIO_SPI)->dr),
&wire_buf_a, WIRE_BUFFER_SIZE, false);
dma_channel_set_irq0_enabled(SOUND_DMA_CHA, true);
snd_dma_b_cfg = dma_channel_get_default_config(SOUND_DMA_CHB);
channel_config_set_transfer_data_size(&snd_dma_b_cfg, DMA_SIZE_16);
channel_config_set_dreq(&snd_dma_b_cfg, spi_get_dreq(AUDIO_SPI, true));
channel_config_set_read_increment(&snd_dma_b_cfg, true);
channel_config_set_chain_to(&snd_dma_b_cfg, SOUND_DMA_CHA);
snd_dma_b_cfg.ctrl |= DMA_CH0_CTRL_TRIG_HIGH_PRIORITY_BITS;
dma_channel_configure(SOUND_DMA_CHB, &snd_dma_b_cfg, &(spi_get_hw(AUDIO_SPI)->dr),
&wire_buf_b, WIRE_BUFFER_SIZE, false);
dma_channel_set_irq0_enabled(SOUND_DMA_CHB, true);
// ready to go
dma_channel_start(SOUND_DMA_CHA);
return true;
}
bool audio_set_paused(uint8_t id, bool paused) {
if (audio_owner != (id & 7)) return false;
else if (audio_paused && paused) return false;
else if (!audio_paused && !paused) return false;
audio_paused = paused;
if (paused) {
audio_last_status[audio_owner] = ASC_PAUSED;
} else {
audio_last_status[audio_owner] = ASC_PLAYING;
}
return true;
}
void audio_stop(uint8_t id) {
if (audio_owner != (id & 7)) return;
// to help mute external hardware, send a bunch of '0' samples prior to
// halting the datastream; easiest way to do this is invalidating the
// sample buffers, same as if there was a sample data underrun
sbufst_a = STALE;
sbufst_b = STALE;
// then indicate that the streams should no longer chain to one another
// and wait for them to shut down naturally
audio_stopping = true;
while (dma_channel_is_busy(SOUND_DMA_CHA)) tight_loop_contents();
while (dma_channel_is_busy(SOUND_DMA_CHB)) tight_loop_contents();
while (spi_is_busy(AUDIO_SPI)) tight_loop_contents();
audio_stopping = false;
// idle the subsystem
audio_last_status[audio_owner] = ASC_COMPLETED;
audio_paused = false;
audio_owner = 0xFF;
}
audio_status_code audio_get_status_code(uint8_t id) {
audio_status_code tmp = audio_last_status[id & 7];
if (tmp == ASC_COMPLETED || tmp == ASC_ERRORED) {
audio_last_status[id & 7] = ASC_NO_STATUS;
}
return tmp;
}
uint16_t audio_get_volume(uint8_t id) {
return volumes[id & 7];
}
void audio_set_volume(uint8_t id, uint16_t vol) {
volumes[id & 7] = vol;
}
uint16_t audio_get_channel(uint8_t id) {
return channels[id & 7];
}
void audio_set_channel(uint8_t id, uint16_t chn) {
channels[id & 7] = chn;
}
#endif // ENABLE_AUDIO_OUTPUT