libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-21 01:08:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

SCI: Renamed various song/songlib related structs and members

Browse Source 
svn-id: r41342
This commit is contained in:
Max Horn 2009-06-07 17:06:32 +00:00
parent 42555118ba
commit f2ca788004
8 changed files with 294 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
engines/sci/console.cpp
View File

@ -37,7 +37,7 @@
#include "sci/gfx/gfx_gui.h" // for sciw_set_status_bar
#include "sci/gfx/gfx_state_internal.h"
#include "sci/gfx/gfx_widgets.h" // for getPort
#include "sci/sfx/songlib.h" // for songlib_t
#include "sci/sfx/songlib.h" // for SongLibrary
#include "sci/sfx/iterator.h" // for SCI_SONG_ITERATOR_TYPE_SCI0
#include "sci/sfx/sci_midi.h"
#include "sci/vocabulary.h"
@ -1530,14 +1530,14 @@ bool Console::cmdShowMap(int argc, const char **argv) {
bool Console::cmdSongLib(int argc, const char **argv) {
DebugPrintf("Song library:\n");
song_t *seeker = *(g_EngineState->_sound._songlib.lib);
Song *seeker = *(g_EngineState->_sound._songlib._lib);
do {
DebugPrintf(" %p", (void *)seeker);
if (seeker) {
DebugPrintf("[%04lx,p=%d,s=%d]->", seeker->handle, seeker->priority, seeker->status);
seeker = seeker->next;
DebugPrintf("[%04lx,p=%d,s=%d]->", seeker->_handle, seeker->_priority, seeker->_status);
seeker = seeker->_next;
}
DebugPrintf("\n");
} while (seeker);

12
engines/sci/engine/ksound.cpp
View File

@ -151,7 +151,7 @@ SongIterator *build_iterator(EngineState *s, int song_nr, SongIteratorType type,
void process_sound_events(EngineState *s) { /* Get all sound events, apply their changes to the heap */
int result;
song_handle_t handle;
SongHandle handle;
int cue;
if (s->_version >= SCI_VERSION_01)
@ -204,7 +204,7 @@ void process_sound_events(EngineState *s) { /* Get all sound events, apply their
reg_t kDoSound_SCI0(EngineState *s, int funct_nr, int argc, reg_t *argv) {
reg_t obj = (argc > 1) ? argv[1] : NULL_REG;
uint16 command = argv[0].toUint16();
song_handle_t handle = FROBNICATE_HANDLE(obj);
SongHandle handle = FROBNICATE_HANDLE(obj);
int number = obj.segment ?
GET_SEL32V(obj, number) :
-1; /* We were not going to use it anyway */
@ -383,7 +383,7 @@ reg_t kDoSound_SCI0(EngineState *s, int funct_nr, int argc, reg_t *argv) {
reg_t kDoSound_SCI01(EngineState *s, int funct_nr, int argc, reg_t *argv) {
uint16 command = argv[0].toUint16();
reg_t obj = (argc > 1) ? argv[1] : NULL_REG;
song_handle_t handle = FROBNICATE_HANDLE(obj);
SongHandle handle = FROBNICATE_HANDLE(obj);
int number = obj.segment ?
GET_SEL32V(obj, number) :
-1; /* We were not going to use it anyway */
@ -673,7 +673,7 @@ reg_t kDoSound_SCI01(EngineState *s, int funct_nr, int argc, reg_t *argv) {
reg_t kDoSound_SCI1(EngineState *s, int funct_nr, int argc, reg_t *argv) {
uint16 command = argv[0].toUint16();
reg_t obj = (argc > 1) ? argv[1] : NULL_REG;
song_handle_t handle = FROBNICATE_HANDLE(obj);
SongHandle handle = FROBNICATE_HANDLE(obj);
int number = obj.segment ?
GET_SEL32V(obj, number) :
-1; /* We were not going to use it anyway */
@ -798,9 +798,9 @@ reg_t kDoSound_SCI1(EngineState *s, int funct_nr, int argc, reg_t *argv) {
int looping = GET_SEL32V(obj, loop);
//int vol = GET_SEL32V(obj, vol);
int pri = GET_SEL32V(obj, pri);
song_t *song = song_lib_find(s->_sound._songlib, handle);
Song *song = song_lib_find(s->_sound._songlib, handle);
if (GET_SEL32V(obj, nodePtr) && (song && number != song->resource_num)) {
if (GET_SEL32V(obj, nodePtr) && (song && number != song->_resourceNum)) {
s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
s->_sound.sfx_remove_song(handle);
PUT_SEL32(obj, nodePtr, NULL_REG);

66
engines/sci/engine/savegame.cpp
View File

@ -52,7 +52,7 @@ SongIterator *build_iterator(EngineState *s, int song_nr, SongIteratorType type,
// of the classes they are syncing.
static void sync_MemObjPtr(Common::Serializer &s, MemObject *&obj);
static void sync_songlib_t(Common::Serializer &s, songlib_t &obj);
static void sync_songlib_t(Common::Serializer &s, SongLibrary &obj);
static void sync_reg_t(Common::Serializer &s, reg_t &obj) {
s.syncAsUint16LE(obj.segment);
@ -73,22 +73,22 @@ static void syncCStr(Common::Serializer &s, char **str) {
}
static void sync_song_t(Common::Serializer &s, song_t &obj) {
s.syncAsSint32LE(obj.handle);
s.syncAsSint32LE(obj.resource_num);
s.syncAsSint32LE(obj.priority);
s.syncAsSint32LE(obj.status);
s.syncAsSint32LE(obj.restore_behavior);
s.syncAsSint32LE(obj.restore_time);
s.syncAsSint32LE(obj.loops);
s.syncAsSint32LE(obj.hold);
static void sync_song_t(Common::Serializer &s, Song &obj) {
s.syncAsSint32LE(obj._handle);
s.syncAsSint32LE(obj._resourceNum);
s.syncAsSint32LE(obj._priority);
s.syncAsSint32LE(obj._status);
s.syncAsSint32LE(obj._restoreBehavior);
s.syncAsSint32LE(obj._restoreTime);
s.syncAsSint32LE(obj._loops);
s.syncAsSint32LE(obj._hold);
if (s.isLoading()) {
obj._it = 0;
obj._delay = 0;
obj.it = 0;
obj.next_playing = 0;
obj.next_stopping = 0;
obj.next = 0;
obj._next = 0;
obj._nextPlaying = 0;
obj._nextStopping = 0;
}
}
@ -401,7 +401,7 @@ void StringFrag::saveLoadWithSerializer(Common::Serializer &s) {
#pragma mark -
static void sync_songlib_t(Common::Serializer &s, songlib_t &obj) {
static void sync_songlib_t(Common::Serializer &s, SongLibrary &obj) {
int songcount = 0;
if (s.isSaving())
songcount = song_lib_count(obj);
@ -410,16 +410,16 @@ static void sync_songlib_t(Common::Serializer &s, songlib_t &obj) {
if (s.isLoading()) {
song_lib_init(&obj);
while (songcount--) {
song_t *newsong = (song_t *)calloc(1, sizeof(song_t));
Song *newsong = (Song *)calloc(1, sizeof(Song));
sync_song_t(s, *newsong);
song_lib_add(obj, newsong);
}
} else {
song_t *seeker = *(obj.lib);
Song *seeker = *(obj._lib);
while (seeker) {
seeker->restore_time = seeker->it->getTimepos();
seeker->_restoreTime = seeker->_it->getTimepos();
sync_song_t(s, *seeker);
seeker = seeker->next;
seeker = seeker->_next;
}
}
}
@ -692,11 +692,11 @@ static void reconstruct_clones(EngineState *s, SegManager *self) {
int _reset_graphics_input(EngineState *s);
static void reconstruct_sounds(EngineState *s) {
song_t *seeker;
Song *seeker;
SongIteratorType it_type = s->resmgr->_sciVersion >= SCI_VERSION_01 ? SCI_SONG_ITERATOR_TYPE_SCI1 : SCI_SONG_ITERATOR_TYPE_SCI0;
if (s->_sound._songlib.lib)
seeker = *(s->_sound._songlib.lib);
if (s->_sound._songlib._lib)
seeker = *(s->_sound._songlib._lib);
else {
song_lib_init(&s->_sound._songlib);
seeker = NULL;
@ -707,21 +707,21 @@ static void reconstruct_sounds(EngineState *s) {
int oldstatus;
SongIterator::Message msg;
base = ff = build_iterator(s, seeker->resource_num, it_type, seeker->handle);
if (seeker->restore_behavior == RESTORE_BEHAVIOR_CONTINUE)
ff = new_fast_forward_iterator(base, seeker->restore_time);
base = ff = build_iterator(s, seeker->_resourceNum, it_type, seeker->_handle);
if (seeker->_restoreBehavior == RESTORE_BEHAVIOR_CONTINUE)
ff = new_fast_forward_iterator(base, seeker->_restoreTime);
ff->init();
msg = SongIterator::Message(seeker->handle, SIMSG_SET_LOOPS(seeker->loops));
msg = SongIterator::Message(seeker->_handle, SIMSG_SET_LOOPS(seeker->_loops));
songit_handle_message(&ff, msg);
msg = SongIterator::Message(seeker->handle, SIMSG_SET_HOLD(seeker->hold));
msg = SongIterator::Message(seeker->_handle, SIMSG_SET_HOLD(seeker->_hold));
songit_handle_message(&ff, msg);
oldstatus = seeker->status;
seeker->status = SOUND_STATUS_STOPPED;
seeker->it = ff;
s->_sound.sfx_song_set_status(seeker->handle, oldstatus);
seeker = seeker->next;
oldstatus = seeker->_status;
seeker->_status = SOUND_STATUS_STOPPED;
seeker->_it = ff;
s->_sound.sfx_song_set_status(seeker->_handle, oldstatus);
seeker = seeker->_next;
}
}
@ -729,7 +729,7 @@ void internal_stringfrag_strncpy(EngineState *s, reg_t *dest, reg_t *src, int le
EngineState *gamestate_restore(EngineState *s, Common::SeekableReadStream *fh) {
EngineState *retval;
songlib_t temp;
SongLibrary temp;
/*
if (s->sound_server) {

181
engines/sci/sfx/core.cpp
View File

@ -47,6 +47,15 @@ class SfxPlayer;
SfxPlayer *player = NULL; // FIXME: Avoid non-const global vars
/* Plays a song iterator that found a PCM through a PCM device, if possible
** Parameters: (SongIterator *) it: The iterator to play
** (SongHandle) handle: Debug handle
** Returns : (int) 0 if the effect will not be played, nonzero if it will
** This assumes that the last call to 'it->next()' returned SI_PCM.
*/
static int sfx_play_iterator_pcm(SongIterator *it, SongHandle handle);
#pragma mark -
@ -351,39 +360,39 @@ SfxState::~SfxState() {
void SfxState::freezeTime() {
/* Freezes the top song delay time */
const Audio::Timestamp ctime = Audio::Timestamp(g_system->getMillis(), SFX_TICKS_PER_SEC);
song_t *song = _song;
Song *song = _song;
while (song) {
song->_delay = song->_wakeupTime.frameDiff(ctime);
if (song->_delay < 0)
song->_delay = 0;
song = song->next_playing;
song = song->_nextPlaying;
}
}
void SfxState::thawTime() {
/* inverse of freezeTime() */
const Audio::Timestamp ctime = Audio::Timestamp(g_system->getMillis(), SFX_TICKS_PER_SEC);
song_t *song = _song;
Song *song = _song;
while (song) {
song->_wakeupTime = ctime.addFrames(song->_delay);
song = song->next_playing;
song = song->_nextPlaying;
}
}
#if 0
// Unreferenced - removed
static void _dump_playing_list(SfxState *self, char *msg) {
song_t *song = self->_song;
Song *song = self->_song;
fprintf(stderr, "[] Song list : [ ");
song = *(self->_songlib.lib);
while (song) {
fprintf(stderr, "%08lx:%d ", song->handle, song->status);
song = song->next_playing;
fprintf(stderr, "%08lx:%d ", song->handle, song->_status);
song = song->_nextPlaying;
}
fprintf(stderr, "]\n");
@ -391,7 +400,7 @@ static void _dump_playing_list(SfxState *self, char *msg) {
while (song) {
fprintf(stderr, "%08lx ", song->handle);
song = song->next_playing;
song = song->_nextPlaying;
}
fprintf(stderr, "]\n");
@ -400,15 +409,15 @@ static void _dump_playing_list(SfxState *self, char *msg) {
#if 0
static void _dump_songs(SfxState *self) {
song_t *song = self->_song;
Song *song = self->_song;
fprintf(stderr, "Cue iterators:\n");
song = *(self->_songlib.lib);
while (song) {
fprintf(stderr, " **\tHandle %08x (p%d): status %d\n",
song->handle, song->priority, song->status);
SIMSG_SEND(song->it, SIMSG_PRINT(1));
song = song->next;
song->handle, song->_priority, song->_status);
SIMSG_SEND(song->_it, SIMSG_PRINT(1));
song = song->_next;
}
if (player) {
@ -418,32 +427,32 @@ static void _dump_songs(SfxState *self) {
}
#endif
bool SfxState::isPlaying(song_t *song) {
song_t *playing_song = _song;
bool SfxState::isPlaying(Song *song) {
Song *playing_song = _song;
/* _dump_playing_list(this, "is-playing");*/
while (playing_song) {
if (playing_song == song)
return true;
playing_song = playing_song->next_playing;
playing_song = playing_song->_nextPlaying;
}
return false;
}
void SfxState::setSongStatus(song_t *song, int status) {
void SfxState::setSongStatus(Song *song, int status) {
const Audio::Timestamp ctime = Audio::Timestamp(g_system->getMillis(), SFX_TICKS_PER_SEC);
switch (status) {
case SOUND_STATUS_STOPPED:
// Reset
song->it->init();
song->_it->init();
break;
case SOUND_STATUS_SUSPENDED:
case SOUND_STATUS_WAITING:
if (song->status == SOUND_STATUS_PLAYING) {
if (song->_status == SOUND_STATUS_PLAYING) {
// Update delay, set wakeup_time
song->_delay += song->_wakeupTime.frameDiff(ctime);
song->_wakeupTime = ctime;
@ -454,7 +463,7 @@ void SfxState::setSongStatus(song_t *song, int status) {
/* otherwise... */
case SOUND_STATUS_PLAYING:
if (song->status == SOUND_STATUS_STOPPED) {
if (song->_status == SOUND_STATUS_STOPPED) {
// Starting anew
song->_wakeupTime = ctime;
}
@ -471,12 +480,12 @@ void SfxState::setSongStatus(song_t *song, int status) {
return;
}
song->status = status;
song->_status = status;
}
/* Update internal state iff only one song may be played */
void SfxState::updateSingleSong() {
song_t *newsong = song_lib_find_active(_songlib);
Song *newsong = song_lib_find_active(_songlib);
if (newsong != _song) {
freezeTime(); /* Store song delay time */
@ -485,11 +494,11 @@ void SfxState::updateSingleSong() {
player->stop();
if (newsong) {
if (!newsong->it)
if (!newsong->_it)
return; /* Restore in progress and not ready for this yet */
/* Change song */
if (newsong->status == SOUND_STATUS_WAITING)
if (newsong->_status == SOUND_STATUS_WAITING)
setSongStatus(newsong, SOUND_STATUS_PLAYING);
/* Change instrument mappings */
@ -497,7 +506,7 @@ void SfxState::updateSingleSong() {
/* Turn off sound */
}
if (_song) {
if (_song->status == SOUND_STATUS_PLAYING)
if (_song->_status == SOUND_STATUS_PLAYING)
setSongStatus(newsong, SOUND_STATUS_WAITING);
}
@ -506,13 +515,13 @@ void SfxState::updateSingleSong() {
debugMessage += " New song:";
} else {
char tmp[50];
sprintf(tmp, " pausing %08lx, now playing ", _song->handle);
sprintf(tmp, " pausing %08lx, now playing ", _song->_handle);
debugMessage += tmp;
}
if (newsong) {
char tmp[20];
sprintf(tmp, "%08lx\n", newsong->handle);
sprintf(tmp, "%08lx\n", newsong->_handle);
debugMessage += tmp;
} else {
debugMessage += " none\n";
@ -524,7 +533,7 @@ void SfxState::updateSingleSong() {
thawTime(); /* Recover song delay time */
if (newsong && player) {
SongIterator *clonesong = newsong->it->clone(newsong->_delay);
SongIterator *clonesong = newsong->_it->clone(newsong->_delay);
player->add_iterator(clonesong, newsong->_wakeupTime.msecs());
}
@ -533,11 +542,11 @@ void SfxState::updateSingleSong() {
void SfxState::updateMultiSong() {
song_t *oldfirst = _song;
song_t *oldseeker;
song_t *newsong = song_lib_find_active(_songlib);
song_t *newseeker;
song_t not_playing_anymore; /* Dummy object, referenced by
Song *oldfirst = _song;
Song *oldseeker;
Song *newsong = song_lib_find_active(_songlib);
Song *newseeker;
Song not_playing_anymore; /* Dummy object, referenced by
** songs which are no longer
** active. */
@ -548,30 +557,30 @@ void SfxState::updateMultiSong() {
return;
for (newseeker = newsong; newseeker;
newseeker = newseeker->next_playing) {
if (!newseeker || !newseeker->it)
newseeker = newseeker->_nextPlaying) {
if (!newseeker || !newseeker->_it)
return; /* Restore in progress and not ready for this yet */
}
/* First, put all old songs into the 'stopping' list and
** mark their 'next-playing' as not_playing_anymore. */
for (oldseeker = oldfirst; oldseeker;
oldseeker = oldseeker->next_stopping) {
oldseeker->next_stopping = oldseeker->next_playing;
oldseeker->next_playing = &not_playing_anymore;
oldseeker = oldseeker->_nextStopping) {
oldseeker->_nextStopping = oldseeker->_nextPlaying;
oldseeker->_nextPlaying = &not_playing_anymore;
if (oldseeker == oldseeker->next_playing) {
if (oldseeker == oldseeker->_nextPlaying) {
error("updateMultiSong() failed. Breakpoint in %s, line %d", __FILE__, __LINE__);
}
}
/* Second, re-generate the new song queue. */
for (newseeker = newsong; newseeker;
newseeker = newseeker->next_playing) {
newseeker->next_playing
newseeker = newseeker->_nextPlaying) {
newseeker->_nextPlaying
= song_lib_find_next_active(_songlib, newseeker);
if (newseeker == newseeker->next_playing) {
if (newseeker == newseeker->_nextPlaying) {
error("updateMultiSong() failed. Breakpoint in %s, line %d", __FILE__, __LINE__);
}
}
@ -582,21 +591,21 @@ void SfxState::updateMultiSong() {
/* Third, stop all old songs */
for (oldseeker = oldfirst; oldseeker;
oldseeker = oldseeker->next_stopping)
if (oldseeker->next_playing == &not_playing_anymore) {
oldseeker = oldseeker->_nextStopping)
if (oldseeker->_nextPlaying == &not_playing_anymore) {
setSongStatus(oldseeker, SOUND_STATUS_SUSPENDED);
debugC(2, kDebugLevelSound, "[SFX] Stopping song %lx\n", oldseeker->handle);
debugC(2, kDebugLevelSound, "[SFX] Stopping song %lx\n", oldseeker->_handle);
if (player && oldseeker->it)
player->iterator_message(SongIterator::Message(oldseeker->it->ID, SIMSG_STOP));
oldseeker->next_playing = NULL; /* Clear this pointer; we don't need the tag anymore */
if (player && oldseeker->_it)
player->iterator_message(SongIterator::Message(oldseeker->_it->ID, SIMSG_STOP));
oldseeker->_nextPlaying = NULL; /* Clear this pointer; we don't need the tag anymore */
}
for (newseeker = newsong; newseeker; newseeker = newseeker->next_playing) {
if (newseeker->status != SOUND_STATUS_PLAYING && player) {
debugC(2, kDebugLevelSound, "[SFX] Adding song %lx\n", newseeker->it->ID);
for (newseeker = newsong; newseeker; newseeker = newseeker->_nextPlaying) {
if (newseeker->_status != SOUND_STATUS_PLAYING && player) {
debugC(2, kDebugLevelSound, "[SFX] Adding song %lx\n", newseeker->_it->ID);
SongIterator *clonesong = newseeker->it->clone(newseeker->_delay);
SongIterator *clonesong = newseeker->_it->clone(newseeker->_delay);
player->add_iterator(clonesong, g_system->getMillis());
}
setSongStatus(newseeker, SOUND_STATUS_PLAYING);
@ -615,7 +624,7 @@ void SfxState::update() {
updateSingleSong();
}
int sfx_play_iterator_pcm(SongIterator *it, song_handle_t handle) {
static int sfx_play_iterator_pcm(SongIterator *it, SongHandle handle) {
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Playing PCM: %08lx\n", handle);
#endif
@ -716,11 +725,11 @@ void SfxState::sfx_suspend(bool suspend) {
_suspended = suspend;
}
int SfxState::sfx_poll(song_handle_t *handle, int *cue) {
int SfxState::sfx_poll(SongHandle *handle, int *cue) {
if (!_song)
return 0; /* No milk today */
*handle = _song->handle;
*handle = _song->_handle;
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Polling any (%08lx)\n", *handle);
@ -728,12 +737,12 @@ int SfxState::sfx_poll(song_handle_t *handle, int *cue) {
return sfx_poll_specific(*handle, cue);
}
int SfxState::sfx_poll_specific(song_handle_t handle, int *cue) {
int SfxState::sfx_poll_specific(SongHandle handle, int *cue) {
const Audio::Timestamp ctime = Audio::Timestamp(g_system->getMillis(), SFX_TICKS_PER_SEC);
song_t *song = _song;
Song *song = _song;
while (song && song->handle != handle)
song = song->next_playing;
while (song && song->_handle != handle)
song = song->_nextPlaying;
if (!song)
return 0; /* Song not playing */
@ -745,7 +754,7 @@ int SfxState::sfx_poll_specific(song_handle_t handle, int *cue) {
return 0; /* Patience, young hacker! */
byte buf[8];
int result = songit_next(&(song->it), buf, cue, IT_READER_MASK_ALL);
int result = songit_next(&(song->_it), buf, cue, IT_READER_MASK_ALL);
switch (result) {
@ -783,8 +792,8 @@ int SfxState::sfx_poll_specific(song_handle_t handle, int *cue) {
/* Song basics */
/*****************/
void SfxState::sfx_add_song(SongIterator *it, int priority, song_handle_t handle, int number) {
song_t *song = song_lib_find(_songlib, handle);
void SfxState::sfx_add_song(SongIterator *it, int priority, SongHandle handle, int number) {
Song *song = song_lib_find(_songlib, handle);
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Adding song: %08lx at %d, it=%p\n", handle, priority, it);
@ -807,10 +816,10 @@ void SfxState::sfx_add_song(SongIterator *it, int priority, song_handle_t handle
setSongStatus( song, SOUND_STATUS_STOPPED);
fprintf(stderr, "Overwriting old song (%08lx) ...\n", handle);
if (song->status == SOUND_STATUS_PLAYING || song->status == SOUND_STATUS_SUSPENDED) {
if (song->_status == SOUND_STATUS_PLAYING || song->_status == SOUND_STATUS_SUSPENDED) {
delete it;
error("Unexpected (error): Song %ld still playing/suspended (%d)",
handle, song->status);
handle, song->_status);
return;
} else {
song_lib_remove(_songlib, handle); /* No duplicates */
@ -819,9 +828,9 @@ void SfxState::sfx_add_song(SongIterator *it, int priority, song_handle_t handle
}
song = song_new(handle, it, priority);
song->resource_num = number;
song->hold = 0;
song->loops = 0;
song->_resourceNum = number;
song->_hold = 0;
song->_loops = 0;
song->_wakeupTime = Audio::Timestamp(g_system->getMillis(), SFX_TICKS_PER_SEC);
song_lib_add(_songlib, song);
_song = NULL; /* As above */
@ -830,11 +839,11 @@ void SfxState::sfx_add_song(SongIterator *it, int priority, song_handle_t handle
return;
}
void SfxState::sfx_remove_song(song_handle_t handle) {
void SfxState::sfx_remove_song(SongHandle handle) {
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Removing song: %08lx\n", handle);
#endif
if (_song && _song->handle == handle)
if (_song && _song->_handle == handle)
_song = NULL;
song_lib_remove(_songlib, handle);
@ -849,8 +858,8 @@ void SfxState::sfx_remove_song(song_handle_t handle) {
#define ASSERT_SONG(s) if (!(s)) { warning("Looking up song handle %08lx failed in %s, L%d", handle, __FILE__, __LINE__); return; }
void SfxState::sfx_song_set_status(song_handle_t handle, int status) {
song_t *song = song_lib_find(_songlib, handle);
void SfxState::sfx_song_set_status(SongHandle handle, int status) {
Song *song = song_lib_find(_songlib, handle);
ASSERT_SONG(song);
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Setting song status to %d"
@ -862,11 +871,11 @@ void SfxState::sfx_song_set_status(song_handle_t handle, int status) {
update();
}
void SfxState::sfx_song_set_fade(song_handle_t handle, fade_params_t *params) {
void SfxState::sfx_song_set_fade(SongHandle handle, fade_params_t *params) {
#ifdef DEBUG_SONG_API
static const char *stopmsg[] = {"??? Should not happen", "Do not stop afterwards", "Stop afterwards"};
#endif
song_t *song = song_lib_find(_songlib, handle);
Song *song = song_lib_find(_songlib, handle);
ASSERT_SONG(song);
@ -877,52 +886,52 @@ void SfxState::sfx_song_set_fade(song_handle_t handle, fade_params_t *params) {
stopmsg[fade->action]);
#endif
SIMSG_SEND_FADE(song->it, params);
SIMSG_SEND_FADE(song->_it, params);
update();
}
void SfxState::sfx_song_renice(song_handle_t handle, int priority) {
song_t *song = song_lib_find(_songlib, handle);
void SfxState::sfx_song_renice(SongHandle handle, int priority) {
Song *song = song_lib_find(_songlib, handle);
ASSERT_SONG(song);
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Renicing song %08lx to %d\n",
handle, priority);
#endif
song->priority = priority;
song->_priority = priority;
update();
}
void SfxState::sfx_song_set_loops(song_handle_t handle, int loops) {
song_t *song = song_lib_find(_songlib, handle);
void SfxState::sfx_song_set_loops(SongHandle handle, int loops) {
Song *song = song_lib_find(_songlib, handle);
SongIterator::Message msg = SongIterator::Message(handle, SIMSG_SET_LOOPS(loops));
ASSERT_SONG(song);
song->loops = loops;
song->_loops = loops;
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Setting loops on %08lx to %d\n",
handle, loops);
#endif
songit_handle_message(&(song->it), msg);
songit_handle_message(&(song->_it), msg);
if (player/* && player->send_iterator_message*/)
/* FIXME: The above should be optional! */
player->iterator_message(msg);
}
void SfxState::sfx_song_set_hold(song_handle_t handle, int hold) {
song_t *song = song_lib_find(_songlib, handle);
void SfxState::sfx_song_set_hold(SongHandle handle, int hold) {
Song *song = song_lib_find(_songlib, handle);
SongIterator::Message msg = SongIterator::Message(handle, SIMSG_SET_HOLD(hold));
ASSERT_SONG(song);
song->hold = hold;
song->_hold = hold;
#ifdef DEBUG_SONG_API
fprintf(stderr, "[sfx-core] Setting hold on %08lx to %d\n",
handle, hold);
#endif
songit_handle_message(&(song->it), msg);
songit_handle_message(&(song->_it), msg);
if (player/* && player->send_iterator_message*/)
/* FIXME: The above should be optional! */
@ -934,9 +943,9 @@ static const int MIDI_cmdlen[16] = {0, 0, 0, 0, 0, 0, 0, 0,
3, 3, 0, 3, 2, 0, 3, 0
};
static const song_handle_t midi_send_base = 0xffff0000;
static const SongHandle midi_send_base = 0xffff0000;
Common::Error SfxState::sfx_send_midi(song_handle_t handle, int channel,
Common::Error SfxState::sfx_send_midi(SongHandle handle, int channel,
int command, int arg1, int arg2) {
byte buffer[5];

46
engines/sci/sfx/core.h
View File

@ -47,8 +47,8 @@ class SfxState {
public: // FIXME, make private
SongIterator *_it; /**< The song iterator at the heart of things */
uint _flags; /**< SFX_STATE_FLAG_* */
songlib_t _songlib; /**< Song library */
song_t *_song; /**< Active song, or start of active song chain */
SongLibrary _songlib; /**< Song library */
Song *_song; /**< Active song, or start of active song chain */
bool _suspended; /**< Whether we are suspended */
ResourceSync *_soundSync; /**< Used by kDoSync for speech syncing in CD talkie games */
AudioResource *_audioResource; /**< Used for audio resources in CD talkie games */
@ -77,17 +77,17 @@ public:
/* Polls the sound server for cues etc.
** Returns : (int) 0 if the cue queue is empty, SI_LOOP, SI_CUE, or SI_FINISHED otherwise
** (song_handle_t) *handle: The affected handle
** (SongHandle) *handle: The affected handle
** (int) *cue: The sound cue number (if SI_CUE), or the loop number (if SI_LOOP)
*/
int sfx_poll(song_handle_t *handle, int *cue);
int sfx_poll(SongHandle *handle, int *cue);
/* Polls the sound server for cues etc.
** Parameters: (song_handle_t) handle: The handle to poll
** Parameters: (SongHandle) handle: The handle to poll
** Returns : (int) 0 if the cue queue is empty, SI_LOOP, SI_CUE, or SI_FINISHED otherwise
** (int) *cue: The sound cue number (if SI_CUE), or the loop number (if SI_LOOP)
*/
int sfx_poll_specific(song_handle_t handle, int *cue);
int sfx_poll_specific(SongHandle handle, int *cue);
/* Determines the current global volume settings
** Returns : (int) The global volume, between 0 (silent) and 127 (max. volume)
@ -111,15 +111,15 @@ public:
/* Adds a song to the internal sound library
** Parameters: (SongIterator *) it: The iterator describing the song
** (int) priority: Initial song priority (higher <-> more important)
** (song_handle_t) handle: The handle to associate with the song
** (SongHandle) handle: The handle to associate with the song
*/
void sfx_add_song(SongIterator *it, int priority, song_handle_t handle, int resnum);
void sfx_add_song(SongIterator *it, int priority, SongHandle handle, int resnum);
/* Deletes a song and its associated song iterator from the song queue
** Parameters: (song_handle_t) handle: The song to remove
** Parameters: (SongHandle) handle: The song to remove
*/
void sfx_remove_song(song_handle_t handle);
void sfx_remove_song(SongHandle handle);
/**********************/
@ -128,48 +128,48 @@ public:
/* Sets the song status, i.e. whether it is playing, suspended, or stopped.
** Parameters: (song_handle_t) handle: Handle of the song to modify
** Parameters: (SongHandle) handle: Handle of the song to modify
** (int) status: The song status the song should assume
** WAITING and PLAYING are set implicitly and essentially describe the same state
** as far as this function is concerned.
*/
void sfx_song_set_status(song_handle_t handle, int status);
void sfx_song_set_status(SongHandle handle, int status);
/* Sets the new song priority
** Parameters: (song_handle_t) handle: The handle to modify
** Parameters: (SongHandle) handle: The handle to modify
** (int) priority: The priority to set
*/
void sfx_song_renice(song_handle_t handle, int priority);
void sfx_song_renice(SongHandle handle, int priority);
/* Sets the number of loops for the specified song
** Parameters: (song_handle_t) handle: The song handle to reference
** Parameters: (SongHandle) handle: The song handle to reference
** (int) loops: Number of loops to set
*/
void sfx_song_set_loops(song_handle_t handle, int loops);
void sfx_song_set_loops(SongHandle handle, int loops);
/* Sets the number of loops for the specified song
** Parameters: (song_handle_t) handle: The song handle to reference
** Parameters: (SongHandle) handle: The song handle to reference
** (int) hold: Number of loops to setn
*/
void sfx_song_set_hold(song_handle_t handle, int hold);
void sfx_song_set_hold(SongHandle handle, int hold);
/* Instructs a song to be faded out
** Parameters: (song_handle_t) handle: The song handle to reference
** Parameters: (SongHandle) handle: The song handle to reference
** (fade_params_t *) fade_setup: The precise fade-out configuration to use
*/
void sfx_song_set_fade(song_handle_t handle, fade_params_t *fade_setup);
void sfx_song_set_fade(SongHandle handle, fade_params_t *fade_setup);
// Previously undocumented:
Common::Error sfx_send_midi(song_handle_t handle, int channel,
Common::Error sfx_send_midi(SongHandle handle, int channel,
int command, int arg1, int arg2);
protected:
void freezeTime();
void thawTime();
bool isPlaying(song_t *song);
void setSongStatus(song_t *song, int status);
bool isPlaying(Song *song);
void setSongStatus(Song *song, int status);
void updateSingleSong();
void updateMultiSong();
void update();

17
engines/sci/sfx/iterator.h
View File

@ -253,7 +253,6 @@ enum SongIteratorType {
| IT_READER_MASK_CUE \
| IT_READER_MASK_PCM )
int songit_next(SongIterator **it, byte *buf, int *result, int mask);
/* Convenience wrapper around it->next
** Parameters: (SongIterator **it) Reference to the iterator to access
** (byte *) buf: The buffer to write to (needs to be able to
@ -270,8 +269,8 @@ int songit_next(SongIterator **it, byte *buf, int *result, int mask);
** to the lower layers) for 0, the cue value for SI_CUE,
** or the number of loops remaining for SI_LOOP.
*/
int songit_next(SongIterator **it, byte *buf, int *result, int mask);
SongIterator *songit_new(byte *data, uint size, SongIteratorType type, songit_id_t id);
/* Constructs a new song iterator object
** Parameters: (byte *) data: The song data to iterate over
** (uint) size: Number of bytes in the song
@ -280,26 +279,17 @@ SongIterator *songit_new(byte *data, uint size, SongIteratorType type, songit_id
** Returns : (SongIterator *) A newly allocated but uninitialized song
** iterator, or NULL if 'type' was invalid or unsupported
*/
SongIterator *songit_new(byte *data, uint size, SongIteratorType type, songit_id_t id);
int songit_handle_message(SongIterator **it_reg, SongIterator::Message msg);
/* Handles a message to the song iterator
** Parameters: (SongIterator **): A reference to the variable storing the song iterator
** Returns : (int) Non-zero if the message was understood
** The song iterator may polymorph as result of msg, so a writeable reference is required.
*/
int songit_handle_message(SongIterator **it_reg, SongIterator::Message msg);
int sfx_play_iterator_pcm(SongIterator *it, unsigned long handle);
/* Plays a song iterator that found a PCM through a PCM device, if possible
** Parameters: (SongIterator *) it: The iterator to play
** (song_handle_t) handle: Debug handle
** Returns : (int) 0 if the effect will not be played, nonzero if it will
** This assumes that the last call to 'it->next()' returned SI_PCM.
*/
SongIterator *new_fast_forward_iterator(SongIterator *it, int delta);
/* Creates a new song iterator which fast-forwards
** Parameters: (SongIterator *) it: The iterator to wrap
** (int) delta: The number of ticks to skip
@ -307,6 +297,7 @@ SongIterator *new_fast_forward_iterator(SongIterator *it, int delta);
** which skips all delta times
** until 'delta' has been used up
*/
SongIterator *new_fast_forward_iterator(SongIterator *it, int delta);

136
engines/sci/sfx/songlib.cpp
View File

@ -31,169 +31,169 @@ namespace Sci {
#define debug_stream stderr
song_t *song_new(song_handle_t handle, SongIterator *it, int priority) {
song_t *retval;
retval = (song_t*) malloc(sizeof(song_t));
Song *song_new(SongHandle handle, SongIterator *it, int priority) {
Song *retval;
retval = (Song *)malloc(sizeof(Song));
#ifdef SATISFY_PURIFY
memset(retval, 0, sizeof(song_t));
memset(retval, 0, sizeof(Song));
#endif
retval->handle = handle;
retval->priority = priority;
retval->next = NULL;
retval->_handle = handle;
retval->_priority = priority;
retval->_next = NULL;
retval->_delay = 0;
retval->_wakeupTime = Audio::Timestamp();
retval->it = it;
retval->status = SOUND_STATUS_STOPPED;
retval->next_playing = NULL;
retval->next_stopping = NULL;
retval->restore_behavior = RESTORE_BEHAVIOR_CONTINUE;
retval->restore_time = 0;
retval->_it = it;
retval->_status = SOUND_STATUS_STOPPED;
retval->_nextPlaying = NULL;
retval->_nextStopping = NULL;
retval->_restoreBehavior = RESTORE_BEHAVIOR_CONTINUE;
retval->_restoreTime = 0;
return retval;
}
void song_lib_add(const songlib_t &songlib, song_t *song) {
song_t **seeker = NULL;
int pri = song->priority;
void song_lib_add(const SongLibrary &songlib, Song *song) {
Song **seeker = NULL;
int pri = song->_priority;
if (NULL == song) {
sciprintf("song_lib_add(): NULL passed for song\n");
return;
}
if (*(songlib.lib) == NULL) {
*(songlib.lib) = song;
song->next = NULL;
if (*(songlib._lib) == NULL) {
*(songlib._lib) = song;
song->_next = NULL;
return;
}
seeker = (songlib.lib);
while (*seeker && ((*seeker)->priority > pri))
seeker = &((*seeker)->next);
seeker = (songlib._lib);
while (*seeker && ((*seeker)->_priority > pri))
seeker = &((*seeker)->_next);
song->next = *seeker;
song->_next = *seeker;
*seeker = song;
}
static void _songfree_chain(song_t *song) {
static void _songfree_chain(Song *song) {
/* Recursively free a chain of songs */
if (song) {
_songfree_chain(song->next);
delete song->it;
song->it = NULL;
_songfree_chain(song->_next);
delete song->_it;
song->_it = NULL;
free(song);
}
}
void song_lib_init(songlib_t *songlib) {
songlib->lib = &(songlib->_s);
void song_lib_init(SongLibrary *songlib) {
songlib->_lib = &(songlib->_s);
songlib->_s = NULL;
}
void song_lib_free(const songlib_t &songlib) {
_songfree_chain(*(songlib.lib));
*(songlib.lib) = NULL;
void song_lib_free(const SongLibrary &songlib) {
_songfree_chain(*(songlib._lib));
*(songlib._lib) = NULL;
}
song_t *song_lib_find(const songlib_t &songlib, song_handle_t handle) {
song_t *seeker = *(songlib.lib);
Song *song_lib_find(const SongLibrary &songlib, SongHandle handle) {
Song *seeker = *(songlib._lib);
while (seeker) {
if (seeker->handle == handle)
if (seeker->_handle == handle)
break;
seeker = seeker->next;
seeker = seeker->_next;
}
return seeker;
}
song_t *song_lib_find_next_active(const songlib_t &songlib, song_t *other) {
song_t *seeker = other ? other->next : *(songlib.lib);
Song *song_lib_find_next_active(const SongLibrary &songlib, Song *other) {
Song *seeker = other ? other->_next : *(songlib._lib);
while (seeker) {
if ((seeker->status == SOUND_STATUS_WAITING) ||
(seeker->status == SOUND_STATUS_PLAYING))
if ((seeker->_status == SOUND_STATUS_WAITING) ||
(seeker->_status == SOUND_STATUS_PLAYING))
break;
seeker = seeker->next;
seeker = seeker->_next;
}
/* Only return songs that have equal priority */
if (other && seeker && other->priority > seeker->priority)
if (other && seeker && other->_priority > seeker->_priority)
return NULL;
return seeker;
}
song_t *song_lib_find_active(const songlib_t &songlib) {
Song *song_lib_find_active(const SongLibrary &songlib) {
return song_lib_find_next_active(songlib, NULL);
}
int song_lib_remove(const songlib_t &songlib, song_handle_t handle) {
int song_lib_remove(const SongLibrary &songlib, SongHandle handle) {
int retval;
song_t *goner = *(songlib.lib);
Song *goner = *(songlib._lib);
if (!goner)
return -1;
if (goner->handle == handle)
*(songlib.lib) = goner->next;
if (goner->_handle == handle)
*(songlib._lib) = goner->_next;
else {
while ((goner->next) && (goner->next->handle != handle))
goner = goner->next;
while ((goner->_next) && (goner->_next->_handle != handle))
goner = goner->_next;
if (goner->next) { /* Found him? */
song_t *oldnext = goner->next;
if (goner->_next) { /* Found him? */
Song *oldnext = goner->_next;
goner->next = goner->next->next;
goner->_next = goner->_next->_next;
goner = oldnext;
} else return -1; /* No. */
}
retval = goner->status;
retval = goner->_status;
delete goner->it;
delete goner->_it;
free(goner);
return retval;
}
void song_lib_resort(const songlib_t &songlib, song_t *song) {
if (*(songlib.lib) == song)
*(songlib.lib) = song->next;
void song_lib_resort(const SongLibrary &songlib, Song *song) {
if (*(songlib._lib) == song)
*(songlib._lib) = song->_next;
else {
song_t *seeker = *(songlib.lib);
Song *seeker = *(songlib._lib);
while (seeker->next && (seeker->next != song))
seeker = seeker->next;
while (seeker->_next && (seeker->_next != song))
seeker = seeker->_next;
if (seeker->next)
seeker->next = seeker->next->next;
if (seeker->_next)
seeker->_next = seeker->_next->_next;
}
song_lib_add(songlib, song);
}
int song_lib_count(const songlib_t &songlib) {
song_t *seeker = *(songlib.lib);
int song_lib_count(const SongLibrary &songlib) {
Song *seeker = *(songlib._lib);
int retval = 0;
while (seeker) {
retval++;
seeker = seeker->next;
seeker = seeker->_next;
}
return retval;
}
void song_lib_set_restore_behavior(const songlib_t &songlib, song_handle_t handle, RESTORE_BEHAVIOR action) {
song_t *seeker = song_lib_find(songlib, handle);
void song_lib_set_restore_behavior(const SongLibrary &songlib, SongHandle handle, RESTORE_BEHAVIOR action) {
Song *seeker = song_lib_find(songlib, handle);
seeker->restore_behavior = action;
seeker->_restoreBehavior = action;
}
} // End of namespace Sci

115
engines/sci/sfx/songlib.h
View File

@ -42,7 +42,7 @@ class SongIterator;
#define SOUND_STATUS_WAITING 3
/* "waiting" means "tagged for playing, but not active right now" */
typedef unsigned long song_handle_t;
typedef unsigned long SongHandle;
enum RESTORE_BEHAVIOR {
RESTORE_BEHAVIOR_CONTINUE, /* restart a song when restored from
@ -50,123 +50,130 @@ enum RESTORE_BEHAVIOR {
RESTORE_BEHAVIOR_RESTART /* continue it from where it was */
};
struct song_t {
song_handle_t handle;
int resource_num; /* Resource number */
int priority; /* Song priority (more important if priority is higher) */
int status; /* See above */
struct Song {
SongHandle _handle;
int _resourceNum; /**<! Resource number */
int _priority; /**!< Song priority (more important if priority is higher) */
int _status; /* See above */
int restore_behavior;
int restore_time;
int _restoreBehavior;
int _restoreTime;
/* Grabbed from the sound iterator, for save/restore purposes */
int loops;
int hold;
int _loops;
int _hold;
SongIterator *it;
int _delay; /* Delay before accessing the iterator, in ticks */
SongIterator *_it;
int _delay; /**!< Delay before accessing the iterator, in ticks */
Audio::Timestamp _wakeupTime; /**< Timestamp indicating the next MIDI event */
Audio::Timestamp _wakeupTime; /**!< Timestamp indicating the next MIDI event */
song_t *next; /* Next song or NULL if this is the last one */
song_t *next_playing; /* Next playing song; used by the
** core song system */
song_t *next_stopping; /* Next song pending stopping; used exclusively by
** the core song system's _update_multi_song() */
Song *_next; /**!< Next song or NULL if this is the last one */
/**
* Next playing song. Used by the core song system.
*/
Song *_nextPlaying;
/**
* Next song pending stopping. Used exclusively by the core song system's
* _update_multi_song()
*/
Song *_nextStopping;
};
struct songlib_t {
song_t **lib;
song_t *_s;
struct SongLibrary {
Song **_lib;
Song *_s;
};
/**************************/
/* Song library commands: */
/**************************/
song_t *song_new(song_handle_t handle, SongIterator *it, int priority);
/* Initializes a new song
** Parameters: (song_handle_t) handle: The sound handle
** Parameters: (SongHandle) handle: The sound handle
** (SongIterator *) it: The song
** (int) priority: The song's priority
** Returns : (song_t *) A freshly allocated song
** Returns : (Song *) A freshly allocated song
** Other values are set to predefined defaults.
*/
Song *song_new(SongHandle handle, SongIterator *it, int priority);
void song_lib_init(songlib_t *songlib);
/* Initializes a static song library
** Parameters: (songlib_t *) songlib: Pointer to the library
** Parameters: (SongLibrary *) songlib: Pointer to the library
** to initialize
** Returns : (void)
*/
void song_lib_init(SongLibrary *songlib);
void song_lib_free(const songlib_t &songlib);
/* Frees a song library
** Parameters: (songlib_t) songlib: The library to free
** Parameters: (SongLibrary) songlib: The library to free
** Returns : (void)
*/
void song_lib_free(const SongLibrary &songlib);
void song_lib_add(const songlib_t &songlib, song_t *song);
/* Adds a song to a song library.
** Parameters: (songlib_t) songlib: An existing sound library, or NULL
** (song_t *) song: The song to add
** Parameters: (SongLibrary) songlib: An existing sound library, or NULL
** (Song *) song: The song to add
** Returns : (void)
*/
void song_lib_add(const SongLibrary &songlib, Song *song);
song_t *song_lib_find(const songlib_t &songlib, song_handle_t handle);
/* Looks up the song with the specified handle
** Parameters: (songlib_t) songlib: An existing sound library, may point to NULL
** (song_handle_t) handle: The sound handle to look for
** Returns : (song_t *) The song or NULL if it wasn't found
** Parameters: (SongLibrary) songlib: An existing sound library, may point to NULL
** (SongHandle) handle: The sound handle to look for
** Returns : (Song *) The song or NULL if it wasn't found
*/
Song *song_lib_find(const SongLibrary &songlib, SongHandle handle);
song_t *song_lib_find_active(const songlib_t &songlib);
/* Finds the first song playing with the highest priority
** Parameters: (songlib_t) songlib: An existing sound library
** Returns : (song_t *) The song that should be played next, or NULL if there is none
** Parameters: (SongLibrary) songlib: An existing sound library
** Returns : (Song *) The song that should be played next, or NULL if there is none
*/
Song *song_lib_find_active(const SongLibrary &songlib);
song_t *song_lib_find_next_active(const songlib_t &songlib, song_t *song);
/* Finds the next song playing with the highest priority
** Parameters: (songlib_t) songlib: The song library to operate on
** (song_t *) song: A song previously returned from the song library
** Returns : (song_t *) The next song to play relative to 'song', or
** Parameters: (SongLibrary) songlib: The song library to operate on
** (Song *) song: A song previously returned from the song library
** Returns : (Song *) The next song to play relative to 'song', or
** NULL if none are left
** The functions 'song_lib_find_active' and 'song_lib_find_next_active
** allow to iterate over all songs that satisfy the requirement of
** being 'playable'.
*/
Song *song_lib_find_next_active(const SongLibrary &songlib, Song *song);
int song_lib_remove(const songlib_t &songlib, song_handle_t handle);
/* Removes a song from the library
** Parameters: (songlib_t) songlib: An existing sound library
** (song_handle_t) handle: Handle of the song to remove
** Parameters: (SongLibrary) songlib: An existing sound library
** (SongHandle) handle: Handle of the song to remove
** Returns : (int) The status of the song that was removed
*/
int song_lib_remove(const SongLibrary &songlib, SongHandle handle);
void song_lib_resort(const songlib_t &songlib, song_t *song);
/* Removes a song from the library and sorts it in again; for use after renicing
** Parameters: (songlib_t) songlib: An existing sound library
** (song_t *) song: The song to work on
** Parameters: (SongLibrary) songlib: An existing sound library
** (Song *) song: The song to work on
** Returns : (void)
*/
void song_lib_resort(const SongLibrary &songlib, Song *song);
int song_lib_count(const songlib_t &songlib);
/* Counts the number of songs in a song library
** Parameters: (songlib_t) songlib: The library to count
** Parameters: (SongLibrary) songlib: The library to count
** Returns : (int) The number of songs
*/
int song_lib_count(const SongLibrary &songlib);
void song_lib_set_restore_behavior(const songlib_t &songlib, song_handle_t handle,
RESTORE_BEHAVIOR action);
/* Determines what should be done with the song "handle" when
** restoring it from a saved game.
** Parameters: (songlib_t) songlib: The library that contains the song
** (song_handle_t) handle: Its handle
** Parameters: (SongLibrary) songlib: The library that contains the song
** (SongHandle) handle: Its handle
** (RESTORE_BEHAVIOR) action: The desired action
*/
void song_lib_set_restore_behavior(const SongLibrary &songlib, SongHandle handle,
RESTORE_BEHAVIOR action);
} // End of namespace Sci