failing an assertion but getting closer
This commit is contained in:
Steve Checkoway
@@ -13,42 +13,50 @@
|
||||
#include "RageUtil.h"
|
||||
#include "RageLog.h"
|
||||
#include <QuickTime/QuickTime.h>
|
||||
#include <stdlib.h>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
/* Ugh */
|
||||
using namespace QT;
|
||||
|
||||
const unsigned channels = 2;
|
||||
const unsigned samplesize = channels*16;
|
||||
const unsigned samples = 512;
|
||||
const unsigned samples = 4096;
|
||||
const unsigned freq = 44100;
|
||||
const unsigned buffersize = samples*samplesize/8;
|
||||
const unsigned SndCommand_qLength = 2;
|
||||
const unsigned initialQTSoundChannels = 8;
|
||||
|
||||
/* Oh boy! dealing with memory at inturupt time. What fun! */
|
||||
#pragma options align=power
|
||||
static volatile Uint32 fill_me = 0;
|
||||
static UInt8 *buffer[2];
|
||||
static CmpSoundHeader header;
|
||||
struct channelInfo {
|
||||
RageSound *snd;
|
||||
bool stopping;
|
||||
int flush_pos;
|
||||
int last_pos;
|
||||
int got;
|
||||
Uint64 start_time;
|
||||
volatile Uint32 fill_me;
|
||||
SndChannelPtr channel;
|
||||
CmpSoundHeader header;
|
||||
Uint8 *buffer[2];
|
||||
channelInfo() { snd=NULL; channel=NULL; }
|
||||
void reset() { stopping=false; flush_pos=0; last_pos=0; start_time=0; fill_me=0; }
|
||||
};
|
||||
static queue<channelInfo *>free_channels;
|
||||
static vector<channelInfo *>playing_channels;
|
||||
static ComponentInstance soundClock;
|
||||
|
||||
|
||||
RageSound_QT::RageSound_QT() {
|
||||
#if 1
|
||||
RageException::ThrowNonfatal("Class not finished!");
|
||||
|
||||
/*SndCallBackUPP callback;
|
||||
callback = NewSndCallBackUPP(GetData);
|
||||
memset(&header, 0, sizeof(header));
|
||||
header.numChannels = channels;
|
||||
header.sampleSize = samplesize / channels;
|
||||
header.sampleRate = rate44khz; /* really 44.1kHz * /
|
||||
header.numFrames = samples;
|
||||
header.encode = cmpSH;
|
||||
#endif
|
||||
|
||||
buffer[0] = new Uint8[buffersize];
|
||||
buffer[1] = new Uint8[buffersize];
|
||||
memset(buffer[0], 0, buffersize);
|
||||
memset(buffer[1], 0, buffersize);
|
||||
if (!CanPlayMultiChannels())
|
||||
RageException::ThrowNonfatal("Multiple Sound Manager channels not supported. Fallback");
|
||||
|
||||
channel = new SndChannel;
|
||||
channel->userInfo = reinterpret_cast<long>(this);
|
||||
channel->qLength = 2;
|
||||
channelInfo *info;
|
||||
SndCallBackUPP callback = NewSndCallBackUPP(GetData);
|
||||
OSErr err;
|
||||
|
||||
soundOutput = OpenDefaultComponent(kSoundOutputDeviceType, NULL);
|
||||
ASSERT(soundOutput != NULL);
|
||||
@@ -56,160 +64,287 @@ RageSound_QT::RageSound_QT() {
|
||||
TimeRecord record;
|
||||
SoundComponentGetInfo(soundOutput, NULL, siOutputLatency, &record);
|
||||
latency = record.value.lo / record.scale;
|
||||
latency += samples / freq; /* double buffer * /
|
||||
|
||||
OSErr err = SndNewChannel(&channel, sampledSynth, initStereo, callback);
|
||||
playing_channels.reserve(initialQTSoundChannels);
|
||||
|
||||
if (err != noErr) {
|
||||
delete channel;
|
||||
channel = NULL;
|
||||
RageException::ThrowNonfatal("Unable to create audio channel");
|
||||
for (unsigned i=0; i<initialQTSoundChannels; ++i) {
|
||||
info = new channelInfo;
|
||||
|
||||
info->buffer[0] = new Uint8[buffersize];
|
||||
info->buffer[1] = new Uint8[buffersize];
|
||||
info->channel = new SndChannel;
|
||||
info->channel->userInfo = reinterpret_cast<long>(this);
|
||||
info->channel->qLength = SndCommand_qLength;
|
||||
info->header.numChannels = channels;
|
||||
info->header.sampleSize = samplesize / channels;
|
||||
info->header.sampleRate = rate44khz;
|
||||
info->header.encode = cmpSH;
|
||||
|
||||
err = SndNewChannel(&info->channel, sampledSynth, initStereo, callback);
|
||||
if (err != noErr) {
|
||||
SAFE_DELETE(info->channel);
|
||||
RageException::ThrowNonfatal("Unable to create audio channel. THIS IS A BUG!");
|
||||
}
|
||||
free_channels.push(info);
|
||||
}
|
||||
|
||||
SndCommand cmd;
|
||||
cmd.cmd = clockComponentCmd;
|
||||
cmd.param1 = true;
|
||||
cmd.param2 = 0;
|
||||
err |= SndDoImmediate(channel, &cmd);
|
||||
err = SndDoImmediate(info->channel, &cmd);
|
||||
|
||||
cmd.cmd = getClockComponentCmd;
|
||||
cmd.param1 = 0;
|
||||
cmd.param2 = reinterpret_cast<long>(&clock);
|
||||
err |= SndDoImmediate(channel, &cmd);
|
||||
last_pos = 0;
|
||||
|
||||
cmd.cmd = callBackCmd;
|
||||
cmd.param2 = 0;
|
||||
err |= SndDoCommand(channel, &cmd, false);
|
||||
cmd.param2 = reinterpret_cast<long>(&soundClock);
|
||||
err |= SndDoImmediate(info->channel, &cmd);
|
||||
|
||||
if (err != noErr)
|
||||
RageException::ThrowNonfatal("Unable to create audio channel");*/
|
||||
RageException::ThrowNonfatal("Unable to create audio channel. THIS IS A BUG!");
|
||||
}
|
||||
|
||||
RageSound_QT::~RageSound_QT() {
|
||||
/*if (channel)
|
||||
SndDisposeChannel(channel, true);
|
||||
SAFE_DELETE_ARRAY(buffer[0]);
|
||||
SAFE_DELETE_ARRAY(buffer[1]);
|
||||
if (soundOutput)
|
||||
CloseComponent(soundOutput);*/
|
||||
}
|
||||
unsigned size = playing_channels.size();
|
||||
|
||||
void RageSound_QT::GetData(SndChannel *chan, SndCommand *cmd_passed) {
|
||||
/*while (!SOUNDMAN)
|
||||
SDL_Delay(10);
|
||||
LockMutex L(SOUNDMAN->lock);
|
||||
static bool gettingData=false;
|
||||
static int recursiveCalls = 0;
|
||||
if (gettingData) {
|
||||
LOG->Warn( "GetData() called recursively %D times.", ++recursiveCalls);
|
||||
if (recursiveCalls >=10)
|
||||
RageException::Throw("GetData() called recursively too many times.");
|
||||
} else
|
||||
recursiveCalls = 0;
|
||||
gettingData = true;
|
||||
static SoundMixBuffer mix;
|
||||
RageSound_QT *P = reinterpret_cast<RageSound_QT *>(chan->userInfo);
|
||||
|
||||
fill_me = cmd_passed->param2;
|
||||
UInt32 play_me = !fill_me;
|
||||
|
||||
if (!P->last_pos){
|
||||
TimeRecord tr;
|
||||
ClockGetTime(P->clock, &tr);
|
||||
UInt64 temp = tr.value.hi;
|
||||
temp <<= 32;
|
||||
temp |= tr.value.lo;
|
||||
double d = static_cast<double>(temp)/tr.scale*freq;
|
||||
temp = static_cast<UInt64>(d);
|
||||
P->last_pos = static_cast<UInt32>(temp % 0x00000000FFFFFFFFLL);
|
||||
} else
|
||||
P->last_pos += samples;
|
||||
|
||||
/* Swap buffers * /
|
||||
header.samplePtr = reinterpret_cast<Ptr>(buffer[play_me]);
|
||||
SndCommand cmd;
|
||||
cmd.cmd = bufferCmd;
|
||||
cmd.param1 = 0;
|
||||
cmd.param2 = reinterpret_cast<long>(&header);
|
||||
SndDoCommand(chan, &cmd, 0);
|
||||
|
||||
/* Clear the fill buffer * /
|
||||
memset(buffer[fill_me], 0, buffersize);
|
||||
|
||||
for (unsigned i=0; i<P->sounds.size(); ++i) {
|
||||
if (P->sounds[i]->stopping)
|
||||
continue;
|
||||
|
||||
unsigned got = P->sounds[i]->snd->GetPCM(reinterpret_cast<char *>(buffer[fill_me]), buffersize, P->last_pos);
|
||||
mix.write(reinterpret_cast<SInt16 *>(buffer[fill_me]), got / 2);
|
||||
if (got < buffersize) {
|
||||
P->sounds[i]->stopping = true;
|
||||
P->sounds[i]->flush_pos = P->last_pos + (got * 8 / samplesize);
|
||||
}
|
||||
for (unsigned i=0; i<size; ++i) {
|
||||
channelInfo *info = playing_channels.back();
|
||||
|
||||
if (info->channel)
|
||||
SndDisposeChannel(info->channel, true);
|
||||
SAFE_DELETE_ARRAY(info->buffer[0]);
|
||||
SAFE_DELETE_ARRAY(info->buffer[1]);
|
||||
playing_channels.pop_back();
|
||||
}
|
||||
|
||||
mix.read(reinterpret_cast<SInt16 *>(buffer[fill_me]));
|
||||
while (!free_channels.empty()) {
|
||||
channelInfo *info = free_channels.front();
|
||||
|
||||
cmd.cmd = callBackCmd;
|
||||
cmd.param2 = play_me;
|
||||
SndDoCommand(chan, &cmd, 0);
|
||||
gettingData=false;*/
|
||||
if (info->channel)
|
||||
SndDisposeChannel(info->channel, true);
|
||||
SAFE_DELETE_ARRAY(info->buffer[0]);
|
||||
SAFE_DELETE_ARRAY(info->buffer[1]);
|
||||
free_channels.pop();
|
||||
}
|
||||
|
||||
if (soundOutput)
|
||||
CloseComponent(soundOutput);
|
||||
if (soundClock)
|
||||
CloseComponent(soundClock);
|
||||
}
|
||||
|
||||
void RageSound_QT::GetData(SndChannelPtr chan, SndCommand *cmd_passed) {
|
||||
LockMutex L(SOUNDMAN->lock);
|
||||
|
||||
channelInfo *info = reinterpret_cast<channelInfo *>(chan->userInfo);
|
||||
ASSERT(info);
|
||||
ASSERT(chan == info->channel);
|
||||
SndCommand cmd;
|
||||
Uint32 play_me;
|
||||
OSErr err;
|
||||
int got;
|
||||
|
||||
if (cmd_passed) {
|
||||
info->fill_me = cmd_passed->param2;
|
||||
play_me = !info->fill_me;
|
||||
info->header.samplePtr = reinterpret_cast<Ptr>(info->buffer[play_me]);
|
||||
info->header.numFrames = info->got;
|
||||
cmd.cmd = bufferCmd;
|
||||
cmd.param1 = 0;
|
||||
cmd.param2 = reinterpret_cast<long>(&info->header);
|
||||
err = SndDoCommand(chan, &cmd, false);
|
||||
if (err != noErr)
|
||||
goto bail;
|
||||
}
|
||||
|
||||
if (info->stopping)
|
||||
return;
|
||||
|
||||
memset(info->buffer[info->fill_me], 0, buffersize);
|
||||
if (!info->last_pos) {
|
||||
TimeRecord tr;
|
||||
ClockGetTime(soundClock, &tr);
|
||||
info->start_time = tr.value.hi;
|
||||
info->start_time <<= 32;
|
||||
info->start_time |= tr.value.lo;
|
||||
}
|
||||
|
||||
got = info->snd->GetPCM(reinterpret_cast<char *>(info->buffer[info->fill_me]), buffersize, info->last_pos);
|
||||
if (static_cast<unsigned>(got) < buffersize) {
|
||||
info->stopping = true;
|
||||
info->flush_pos = info->last_pos + (got * 8 / samplesize);
|
||||
}
|
||||
info->got = got * 8 / samplesize; /* got / (samplesize / 8) */
|
||||
info->last_pos += samples;
|
||||
|
||||
if (cmd_passed) {
|
||||
cmd.cmd = callBackCmd;
|
||||
cmd.param2 = play_me;
|
||||
err = SndDoCommand(chan, &cmd, false);
|
||||
if (err != noErr)
|
||||
goto bail;
|
||||
}
|
||||
return;
|
||||
|
||||
bail:
|
||||
RageException::Throw("SndDoCommand failed with error %d", err);
|
||||
}
|
||||
|
||||
void RageSound_QT::StartMixing(RageSound *snd) {
|
||||
/*sound *s = new sound;
|
||||
s->snd = snd;
|
||||
|
||||
LockMutex L(SOUNDMAN->lock);
|
||||
sounds.push_back(s);
|
||||
LOG->Trace("There are %D sounds playing", sounds.size());*/
|
||||
SndCommand cmd;
|
||||
channelInfo *info;
|
||||
|
||||
if (free_channels.size()) {
|
||||
info = free_channels.front();
|
||||
free_channels.pop();
|
||||
} else { /* No free audio channels, create another */
|
||||
LOG->Warn("Out of audio channels, creating channel number %D", playing_channels.size()+1);
|
||||
info = new channelInfo;
|
||||
|
||||
memset(&info->header, 0, sizeof(&info->header));
|
||||
info->header.numChannels = channels;
|
||||
info->header.sampleSize = samplesize / channels;
|
||||
info->header.sampleRate = rate44khz; /* really 44.1kHz */
|
||||
info->header.numFrames = samples;
|
||||
info->header.encode = cmpSH;
|
||||
|
||||
info->buffer[0] = new Uint8[buffersize];
|
||||
info->buffer[1] = new Uint8[buffersize];
|
||||
memset(info->buffer[0], 0, buffersize);
|
||||
memset(info->buffer[1], 0, buffersize);
|
||||
|
||||
info->channel = new SndChannel;
|
||||
info->channel->userInfo = reinterpret_cast<long>(info);
|
||||
info->channel->qLength = SndCommand_qLength;
|
||||
OSErr err = SndNewChannel(&(info->channel), sampledSynth, initStereo, NewSndCallBackUPP(GetData));
|
||||
|
||||
if (err != noErr) {
|
||||
SAFE_DELETE(info->channel);
|
||||
RageException::Throw("Unable to create audio channel. THIS IS A BUG.");
|
||||
}
|
||||
}
|
||||
|
||||
info->reset();
|
||||
info->snd = snd;
|
||||
/* Fill the first buffer with data */
|
||||
playing_channels.push_back(info);
|
||||
GetData(info->channel, NULL);
|
||||
cmd.cmd = callBackCmd;
|
||||
cmd.param1 = 0;
|
||||
cmd.param2 = !info->fill_me;
|
||||
SndDoCommand(info->channel, &cmd, 0); /* command queue is empty */
|
||||
}
|
||||
|
||||
void RageSound_QT::StopMixing(RageSound *snd) {
|
||||
/*LockMutex L(SOUNDMAN->lock);
|
||||
LockMutex L(SOUNDMAN->lock);
|
||||
LOG->Trace("StopMixing(). Stopping sound 0x%X", reinterpret_cast<long>(snd));
|
||||
/* Find the sound. */
|
||||
int size = playing_channels.size();
|
||||
int i;
|
||||
channelInfo *info;
|
||||
|
||||
/* Find the sound. * /
|
||||
unsigned i;
|
||||
for(i = 0; i < sounds.size(); ++i)
|
||||
if(sounds[i]->snd == snd) break;
|
||||
if(i == sounds.size())
|
||||
{
|
||||
LOG->Trace("not stopping a sound because it's not playing");
|
||||
for (i=0; i<=size; ++i)
|
||||
if ((info=playing_channels[i])->snd == snd)
|
||||
break;
|
||||
if (i==size) {
|
||||
LOG->Trace("Not stopping a sound because it's not playing.");
|
||||
return;
|
||||
}
|
||||
|
||||
delete sounds[i];
|
||||
sounds.erase(sounds.begin()+i, sounds.begin()+i+1);
|
||||
LOG->Trace("There are %D sounds playing", sounds.size());*/
|
||||
playing_channels.erase(playing_channels.begin()+i);
|
||||
SndCommand cmd;
|
||||
cmd.cmd = flushCmd;
|
||||
cmd.param1 = 0;
|
||||
cmd.param2 = 0;
|
||||
LOG->Trace("Flushing channel with song %X", reinterpret_cast<long>(snd));
|
||||
SndDoImmediate(info->channel, &cmd);
|
||||
cmd.cmd = quietCmd;
|
||||
SndDoImmediate(info->channel, &cmd);
|
||||
free_channels.push(info);
|
||||
}
|
||||
|
||||
void RageSound_QT::Update(float delta) {
|
||||
#pragma unused (delta)
|
||||
/*LockMutex L(SOUNDMAN->lock);
|
||||
LockMutex L(SOUNDMAN->lock);
|
||||
|
||||
vector<sound *>snds = sounds;
|
||||
for (unsigned i = 0; i < snds.size(); ++i) {
|
||||
if (!sounds[i]->stopping)
|
||||
vector<channelInfo *> playing = playing_channels;
|
||||
int size = playing.size();
|
||||
for (int i=0; i<size; ++i) {
|
||||
channelInfo *info = playing[i];
|
||||
if (info->stopping != 0)
|
||||
continue;
|
||||
if (GetPosition(snds[i]->snd) < sounds[i]->flush_pos)
|
||||
if (GetPosition(info->snd) < info->flush_pos)
|
||||
continue;
|
||||
snds[i]->snd->StopPlaying();
|
||||
}*/
|
||||
info->snd->StopPlaying();
|
||||
}
|
||||
}
|
||||
|
||||
int RageSound_QT::GetPosition(const RageSound *snd) const {
|
||||
#pragma unused (snd)
|
||||
/*TimeRecord tr;
|
||||
ClockGetTime(clock, &tr);
|
||||
UInt64 temp = tr.value.hi;
|
||||
temp <<= 32;
|
||||
temp |= tr.value.lo;
|
||||
double d = static_cast<double>(temp)/tr.scale*freq;
|
||||
temp = static_cast<UInt64>(d);
|
||||
return static_cast<UInt32>(temp % 0x00000000FFFFFFFFLL);*/
|
||||
LockMutex L(SOUNDMAN->lock);
|
||||
TimeRecord tr;
|
||||
ClockGetTime(soundClock, &tr);
|
||||
UInt64 time = tr.value.hi;
|
||||
time <<= 32;
|
||||
time |= tr.value.lo;
|
||||
|
||||
/* Find the info */
|
||||
int size = playing_channels.size();
|
||||
int i;
|
||||
channelInfo *info;
|
||||
for (i=0; i<size; ++i)
|
||||
if ((info = playing_channels[i])->snd == snd)
|
||||
break;
|
||||
if (i == size)
|
||||
RageException::Throw("Can't get the position of a sound that isn't playing");
|
||||
|
||||
LOG->Trace("GetPosition() sound 0x%X", reinterpret_cast<long>(snd));
|
||||
|
||||
time -= info->start_time; /* Now time contains the total time the sound was played. */
|
||||
time = time * freq / tr.scale; /* Now time contains the number of samples played. */
|
||||
return static_cast<int>(time % 0x00000000FFFFFFFFLL);
|
||||
}
|
||||
|
||||
float RageSound_QT::GetPlayLatency() const {
|
||||
//return latency;
|
||||
/* Pascal code from SoundManager docs.
|
||||
|
||||
FUNCTION MyCanPlayMultiChannels: Boolean;
|
||||
VAR
|
||||
myResponse: LongInt;
|
||||
myResult: Boolean;
|
||||
myErr: OSErr;
|
||||
myVersion: NumVersion;
|
||||
BEGIN
|
||||
myResult := FALSE;
|
||||
myVersion := SndSoundManagerVersion;
|
||||
myErr := Gestalt(gestaltSoundAttr, myResponse);
|
||||
IF myVersion.majorRev >= 3 THEN
|
||||
IF (myErr = noErr) AND (BTst(myResponse, gestaltMultiChannels)) THEN
|
||||
myResult := TRUE
|
||||
ELSE
|
||||
BEGIN
|
||||
myErr := Gestalt(gestaltHardwareAttr, myResponse);
|
||||
IF (myErr = noErr) AND (BTst(myResponse, gestaltHasASC)) THEN
|
||||
myResult := TRUE
|
||||
END;
|
||||
MyCanPlayMultiChannels := myResult;
|
||||
END;
|
||||
*/
|
||||
|
||||
bool RageSound_QT::CanPlayMultiChannels(){
|
||||
register long response;
|
||||
register OSErr err;
|
||||
NumVersion version;
|
||||
register bool result;
|
||||
|
||||
result = false;
|
||||
version = SndSoundManagerVersion();
|
||||
err = Gestalt(gestaltSoundAttr, &response);
|
||||
if (version.majorRev >= 3){
|
||||
if((err == noErr) && (response & gestaltMultiChannels == gestaltMultiChannels))
|
||||
result = true;
|
||||
} else {
|
||||
err = Gestalt(gestaltHardwareAttr, &response);
|
||||
if ((err == noErr) && (response & gestaltHasASC == gestaltHasASC))
|
||||
result = true;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -25,26 +25,17 @@ namespace QT {
|
||||
|
||||
class RageSound_QT: public RageSoundDriver {
|
||||
private:
|
||||
struct sound {
|
||||
RageSound *snd;
|
||||
bool stopping;
|
||||
int flush_pos;
|
||||
sound() { snd=NULL; stopping=false; flush_pos=0; }
|
||||
};
|
||||
|
||||
vector<sound *> sounds;
|
||||
QT::ComponentInstance clock;
|
||||
QT::ComponentInstance soundOutput;
|
||||
QT::SndChannelPtr channel;
|
||||
int last_pos;
|
||||
float latency;
|
||||
|
||||
bool CanPlayMultiChannels();
|
||||
|
||||
protected:
|
||||
virtual void StartMixing(RageSound *snd);
|
||||
virtual void StopMixing(RageSound *snd);
|
||||
virtual int GetPosition(const RageSound *snd) const;
|
||||
virtual void Update (float delta);
|
||||
virtual float GetPlayLatency() const;
|
||||
virtual float GetPlayLatency() const { return latency; }
|
||||
|
||||
public:
|
||||
RageSound_QT();
|
||||
|
||||
Reference in New Issue
Block a user