mirror of
https://github.com/jorio/Pomme.git
synced 2024-06-05 03:29:33 +00:00
634 lines
15 KiB
C++
634 lines
15 KiB
C++
#include "Pomme.h"
|
|
#include "PommeFiles.h"
|
|
#include "cmixer.h"
|
|
#include "PommeSound.h"
|
|
#include "Utilities/bigendianstreams.h"
|
|
#include "Utilities/IEEEExtended.h"
|
|
#include "Utilities/memstream.h"
|
|
|
|
#include <thread>
|
|
#include <chrono>
|
|
#include <iostream>
|
|
#include <cassert>
|
|
#include <cstring>
|
|
|
|
#define LOG POMME_GENLOG(POMME_DEBUG_SOUND, "SOUN")
|
|
#define LOG_NOPREFIX POMME_GENLOG_NOPREFIX(POMME_DEBUG_SOUND)
|
|
|
|
static struct ChannelImpl* headChan = nullptr;
|
|
static int nManagedChans = 0;
|
|
static double midiNoteFrequencies[128];
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Internal channel info
|
|
|
|
enum ApplyParametersMask
|
|
{
|
|
kApplyParameters_PanAndGain = 1 << 0,
|
|
kApplyParameters_Pitch = 1 << 1,
|
|
kApplyParameters_Loop = 1 << 2,
|
|
kApplyParameters_Interpolation = 1 << 3,
|
|
kApplyParameters_All = 0xFFFFFFFF
|
|
};
|
|
|
|
struct ChannelImpl
|
|
{
|
|
private:
|
|
ChannelImpl* prev;
|
|
ChannelImpl* next;
|
|
|
|
public:
|
|
// Pointer to application-facing interface
|
|
SndChannelPtr macChannel;
|
|
|
|
bool macChannelStructAllocatedByPomme;
|
|
cmixer::WavStream source;
|
|
|
|
// Parameters coming from Mac sound commands, passed back to cmixer source
|
|
double pan;
|
|
double gain;
|
|
Byte baseNote;
|
|
Byte playbackNote;
|
|
double pitchMult;
|
|
bool loop;
|
|
bool interpolate;
|
|
|
|
bool temporaryPause = false;
|
|
|
|
ChannelImpl(SndChannelPtr _macChannel, bool transferMacChannelOwnership)
|
|
: macChannel(_macChannel)
|
|
, macChannelStructAllocatedByPomme(transferMacChannelOwnership)
|
|
, source()
|
|
, pan(0.0)
|
|
, gain(1.0)
|
|
, baseNote(kMiddleC)
|
|
, playbackNote(kMiddleC)
|
|
, pitchMult(1.0)
|
|
, loop(false)
|
|
, interpolate(false)
|
|
{
|
|
macChannel->channelImpl = (Ptr) this;
|
|
|
|
Link(); // Link chan into our list of managed chans
|
|
}
|
|
|
|
~ChannelImpl()
|
|
{
|
|
Unlink();
|
|
|
|
macChannel->channelImpl = nullptr;
|
|
|
|
if (macChannelStructAllocatedByPomme)
|
|
{
|
|
delete macChannel;
|
|
}
|
|
}
|
|
|
|
void Recycle()
|
|
{
|
|
source.Clear();
|
|
}
|
|
|
|
void SetInitializationParameters(long initBits)
|
|
{
|
|
interpolate = !(initBits & initNoInterp);
|
|
source.SetInterpolation(interpolate);
|
|
}
|
|
|
|
void ApplyParametersToSource(uint32_t mask, bool evenIfInactive = false)
|
|
{
|
|
if (!evenIfInactive && !source.active)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Pitch
|
|
if (mask & kApplyParameters_Pitch)
|
|
{
|
|
double baseFreq = midiNoteFrequencies[baseNote];
|
|
double playbackFreq = midiNoteFrequencies[playbackNote];
|
|
source.SetPitch(pitchMult * playbackFreq / baseFreq);
|
|
}
|
|
|
|
// Pan and gain
|
|
if (mask & kApplyParameters_PanAndGain)
|
|
{
|
|
source.SetPan(pan);
|
|
source.SetGain(gain);
|
|
}
|
|
|
|
// Interpolation
|
|
if (mask & kApplyParameters_Interpolation)
|
|
{
|
|
source.SetInterpolation(interpolate);
|
|
}
|
|
|
|
// Interpolation
|
|
if (mask & kApplyParameters_Loop)
|
|
{
|
|
source.SetLoop(loop);
|
|
}
|
|
}
|
|
|
|
ChannelImpl* GetPrev() const
|
|
{
|
|
return prev;
|
|
}
|
|
|
|
ChannelImpl* GetNext() const
|
|
{
|
|
return next;
|
|
}
|
|
|
|
void SetPrev(ChannelImpl* newPrev)
|
|
{
|
|
prev = newPrev;
|
|
}
|
|
|
|
void SetNext(ChannelImpl* newNext)
|
|
{
|
|
next = newNext;
|
|
macChannel->nextChan = newNext ? newNext->macChannel : nullptr;
|
|
}
|
|
|
|
void Link()
|
|
{
|
|
if (!headChan)
|
|
{
|
|
SetNext(nullptr);
|
|
}
|
|
else
|
|
{
|
|
assert(nullptr == headChan->GetPrev());
|
|
headChan->SetPrev(this);
|
|
SetNext(headChan);
|
|
}
|
|
|
|
headChan = this;
|
|
SetPrev(nullptr);
|
|
|
|
nManagedChans++;
|
|
}
|
|
|
|
void Unlink()
|
|
{
|
|
if (headChan == this)
|
|
{
|
|
headChan = GetNext();
|
|
}
|
|
|
|
if (nullptr != GetPrev())
|
|
{
|
|
GetPrev()->SetNext(GetNext());
|
|
}
|
|
|
|
if (nullptr != GetNext())
|
|
{
|
|
GetNext()->SetPrev(GetPrev());
|
|
}
|
|
|
|
SetPrev(nullptr);
|
|
SetNext(nullptr);
|
|
|
|
nManagedChans--;
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Internal utilities
|
|
|
|
static inline ChannelImpl& GetChannelImpl(SndChannelPtr chan)
|
|
{
|
|
return *(ChannelImpl*) chan->channelImpl;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// MIDI note utilities
|
|
|
|
// Note: these names are according to IM:S:2-43.
|
|
// These names won't match real-world names.
|
|
// E.g. for note 67 (A 440Hz), this will return "A6", whereas the real-world
|
|
// convention for that note is "A4".
|
|
static std::string GetMidiNoteName(int i)
|
|
{
|
|
static const char* gamme[12] = {"A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"};
|
|
|
|
int octave = 1 + (i + 3) / 12;
|
|
int semitonesFromA = (i + 3) % 12;
|
|
|
|
std::stringstream ss;
|
|
ss << gamme[semitonesFromA] << octave;
|
|
return ss.str();
|
|
}
|
|
|
|
static void InitMidiFrequencyTable()
|
|
{
|
|
// powers of twelfth root of two
|
|
double gamme[12];
|
|
gamme[0] = 1.0;
|
|
for (int i = 1; i < 12; i++)
|
|
{
|
|
gamme[i] = gamme[i - 1] * 1.059630943592952646;
|
|
}
|
|
|
|
for (int i = 0; i < 128; i++)
|
|
{
|
|
int octave = 1 + (i + 3) / 12; // A440 and middle C are in octave 7
|
|
int semitone = (i + 3) % 12; // halfsteps up from A in current octave
|
|
if (octave < 7)
|
|
midiNoteFrequencies[i] = gamme[semitone] * 440.0 / (1 << (7 - octave)); // 440/(2**octaveDiff)
|
|
else
|
|
midiNoteFrequencies[i] = gamme[semitone] * 440.0 * (1 << (octave - 7)); // 440*(2**octaveDiff)
|
|
//LOG << i << "\t" << GetMidiNoteName(i) << "\t" << midiNoteFrequencies[i] << "\n";
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sound Manager
|
|
|
|
OSErr GetDefaultOutputVolume(long* stereoLevel)
|
|
{
|
|
unsigned short g = (unsigned short) (cmixer::GetMasterGain() * 256.0);
|
|
*stereoLevel = (g << 16) | g;
|
|
return noErr;
|
|
}
|
|
|
|
// See IM:S:2-139, "Controlling Volume Levels".
|
|
OSErr SetDefaultOutputVolume(long stereoLevel)
|
|
{
|
|
unsigned short left = 0xFFFF & stereoLevel;
|
|
unsigned short right = 0xFFFF & (stereoLevel >> 16);
|
|
if (right != left)
|
|
TODOMINOR2("setting different volumes for left & right is not implemented");
|
|
LOG << left / 256.0 << "\n";
|
|
cmixer::SetMasterGain(left / 256.0);
|
|
return noErr;
|
|
}
|
|
|
|
// IM:S:2-127
|
|
OSErr SndNewChannel(SndChannelPtr* macChanPtr, short synth, long init, SndCallBackProcPtr userRoutine)
|
|
{
|
|
if (synth != sampledSynth)
|
|
{
|
|
TODO2("unimplemented synth type " << sampledSynth);
|
|
return unimpErr;
|
|
}
|
|
|
|
//---------------------------
|
|
// Allocate Mac channel record if needed
|
|
|
|
bool transferMacChannelOwnership = false;
|
|
|
|
if (!*macChanPtr)
|
|
{
|
|
*macChanPtr = new SndChannel;
|
|
(**macChanPtr) = {};
|
|
transferMacChannelOwnership = true;
|
|
}
|
|
|
|
//---------------------------
|
|
// Set up
|
|
|
|
(**macChanPtr).callBack = userRoutine;
|
|
auto channelImpl = new ChannelImpl(*macChanPtr, transferMacChannelOwnership);
|
|
|
|
channelImpl->SetInitializationParameters(init);
|
|
|
|
//---------------------------
|
|
// Done
|
|
|
|
LOG << "New channel created, init = $" << std::hex << init << std::dec << ", total managed channels = " << nManagedChans << "\n";
|
|
|
|
return noErr;
|
|
}
|
|
|
|
// IM:S:2-129
|
|
OSErr SndDisposeChannel(SndChannelPtr macChanPtr, Boolean quietNow)
|
|
{
|
|
if (!quietNow)
|
|
{
|
|
TODO2("SndDisposeChannel: quietNow == false is not implemented");
|
|
}
|
|
delete &GetChannelImpl(macChanPtr);
|
|
return noErr;
|
|
}
|
|
|
|
OSErr SndChannelStatus(SndChannelPtr chan, short theLength, SCStatusPtr theStatus)
|
|
{
|
|
*theStatus = {};
|
|
|
|
auto& source = GetChannelImpl(chan).source;
|
|
|
|
theStatus->scChannelPaused = source.GetState() == cmixer::CM_STATE_PAUSED;
|
|
theStatus->scChannelBusy = source.GetState() == cmixer::CM_STATE_PLAYING;
|
|
|
|
return noErr;
|
|
}
|
|
|
|
// Install a sampled sound as a voice in a channel.
|
|
static void InstallSoundInChannel(SndChannelPtr chan, const Ptr sampledSoundHeader)
|
|
{
|
|
//---------------------------------
|
|
// Get internal channel
|
|
|
|
|
|
auto& impl = GetChannelImpl(chan);
|
|
impl.Recycle();
|
|
|
|
//---------------------------------
|
|
// Distill sound info
|
|
|
|
Pomme::Sound::SampledSoundInfo info;
|
|
GetSoundInfo(sampledSoundHeader, info);
|
|
|
|
//---------------------------------
|
|
// Set cmixer source data
|
|
|
|
auto spanIn = std::span(info.dataStart, info.compressedLength);
|
|
|
|
if (info.isCompressed)
|
|
{
|
|
auto spanOut = impl.source.GetBuffer(info.decompressedLength);
|
|
|
|
std::unique_ptr<Pomme::Sound::Codec> codec = Pomme::Sound::GetCodec(info.compressionType);
|
|
codec->Decode(info.nChannels, spanIn, spanOut);
|
|
impl.source.Init(info.sampleRate, 16, info.nChannels, false, spanOut);
|
|
}
|
|
else
|
|
{
|
|
impl.source.Init(info.sampleRate, info.codecBitDepth, info.nChannels, info.bigEndian, spanIn);
|
|
}
|
|
|
|
//---------------------------------
|
|
// Base note
|
|
|
|
impl.baseNote = info.baseNote;
|
|
|
|
//---------------------------------
|
|
// Loop
|
|
|
|
if (info.loopEnd - info.loopStart >= 2)
|
|
{
|
|
impl.source.SetLoop(true);
|
|
|
|
if (info.loopStart != 0)
|
|
TODO2("Warning: looping on a portion of the snd isn't supported yet");
|
|
}
|
|
|
|
//---------------------------------
|
|
// Pass Mac channel parameters to cmixer source.
|
|
|
|
// The loop param is a special case -- we're detecting it automatically according
|
|
// to the sound header. If your application needs to force set the loop, it must
|
|
// issue pommeSetLoopCmd *after* bufferCmd/soundCmd.
|
|
impl.ApplyParametersToSource(kApplyParameters_All & ~kApplyParameters_Loop, true);
|
|
|
|
// Override systemwide audio pause.
|
|
impl.temporaryPause = false;
|
|
|
|
// Get it going!
|
|
impl.source.Play();
|
|
}
|
|
|
|
OSErr SndDoImmediate(SndChannelPtr chan, const SndCommand* cmd)
|
|
{
|
|
auto& impl = GetChannelImpl(chan);
|
|
|
|
// Discard the high bit of the command (it indicates whether an 'snd ' resource has associated data).
|
|
switch (cmd->cmd & 0x7FFF)
|
|
{
|
|
case nullCmd:
|
|
break;
|
|
|
|
case flushCmd:
|
|
// flushCmd is a no-op for now because we don't support queuing commands--
|
|
// all commands are executed immediately in the current implementation.
|
|
break;
|
|
|
|
case quietCmd:
|
|
impl.source.Stop();
|
|
break;
|
|
|
|
case bufferCmd:
|
|
case soundCmd:
|
|
InstallSoundInChannel(chan, cmd->ptr);
|
|
break;
|
|
|
|
case ampCmd:
|
|
impl.gain = cmd->param1 / 256.0;
|
|
impl.ApplyParametersToSource(kApplyParameters_PanAndGain);
|
|
break;
|
|
|
|
case volumeCmd:
|
|
{
|
|
uint16_t lvol = (cmd->param2 ) & 0xFFFF;
|
|
uint16_t rvol = (cmd->param2 >> 16) & 0xFFFF;
|
|
uint32_t volsum = lvol + rvol;
|
|
|
|
double pan = 0;
|
|
if (volsum != 0) // don't divide by zero
|
|
{
|
|
pan = (double)rvol / volsum;
|
|
pan = 2*pan - 1; // Transpose pan from [0...1] to [-1...+1]
|
|
}
|
|
|
|
impl.pan = pan;
|
|
impl.gain = std::max(lvol, rvol) / 256.0;
|
|
|
|
impl.ApplyParametersToSource(kApplyParameters_PanAndGain);
|
|
break;
|
|
}
|
|
|
|
case freqCmd:
|
|
LOG << "freqCmd " << cmd->param2 << " " << GetMidiNoteName(cmd->param2) << " " << midiNoteFrequencies[cmd->param2] << "\n";
|
|
impl.playbackNote = Byte(cmd->param2);
|
|
impl.ApplyParametersToSource(kApplyParameters_Pitch);
|
|
break;
|
|
|
|
case rateCmd:
|
|
// IM:S says it's a fixed-point multiplier of 22KHz, but Nanosaur uses rate "1" everywhere,
|
|
// even for sounds sampled at 44Khz, so I'm treating it as just a pitch multiplier.
|
|
impl.pitchMult = cmd->param2 / 65536.0;
|
|
impl.ApplyParametersToSource(kApplyParameters_Pitch);
|
|
break;
|
|
|
|
case rateMultiplierCmd:
|
|
impl.pitchMult = cmd->param2 / 65536.0;
|
|
impl.ApplyParametersToSource(kApplyParameters_Pitch);
|
|
break;
|
|
|
|
case reInitCmd:
|
|
impl.SetInitializationParameters(cmd->param2);
|
|
break;
|
|
|
|
case pommeSetLoopCmd:
|
|
impl.loop = cmd->param1;
|
|
impl.ApplyParametersToSource(kApplyParameters_Loop);
|
|
break;
|
|
|
|
default:
|
|
TODOMINOR2(cmd->cmd << "(" << cmd->param1 << "," << cmd->param2 << ")");
|
|
}
|
|
|
|
return noErr;
|
|
}
|
|
|
|
// Not implemented yet, but you can probably use SndDoImmediateInstead.
|
|
OSErr SndDoCommand(SndChannelPtr chan, const SndCommand* cmd, Boolean noWait)
|
|
{
|
|
TODOMINOR2("SndDoCommand isn't implemented yet, but you can probably use SndDoImmediate instead.");
|
|
return noErr;
|
|
}
|
|
|
|
OSErr SndStartFilePlay(
|
|
SndChannelPtr chan,
|
|
short fRefNum,
|
|
short resNum,
|
|
long bufferSize,
|
|
Ptr theBuffer,
|
|
/*AudioSelectionPtr*/ void* theSelection,
|
|
FilePlayCompletionUPP theCompletion,
|
|
Boolean async)
|
|
{
|
|
if (resNum != 0)
|
|
{
|
|
TODO2("playing snd resource not implemented yet, resource " << resNum);
|
|
return unimpErr;
|
|
}
|
|
|
|
if (!chan)
|
|
{
|
|
if (async) // async requires passing in a channel
|
|
return badChannel;
|
|
TODO2("nullptr chan for sync play, check IM:S:1-37");
|
|
return unimpErr;
|
|
}
|
|
|
|
if (theSelection)
|
|
{
|
|
TODO2("audio selection record not implemented");
|
|
return unimpErr;
|
|
}
|
|
|
|
auto& impl = GetChannelImpl(chan);
|
|
impl.Recycle();
|
|
|
|
auto& fileStream = Pomme::Files::GetStream(fRefNum);
|
|
|
|
// Rewind -- the file might've been fully played already and we might just be trying to loop it
|
|
fileStream.seekg(0, std::ios::beg);
|
|
|
|
// Get metadata from AIFF
|
|
Pomme::Sound::SampledSoundInfo info = {};
|
|
std::streampos sampledSoundDataOffset = GetSoundInfoFromAIFF(fileStream, info);
|
|
|
|
// Have file stream seek to start of SSND sampled sound data
|
|
if (sampledSoundDataOffset <= 0)
|
|
throw std::runtime_error("dubious offset to SSND data");
|
|
fileStream.seekg(sampledSoundDataOffset, std::ios::beg);
|
|
|
|
// Read samples into WavStream
|
|
if (!info.isCompressed)
|
|
{
|
|
// Raw big-endian PCM -- just init the WavStream without decoding
|
|
auto spanOut = impl.source.GetBuffer(info.decompressedLength);
|
|
fileStream.read(spanOut.data(), info.decompressedLength);
|
|
impl.source.Init(info.sampleRate, info.codecBitDepth, info.nChannels, info.bigEndian, spanOut);
|
|
}
|
|
else
|
|
{
|
|
auto ssnd = std::vector<char>(info.compressedLength);
|
|
fileStream.read(ssnd.data(), info.compressedLength);
|
|
auto codec = Pomme::Sound::GetCodec(info.compressionType);
|
|
auto spanIn = std::span(ssnd);
|
|
auto spanOut = impl.source.GetBuffer(info.decompressedLength);
|
|
codec->Decode(info.nChannels, spanIn, spanOut);
|
|
impl.source.Init(info.sampleRate, 16, info.nChannels, false, spanOut);
|
|
}
|
|
|
|
if (theCompletion)
|
|
{
|
|
impl.source.onComplete = [=]() { theCompletion(chan); };
|
|
}
|
|
|
|
impl.temporaryPause = false;
|
|
impl.source.Play();
|
|
|
|
if (!async)
|
|
{
|
|
while (impl.source.GetState() != cmixer::CM_STATE_STOPPED)
|
|
{
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
}
|
|
impl.Recycle();
|
|
return noErr;
|
|
}
|
|
|
|
return noErr;
|
|
}
|
|
|
|
OSErr SndPauseFilePlay(SndChannelPtr chan)
|
|
{
|
|
// TODO: check that chan is being used for play from disk
|
|
GetChannelImpl(chan).source.TogglePause();
|
|
return noErr;
|
|
}
|
|
|
|
OSErr SndStopFilePlay(SndChannelPtr chan, Boolean quietNow)
|
|
{
|
|
// TODO: check that chan is being used for play from disk
|
|
if (!quietNow)
|
|
TODO2("quietNow==false not supported yet, sound will be cut off immediately instead");
|
|
GetChannelImpl(chan).source.Stop();
|
|
return noErr;
|
|
}
|
|
|
|
NumVersion SndSoundManagerVersion()
|
|
{
|
|
NumVersion v = {};
|
|
v.majorRev = 3;
|
|
v.minorAndBugRev = 9;
|
|
v.stage = 0x80;
|
|
v.nonRelRev = 0;
|
|
return v;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Extension: pause/unpause channels that are currently playing
|
|
|
|
void Pomme_PauseAllChannels(Boolean pause)
|
|
{
|
|
for (auto* chan = headChan; chan; chan = chan->GetNext())
|
|
{
|
|
auto& source = chan->source;
|
|
if (pause && source.state == cmixer::CM_STATE_PLAYING && !chan->temporaryPause)
|
|
{
|
|
source.Pause();
|
|
chan->temporaryPause = true;
|
|
}
|
|
else if (!pause && source.state == cmixer::CM_STATE_PAUSED && chan->temporaryPause)
|
|
{
|
|
source.Play();
|
|
chan->temporaryPause = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Init Sound Manager
|
|
|
|
void Pomme::Sound::Init()
|
|
{
|
|
InitMidiFrequencyTable();
|
|
cmixer::InitWithSDL();
|
|
}
|
|
|
|
void Pomme::Sound::Shutdown()
|
|
{
|
|
cmixer::ShutdownWithSDL();
|
|
while (headChan)
|
|
{
|
|
SndDisposeChannel(headChan->macChannel, true);
|
|
}
|
|
}
|