Move to Opus 1.5.1 Remove OpusFile and OGG libraries because we parse the OGG file in the object directly with way less memory and overhead. Update example for LittleFS and RP2040 Fixes #372
280 lines
8.7 KiB
C++
280 lines
8.7 KiB
C++
/*
|
|
AudioGeneratorOpus
|
|
Audio output generator that plays Opus audio files
|
|
|
|
Copyright (C) 2025 Earle F. Philhower, III
|
|
|
|
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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <AudioGeneratorOpus.h>
|
|
|
|
AudioGeneratorOpus::AudioGeneratorOpus() {
|
|
od = nullptr;
|
|
buff = nullptr;
|
|
buffPtr = 0;
|
|
packet = nullptr;
|
|
buffLen = 0;
|
|
running = false;
|
|
}
|
|
|
|
AudioGeneratorOpus::~AudioGeneratorOpus() {
|
|
if (od) {
|
|
free(od);
|
|
}
|
|
od = nullptr;
|
|
free(buff);
|
|
buff = nullptr;
|
|
free(packet);
|
|
packet = nullptr;
|
|
}
|
|
|
|
bool AudioGeneratorOpus::begin(AudioFileSource *source, AudioOutput *output) {
|
|
buff = (opus_int16*)malloc(4096 * sizeof(opus_int16));
|
|
if (!buff) {
|
|
return false;
|
|
}
|
|
|
|
packet = (uint8_t *)malloc(1024);
|
|
if (!packet) {
|
|
free(buff);
|
|
buff = nullptr;
|
|
return false;
|
|
}
|
|
packetOff = 0;
|
|
|
|
od = (OpusDecoder *) malloc(opus_decoder_get_size(2));
|
|
if (!od) {
|
|
free(buff);
|
|
buff = nullptr;
|
|
free(packet);
|
|
packet = nullptr;
|
|
return false;
|
|
}
|
|
opus_decoder_init(od, 48000, 2);
|
|
|
|
if (!source) {
|
|
return false;
|
|
}
|
|
file = source;
|
|
|
|
if (!output) {
|
|
return false;
|
|
}
|
|
this->output = output;
|
|
|
|
if (!file->isOpen()) {
|
|
return false; // Error
|
|
}
|
|
|
|
lastSample[0] = 0;
|
|
lastSample[1] = 0;
|
|
|
|
buffPtr = 0;
|
|
buffLen = 0;
|
|
|
|
bzero(hdr, sizeof(hdr));
|
|
packetOff = 0;
|
|
state = WaitHeader;
|
|
preskip = 0;
|
|
|
|
output->begin();
|
|
|
|
// These are fixed by Opus
|
|
output->SetRate(48000);
|
|
output->SetBitsPerSample(16);
|
|
output->SetChannels(2);
|
|
|
|
running = true;
|
|
return true;
|
|
}
|
|
|
|
bool AudioGeneratorOpus::demux() {
|
|
int r;
|
|
uint8_t b;
|
|
//static int pktno = 0;
|
|
|
|
while (true) {
|
|
switch (state) {
|
|
case WaitHeader:
|
|
//audioLogger->printf("STATE: WaitHeader\n");
|
|
if (!file->read(&b, 1)) {
|
|
return false; // No data
|
|
}
|
|
memmove(hdr, hdr + 1, 26);
|
|
hdr[26] = b;
|
|
if ((hdr[0] == 'O') && (hdr[1] == 'g') && (hdr[2] == 'g') && (hdr[3] == 'S') && (hdr[4] == 0)) {
|
|
// We have a header!
|
|
type = hdr[5];
|
|
agp = hdr[13];
|
|
for (int i = 1; i < 7; i++) {
|
|
agp <<= 8;
|
|
agp |= hdr[13 - i];
|
|
}
|
|
ssn = hdr[14] | (hdr[15] << 8) | (hdr[16] << 16) | (hdr[17] << 24);
|
|
psn = hdr[18] | (hdr[19] << 8) | (hdr[20] << 16) | (hdr[21] << 24);
|
|
pcs = hdr[22] | (hdr[23] << 8) | (hdr[24] << 16) | (hdr[25] << 24);
|
|
ps = hdr[26];
|
|
readPS = 0;
|
|
//audioLogger->printf("HEADER: typ: %d, agp: %llu, ssn: %08x, psn: %08x, pcs: %08x, ps: %d\n", type, agp, ssn, psn, pcs, ps);
|
|
state = WaitSegment;
|
|
}
|
|
break;
|
|
case WaitSegment:
|
|
//audioLogger->printf("STATE: WaitSegment\n");
|
|
r = file->read(seg + readPS, ps - readPS);
|
|
readPS += r; // Keep track of what we read
|
|
if (readPS < ps) {
|
|
// Not enough data avail to finish, loop
|
|
return false;
|
|
}
|
|
//audioLogger->printf("SEGMENTS (%d): ", ps);
|
|
for (int i = 0; i < ps; i++) {
|
|
//audioLogger->printf(" %02x", seg[i]);
|
|
}
|
|
//audioLogger->printf("\n");
|
|
curSeg = 0;
|
|
lacingBytesToRead = seg[0];
|
|
state = ReadPacket;
|
|
break;
|
|
case ReadPacket:
|
|
//audioLogger->printf("STATE: ReadPacket\n");
|
|
//audioLogger->printf("readpacket seg %d len %d\n", curSeg, seg[curSeg]);
|
|
r = file->read(packet + packetOff, lacingBytesToRead);
|
|
packetOff += r;
|
|
lacingBytesToRead -= r;
|
|
if (lacingBytesToRead) {
|
|
//audioLogger->printf("short read\n");
|
|
return false; // Not enough avail
|
|
}
|
|
// Read lacing bit, see if there's more
|
|
if (seg[curSeg] != 0xff) {
|
|
//audioLogger->printf("PACKET %d (%d): ", pktno++, packetOff);
|
|
for (uint32_t i = 0; i < packetOff; i++) {
|
|
//audioLogger->printf(" %02X", packet[i]);
|
|
}
|
|
//audioLogger->printf("\n");
|
|
// We have a full packet in the buffer, decode it
|
|
// First, is it a header?
|
|
if ((packetOff >= 17) && !memcmp(packet, "OpusHead", 8) && (packet[8] == 1)) {
|
|
channels = packet[9];
|
|
preskip = packet[10] | (packet[11] << 8);
|
|
samplerate = packet[12] | (packet[13] << 8) | (packet[14] << 16) | (packet[15] << 24);
|
|
gain = packet[16] | (packet[17]++);
|
|
//audioLogger->printf("HEADER: chan: %d, sr: %d, skip %d\n", channels, samplerate, preskip);
|
|
packetOff = 0; // For better or worse, we've processed this pkt
|
|
} else if ((packetOff >= 9) && !memcmp(packet, "OpusTags", 8)) {
|
|
// This is an unparsed TAG. TODO find metadata format
|
|
packetOff = 0; // For better or worse, we've processed this pkt
|
|
} else {
|
|
// This should be a regular packet
|
|
int ret = opus_decode(od, packet, packetOff, buff, 2048, 0);
|
|
packetOff = 0; // For better or worse, we've processed this pkt
|
|
if (ret > 0) {
|
|
buffLen = ret * 2;
|
|
if (preskip) {
|
|
if (buffLen >= preskip) {
|
|
buffPtr = preskip;
|
|
preskip = 0;
|
|
//audioLogger->printf("donepreskip\n");
|
|
} else {
|
|
buffPtr = buffLen;
|
|
preskip -= buffLen;
|
|
}
|
|
} else {
|
|
buffPtr = 0;
|
|
}
|
|
curSeg++;
|
|
if (curSeg >= ps) {
|
|
state = WaitHeader;
|
|
lacingBytesToRead = 0;
|
|
} else {
|
|
lacingBytesToRead = seg[curSeg];
|
|
}
|
|
return true; // We have filled a buffer
|
|
} else {
|
|
//audioLogger->printf("nodecode\n");
|
|
// Could be header pkt, we ignore them here
|
|
// That means we ignore the preskip value, for now
|
|
}
|
|
packetOff = 0; // For better or worse, we've processed this pkt
|
|
}
|
|
}
|
|
// Only have partial pkt, need next segment
|
|
curSeg++;
|
|
if (curSeg >= ps) {
|
|
state = WaitHeader;
|
|
lacingBytesToRead = 0;
|
|
} else {
|
|
lacingBytesToRead = seg[curSeg];
|
|
}
|
|
break;
|
|
default:
|
|
state = WaitHeader;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool AudioGeneratorOpus::loop() {
|
|
if (!running) {
|
|
goto done;
|
|
}
|
|
|
|
if (!output->ConsumeSample(lastSample)) {
|
|
goto done; // Try and send last buffered sample
|
|
}
|
|
|
|
do {
|
|
if (buffPtr == buffLen) {
|
|
// Will run until we either run out of data, would block, or decode something
|
|
if (!demux()) {
|
|
running = false;
|
|
goto done;
|
|
}
|
|
}
|
|
if (buffPtr == buffLen) {
|
|
// Still nothing
|
|
goto done;
|
|
}
|
|
|
|
lastSample[AudioOutput::LEFTCHANNEL] = buff[buffPtr] & 0xffff;
|
|
lastSample[AudioOutput::RIGHTCHANNEL] = buff[buffPtr + 1] & 0xffff;
|
|
buffPtr += 2;
|
|
} while (running && output->ConsumeSample(lastSample));
|
|
|
|
done:
|
|
file->loop();
|
|
output->loop();
|
|
|
|
return running;
|
|
}
|
|
|
|
bool AudioGeneratorOpus::stop() {
|
|
if (od) {
|
|
free(od);
|
|
}
|
|
od = nullptr;
|
|
free(buff);
|
|
buff = nullptr;
|
|
running = false;
|
|
output->stop();
|
|
return true;
|
|
}
|
|
|
|
bool AudioGeneratorOpus::isRunning() {
|
|
return running;
|
|
}
|