[Scummvm-cvs-logs] CVS: residual/imuse imuse_script.cpp,NONE,1.1 imuse_sndmgr.cpp,NONE,1.1 imuse_sndmgr.h,NONE,1.1 imuse_track.cpp,NONE,1.1 imuse.cpp,1.2,1.3
Pawel Kolodziejski
aquadran at users.sourceforge.net
Sun Dec 26 05:44:02 CET 2004
- Previous message: [Scummvm-cvs-logs] CVS: residual main.cpp,1.35,1.36 sound.cpp,1.13,1.14 stdafx.h,1.5,1.6
- Next message: [Scummvm-cvs-logs] CVS: docs/docbook manual.html,1.14,1.15 manual.pdf,1.14,1.15 manual.txt,1.13,1.14 manual.xml,1.17,1.18
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Update of /cvsroot/scummvm/residual/imuse
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32254
Modified Files:
imuse.cpp
Added Files:
imuse_script.cpp imuse_sndmgr.cpp imuse_sndmgr.h
imuse_track.cpp
Log Message:
add more temporary imuse code
--- NEW FILE: imuse_script.cpp ---
// Residual - Virtual machine to run LucasArts' 3D adventure games
// Copyright (C) 2003-2004 The ScummVM-Residual Team (www.scummvm.org)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include "../stdafx.h"
#include "../bits.h"
#include "../debug.h"
#include "../timer.h"
#include "../mixer/mixer.h"
#include "../mixer/audiostream.h"
#include "imuse_sndmgr.h"
void Imuse::parseScriptCmds(int cmd, int b, int c, int d, int e, int f, int g, int h) {
int soundId = b;
int sub_cmd = c;
if (!cmd)
return;
switch (cmd) {
case 10: // ImuseStopAllSounds
stopAllSounds();
break;
case 12: // ImuseSetParam
switch (sub_cmd) {
case 0x400: // select group volume
selectVolumeGroup(soundId, d);
break;
case 0x500: // set priority
setPriority(soundId, d);
break;
case 0x600: // set volume
setVolume(soundId, d);
break;
case 0x700: // set pan
setPan(soundId, d);
break;
default:
warning("Imuse::doCommand SetParam DEFAULT command %d", sub_cmd);
break;
}
break;
case 14: // ImuseFadeParam
switch (sub_cmd) {
case 0x600: // set volume fading
if ((d != 0) && (e == 0))
setVolume(soundId, d);
else if ((d == 0) && (e == 0))
stopSound(soundId);
else
setFade(soundId, d, e);
break;
default:
warning("Imuse::doCommand FadeParam DEFAULT sub command %d", sub_cmd);
break;
}
break;
case 0x1000: // ImuseSetState
debug(5, "ImuseSetState (%d)", b);
setMusicState(b);
break;
case 0x1001: // ImuseSetSequence
debug(5, "ImuseSetSequence (%d)", b);
setMusicSequence(b);
break;
case 0x1002: // ImuseSetCuePoint
debug(5, "ImuseSetCuePoint (%d)", b);
break;
case 0x1003: // ImuseSetAttribute
debug(5, "ImuseSetAttribute (%d, %d)", b, c);
_attributes[b] = c;
break;
case 0x2000: // ImuseSetGroupSfxVolume
debug(5, "ImuseSetGroupSFXVolume (%d)", b);
// setGroupSfxVolume(b);
break;
case 0x2001: // ImuseSetGroupVoiceVolume
debug(5, "ImuseSetGroupVoiceVolume (%d)", b);
// setGroupVoiceVolume(b);
break;
case 0x2002: // ImuseSetGroupMusicVolume
debug(5, "ImuseSetGroupMusicVolume (%d)", b);
// setGroupMusicVolume(b);
break;
default:
error("Imuse::doCommand DEFAULT command %d", cmd);
}
}
void Imuse::flushTracks() {
debug(5, "flushTracks()");
for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
Track *track = _track[l];
if (track->used && track->readyToRemove) {
if (track->stream) {
if (!track->stream->endOfStream()) {
track->stream->finish();
}
if (track->stream->endOfStream()) {
_vm->_mixer->stopHandle(track->handle);
delete track->stream;
track->stream = NULL;
_sound->closeSound(track->soundHandle);
track->soundHandle = NULL;
track->used = false;
}
}
}
}
}
void Imuse::refreshScripts() {
debug(5, "refreshScripts()");
bool found = false;
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
found = true;
}
}
if (!found && (_curMusicSeq != 0)) {
debug(5, "refreshScripts() Start Sequence");
parseScriptCmds(0x1001, 0, 0, 0, 0, 0, 0, 0);
}
}
void Imuse::startVoice(const char *soundName, int soundId) {
debug(5, "startVoiceBundle(%s)", soundName);
startSound(soundId, soundName, IMUSE_VOLGRP_VOICE, NULL, 0, 127, 127);
}
void Imuse::startMusic(const char *soundName, int soundId, int hookId, int volume, int pan) {
debug(5, "startMusicBundle(%s)", soundName);
startSound(soundId, soundName, IMUSE_VOLGRP_MUSIC, NULL, hookId, volume, pan, 126);
}
void Imuse::startSfx(const char *soundName, int soundId, int priority) {
debug(5, "startSfx(%d)", soundId);
startSound(soundId, soundName, IMUSE_VOLGRP_SFX, NULL, 0, 127, priority);
}
int32 Imuse::getPosInMs(int soundId) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
int32 pos = (5 * (track->dataOffset + track->regionOffset)) / (track->iteration / 200);
return pos;
}
}
return 0;
}
bool Imuse::getSoundStatus(int sound) const {
debug(5, "Imuse::getSoundStatus(%d)", sound);
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if (track->soundId == sound) {
if (track->handle.isActive() || (track->stream && track->used && !track->readyToRemove)) {
return true;
}
}
}
return false;
}
void Imuse::stopSound(int soundId) {
debug(5, "Imuse::stopSound(%d)", soundId);
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
track->toBeRemoved = true;
}
}
}
int32 Imuse::getCurMusicPosInMs() {
int soundId = -1;
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
soundId = track->soundId;
}
}
int32 msPos = getPosInMs(soundId);
debug(5, "Imuse::getCurMusicPosInMs(%d) = %d", soundId, msPos);
return msPos;
}
void Imuse::stopAllSounds() {
debug(5, "Imuse::stopAllSounds");
for(;;) {
bool foundNotRemoved = false;
for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
Track *track = _track[l];
if (track->used) {
track->toBeRemoved = true;
foundNotRemoved = true;
}
}
if (!foundNotRemoved)
break;
flushTracks();
SDL_Delay(50);
}
}
void Imuse::pause(bool p) {
_pause = p;
}
--- NEW FILE: imuse_sndmgr.cpp ---
// Residual - Virtual machine to run LucasArts' 3D adventure games
// Copyright (C) 2003-2004 The ScummVM-Residual Team (www.scummvm.org)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include "../stdafx.h"
#include "../bits.h"
#include "../debug.h"
#include "../timer.h"
#include "../mixer/mixer.h"
#include "../mixer/audiostream.h"
#include "imuse_sndmgr.h"
ImuseSndMgr::ImuseSndMgr(ScummEngine *scumm) {
for (int l = 0; l < MAX_IMUSE_SOUNDS; l++) {
memset(&_sounds[l], 0, sizeof(soundStruct));
}
_vm = scumm;
_disk = 0;
// _cacheBundleDir = new BundleDirCache();
// BundleCodecs::initializeImcTables();
}
ImuseSndMgr::~ImuseSndMgr() {
for (int l = 0; l < MAX_IMUSE_SOUNDS; l++) {
closeSound(&_sounds[l]);
}
}
void ImuseSndMgr::countElements(byte *ptr, int &numRegions, int &numJumps) {
uint32 tag;
int32 size = 0;
do {
tag = READ_BE_UINT32(ptr); ptr += 4;
switch(tag) {
case MKID_BE('TEXT'):
case MKID_BE('STOP'):
case MKID_BE('FRMT'):
case MKID_BE('DATA'):
size = READ_BE_UINT32(ptr); ptr += size + 4;
break;
case MKID_BE('REGN'):
numRegions++;
size = READ_BE_UINT32(ptr); ptr += size + 4;
break;
case MKID_BE('JUMP'):
numJumps++;
size = READ_BE_UINT32(ptr); ptr += size + 4;
break;
default:
error("ImuseSndMgr::countElements() Unknown sfx header '%s'", tag2str(tag));
}
} while (tag != MKID_BE('DATA'));
}
void ImuseSndMgr::prepareSound(byte *ptr, soundStruct *sound) {
if (READ_UINT32(ptr) == MKID('iMUS')) {
uint32 tag;
int32 size = 0;
byte *s_ptr = ptr;
ptr += 16;
int curIndexRegion = 0;
int curIndexJump = 0;
sound->numRegions = 0;
sound->numJumps = 0;
countElements(ptr, sound->numRegions, sound->numJumps, sound->numSyncs);
sound->region = (_region *)malloc(sizeof(_region) * sound->numRegions);
sound->jump = (_jump *)malloc(sizeof(_jump) * sound->numJumps);
do {
tag = READ_BE_UINT32(ptr); ptr += 4;
switch(tag) {
case MKID_BE('FRMT'):
ptr += 12;
sound->bits = READ_BE_UINT32(ptr); ptr += 4;
sound->freq = READ_BE_UINT32(ptr); ptr += 4;
sound->channels = READ_BE_UINT32(ptr); ptr += 4;
break;
case MKID_BE('TEXT'):
case MKID_BE('STOP'):
size = READ_BE_UINT32(ptr); ptr += size + 4;
break;
case MKID_BE('REGN'):
ptr += 4;
sound->region[curIndexRegion].offset = READ_BE_UINT32(ptr); ptr += 4;
sound->region[curIndexRegion].length = READ_BE_UINT32(ptr); ptr += 4;
curIndexRegion++;
break;
case MKID_BE('JUMP'):
ptr += 4;
sound->jump[curIndexJump].offset = READ_BE_UINT32(ptr); ptr += 4;
sound->jump[curIndexJump].dest = READ_BE_UINT32(ptr); ptr += 4;
sound->jump[curIndexJump].hookId = READ_BE_UINT32(ptr); ptr += 4;
sound->jump[curIndexJump].fadeDelay = READ_BE_UINT32(ptr); ptr += 4;
curIndexJump++;
break;
case MKID_BE('DATA'):
ptr += 4;
break;
default:
error("ImuseSndMgr::prepareSound(%d/%s) Unknown sfx header '%s'", sound->soundId, sound->name, tag2str(tag));
}
} while (tag != MKID_BE('DATA'));
sound->offsetData = ptr - s_ptr;
} else {
error("ImuseSndMgr::prepareSound(): Unknown sound format");
}
}
ImuseSndMgr::soundStruct *ImuseSndMgr::allocSlot() {
for (int l = 0; l < MAX_IMUSE_SOUNDS; l++) {
if (!_sounds[l].inUse) {
_sounds[l].inUse = true;
return &_sounds[l];
}
}
return NULL;
}
ImuseSndMgr::soundStruct *ImuseSndMgr::openSound(int32 soundId, const char *soundName, int soundType, int volGroupId, int disk) {
assert(soundId >= 0);
assert(soundType);
soundStruct *sound = allocSlot();
if (!sound) {
error("ImuseSndMgr::openSound() can't alloc free sound slot");
}
const bool header_outside = true;
bool result = false;
byte *ptr = NULL;
if (!result) {
closeSound(sound);
return NULL;
}
if (soundName[0] == 0) {
// if (sound->bundle->decompressSampleByIndex(soundId, 0, 0x2000, &ptr, 0, header_outside) == 0 || ptr == NULL) {
// closeSound(sound);
// return NULL;
// }
} else {
// if (sound->bundle->decompressSampleByName(soundName, 0, 0x2000, &ptr, header_outside) == 0 || ptr == NULL) {
// closeSound(sound);
// return NULL;
// }
}
strcpy(sound->name, soundName);
sound->soundId = soundId;
sound->type = soundType;
sound->volGroupId = volGroupId;
sound->disk = _disk;
prepareSound(ptr, sound);
return sound;
}
void ImuseSndMgr::closeSound(soundStruct *soundHandle) {
assert(checkForProperHandle(soundHandle));
if (soundHandle->resPtr) {
bool found = false;
for (int l = 0; l < MAX_IMUSE_SOUNDS; l++) {
if ((_sounds[l].soundId == soundHandle->soundId) && (&_sounds[l] != soundHandle))
found = true;
}
if (!found)
_vm->unlock(rtSound, soundHandle->soundId);
}
delete soundHandle->bundle;
for (int r = 0; r < soundHandle->numSyncs; r++)
free(soundHandle->sync[r].ptr);
free(soundHandle->region);
free(soundHandle->jump);
free(soundHandle->sync);
memset(soundHandle, 0, sizeof(soundStruct));
}
ImuseSndMgr::soundStruct *ImuseDSndMgr::cloneSound(soundStruct *soundHandle) {
assert(checkForProperHandle(soundHandle));
return openSound(soundHandle->soundId, soundHandle->name, soundHandle->type, soundHandle->volGroupId, soundHandle->disk);
}
bool ImuseSndMgr::checkForProperHandle(soundStruct *soundHandle) {
if (!soundHandle)
return false;
for (int l = 0; l < MAX_IMUSE_SOUNDS; l++) {
if (soundHandle == &_sounds[l])
return true;
}
return false;
}
int ImuseSndMgr::getFreq(soundStruct *soundHandle) {
assert(checkForProperHandle(soundHandle));
return soundHandle->freq;
}
int ImuseSndMgr::getBits(soundStruct *soundHandle) {
assert(checkForProperHandle(soundHandle));
return soundHandle->bits;
}
int ImuseSndMgr::getChannels(soundStruct *soundHandle) {
assert(checkForProperHandle(soundHandle));
return soundHandle->channels;
}
bool ImuseSndMgr::isEndOfRegion(soundStruct *soundHandle, int region) {
assert(checkForProperHandle(soundHandle));
assert(region >= 0 && region < soundHandle->numRegions);
return soundHandle->endFlag;
}
int ImuseSndMgr::getNumRegions(soundStruct *soundHandle) {
assert(checkForProperHandle(soundHandle));
return soundHandle->numRegions;
}
int ImuseSndMgr::getNumJumps(soundStruct *soundHandle) {
assert(checkForProperHandle(soundHandle));
return soundHandle->numJumps;
}
int ImuseSndMgr::getRegionOffset(soundStruct *soundHandle, int region) {
debug(5, "getRegionOffset() region:%d", region);
assert(checkForProperHandle(soundHandle));
assert(region >= 0 && region < soundHandle->numRegions);
return soundHandle->region[region].offset;
}
int ImuseSndMgr::getJumpIdByRegionAndHookId(soundStruct *soundHandle, int region, int hookId) {
debug(5, "getJumpIdByRegionAndHookId() region:%d, hookId:%d", region, hookId);
assert(checkForProperHandle(soundHandle));
assert(region >= 0 && region < soundHandle->numRegions);
int32 offset = soundHandle->region[region].offset;
for (int l = 0; l < soundHandle->numJumps; l++) {
if (offset == soundHandle->jump[l].offset) {
if (soundHandle->jump[l].hookId == hookId)
return l;
}
}
return -1;
}
int ImuseSndMgr::getRegionIdByJumpId(soundStruct *soundHandle, int jumpId) {
debug(5, "getRegionIdByJumpId() jumpId:%d", jumpId);
assert(checkForProperHandle(soundHandle));
assert(jumpId >= 0 && jumpId < soundHandle->numJumps);
int32 dest = soundHandle->jump[jumpId].dest;
for (int l = 0; l < soundHandle->numRegions; l++) {
if (dest == soundHandle->region[l].offset) {
return l;
}
}
return -1;
}
int ImuseSndMgr::getJumpHookId(soundStruct *soundHandle, int number) {
debug(5, "getJumpHookId() number:%d", number);
assert(checkForProperHandle(soundHandle));
assert(number >= 0 && number < soundHandle->numJumps);
return soundHandle->jump[number].hookId;
}
int ImuseSndMgr::getJumpFade(soundStruct *soundHandle, int number) {
debug(5, "getJumpFade() number:%d", number);
assert(checkForProperHandle(soundHandle));
assert(number >= 0 && number < soundHandle->numJumps);
return soundHandle->jump[number].fadeDelay;
}
int32 ImuseSndMgr::getDataFromRegion(soundStruct *soundHandle, int region, byte **buf, int32 offset, int32 size) {
debug(5, "getDataFromRegion() region:%d, offset:%d, size:%d, numRegions:%d", region, offset, size, soundHandle->numRegions);
assert(checkForProperHandle(soundHandle));
assert(buf && offset >= 0 && size >= 0);
assert(region >= 0 && region < soundHandle->numRegions);
int32 region_offset = soundHandle->region[region].offset;
int32 region_length = soundHandle->region[region].length;
int32 offset_data = soundHandle->offsetData;
int32 start = region_offset - offset_data;
if (offset + size + offset_data > region_length) {
size = region_length - offset;
soundHandle->endFlag = true;
} else {
soundHandle->endFlag = false;
}
int header_size = soundHandle->offsetData;
bool header_outside = true;
// size = soundHandle->bundle->decompressSampleByCurIndex(start + offset, size, buf, header_size, header_outside);
return size;
}
--- NEW FILE: imuse_sndmgr.h ---
// Residual - Virtual machine to run LucasArts' 3D adventure games
// Copyright (C) 2003-2004 The ScummVM-Residual Team (www.scummvm.org)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#ifndef IMUSE_SNDMGR_H
#define IMUSE_SNDMGR_H
#include "../stdafx.h"
#include "../bits.h"
#include "../debug.h"
#include "../timer.h"
#include "../mixer/mixer.h"
#include "../mixer/audiostream.h"
class ImuseSndMgr {
public:
#define MAX_IMUSE_SOUNDS 16
#define IMUSE_VOLGRP_VOICE 1
#define IMUSE_VOLGRP_SFX 2
#define IMUSE_VOLGRP_MUSIC 3
private:
struct _region {
int32 offset; // offset of region
int32 length; // lenght of region
};
struct _jump {
int32 offset; // jump offset position
int32 dest; // jump to dest position
byte hookId; // id of hook
int16 fadeDelay; // fade delay in ms
};
public:
struct soundStruct {
uint16 freq; // frequency
byte channels; // stereo or mono
byte bits; // 8, 12, 16
int numJumps; // number of Jumps
int numRegions; // number of Regions
_region *region;
_jump *jump;
bool endFlag;
bool inUse;
int32 offsetData;
char name[15];
int16 soundId;
BundleMgr *bundle;
int type;
int volGroupId;
int disk;
};
private:
soundStruct _sounds[MAX_IMUSE_SOUNDS];
bool checkForProperHandle(soundStruct *soundHandle);
soundStruct *allocSlot();
void prepareSound(byte *ptr, soundStruct *sound);
byte _disk;
void countElements(byte *ptr, int &numRegions, int &numJumps);
public:
ImuseSndMgr();
~ImuseSndMgr();
soundStruct *openSound(int32 soundId, const char *soundName, int soundType, int volGroupId, int disk);
void closeSound(soundStruct *soundHandle);
soundStruct *cloneSound(soundStruct *soundHandle);
int getFreq(soundStruct *soundHandle);
int getBits(soundStruct *soundHandle);
int getChannels(soundStruct *soundHandle);
bool isEndOfRegion(soundStruct *soundHandle, int region);
int getNumRegions(soundStruct *soundHandle);
int getNumJumps(soundStruct *soundHandle);
int getRegionOffset(soundStruct *soundHandle, int region);
int getJumpIdByRegionAndHookId(soundStruct *soundHandle, int region, int hookId);
int getRegionIdByJumpId(soundStruct *soundHandle, int jumpId);
int getJumpHookId(soundStruct *soundHandle, int number);
int getJumpFade(soundStruct *soundHandle, int number);
int32 getDataFromRegion(soundStruct *soundHandle, int region, byte **buf, int32 offset, int32 size);
};
#endif
--- NEW FILE: imuse_track.cpp ---
// Residual - Virtual machine to run LucasArts' 3D adventure games
// Copyright (C) 2003-2004 The ScummVM-Residual Team (www.scummvm.org)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include "../stdafx.h"
#include "../bits.h"
#include "../debug.h"
#include "../timer.h"
#include "../mixer/mixer.h"
#include "../mixer/audiostream.h"
#include "imuse_sndmgr.h"
int Imuse::allocSlot(int priority) {
int l, lowest_priority = 127;
int trackId = -1;
for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
if (!_track[l]->used) {
trackId = l;
break;
}
}
if (trackId == -1) {
debug(5, "Imuse::startSound(): All slots are full");
for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if (track->used && !track->toBeRemoved && (lowest_priority > track->priority) && !track->stream2) {
lowest_priority = track->priority;
trackId = l;
}
}
if (lowest_priority <= priority) {
assert(trackId != -1);
_track[trackId]->toBeRemoved = true;
debug(5, "Imuse::startSound(): Removed sound %d from track %d", _track[trackId]->soundId, trackId);
} else {
debug(5, "Imuse::startSound(): Priority sound too low");
return -1;
}
}
return trackId;
}
void Imuse::startSound(int soundId, const char *soundName, int soundType, int volGroupId, AudioStream *input, int hookId, int volume, int pan = 64, int priority) {
debug(5, "Imuse::startSound(%d)", soundId);
int l = allocSlot(priority);
if (l == -1) {
warning("Imuse::startSound() Can't start sound - no free slots");
return;
}
Track *track = _track[l];
while (track->used) {
// The designated track is not yet available. So, we call flushTracks()
// to get it processed (and thus made ready for us). Since the actual
// processing is done by another thread, we also call parseEvents to
// give it some time (and to avoid busy waiting/looping).
flushTracks();
}
track->pan = pan;
track->vol = volume * 1000;
track->volFadeDest = 0;
track->volFadeStep = 0;
track->volFadeDelay = 0;
track->volFadeUsed = false;
track->soundId = soundId;
track->started = false;
track->volGroupId = volGroupId;
track->curHookId = hookId;
track->priority = priority;
track->curRegion = -1;
track->dataOffset = 0;
track->regionOffset = 0;
track->mixerFlags = 0;
track->mixerPan = 0;
track->mixerVol = volume;
track->toBeRemoved = false;
track->readyToRemove = false;
track->soundType = soundType;
int bits = 0, freq = 0, channels = 0;
strcpy(track->soundName, soundName);
track->soundHandle = _sound->openSound(soundId, soundName, soundType, volGroupId, -1);
if (track->soundHandle == NULL)
return;
bits = _sound->getBits(track->soundHandle);
channels = _sound->getChannels(track->soundHandle);
freq = _sound->getFreq(track->soundHandle);
/*
if (soundId == kTalkSoundID) {
if (_vm->_actorToPrintStrFor != 0xFF && _vm->_actorToPrintStrFor != 0) {
Actor *a = _vm->derefActor(_vm->_actorToPrintStrFor, "Imuse::startSound");
freq = (freq * a->talkFrequency) / 256;
track->pan = a->talkPan;
track->vol = a->talkVolume * 1000;
}
}
*/
assert(bits == 8 || bits == 12 || bits == 16);
assert(channels == 1 || channels == 2);
assert(0 < freq && freq <= 65535);
track->iteration = freq * channels * 2;
track->mixerFlags = SoundMixer::FLAG_16BITS;
if (channels == 2)
track->mixerFlags |= SoundMixer::FLAG_STEREO | SoundMixer::FLAG_REVERSE_STEREO;
}
pan = (track->pan != 64) ? 2 * track->pan - 127 : 0;
volume = track->vol / 1000;
if (track->volGroupId == 1)
volume = (volume * _volVoice) / 128;
if (track->volGroupId == 2)
volume = (volume * _volSfx) / 128;
if (track->volGroupId == 3)
volume = (volume * _volMusic) / 128;
track->mixerPan = pan;
track->mixerVol = volume;
// setup 1 second stream wrapped buffer
int32 streamBufferSize = track->iteration;
track->stream = makeAppendableAudioStream(freq, track->mixerFlags, streamBufferSize);
_vm->_mixer->playInputStream(&track->handle, track->stream, false, -1, track->mixerVol, track->mixerPan, false);
track->started = true;
}
track->used = true;
}
void Imuse::setPriority(int soundId, int priority) {
debug(5, "Imuse::setPriority(%d, %d)", soundId, priority);
assert ((priority >= 0) && (priority <= 127));
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
track->priority = priority;
}
}
}
void Imuse::setVolume(int soundId, int volume) {
debug(5, "IMuseDigital::setVolume(%d, %d)", soundId, volume);
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
track->vol = volume * 1000;
}
}
}
void Imuse::setPan(int soundId, int pan) {
debug(5, "Imuse::setPan(%d, %d)", soundId, pan);
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
track->pan = pan;
}
}
}
void Imuse::selectVolumeGroup(int soundId, int volGroupId) {
debug(5, "Imuse::setGroupVolume(%d, %d)", soundId, volGroupId);
assert((volGroupId >= 1) && (volGroupId <= 4));
if (volGroupId == 4)
volGroupId = 3;
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
track->volGroupId = volGroupId;
}
}
}
void Imuse::setFade(int soundId, int destVolume, int delay60HzTicks) {
StackLock lock(_mutex);
debug(5, "Imuse::setFade(%d, %d, %d)", soundId, destVolume, delay60HzTicks);
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
track->volFadeDelay = delay60HzTicks;
track->volFadeDest = destVolume * 1000;
track->volFadeStep = (track->volFadeDest - track->vol) * 60 * (1000 / _callbackFps) / (1000 * delay60HzTicks);
track->volFadeUsed = true;
}
}
}
void Imuse::fadeOutMusic(int fadeDelay) {
debug(5, "Imuse::fadeOutMusic");
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
cloneToFadeOutTrack(track, fadeDelay);
track->toBeRemoved = true;
}
}
}
ImuseDigital::Track *Imuse::cloneToFadeOutTrack(Track *track, int fadeDelay) {
assert(track);
Track *fadeTrack = 0;
debug(5, "Imuse::cloneToFadeOutTrack(%d, %d)", track->trackId, fadeDelay);
{
StackLock lock(_mutex);
for (int l = MAX_DIGITAL_TRACKS; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
if (!_track[l]->used) {
fadeTrack = _track[l];
break;
}
}
if (fadeTrack == 0)
error("IMuseDigital::cloneTofadeTrackId() Can't find free fade track");
fadeTrack->pan = track->pan;
fadeTrack->vol = track->vol;
fadeTrack->volGroupId = track->volGroupId;
fadeTrack->priority = track->priority;
fadeTrack->soundId = track->soundId;
fadeTrack->dataOffset = track->dataOffset;
fadeTrack->regionOffset = track->regionOffset;
fadeTrack->curRegion = track->curRegion;
fadeTrack->curHookId = track->curHookId;
fadeTrack->iteration = track->iteration;
fadeTrack->mixerFlags = track->mixerFlags;
fadeTrack->mixerVol = track->mixerVol;
fadeTrack->mixerPan = track->mixerPan;
fadeTrack->toBeRemoved = track->toBeRemoved;
fadeTrack->readyToRemove = track->readyToRemove;
fadeTrack->started = track->started;
strcpy(fadeTrack->soundName, track->soundName);
fadeTrack->soundType = track->soundType;
fadeTrack->soundHandle = _sound->cloneSound(track->soundHandle);
assert(fadeTrack->soundHandle);
fadeTrack->volFadeDelay = fadeDelay;
fadeTrack->volFadeDest = 0;
fadeTrack->volFadeStep = (fadeTrack->volFadeDest - fadeTrack->vol) * 60 * (1000 / _callbackFps) / (1000 * fadeDelay);
fadeTrack->volFadeUsed = true;
}
// setup 1 second stream wrapped buffer
int32 streamBufferSize = fadeTrack->iteration;
fadeTrack->stream = makeAppendableAudioStream(_sound->getFreq(fadeTrack->soundHandle), fadeTrack->mixerFlags, streamBufferSize);
_vm->_mixer->playInputStream(&fadeTrack->handle, fadeTrack->stream, false, -1, fadeTrack->vol / 1000, fadeTrack->pan, false);
fadeTrack->started = true;
fadeTrack->used = true;
return fadeTrack;
}
Index: imuse.cpp
===================================================================
RCS file: /cvsroot/scummvm/residual/imuse/imuse.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- imuse.cpp 26 Dec 2004 12:23:59 -0000 1.2
+++ imuse.cpp 26 Dec 2004 13:43:43 -0000 1.3
@@ -20,11 +20,11 @@
#include "../debug.h"
#include "../timer.h"
-#include "imuse_sndmgr.h"
-
#include "../mixer/mixer.h"
#include "../mixer/audiostream.h"
+#include "imuse_sndmgr.h"
+
Imuse::Track::Track()
: soundId(-1), used(false), stream(NULL) {
}
- Previous message: [Scummvm-cvs-logs] CVS: residual main.cpp,1.35,1.36 sound.cpp,1.13,1.14 stdafx.h,1.5,1.6
- Next message: [Scummvm-cvs-logs] CVS: docs/docbook manual.html,1.14,1.15 manual.pdf,1.14,1.15 manual.txt,1.13,1.14 manual.xml,1.17,1.18
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the Scummvm-git-logs
mailing list