2001-12-01 17:23:50 +00:00
|
|
|
/* ScummVM - Scumm Interpreter
|
|
|
|
* Copyright (C) 2001 The ScummVM project
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*
|
|
|
|
* $Header$
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "stdafx.h"
|
|
|
|
|
|
|
|
#include "scumm.h"
|
|
|
|
#include "sound.h"
|
|
|
|
|
|
|
|
int num_mix;
|
|
|
|
|
|
|
|
#define TICKS_PER_BEAT 480
|
|
|
|
|
|
|
|
#ifdef USE_ADLIB
|
|
|
|
#define TEMPO_BASE 0x1924E0
|
|
|
|
#define HARDWARE_TYPE 1
|
|
|
|
#else
|
|
|
|
#define TEMPO_BASE 0x400000
|
|
|
|
#define HARDWARE_TYPE 5
|
|
|
|
#endif
|
|
|
|
#define SYSEX_ID 0x7D
|
|
|
|
#define SPECIAL_CHANNEL 9
|
|
|
|
|
|
|
|
#define TRIGGER_ID 0
|
|
|
|
#define COMMAND_ID 1
|
|
|
|
|
|
|
|
#ifdef SAMNMAX
|
|
|
|
#define MDHD_TAG "MDpg"
|
|
|
|
#else
|
|
|
|
#define MDHD_TAG "MDhd"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int clamp(int val, int min, int max) {
|
|
|
|
if (val<min)
|
|
|
|
return min;
|
|
|
|
if (val>max)
|
|
|
|
return max;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
int transpose_clamp(int a, int b, int c) {
|
|
|
|
if (b>a) a += (b - a + 11) / 12 * 12;
|
|
|
|
if (c<a) a -= (a - c + 11) / 12 * 12;
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32 get_delta_time(byte **s) {
|
|
|
|
byte *d = *s,b;
|
|
|
|
uint32 time = 0;
|
|
|
|
do {
|
|
|
|
b = *d++;
|
|
|
|
time = (time<<7) | (b&0x7F);
|
|
|
|
} while (b&0x80);
|
|
|
|
*s = d;
|
|
|
|
return time;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint read_word(byte *a) {
|
|
|
|
return (a[0]<<8) + a[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
void skip_midi_cmd(byte **song_ptr) {
|
|
|
|
byte *s, code;
|
|
|
|
|
|
|
|
const byte num_skip[] = {
|
|
|
|
2,2,2,2,1,1,2
|
|
|
|
};
|
|
|
|
|
|
|
|
s = *song_ptr;
|
|
|
|
|
|
|
|
code = *s++;
|
|
|
|
|
|
|
|
if (code<0x80) {
|
|
|
|
s = NULL;
|
|
|
|
} else if (code<0xF0) {
|
|
|
|
s += num_skip[(code&0x70)>>4];
|
|
|
|
} else {
|
|
|
|
if (code==0xF0 || code==0xF7 || code==0xFF && *s++ != 0x2F) {
|
|
|
|
s += get_delta_time(&s);
|
|
|
|
} else {
|
|
|
|
s = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*song_ptr = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
int is_note_cmd(byte **a, IsNoteCmdData *isnote) {
|
|
|
|
byte *s = *a;
|
|
|
|
byte code;
|
|
|
|
|
|
|
|
code = *s++;
|
|
|
|
|
|
|
|
switch(code>>4) {
|
|
|
|
case 8: /* key off */
|
|
|
|
isnote->chan = code&0xF;
|
|
|
|
isnote->note = *s++;
|
|
|
|
isnote->vel = *s++;
|
|
|
|
*a = s;
|
|
|
|
return 1;
|
|
|
|
case 9: /* key on */
|
|
|
|
isnote->chan = code&0xF;
|
|
|
|
isnote->note = *s++;
|
|
|
|
isnote->vel = *s++;
|
|
|
|
*a = s;
|
|
|
|
if (isnote->vel)
|
|
|
|
return 2;
|
|
|
|
return 1;
|
|
|
|
case 0xA:
|
|
|
|
case 0xB:
|
|
|
|
case 0xE:
|
|
|
|
s++;
|
|
|
|
case 0xC:
|
|
|
|
case 0xD:
|
|
|
|
s++;
|
|
|
|
break;
|
|
|
|
case 0xF:
|
|
|
|
if (code==0xF0 || code==0xF7 || code==0xFF && *s++ != 0x2F) {
|
|
|
|
s += get_delta_time(&s);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
*a = s;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************/
|
|
|
|
|
|
|
|
void SoundEngine::lock() {
|
|
|
|
_locked++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::unlock() {
|
|
|
|
_locked--;
|
|
|
|
}
|
|
|
|
|
|
|
|
byte *SoundEngine::findTag(int sound, char *tag, int index) {
|
|
|
|
byte *ptr = _base_sounds[sound];
|
|
|
|
int32 size,pos;
|
|
|
|
|
|
|
|
if (ptr==NULL) {
|
|
|
|
debug(1, "SoundEngine::findTag completely failed finding sound %d", sound);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr += 8;
|
|
|
|
size = READ_BE_UINT32_UNALIGNED(ptr);
|
|
|
|
ptr += 4;
|
|
|
|
|
|
|
|
pos = 0;
|
|
|
|
while (pos < size) {
|
|
|
|
if (!memcmp(ptr + pos, tag, 4) && !index--)
|
|
|
|
return ptr + pos + 8;
|
|
|
|
pos += READ_BE_UINT32_UNALIGNED(ptr + pos + 4) + 8;
|
|
|
|
}
|
|
|
|
debug(1, "SoundEngine::findTag failed finding sound %d", sound);
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SoundEngine::start_sound(int sound) {
|
|
|
|
Player *player;
|
|
|
|
void *mdhd;
|
|
|
|
|
|
|
|
mdhd = findTag(sound, MDHD_TAG, 0);
|
2002-02-12 18:20:37 +00:00
|
|
|
if (!mdhd)
|
2001-12-01 17:23:50 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
player = allocate_player(128);
|
|
|
|
if (!player)
|
|
|
|
return false;
|
2002-03-02 12:54:37 +00:00
|
|
|
|
2001-12-01 17:23:50 +00:00
|
|
|
player->clear();
|
|
|
|
return player->start_sound(sound);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Player *SoundEngine::allocate_player(byte priority) {
|
|
|
|
Player *player = _players, *best = NULL;
|
|
|
|
int i;
|
|
|
|
byte bestpri = 255;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_players); i!=0; i--, player++) {
|
|
|
|
if (!player->_active)
|
|
|
|
return player;
|
|
|
|
if (player->_priority < bestpri) {
|
|
|
|
best = player;
|
|
|
|
bestpri = player->_priority;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bestpri < priority)
|
|
|
|
return best;
|
|
|
|
|
|
|
|
debug(1, "Denying player request");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::init_players() {
|
|
|
|
Player *player = _players;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_players); i!=0; i--, player++) {
|
|
|
|
player->_active = false;
|
2002-03-02 12:54:37 +00:00
|
|
|
player->_se = this;
|
2001-12-01 17:23:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::init_sustaining_notes() {
|
|
|
|
SustainingNotes *next = NULL, *sn = _sustaining_notes;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
_sustain_notes_used = NULL;
|
|
|
|
_sustain_notes_head = NULL;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_sustaining_notes);i!=0; i--,sn++) {
|
|
|
|
sn->next = next;
|
|
|
|
next = sn;
|
|
|
|
}
|
|
|
|
_sustain_notes_free = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::init_volume_fader() {
|
|
|
|
VolumeFader *vf = _volume_fader;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_volume_fader); i!=0; i--, vf++)
|
|
|
|
vf->initialize();
|
|
|
|
|
|
|
|
_active_volume_faders = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::init_parts() {
|
|
|
|
Part *part;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=0,part=_parts; i!=ARRAYSIZE(_parts); i++, part++) {
|
|
|
|
part->init(_driver);
|
|
|
|
part->_slot = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::stop_sound(int sound) {
|
|
|
|
Player *player = _players;
|
|
|
|
int i;
|
|
|
|
int r = -1;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_players); i!=0; i--,player++) {
|
|
|
|
if (player->_active && player->_id==sound) {
|
|
|
|
player->clear();
|
|
|
|
r = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::stop_all_sounds() {
|
|
|
|
Player *player = _players;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_players); i!=0; i--,player++) {
|
|
|
|
if (player->_active)
|
|
|
|
player->clear();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::on_timer() {
|
|
|
|
if (_locked || _paused)
|
|
|
|
return;
|
|
|
|
|
|
|
|
lock();
|
|
|
|
|
|
|
|
sequencer_timers();
|
|
|
|
expire_sustain_notes();
|
|
|
|
expire_volume_faders();
|
|
|
|
_driver->on_timer();
|
|
|
|
|
|
|
|
unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::sequencer_timers() {
|
|
|
|
Player *player = _players;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_players); i!=0; i--,player++) {
|
|
|
|
if (player->_active)
|
|
|
|
player->sequencer_timer();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::sequencer_timer() {
|
|
|
|
byte *mtrk;
|
|
|
|
uint32 counter;
|
|
|
|
byte *song_ptr;
|
|
|
|
|
|
|
|
counter = _timer_counter + _timer_speed;
|
|
|
|
_timer_counter = counter&0xFFFF;
|
|
|
|
_cur_pos += counter>>16;
|
|
|
|
_tick_index += counter>>16;
|
|
|
|
|
|
|
|
if (_tick_index>=_ticks_per_beat) {
|
|
|
|
_beat_index += _tick_index/_ticks_per_beat;
|
|
|
|
_tick_index %= _ticks_per_beat;
|
|
|
|
}
|
|
|
|
if (_loop_counter && _beat_index >= _loop_from_beat && _tick_index >= _loop_from_tick) {
|
|
|
|
_loop_counter--;
|
|
|
|
jump(_track_index, _loop_to_beat, _loop_to_tick);
|
|
|
|
}
|
|
|
|
if (_next_pos <= _cur_pos) {
|
|
|
|
mtrk = _se->findTag(_song_index, "MTrk", _track_index);
|
|
|
|
if (!mtrk) {
|
|
|
|
warning("Sound %d was unloaded while active", _song_index);
|
|
|
|
clear();
|
|
|
|
} else {
|
|
|
|
song_ptr = mtrk + _song_offset;
|
|
|
|
_abort = false;
|
|
|
|
|
|
|
|
while (_next_pos <= _cur_pos) {
|
|
|
|
song_ptr = parse_midi(song_ptr);
|
|
|
|
if (!song_ptr || _abort)
|
|
|
|
return;
|
|
|
|
_next_pos += get_delta_time(&song_ptr);
|
|
|
|
}
|
|
|
|
_song_offset = song_ptr - mtrk;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::handle_marker(uint id, byte data) {
|
|
|
|
uint16 *p;
|
2002-02-24 17:25:03 +00:00
|
|
|
uint pos;
|
2001-12-01 17:23:50 +00:00
|
|
|
|
|
|
|
pos = _queue_end;
|
|
|
|
if (pos == _queue_pos)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (_queue_adding && _queue_sound==id && data==_queue_marker)
|
|
|
|
return;
|
|
|
|
|
|
|
|
p = _cmd_queue[pos].array;
|
|
|
|
|
|
|
|
if (p[0] != TRIGGER_ID || p[1] != id || p[2] != data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
_trigger_count--;
|
|
|
|
_queue_cleared = false;
|
|
|
|
do {
|
2001-12-28 18:43:02 +00:00
|
|
|
pos = (pos+1) & (ARRAYSIZE(_cmd_queue)-1);
|
2001-12-01 17:23:50 +00:00
|
|
|
if (_queue_pos == pos)
|
|
|
|
break;
|
|
|
|
p = _cmd_queue[pos].array;
|
|
|
|
if (*p++ != COMMAND_ID)
|
|
|
|
break;
|
|
|
|
_queue_end = pos;
|
|
|
|
|
|
|
|
do_command(p[0],p[1],p[2],p[3],p[4],p[5],p[6],0);
|
|
|
|
|
|
|
|
if (_queue_cleared)
|
|
|
|
return;
|
|
|
|
pos = _queue_end;
|
|
|
|
} while (1);
|
|
|
|
|
|
|
|
_queue_end = pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::get_channel_volume(uint a) {
|
|
|
|
if (a<8)
|
|
|
|
return _channel_volume_eff[a];
|
|
|
|
return _master_volume;
|
|
|
|
}
|
|
|
|
|
|
|
|
Part *SoundEngine::allocate_part(byte pri) {
|
|
|
|
Part *part,*best=NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_parts),part=_parts; i!=0; i--,part++) {
|
|
|
|
if (!part->_player)
|
|
|
|
return part;
|
|
|
|
if (pri >= part->_pri_eff) {
|
|
|
|
pri = part->_pri_eff;
|
|
|
|
best = part;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (best)
|
|
|
|
best->uninit();
|
|
|
|
else
|
|
|
|
debug(1, "Denying part request");
|
|
|
|
return best;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::expire_sustain_notes() {
|
|
|
|
SustainingNotes *sn,*next;
|
|
|
|
Player *player;
|
|
|
|
uint32 counter;
|
|
|
|
|
|
|
|
for(sn=_sustain_notes_head; sn; sn = next) {
|
|
|
|
next = sn->next;
|
|
|
|
player = sn->player;
|
|
|
|
|
|
|
|
counter = sn->counter + player->_timer_speed;
|
|
|
|
sn->pos += counter>>16;
|
2002-02-24 17:25:03 +00:00
|
|
|
sn->counter = (unsigned short)counter & 0xFFFF;
|
2001-12-01 17:23:50 +00:00
|
|
|
|
|
|
|
if (sn->pos >= sn->off_pos) {
|
|
|
|
player->key_off(sn->chan, sn->note);
|
|
|
|
|
|
|
|
/* Unlink the node */
|
|
|
|
if (next)
|
|
|
|
next->prev = sn->prev;
|
|
|
|
if (sn->prev)
|
|
|
|
sn->prev->next = next;
|
|
|
|
else
|
|
|
|
_sustain_notes_head = next;
|
|
|
|
|
|
|
|
/* And put it in the free list */
|
|
|
|
sn->next = _sustain_notes_free;
|
|
|
|
_sustain_notes_free = sn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::expire_volume_faders() {
|
|
|
|
VolumeFader *vf;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (++_volume_fader_counter & 7)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!_active_volume_faders)
|
|
|
|
return;
|
|
|
|
|
|
|
|
_active_volume_faders = false;
|
|
|
|
vf = _volume_fader;
|
|
|
|
for (i=ARRAYSIZE(_volume_fader); i!=0; i--,vf++) {
|
|
|
|
if (vf->active) {
|
|
|
|
_active_volume_faders = true;
|
|
|
|
vf->on_timer();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void VolumeFader::on_timer() {
|
|
|
|
byte newvol;
|
|
|
|
|
|
|
|
newvol = curvol + speed_hi;
|
|
|
|
speed_lo_counter += speed_lo;
|
|
|
|
|
|
|
|
if (speed_lo_counter >= speed_lo_max) {
|
|
|
|
speed_lo_counter -= speed_lo_max;
|
|
|
|
newvol += direction;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (curvol!=newvol) {
|
|
|
|
if (!newvol) {
|
|
|
|
player->clear();
|
|
|
|
active = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
curvol = newvol;
|
|
|
|
player->set_vol(newvol);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!--num_steps) {
|
|
|
|
active = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::get_sound_status(int sound) {
|
|
|
|
int i;
|
|
|
|
Player *player;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_players),player=_players; i!=0; i--,player++) {
|
|
|
|
if (player->_active && player->_id==(uint16)sound)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return get_queue_sound_status(sound);
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::get_queue_sound_status(int sound) {
|
|
|
|
uint16 *a;
|
|
|
|
int i,j;
|
|
|
|
|
|
|
|
j = _queue_pos;
|
|
|
|
i = _queue_end;
|
|
|
|
|
|
|
|
while (i!=j) {
|
|
|
|
a = _cmd_queue[i].array;
|
|
|
|
if (a[0] == COMMAND_ID && a[1] == 8 && a[2] == (uint16)sound)
|
|
|
|
return 2;
|
2001-12-28 18:43:02 +00:00
|
|
|
i = (i+1) & (ARRAYSIZE(_cmd_queue)-1);
|
2001-12-01 17:23:50 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::set_volchan(int sound, int volchan) {
|
|
|
|
int r;
|
|
|
|
int i;
|
|
|
|
int num;
|
|
|
|
Player *player,*best,*sameid;
|
|
|
|
|
|
|
|
r = get_volchan_entry(volchan);
|
|
|
|
if (r==-1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (r >= 8) {
|
|
|
|
for(i=ARRAYSIZE(_players),player=_players; i!=0; i--,player++) {
|
|
|
|
if (player->_active && player->_id==(uint16)sound && player->_vol_chan!=(uint16)volchan) {
|
|
|
|
player->_vol_chan = volchan;
|
|
|
|
player->set_vol(player->_volume);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
best = NULL;
|
|
|
|
num = 0;
|
|
|
|
sameid = NULL;
|
|
|
|
for(i=ARRAYSIZE(_players),player=_players; i!=0; i--,player++) {
|
|
|
|
if (player->_active) {
|
|
|
|
if (player->_vol_chan==(uint16)volchan) {
|
|
|
|
num++;
|
|
|
|
if (!best || player->_priority <= best->_priority)
|
|
|
|
best = player;
|
|
|
|
} else if (player->_id == (uint16)sound) {
|
|
|
|
sameid = player;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sameid==NULL)
|
|
|
|
return -1;
|
|
|
|
if (num >= r)
|
|
|
|
best->clear();
|
|
|
|
player->_vol_chan = volchan;
|
|
|
|
player->set_vol(player->_volume);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::clear_queue() {
|
|
|
|
_queue_adding = false;
|
|
|
|
_queue_cleared = true;
|
|
|
|
_queue_pos = 0;
|
|
|
|
_queue_end = 0;
|
|
|
|
_trigger_count = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::enqueue_command(int a, int b, int c, int d, int e, int f, int g) {
|
|
|
|
uint16 *p;
|
|
|
|
uint i;
|
|
|
|
|
|
|
|
i = _queue_pos;
|
|
|
|
|
|
|
|
if (i == _queue_end)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (a==-1) {
|
|
|
|
_queue_adding = false;
|
|
|
|
_trigger_count++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = _cmd_queue[_queue_pos].array;
|
|
|
|
p[0] = COMMAND_ID;
|
|
|
|
p[1] = a;
|
|
|
|
p[2] = b;
|
|
|
|
p[3] = c;
|
|
|
|
p[4] = d;
|
|
|
|
p[5] = e;
|
|
|
|
p[6] = f;
|
|
|
|
p[7] = g;
|
|
|
|
|
2001-12-28 18:43:02 +00:00
|
|
|
i = (i+1) & (ARRAYSIZE(_cmd_queue)-1);
|
2001-12-01 17:23:50 +00:00
|
|
|
|
|
|
|
if (_queue_end!=i) {
|
|
|
|
_queue_pos = i;
|
|
|
|
return 0;
|
|
|
|
} else {
|
2001-12-28 18:43:02 +00:00
|
|
|
_queue_pos = (i-1) & (ARRAYSIZE(_cmd_queue)-1);
|
2001-12-01 17:23:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::query_queue(int param) {
|
|
|
|
switch(param) {
|
|
|
|
case 0: /* get trigger count */
|
|
|
|
return _trigger_count;
|
|
|
|
case 1: /* get trigger type */
|
|
|
|
if (_queue_end==_queue_pos)
|
|
|
|
return -1;
|
|
|
|
return _cmd_queue[_queue_end].array[1];
|
|
|
|
case 2: /* get trigger sound */
|
|
|
|
if (_queue_end==_queue_pos)
|
|
|
|
return 0xFF;
|
|
|
|
return _cmd_queue[_queue_end].array[2];
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::set_master_volume(uint vol) {
|
|
|
|
int i;
|
|
|
|
if (vol > 127)
|
|
|
|
return -1;
|
|
|
|
_master_volume = vol;
|
|
|
|
for (i=0; i!=8; i++)
|
|
|
|
_channel_volume_eff[i] = (_channel_volume[i]+1) * vol >> 7;
|
|
|
|
update_volumes();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::get_master_volume() {
|
|
|
|
return _master_volume;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::terminate() {
|
|
|
|
return 0;
|
|
|
|
/* not implemented */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int SoundEngine::enqueue_trigger(int sound, int marker) {
|
|
|
|
uint16 *p;
|
|
|
|
uint pos;
|
|
|
|
|
|
|
|
pos = _queue_pos;
|
|
|
|
|
|
|
|
p = _cmd_queue[pos].array;
|
|
|
|
p[0] = TRIGGER_ID;
|
|
|
|
p[1] = sound;
|
|
|
|
p[2] = marker;
|
|
|
|
|
2001-12-28 18:43:02 +00:00
|
|
|
pos = (pos+1) & (ARRAYSIZE(_cmd_queue)-1);
|
2001-12-01 17:23:50 +00:00
|
|
|
if (_queue_end==pos) {
|
2001-12-28 18:43:02 +00:00
|
|
|
_queue_pos = (pos-1) & (ARRAYSIZE(_cmd_queue)-1);
|
2001-12-01 17:23:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
_queue_pos = pos;
|
|
|
|
_queue_adding = true;
|
|
|
|
_queue_sound = sound;
|
|
|
|
_queue_marker = marker;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32 SoundEngine::do_command(int a, int b, int c, int d, int e, int f, int g, int h) {
|
|
|
|
byte cmd = a&0xFF;
|
|
|
|
byte param = a>>8;
|
|
|
|
Player *player;
|
|
|
|
|
|
|
|
if (!_initialized && (cmd || param))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (param==0) {
|
|
|
|
switch(cmd) {
|
|
|
|
case 6:
|
|
|
|
return set_master_volume(b);
|
|
|
|
case 7:
|
|
|
|
return get_master_volume();
|
|
|
|
case 8:
|
|
|
|
return start_sound(b) ? 0 : -1;
|
|
|
|
case 9:
|
|
|
|
return stop_sound(b);
|
|
|
|
case 11:
|
|
|
|
return stop_all_sounds();
|
|
|
|
case 13:
|
|
|
|
return get_sound_status(b);
|
|
|
|
case 16:
|
|
|
|
return set_volchan(b,c);
|
|
|
|
case 17:
|
|
|
|
return set_channel_volume(b,c);
|
|
|
|
case 18:
|
|
|
|
return set_volchan_entry(b,c);
|
|
|
|
default:
|
|
|
|
warning("SoundEngine::do_command invalid command %d", cmd);
|
|
|
|
}
|
|
|
|
} else if (param==1) {
|
|
|
|
|
|
|
|
if ( (1<<cmd) & (0x783FFF)) {
|
|
|
|
player = get_player_byid(b);
|
|
|
|
if (!player)
|
|
|
|
return -1;
|
|
|
|
if ( (1<<cmd) & (1<<11 | 1<<22) ) {
|
|
|
|
assert(c>=0 && c<=15);
|
|
|
|
player = (Player*)player->get_part(c);
|
|
|
|
if(!player)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(cmd) {
|
|
|
|
case 0:
|
|
|
|
return player->get_param(c, d);
|
|
|
|
case 1:
|
|
|
|
player->set_priority(c);
|
|
|
|
return 0;
|
|
|
|
case 2:
|
|
|
|
return player->set_vol(c);
|
|
|
|
case 3:
|
|
|
|
player->set_pan(c);
|
|
|
|
return 0;
|
|
|
|
case 4:
|
|
|
|
return player->set_transpose(c, d);
|
|
|
|
case 5:
|
|
|
|
player->set_detune(c);
|
|
|
|
return 0;
|
|
|
|
case 6:
|
|
|
|
player->set_speed(c);
|
|
|
|
return 0;
|
|
|
|
case 7:
|
|
|
|
return player->jump(c,d,e) ? 0 : -1;
|
|
|
|
case 8:
|
|
|
|
return player->scan(c,d,e);
|
|
|
|
case 9:
|
|
|
|
return player->set_loop(c,d,e,f,g) ? 0 : -1;
|
|
|
|
case 10:
|
|
|
|
player->clear_loop();
|
|
|
|
return 0;
|
|
|
|
case 11:
|
|
|
|
((Part*)player)->set_onoff(d!=0);
|
|
|
|
return 0;
|
|
|
|
case 12:
|
|
|
|
return player->_hook.set(c, d, e);
|
|
|
|
case 13:
|
|
|
|
return player->fade_vol(c,d);
|
|
|
|
case 14:
|
|
|
|
return enqueue_trigger(b,c);
|
|
|
|
case 15:
|
|
|
|
return enqueue_command(b,c,d,e,f,g,h);
|
|
|
|
case 16:
|
|
|
|
return clear_queue();
|
|
|
|
case 19:
|
|
|
|
return player->get_param(c,d);
|
|
|
|
case 20:
|
|
|
|
return player->_hook.set(c,d,e);
|
|
|
|
case 21:
|
|
|
|
return -1;
|
|
|
|
case 22:
|
|
|
|
((Part*)player)->set_vol(d);
|
|
|
|
return 0;
|
|
|
|
case 23:
|
|
|
|
return query_queue(b);
|
|
|
|
case 24:
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
warning("SoundEngine::do_command default midi command %d", cmd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::set_channel_volume(uint chan, uint vol) {
|
|
|
|
if (chan>=8 || vol>127)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
_channel_volume[chan] = vol;
|
|
|
|
_channel_volume_eff[chan] = _master_volume * (vol+1) >> 7;
|
|
|
|
update_volumes();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::update_volumes() {
|
|
|
|
Player *player;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i=ARRAYSIZE(_players),player=_players; i!=0; i--,player++) {
|
|
|
|
if (player->_active)
|
|
|
|
player->set_vol(player->_volume);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::set_volchan_entry(uint a, uint b) {
|
|
|
|
if (a >= 8)
|
|
|
|
return -1;
|
|
|
|
_volchan_table[a] = b;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int HookDatas::query_param(int param, byte chan) {
|
|
|
|
switch(param) {
|
|
|
|
case 18:
|
|
|
|
return _jump;
|
|
|
|
case 19:
|
|
|
|
return _transpose;
|
|
|
|
case 20:
|
|
|
|
return _part_onoff[chan];
|
|
|
|
case 21:
|
|
|
|
return _part_volume[chan];
|
|
|
|
case 22:
|
|
|
|
return _part_program[chan];
|
|
|
|
case 23:
|
|
|
|
return _part_transpose[chan];
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int HookDatas::set(byte cls, byte value, byte chan) {
|
|
|
|
switch(cls) {
|
|
|
|
case 0:
|
|
|
|
_jump = value;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
_transpose = value;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (chan<16)
|
|
|
|
_part_onoff[chan] = value;
|
|
|
|
else if (chan==16)
|
|
|
|
memset(_part_onoff, value, 16);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
if (chan<16)
|
|
|
|
_part_volume[chan] = value;
|
|
|
|
else if (chan==16)
|
|
|
|
memset(_part_volume, value, 16);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
if (chan<16)
|
|
|
|
_part_program[chan] = value;
|
|
|
|
else if (chan==16)
|
|
|
|
memset(_part_program, value, 16);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
if (chan<16)
|
|
|
|
_part_transpose[chan] = value;
|
|
|
|
else if (chan==16)
|
|
|
|
memset(_part_transpose, value, 16);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
VolumeFader *SoundEngine::allocate_volume_fader() {
|
|
|
|
VolumeFader *vf;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
vf = _volume_fader;
|
|
|
|
for(i=ARRAYSIZE(_volume_fader); vf->active; ) {
|
|
|
|
vf++;
|
|
|
|
if (!--i)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
vf->active = true;
|
|
|
|
_active_volume_faders = true;
|
|
|
|
return vf;
|
|
|
|
}
|
|
|
|
|
|
|
|
Player *SoundEngine::get_player_byid(int id) {
|
|
|
|
int i;
|
|
|
|
Player *player,*found=NULL;
|
|
|
|
|
|
|
|
for(i=ARRAYSIZE(_players),player=_players; i!=0; i--,player++) {
|
|
|
|
if (player->_active && player->_id==(uint16)id) {
|
|
|
|
if(found)
|
|
|
|
return NULL;
|
|
|
|
found = player;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::get_volchan_entry(uint a) {
|
|
|
|
if (a<8)
|
|
|
|
return _volchan_table[a];
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::initialize(Scumm *scumm, SoundDriver *driver) {
|
|
|
|
int i;
|
|
|
|
if (_initialized)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
scumm->_soundEngine = this;
|
|
|
|
_s = scumm;
|
|
|
|
|
|
|
|
_driver = (SOUND_DRIVER_TYPE*)driver;
|
|
|
|
|
|
|
|
_master_volume = 127;
|
|
|
|
for (i=0; i!=8; i++)
|
|
|
|
_channel_volume[i] = _channel_volume_eff[i] = _volchan_table[i] = 127;
|
|
|
|
|
|
|
|
init_players();
|
|
|
|
init_sustaining_notes();
|
|
|
|
init_volume_fader();
|
|
|
|
init_queue();
|
|
|
|
init_parts();
|
|
|
|
|
|
|
|
_driver->init(this);
|
|
|
|
|
|
|
|
_initialized = true;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::init_queue() {
|
|
|
|
_queue_adding = false;
|
|
|
|
_queue_pos = 0;
|
|
|
|
_queue_end = 0;
|
|
|
|
_trigger_count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundEngine::pause(bool paused) {
|
|
|
|
lock();
|
|
|
|
|
|
|
|
#if 0
|
2002-02-24 17:25:03 +00:00
|
|
|
int i;
|
|
|
|
Part *part;
|
|
|
|
MidiChannel *mc;
|
2001-12-01 17:23:50 +00:00
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_parts),part=_parts; i!=0; i--, part++) {
|
|
|
|
if (part->_player) {
|
|
|
|
if (paused) {
|
|
|
|
part->_vol_eff = 0;
|
|
|
|
} else {
|
|
|
|
part->set_vol(part->_vol);
|
|
|
|
}
|
|
|
|
part->vol_changed();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
_paused = paused;
|
|
|
|
|
|
|
|
unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
|
|
int Player::fade_vol(byte vol, int time) {
|
|
|
|
VolumeFader *vf;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cancel_volume_fade();
|
|
|
|
if (time==0) {
|
|
|
|
set_vol(vol);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
vf = _se->allocate_volume_fader();
|
|
|
|
if (vf==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
vf->player = this;
|
|
|
|
vf->num_steps = vf->speed_lo_max = time;
|
|
|
|
vf->curvol = _volume;
|
|
|
|
i = (vol - vf->curvol);
|
|
|
|
vf->speed_hi = i / time;
|
|
|
|
if (i<0) {
|
|
|
|
i = -i;
|
|
|
|
vf->direction = -1;
|
|
|
|
} else {
|
|
|
|
vf->direction = 1;
|
|
|
|
}
|
|
|
|
vf->speed_lo = i % time;
|
|
|
|
vf->speed_lo_counter = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::clear() {
|
|
|
|
uninit_seq();
|
|
|
|
cancel_volume_fade();
|
|
|
|
uninit_parts();
|
|
|
|
_active = false;
|
|
|
|
_ticks_per_beat = TICKS_PER_BEAT;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Player::start_sound(int sound) {
|
|
|
|
void *mdhd;
|
|
|
|
|
|
|
|
mdhd = _se->findTag(sound, MDHD_TAG, 0);
|
|
|
|
if (mdhd==NULL)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
_parts = NULL;
|
|
|
|
_active = true;
|
|
|
|
_id = sound;
|
|
|
|
_priority = 0x80;
|
|
|
|
_volume = 0x7F;
|
|
|
|
_vol_chan = 0xFFFF;
|
|
|
|
|
|
|
|
_vol_eff = (_se->get_channel_volume(0xFFFF)<<7)>>7;
|
|
|
|
|
|
|
|
_pan = 0;
|
|
|
|
_transpose = 0;
|
|
|
|
_detune = 0;
|
|
|
|
|
|
|
|
hook_clear();
|
|
|
|
if (start_seq_sound(sound) != 0) {
|
|
|
|
_active = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::hook_clear() {
|
|
|
|
memset(&_hook, 0, sizeof(_hook));
|
|
|
|
}
|
|
|
|
|
|
|
|
int Player::start_seq_sound(int sound) {
|
|
|
|
byte *ptr, *track_ptr;
|
|
|
|
|
|
|
|
_song_index = sound;
|
|
|
|
_timer_counter = 0;
|
|
|
|
_loop_to_beat = 1;
|
|
|
|
_loop_from_beat = 1;
|
|
|
|
_track_index = 0;
|
|
|
|
_loop_counter = 0;
|
|
|
|
_loop_to_tick = 0;
|
|
|
|
_loop_from_tick = 0;
|
|
|
|
|
|
|
|
set_tempo(500000);
|
|
|
|
set_speed(128);
|
|
|
|
ptr = _se->findTag(sound, "MTrk", _track_index);
|
|
|
|
if (ptr==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
track_ptr = ptr;
|
|
|
|
_cur_pos = _next_pos = get_delta_time(&track_ptr);
|
|
|
|
_song_offset = track_ptr - ptr;
|
|
|
|
|
|
|
|
_tick_index = _cur_pos;
|
|
|
|
_beat_index = 1;
|
|
|
|
|
|
|
|
if (_tick_index >= _ticks_per_beat) {
|
|
|
|
_beat_index += _tick_index/_ticks_per_beat;
|
|
|
|
_tick_index %= _ticks_per_beat;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::set_tempo(uint32 b) {
|
|
|
|
uint32 i,j;
|
2002-03-02 12:54:37 +00:00
|
|
|
printf("is: %d\n", _se->_s->_gameTempo);
|
|
|
|
if (_se->_s->_gameTempo < 1000)
|
|
|
|
i = TEMPO_BASE;
|
|
|
|
else
|
|
|
|
i = _se->_s->_gameTempo;
|
|
|
|
printf("Tempo set to: %d\n", i);
|
2001-12-01 17:23:50 +00:00
|
|
|
j = _tempo = b;
|
|
|
|
|
|
|
|
while (i&0xFFFF0000 || j&0xFFFF0000) { i>>=1; j>>=1; }
|
|
|
|
|
|
|
|
_tempo_eff = (i<<16) / j;
|
|
|
|
|
|
|
|
set_speed(_speed);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::cancel_volume_fade() {
|
|
|
|
VolumeFader *vf = _se->_volume_fader;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=0; i<8; i++,vf++) {
|
|
|
|
if (vf->active && vf->player==this)
|
|
|
|
vf->active = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::uninit_parts() {
|
|
|
|
if (_parts && _parts->_player != this)
|
|
|
|
error("asd");
|
|
|
|
while(_parts)
|
|
|
|
_parts->uninit();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::uninit_seq() {
|
|
|
|
_abort = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::set_speed(byte speed) {
|
|
|
|
_speed = speed;
|
|
|
|
_timer_speed = (_tempo_eff * speed >> 7);
|
|
|
|
}
|
|
|
|
|
|
|
|
byte *Player::parse_midi(byte *s) {
|
|
|
|
byte cmd,chan,note,velocity,control;
|
|
|
|
uint value;
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
cmd = *s++;
|
|
|
|
|
|
|
|
chan = cmd&0xF;
|
|
|
|
|
|
|
|
switch(cmd>>4) {
|
|
|
|
case 0x8: /* key off */
|
|
|
|
note = *s++;
|
|
|
|
if (!_scanning) {
|
|
|
|
key_off(chan, note);
|
|
|
|
} else {
|
|
|
|
clear_active_note(chan, note);
|
|
|
|
}
|
|
|
|
s++; /* skip velocity */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x9: /* key on */
|
|
|
|
note = *s++;
|
|
|
|
velocity = *s++;
|
|
|
|
if (velocity) {
|
|
|
|
if (!_scanning)
|
|
|
|
key_on(chan, note,velocity);
|
|
|
|
else
|
|
|
|
set_active_note(chan,note);
|
|
|
|
} else {
|
|
|
|
if (!_scanning)
|
|
|
|
key_off(chan, note);
|
|
|
|
else
|
|
|
|
clear_active_note(chan,note);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xA: /* aftertouch */
|
|
|
|
s += 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xB: /* control change */
|
|
|
|
control = *s++;
|
|
|
|
value = *s++;
|
|
|
|
part = get_part(chan);
|
|
|
|
if (!part)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch(control) {
|
|
|
|
case 1: /* modulation wheel */
|
|
|
|
part->set_modwheel(value);
|
|
|
|
break;
|
|
|
|
case 7: /* volume */
|
|
|
|
part->set_vol(value);
|
|
|
|
break;
|
|
|
|
case 10: /* pan position */
|
|
|
|
part->set_pan(value - 0x40);
|
|
|
|
break;
|
|
|
|
case 16: /* pitchbend factor */
|
|
|
|
part->set_pitchbend_factor(value);
|
|
|
|
break;
|
|
|
|
case 17: /* gp slider 2 */
|
|
|
|
part->set_detune(value - 0x40);
|
|
|
|
break;
|
|
|
|
case 18: /* gp slider 3 */
|
|
|
|
part->set_pri(value - 0x40);
|
|
|
|
_se->_driver->update_pris();
|
|
|
|
break;
|
|
|
|
case 64: /* hold pedal */
|
|
|
|
part->set_pedal(value!=0);
|
|
|
|
break;
|
|
|
|
case 91: /* effects level */
|
|
|
|
part->set_effect_level(value);
|
|
|
|
break;
|
|
|
|
case 93: /* chorus */
|
|
|
|
part->set_chorus(value);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
warning("parse_midi: invalid control %d", control);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xC: /* program change */
|
|
|
|
value = *s++;
|
|
|
|
part = get_part(chan);
|
|
|
|
if (part)
|
|
|
|
part->set_program(value);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xD: /* channel pressure */
|
|
|
|
s++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xE: /* pitch bend */
|
|
|
|
part = get_part(chan);
|
|
|
|
if (part)
|
|
|
|
part->set_pitchbend(((s[1]-0x40)<<7)|s[0]);
|
|
|
|
s+=2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xF:
|
|
|
|
if (chan==0) {
|
|
|
|
uint size = get_delta_time(&s);
|
|
|
|
if (*s==SYSEX_ID)
|
|
|
|
parse_sysex(s,size);
|
|
|
|
s += size;
|
|
|
|
} else if (chan==0xF) {
|
|
|
|
cmd = *s++;
|
|
|
|
if (cmd==47)
|
|
|
|
goto Error; /* end of song */
|
|
|
|
if (cmd==81) {
|
|
|
|
set_tempo((s[1]<<16) | (s[2]<<8) | s[3]);
|
|
|
|
s+=4;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
s += get_delta_time(&s);
|
|
|
|
} else if (chan==0x7) {
|
|
|
|
s += get_delta_time(&s);
|
|
|
|
} else {
|
|
|
|
goto Error;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
Error:;
|
|
|
|
if(!_scanning)
|
|
|
|
clear();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::parse_sysex(byte *p, uint len) {
|
|
|
|
byte code;
|
|
|
|
byte a;
|
|
|
|
uint b;
|
|
|
|
byte buf[128];
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
/* too big? */
|
|
|
|
if (len>=sizeof(buf)*2)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* skip sysex manufacturer */
|
|
|
|
p++;
|
|
|
|
len -= 2;
|
|
|
|
|
|
|
|
switch(code=*p++) {
|
|
|
|
case 16: /* set instrument in part */
|
|
|
|
a = *p++ & 0x0F;
|
|
|
|
if (HARDWARE_TYPE != *p++)
|
|
|
|
break;
|
|
|
|
decode_sysex_bytes(p, buf, len - 3);
|
|
|
|
part = get_part(a);
|
|
|
|
if(part)
|
|
|
|
part->set_instrument((Instrument*)buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 17: /* set global instrument */
|
|
|
|
p++;
|
|
|
|
if (HARDWARE_TYPE != *p++)
|
|
|
|
break;
|
|
|
|
a=*p++;
|
|
|
|
decode_sysex_bytes(p, buf, len - 4);
|
|
|
|
_se->_driver->set_instrument(a, buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 33: /* param adjust */
|
|
|
|
a = *p++ & 0x0F;
|
|
|
|
if (HARDWARE_TYPE != *p++)
|
|
|
|
break;
|
|
|
|
decode_sysex_bytes(p, buf, len - 3);
|
|
|
|
part = get_part(a);
|
|
|
|
if (part)
|
|
|
|
part->set_param(read_word(buf),read_word(buf+2));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 48: /* hook - jump */
|
|
|
|
if (_scanning)
|
|
|
|
break;
|
|
|
|
decode_sysex_bytes(p+1,buf,len-2);
|
|
|
|
maybe_jump(buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 49: /* hook - global transpose */
|
|
|
|
decode_sysex_bytes(p+1,buf,len-2);
|
|
|
|
maybe_set_transpose(buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 50: /* hook - part on/off */
|
|
|
|
buf[0] = *p++ & 0x0F;
|
|
|
|
decode_sysex_bytes(p,buf+1,len-2);
|
|
|
|
maybe_part_onoff(buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 51: /* hook - set volume */
|
|
|
|
buf[0] = *p++ & 0x0F;
|
|
|
|
decode_sysex_bytes(p,buf+1,len-2);
|
|
|
|
maybe_set_volume(buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 52: /* hook - set program */
|
|
|
|
buf[0] = *p++ & 0x0F;
|
|
|
|
decode_sysex_bytes(p,buf+1,len-2);
|
|
|
|
maybe_set_program(buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 53: /* hook - set transpose */
|
|
|
|
buf[0] = *p++ & 0x0F;
|
|
|
|
decode_sysex_bytes(p,buf+1,len-2);
|
|
|
|
maybe_set_transpose_part(buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 64: /* marker */
|
|
|
|
p++;
|
|
|
|
len -= 2;
|
|
|
|
while (len--) {
|
|
|
|
_se->handle_marker(_id, *p++);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 80: /* loop */
|
|
|
|
decode_sysex_bytes(p+1,buf,len-2);
|
|
|
|
set_loop(
|
|
|
|
read_word(buf),
|
|
|
|
read_word(buf+2),
|
|
|
|
read_word(buf+4),
|
|
|
|
read_word(buf+6),
|
|
|
|
read_word(buf+8)
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 81: /* end loop */
|
|
|
|
clear_loop();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 96: /* set instrument */
|
|
|
|
part = get_part(p[0] & 0x0F);
|
|
|
|
b = (p[1]&0x0F)<<12 | (p[2]&0x0F)<<8 | (p[4]&0x0F)<<4 | (p[4]&0x0F);
|
|
|
|
if(part)
|
|
|
|
part->set_instrument(b);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
debug(6,"unknown sysex %d", code);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::decode_sysex_bytes(byte *src, byte *dst, int len) {
|
|
|
|
while(len>=0) {
|
|
|
|
*dst++ = (src[0]<<4)|(src[1]&0xF);
|
|
|
|
src += 2;
|
|
|
|
len -= 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::maybe_jump(byte *data) {
|
|
|
|
byte cmd;
|
|
|
|
|
|
|
|
cmd = data[0];
|
|
|
|
|
|
|
|
/* is this the hook i'm waiting for? */
|
|
|
|
if (cmd && _hook._jump!=cmd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* reset hook? */
|
|
|
|
if(cmd!=0 && cmd<0x80)
|
|
|
|
_hook._jump = 0;
|
|
|
|
|
|
|
|
jump(read_word(data+1), read_word(data+3), read_word(data+5));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::maybe_set_transpose(byte *data) {
|
|
|
|
byte cmd;
|
|
|
|
|
|
|
|
cmd = data[0];
|
|
|
|
|
|
|
|
/* is this the hook i'm waiting for? */
|
|
|
|
if (cmd && _hook._transpose!=cmd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* reset hook? */
|
|
|
|
if(cmd!=0 && cmd<0x80)
|
|
|
|
_hook._transpose = 0;
|
|
|
|
|
|
|
|
set_transpose(data[1], (int8)data[2]);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::maybe_part_onoff(byte *data) {
|
|
|
|
byte cmd,*p;
|
|
|
|
uint chan;
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
cmd = data[1];
|
|
|
|
chan = data[0];
|
|
|
|
|
|
|
|
p = &_hook._part_onoff[chan];
|
|
|
|
|
|
|
|
/* is this the hook i'm waiting for? */
|
|
|
|
if (cmd && *p!=cmd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (cmd!=0 && cmd<0x80)
|
|
|
|
*p = 0;
|
|
|
|
|
|
|
|
part = get_part(chan);
|
|
|
|
if (part)
|
|
|
|
part->set_onoff(data[2]!=0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::maybe_set_volume(byte *data) {
|
|
|
|
byte cmd;
|
|
|
|
byte *p;
|
|
|
|
uint chan;
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
cmd = data[1];
|
|
|
|
chan = data[0];
|
|
|
|
|
|
|
|
p = &_hook._part_volume[chan];
|
|
|
|
|
|
|
|
/* is this the hook i'm waiting for? */
|
|
|
|
if (cmd && *p!=cmd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* reset hook? */
|
|
|
|
if (cmd!=0 && cmd<0x80)
|
|
|
|
*p = 0;
|
|
|
|
|
|
|
|
part = get_part(chan);
|
|
|
|
if (part)
|
|
|
|
part->set_vol(data[2]);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::maybe_set_program(byte *data) {
|
|
|
|
byte cmd;
|
|
|
|
byte *p;
|
|
|
|
uint chan;
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
cmd = data[1];
|
|
|
|
chan = data[0];
|
|
|
|
|
|
|
|
/* is this the hook i'm waiting for? */
|
|
|
|
p = &_hook._part_program[chan];
|
|
|
|
|
|
|
|
if (cmd && *p!=cmd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (cmd!=0 && cmd<0x80)
|
|
|
|
*p = 0;
|
|
|
|
|
|
|
|
part = get_part(chan);
|
|
|
|
if (part)
|
|
|
|
part->set_program(data[2]);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::maybe_set_transpose_part(byte *data) {
|
|
|
|
byte cmd;
|
|
|
|
byte *p;
|
|
|
|
uint chan;
|
|
|
|
|
|
|
|
cmd = data[1];
|
|
|
|
chan = data[0];
|
|
|
|
|
|
|
|
/* is this the hook i'm waiting for? */
|
|
|
|
p = &_hook._part_transpose[chan];
|
|
|
|
|
|
|
|
if (cmd && *p!=cmd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* reset hook? */
|
|
|
|
if (cmd!=0 && cmd<0x80)
|
|
|
|
*p = 0;
|
|
|
|
|
|
|
|
part_set_transpose(chan, data[2], (int8)data[3]);
|
|
|
|
}
|
|
|
|
|
|
|
|
int Player::set_transpose(byte relative, int b) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
if (b>24 || b<-24 || relative>1)
|
|
|
|
return -1;
|
|
|
|
if (relative)
|
|
|
|
b = transpose_clamp(_transpose + b, -7, 7);
|
|
|
|
|
|
|
|
_transpose = b;
|
|
|
|
|
|
|
|
for(part=_parts; part; part=part->_next) {
|
|
|
|
part->set_transpose(part->_transpose);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::clear_active_notes() {
|
|
|
|
memset(_se->_active_notes, 0, sizeof(_se->_active_notes));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::clear_active_note(int chan, byte note) {
|
|
|
|
_se->_active_notes[note] &= ~(1<<chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::set_active_note(int chan, byte note) {
|
|
|
|
_se->_active_notes[note] |= (1<<chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::part_set_transpose(uint8 chan, byte relative, int8 b) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
if (b>24 || b<-24)
|
|
|
|
return;
|
|
|
|
|
|
|
|
part = get_part(chan);
|
|
|
|
if (!part)
|
|
|
|
return;
|
|
|
|
if (relative)
|
|
|
|
b = transpose_clamp(b + part->_transpose, -7, 7);
|
|
|
|
part->set_transpose(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::key_on(uint8 chan, uint8 note, uint8 velocity) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
part = get_part(chan);
|
|
|
|
if (!part || !part->_on)
|
|
|
|
return;
|
|
|
|
|
|
|
|
part->key_on(note, velocity);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::key_off(uint8 chan, uint8 note) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
for(part=_parts; part; part = part->_next) {
|
|
|
|
if (part->_chan==(byte)chan && part->_on)
|
|
|
|
part->key_off(note);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Player::jump(uint track, uint beat, uint tick) {
|
|
|
|
byte *mtrk, *cur_mtrk, *scanpos;
|
|
|
|
uint32 topos,curpos,track_offs;
|
|
|
|
|
|
|
|
if (!_active)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
mtrk = _se->findTag(_song_index, "MTrk", track);
|
|
|
|
if (!mtrk)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
cur_mtrk = _se->findTag(_song_index,"MTrk", _track_index);
|
|
|
|
if (!cur_mtrk)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
_se->lock();
|
|
|
|
|
|
|
|
if (beat==0)
|
|
|
|
beat=1;
|
|
|
|
|
|
|
|
topos = (beat-1) * _ticks_per_beat + tick;
|
|
|
|
|
|
|
|
if (track == _track_index && topos >= _cur_pos) {
|
|
|
|
scanpos = _song_offset + mtrk;
|
|
|
|
curpos = _next_pos;
|
|
|
|
} else {
|
|
|
|
scanpos = mtrk;
|
|
|
|
curpos = get_delta_time(&scanpos);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (curpos < topos) {
|
|
|
|
skip_midi_cmd(&scanpos);
|
|
|
|
if (!scanpos) {
|
|
|
|
_se->unlock();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
curpos += get_delta_time(&scanpos);
|
|
|
|
}
|
|
|
|
|
|
|
|
track_offs = scanpos - mtrk;
|
|
|
|
|
|
|
|
turn_off_pedals();
|
|
|
|
|
|
|
|
find_sustaining_notes(cur_mtrk+_song_offset, mtrk+track_offs, curpos-topos);
|
|
|
|
|
|
|
|
_beat_index = beat;
|
|
|
|
_tick_index = tick;
|
|
|
|
_cur_pos = topos;
|
|
|
|
_next_pos = curpos;
|
|
|
|
_timer_counter = 0;
|
|
|
|
_song_offset = track_offs;
|
|
|
|
if (track != _track_index) {
|
|
|
|
_track_index = track;
|
|
|
|
_loop_counter = 0;
|
|
|
|
}
|
|
|
|
_abort = true;
|
|
|
|
_se->unlock();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Player::set_loop(uint count, uint tobeat, uint totick, uint frombeat, uint fromtick) {
|
|
|
|
if (tobeat+1 >= frombeat)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (tobeat==0)
|
|
|
|
tobeat=1;
|
|
|
|
|
|
|
|
_loop_counter = 0; /* because of possible interrupts */
|
|
|
|
_loop_to_beat = tobeat;
|
|
|
|
_loop_to_tick = totick;
|
|
|
|
_loop_from_beat = frombeat;
|
|
|
|
_loop_from_tick = fromtick;
|
|
|
|
_loop_counter = count;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::clear_loop() {
|
|
|
|
_loop_counter = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::turn_off_pedals() {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
for(part=_parts; part; part = part->_next) {
|
|
|
|
if (part->_pedal)
|
|
|
|
part->set_pedal(false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::find_sustaining_notes(byte *a, byte *b, uint32 l) {
|
|
|
|
uint32 pos;
|
|
|
|
uint16 mask;
|
|
|
|
uint16 *bitlist_ptr;
|
|
|
|
SustainingNotes *sn,*next;
|
|
|
|
IsNoteCmdData isnote;
|
|
|
|
int j;
|
|
|
|
uint num_active;
|
|
|
|
uint max_off_pos;
|
|
|
|
|
|
|
|
num_active = update_actives();
|
|
|
|
|
|
|
|
/* pos contains number of ticks since current position */
|
|
|
|
pos = _next_pos - _cur_pos;
|
|
|
|
if ((int32)pos<0)
|
|
|
|
pos = 0;
|
|
|
|
|
|
|
|
/* locate the positions where the notes are turned off.
|
|
|
|
* remember each note that was turned off
|
|
|
|
*/
|
|
|
|
while (num_active != 0) {
|
|
|
|
/* is note off? */
|
|
|
|
j = is_note_cmd(&a,&isnote);
|
|
|
|
if (j==-1)
|
|
|
|
break;
|
|
|
|
if (j == 1) {
|
|
|
|
mask = 1<<isnote.chan;
|
|
|
|
bitlist_ptr = _se->_active_notes + isnote.note;
|
|
|
|
if (*bitlist_ptr & mask) {
|
|
|
|
*bitlist_ptr &= ~mask;
|
|
|
|
num_active--;
|
|
|
|
/* Get a node from the free list */
|
|
|
|
if ((sn=_se->_sustain_notes_free) == NULL)
|
|
|
|
return;
|
|
|
|
_se->_sustain_notes_free = sn->next;
|
|
|
|
|
|
|
|
/* Insert it in the beginning of the used list */
|
|
|
|
sn->next = _se->_sustain_notes_used;
|
|
|
|
_se->_sustain_notes_used = sn;
|
|
|
|
sn->prev = NULL;
|
|
|
|
if (sn->next)
|
|
|
|
sn->next->prev = sn;
|
|
|
|
|
|
|
|
sn->note = isnote.note;
|
|
|
|
sn->chan = isnote.chan;
|
|
|
|
sn->player = this;
|
|
|
|
sn->off_pos = pos;
|
|
|
|
sn->pos = 0;
|
|
|
|
sn->counter = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pos += get_delta_time(&a);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* find the maximum position where a note was turned off */
|
|
|
|
max_off_pos = 0;
|
|
|
|
for(sn=_se->_sustain_notes_used; sn; sn = sn->next) {
|
|
|
|
_se->_active_notes[sn->note] |= (1<<sn->chan);
|
|
|
|
if (sn->off_pos > max_off_pos) {
|
|
|
|
max_off_pos = sn->off_pos;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* locate positions where notes are turned on */
|
|
|
|
pos = l;
|
|
|
|
while (pos < max_off_pos) {
|
|
|
|
j = is_note_cmd(&b,&isnote);
|
|
|
|
if (j==-1)
|
|
|
|
break;
|
|
|
|
if (j == 2) {
|
|
|
|
mask = 1<<isnote.chan;
|
|
|
|
bitlist_ptr = _se->_active_notes + isnote.note;
|
|
|
|
|
|
|
|
if (*bitlist_ptr&mask) {
|
|
|
|
sn = _se->_sustain_notes_used;
|
|
|
|
while (sn) {
|
|
|
|
next = sn->next;
|
|
|
|
if (sn->note==isnote.note && sn->chan==isnote.chan && pos < sn->off_pos) {
|
|
|
|
*bitlist_ptr &= ~mask;
|
|
|
|
/* Unlink from the sustain list */
|
|
|
|
if (next)
|
|
|
|
next->prev = sn->prev;
|
|
|
|
if (sn->prev)
|
|
|
|
sn->prev->next = next;
|
|
|
|
else
|
|
|
|
_se->_sustain_notes_used = next;
|
|
|
|
/* Insert into the free list */
|
|
|
|
sn->next = _se->_sustain_notes_free;
|
|
|
|
_se->_sustain_notes_free = sn;
|
|
|
|
}
|
|
|
|
sn = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pos += get_delta_time(&b);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Concatenate head and used list */
|
|
|
|
if (!_se->_sustain_notes_head) {
|
|
|
|
_se->_sustain_notes_head = _se->_sustain_notes_used;
|
|
|
|
_se->_sustain_notes_used = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sn = _se->_sustain_notes_head;
|
|
|
|
while (sn->next) sn = sn->next;
|
|
|
|
sn->next = _se->_sustain_notes_used;
|
|
|
|
_se->_sustain_notes_used = NULL;
|
|
|
|
if (sn->next)
|
|
|
|
sn->next->prev = sn;
|
|
|
|
}
|
|
|
|
|
|
|
|
Part *Player::get_part(uint8 chan) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
part = _parts;
|
|
|
|
while (part) {
|
|
|
|
if (part->_chan == chan)
|
|
|
|
return part;
|
|
|
|
part = part->_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
part = _se->allocate_part(_priority);
|
|
|
|
if (!part) {
|
|
|
|
warning("no parts available");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
part->_chan = chan;
|
|
|
|
part->setup(this);
|
|
|
|
|
|
|
|
return part;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint Player::update_actives() {
|
|
|
|
Part *part;
|
|
|
|
uint16 *active;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
clear_active_notes();
|
|
|
|
active = _se->_active_notes;
|
|
|
|
for(part=_parts; part; part = part->_next) {
|
|
|
|
if (part->_mc)
|
|
|
|
count += part->update_actives(active);
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::set_priority(int pri) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
_priority = pri;
|
|
|
|
for(part=_parts; part; part = part->_next) {
|
|
|
|
part->set_pri(part->_pri);
|
|
|
|
}
|
|
|
|
_se->_driver->update_pris();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::set_pan(int pan) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
_pan = pan;
|
|
|
|
for(part=_parts; part; part = part->_next) {
|
|
|
|
part->set_pan(part->_pan);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::set_detune(int detune) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
_detune = detune;
|
|
|
|
for(part=_parts; part; part = part->_next) {
|
|
|
|
part->set_detune(part->_detune);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int Player::scan(uint totrack, uint tobeat, uint totick) {
|
|
|
|
byte *mtrk,*scanptr;
|
|
|
|
uint32 curpos,topos;
|
|
|
|
uint32 pos;
|
|
|
|
|
|
|
|
assert(totrack>=0 && tobeat>=0 && totick>=0);
|
|
|
|
|
|
|
|
if (!_active)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
mtrk = _se->findTag(_song_index, "MTrk", totrack);
|
|
|
|
if (!mtrk)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
_se->lock();
|
|
|
|
if (tobeat==0)
|
|
|
|
tobeat++;
|
|
|
|
|
|
|
|
turn_off_parts();
|
|
|
|
clear_active_notes();
|
|
|
|
scanptr = mtrk;
|
|
|
|
curpos = get_delta_time(&scanptr);
|
|
|
|
_scanning=true;
|
|
|
|
|
|
|
|
topos = (tobeat-1) * _ticks_per_beat + totick;
|
|
|
|
|
|
|
|
while (curpos < topos) {
|
|
|
|
scanptr = parse_midi(scanptr);
|
|
|
|
if (!scanptr) {
|
|
|
|
_scanning=false;
|
|
|
|
_se->unlock();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
curpos += get_delta_time(&scanptr);
|
|
|
|
}
|
|
|
|
pos = scanptr - mtrk;
|
|
|
|
|
|
|
|
_scanning=false;
|
|
|
|
_se->driver()->update_pris();
|
|
|
|
play_active_notes();
|
|
|
|
_beat_index = tobeat;
|
|
|
|
_tick_index = totick;
|
|
|
|
_cur_pos = topos;
|
|
|
|
_next_pos = curpos;
|
|
|
|
_timer_counter = 0;
|
|
|
|
_song_offset = pos;
|
|
|
|
if (_track_index != totrack) {
|
|
|
|
_track_index = totrack;
|
|
|
|
_loop_counter = 0;
|
|
|
|
}
|
|
|
|
_se->unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::turn_off_parts() {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
for(part=_parts; part; part = part->_next)
|
|
|
|
part->off();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::play_active_notes() {
|
|
|
|
int i,j;
|
|
|
|
uint mask;
|
|
|
|
|
|
|
|
for (i=0; i!=128; i++) {
|
|
|
|
mask = _se->_active_notes[i];
|
|
|
|
for (j=0; j!=16; j++,mask>>=1) {
|
|
|
|
if (mask&1) {
|
|
|
|
key_on(j, i, 80);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int Player::set_vol(byte vol) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
if (vol > 127)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
_volume = vol;
|
|
|
|
_vol_eff = _se->get_channel_volume(_vol_chan) * (vol + 1) >> 7;
|
|
|
|
|
|
|
|
for(part=_parts; part; part=part->_next) {
|
|
|
|
part->set_vol(part->_vol);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Player::get_param(int param, byte chan) {
|
|
|
|
switch(param) {
|
|
|
|
case 0:
|
|
|
|
return (byte)_priority;
|
|
|
|
case 1:
|
|
|
|
return (byte)_volume;
|
|
|
|
case 2:
|
|
|
|
return (byte)_pan;
|
|
|
|
case 3:
|
|
|
|
return (byte)_transpose;
|
|
|
|
case 4:
|
|
|
|
return (byte)_detune;
|
|
|
|
case 5:
|
|
|
|
return _speed;
|
|
|
|
case 6:
|
|
|
|
return _track_index;
|
|
|
|
case 7:
|
|
|
|
return _beat_index;
|
|
|
|
case 8:
|
|
|
|
return _tick_index;
|
|
|
|
case 9:
|
|
|
|
return _loop_counter;
|
|
|
|
case 10:
|
|
|
|
return _loop_to_beat;
|
|
|
|
case 11:
|
|
|
|
return _loop_to_tick;
|
|
|
|
case 12:
|
|
|
|
return _loop_from_beat;
|
|
|
|
case 13:
|
|
|
|
return _loop_from_tick;
|
|
|
|
case 14: case 15: case 16: case 17:
|
|
|
|
return query_part_param(param, chan);
|
|
|
|
case 18: case 19: case 20: case 21: case 22: case 23:
|
|
|
|
return _hook.query_param(param, chan);
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int Player::query_part_param(int param, byte chan) {
|
|
|
|
Part *part;
|
|
|
|
|
|
|
|
part = _parts;
|
|
|
|
while (part) {
|
|
|
|
if(part->_chan==chan) {
|
|
|
|
switch(param) {
|
|
|
|
case 14:
|
|
|
|
return part->_on;
|
|
|
|
case 15:
|
|
|
|
return part->_vol;
|
|
|
|
case 16:
|
|
|
|
return part->_program;
|
|
|
|
case 17:
|
|
|
|
return part->_transpose;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
part = part->_next;
|
|
|
|
}
|
|
|
|
return 129;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************/
|
|
|
|
|
|
|
|
#define OFFS(type,item) ((int)(&((type*)0)->item))
|
|
|
|
#define SIZE(type,item) sizeof(((type*)0)->item)
|
|
|
|
#define MKLINE(type,item,saveas) {OFFS(type,item),saveas,SIZE(type,item)}
|
|
|
|
#define MKARRAY(type,item,saveas,num) {OFFS(type,item),128|saveas,SIZE(type,item)}, {num,0,0}
|
|
|
|
#define MKEND() {0xFFFF,0xFF,0xFF}
|
|
|
|
|
|
|
|
#define MKREF(type,item,refid) {OFFS(type,item),refid,0xFF}
|
|
|
|
|
|
|
|
enum {
|
|
|
|
TYPE_PART = 1,
|
|
|
|
TYPE_PLAYER = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
int SoundEngine::saveReference(SoundEngine *me, byte type, void*ref) {
|
|
|
|
switch(type) {
|
|
|
|
case TYPE_PART: return (Part*)ref - me->_parts;
|
|
|
|
case TYPE_PLAYER: return (Player*)ref - me->_players;
|
|
|
|
default:
|
|
|
|
error("saveReference: invalid type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void *SoundEngine::loadReference(SoundEngine *me, byte type, int ref) {
|
|
|
|
switch(type) {
|
|
|
|
case TYPE_PART: return &me->_parts[ref];
|
|
|
|
case TYPE_PLAYER: return &me->_players[ref];
|
|
|
|
default:
|
|
|
|
error("loadReference: invalid type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int SoundEngine::save_or_load(Serializer *ser) {
|
|
|
|
const SaveLoadEntry mainEntries[] = {
|
|
|
|
MKLINE(SoundEngine,_queue_end, sleUint8),
|
|
|
|
MKLINE(SoundEngine,_queue_pos, sleUint8),
|
|
|
|
MKLINE(SoundEngine,_queue_sound, sleUint16),
|
|
|
|
MKLINE(SoundEngine,_queue_adding, sleByte),
|
|
|
|
MKLINE(SoundEngine,_queue_marker, sleByte),
|
|
|
|
MKLINE(SoundEngine,_queue_cleared, sleByte),
|
|
|
|
MKLINE(SoundEngine,_master_volume, sleByte),
|
|
|
|
MKLINE(SoundEngine,_trigger_count, sleUint16),
|
|
|
|
MKARRAY(SoundEngine,_channel_volume[0], sleUint16, 8),
|
|
|
|
MKARRAY(SoundEngine,_volchan_table[0], sleUint16, 8),
|
|
|
|
MKEND()
|
|
|
|
};
|
|
|
|
|
|
|
|
const SaveLoadEntry playerEntries[] = {
|
|
|
|
MKREF(Player,_parts,TYPE_PART),
|
|
|
|
MKLINE(Player,_active,sleByte),
|
|
|
|
MKLINE(Player,_id,sleUint16),
|
|
|
|
MKLINE(Player,_priority,sleByte),
|
|
|
|
MKLINE(Player,_volume,sleByte),
|
|
|
|
MKLINE(Player,_pan,sleInt8),
|
|
|
|
MKLINE(Player,_transpose,sleByte),
|
|
|
|
MKLINE(Player,_detune,sleInt8),
|
|
|
|
MKLINE(Player,_vol_chan,sleUint16),
|
|
|
|
MKLINE(Player,_vol_eff,sleByte),
|
|
|
|
MKLINE(Player,_speed,sleByte),
|
|
|
|
MKLINE(Player,_song_index,sleUint16),
|
|
|
|
MKLINE(Player,_track_index,sleUint16),
|
|
|
|
MKLINE(Player,_timer_counter,sleUint16),
|
|
|
|
MKLINE(Player,_loop_to_beat,sleUint16),
|
|
|
|
MKLINE(Player,_loop_from_beat,sleUint16),
|
|
|
|
MKLINE(Player,_loop_counter,sleUint16),
|
|
|
|
MKLINE(Player,_loop_to_tick,sleUint16),
|
|
|
|
MKLINE(Player,_loop_from_tick,sleUint16),
|
|
|
|
MKLINE(Player,_tempo,sleUint32),
|
|
|
|
MKLINE(Player,_cur_pos,sleUint32),
|
|
|
|
MKLINE(Player,_next_pos,sleUint32),
|
|
|
|
MKLINE(Player,_song_offset,sleUint32),
|
|
|
|
MKLINE(Player,_tick_index,sleUint16),
|
|
|
|
MKLINE(Player,_beat_index,sleUint16),
|
|
|
|
MKLINE(Player,_ticks_per_beat,sleUint16),
|
|
|
|
MKLINE(Player,_hook._jump,sleByte),
|
|
|
|
MKLINE(Player,_hook._transpose,sleByte),
|
|
|
|
MKARRAY(Player,_hook._part_onoff[0],sleByte,16),
|
|
|
|
MKARRAY(Player,_hook._part_volume[0],sleByte,16),
|
|
|
|
MKARRAY(Player,_hook._part_program[0],sleByte,16),
|
|
|
|
MKARRAY(Player,_hook._part_transpose[0],sleByte,16),
|
|
|
|
MKEND()
|
|
|
|
};
|
|
|
|
|
|
|
|
const SaveLoadEntry volumeFaderEntries[] = {
|
|
|
|
MKREF(VolumeFader,player,TYPE_PLAYER),
|
|
|
|
MKLINE(VolumeFader,active,sleUint8),
|
|
|
|
MKLINE(VolumeFader,curvol,sleUint8),
|
|
|
|
MKLINE(VolumeFader,speed_lo_max,sleUint16),
|
|
|
|
MKLINE(VolumeFader,num_steps,sleUint16),
|
|
|
|
MKLINE(VolumeFader,speed_hi,sleInt8),
|
|
|
|
MKLINE(VolumeFader,direction,sleInt8),
|
|
|
|
MKLINE(VolumeFader,speed_lo,sleInt8),
|
|
|
|
MKLINE(VolumeFader,speed_lo_counter,sleUint16),
|
|
|
|
MKEND()
|
|
|
|
};
|
|
|
|
|
|
|
|
const SaveLoadEntry partEntries[] = {
|
|
|
|
MKREF(Part,_next,TYPE_PART),
|
|
|
|
MKREF(Part,_prev,TYPE_PART),
|
|
|
|
MKREF(Part,_player,TYPE_PLAYER),
|
|
|
|
MKLINE(Part,_pitchbend,sleInt16),
|
|
|
|
MKLINE(Part,_pitchbend_factor,sleUint8),
|
|
|
|
MKLINE(Part,_transpose,sleInt8),
|
|
|
|
MKLINE(Part,_vol,sleUint8),
|
|
|
|
MKLINE(Part,_detune,sleInt8),
|
|
|
|
MKLINE(Part,_pan,sleInt8),
|
|
|
|
MKLINE(Part,_on,sleUint8),
|
|
|
|
MKLINE(Part,_modwheel,sleUint8),
|
|
|
|
MKLINE(Part,_pedal,sleUint8),
|
|
|
|
MKLINE(Part,_program,sleUint8),
|
|
|
|
MKLINE(Part,_pri,sleUint8),
|
|
|
|
MKLINE(Part,_chan,sleUint8),
|
|
|
|
MKLINE(Part,_effect_level,sleUint8),
|
|
|
|
MKLINE(Part,_chorus,sleUint8),
|
|
|
|
MKLINE(Part,_percussion,sleUint8),
|
|
|
|
MKLINE(Part,_bank,sleUint8),
|
|
|
|
MKEND()
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!ser->isSaving()) {
|
|
|
|
stop_all_sounds();
|
|
|
|
}
|
|
|
|
|
|
|
|
ser->_ref_me = this;
|
|
|
|
ser->_saveload_ref = ser->isSaving() ? ((void*)&saveReference) : ((void*)&loadReference);
|
|
|
|
|
|
|
|
ser->saveLoadEntries(this, mainEntries);
|
|
|
|
ser->saveLoadArrayOf(_players, ARRAYSIZE(_players), sizeof(_players[0]), playerEntries);
|
|
|
|
ser->saveLoadArrayOf(_parts, ARRAYSIZE(_parts),sizeof(_parts[0]), partEntries);
|
|
|
|
ser->saveLoadArrayOf(_volume_fader,ARRAYSIZE(_volume_fader),
|
|
|
|
sizeof(_volume_fader[0]), volumeFaderEntries);
|
|
|
|
|
|
|
|
if (!ser->isSaving()) {
|
|
|
|
/* Load all sounds that we need */
|
|
|
|
fix_players_after_load();
|
|
|
|
init_sustaining_notes();
|
|
|
|
_active_volume_faders = true;
|
|
|
|
fix_parts_after_load();
|
|
|
|
_driver->update_pris();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef MKLINE
|
|
|
|
#undef MKEND
|
|
|
|
|
|
|
|
void SoundEngine::fix_parts_after_load() {
|
|
|
|
Part *part;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_parts),part=_parts; i!=0; i--, part++) {
|
|
|
|
if (part->_player)
|
|
|
|
part->fix_after_load();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only call this routine from the main thread,
|
|
|
|
* since it uses getResourceAddress */
|
|
|
|
void SoundEngine::fix_players_after_load() {
|
|
|
|
Player *player = _players;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=ARRAYSIZE(_players); i!=0; i--, player++) {
|
|
|
|
if (player->_active) {
|
|
|
|
player->set_tempo(player->_tempo);
|
|
|
|
_s->getResourceAddress(rtSound, player->_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_detune(int8 detune) {
|
|
|
|
_detune_eff = clamp((_detune=detune) + _player->_detune, -128, 127);
|
|
|
|
changed(SoundDriver::pcMod);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_pitchbend(int value) {
|
|
|
|
_pitchbend = value * _pitchbend_factor >> 6;
|
|
|
|
changed(SoundDriver::pcMod);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_vol(uint8 vol) {
|
|
|
|
_vol_eff = ((_vol=vol)+1)*_player->_vol_eff >> 7;
|
|
|
|
changed(SoundDriver::pcVolume);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_pri(int8 pri) {
|
|
|
|
_pri_eff = clamp((_pri=pri) + _player->_priority, 0, 255);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_pan(int8 pan) {
|
|
|
|
_pan_eff = clamp((_pan=pan) + _player->_pan, -64, 63);
|
|
|
|
changed(SoundDriver::pcPan);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_transpose(int8 transpose) {
|
|
|
|
_transpose_eff = transpose_clamp((_transpose=transpose) +
|
|
|
|
_player->_transpose, -12, 12);
|
|
|
|
changed(SoundDriver::pcMod);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_pedal(bool value) {
|
|
|
|
_pedal = value;
|
|
|
|
changed(SoundDriver::pcPedal);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_modwheel(uint value) {
|
|
|
|
_modwheel = value;
|
|
|
|
changed(SoundDriver::pcModwheel);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_chorus(uint chorus) {
|
|
|
|
_chorus = chorus;
|
|
|
|
changed(SoundDriver::pcChorus);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_effect_level(uint level) {
|
|
|
|
_effect_level = level;
|
|
|
|
changed(SoundDriver::pcEffectLevel);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::fix_after_load() {
|
|
|
|
set_transpose(_transpose);
|
|
|
|
set_vol(_vol);
|
|
|
|
set_detune(_detune);
|
|
|
|
set_pri(_pri);
|
|
|
|
set_pan(_pan);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_pitchbend_factor(uint8 value) {
|
|
|
|
if (value > 12)
|
|
|
|
return;
|
|
|
|
set_pitchbend(0);
|
|
|
|
_pitchbend_factor = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_onoff(bool on) {
|
|
|
|
if (_on != on) {
|
|
|
|
_on = on;
|
|
|
|
if (!on)
|
|
|
|
off();
|
|
|
|
if (!_percussion)
|
|
|
|
update_pris();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_instrument(Instrument *data) {
|
|
|
|
_drv->part_set_instrument(this, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::key_on(byte note, byte velocity) {
|
|
|
|
_drv->part_key_on(this, note, velocity);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::key_off(byte note) {
|
|
|
|
_drv->part_key_off(this, note);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::init(SoundDriver *driver) {
|
|
|
|
_drv = (SOUND_DRIVER_TYPE*)driver;
|
|
|
|
_player = NULL;
|
|
|
|
_next = NULL;
|
|
|
|
_prev = NULL;
|
|
|
|
_mc = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::setup(Player *player) {
|
|
|
|
_player = player;
|
|
|
|
|
|
|
|
/* Insert first into player's list */
|
|
|
|
_prev = NULL;
|
|
|
|
_next = player->_parts;
|
|
|
|
if (player->_parts)
|
|
|
|
player->_parts->_prev = this;
|
|
|
|
player->_parts = this;
|
|
|
|
|
|
|
|
_percussion = true;
|
|
|
|
_on = true;
|
|
|
|
_pri_eff = player->_priority;
|
|
|
|
_pri = 0;
|
|
|
|
_vol = 127;
|
|
|
|
_vol_eff = player->_vol_eff;
|
|
|
|
_pan = clamp(player->_pan, -64, 63);
|
|
|
|
_transpose_eff = player->_transpose;
|
|
|
|
_transpose = 0;
|
|
|
|
_detune = 0;
|
|
|
|
_detune_eff = player->_detune;
|
|
|
|
_pitchbend_factor = 2;
|
|
|
|
_pitchbend = 0;
|
|
|
|
_effect_level = 64;
|
|
|
|
_program = 255;
|
|
|
|
_chorus = 0;
|
|
|
|
_modwheel = 0;
|
|
|
|
_bank = 0;
|
|
|
|
_pedal = false;
|
|
|
|
_mc = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::uninit() {
|
|
|
|
if (!_player)
|
|
|
|
return;
|
|
|
|
off();
|
|
|
|
|
|
|
|
/* unlink */
|
|
|
|
if (_next)
|
|
|
|
_next->_prev = _prev;
|
|
|
|
if (_prev)
|
|
|
|
_prev->_next = _next;
|
|
|
|
else
|
|
|
|
_player->_parts = _next;
|
|
|
|
_player = NULL;
|
|
|
|
_next = NULL;
|
|
|
|
_prev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::off() {
|
|
|
|
_drv->part_off(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::changed(byte what) {
|
|
|
|
_drv->part_changed(this, what);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_param(byte param, int value) {
|
|
|
|
_drv->part_set_param(this,param,value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::update_pris() {
|
|
|
|
_drv->update_pris();
|
|
|
|
}
|
|
|
|
|
|
|
|
int Part::update_actives(uint16 *active) {
|
|
|
|
return _drv->part_update_active(this, active);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_program(byte program) {
|
|
|
|
if (_program!=program || _bank!=0) {
|
|
|
|
_program = program;
|
|
|
|
_bank = 0;
|
|
|
|
changed(SoundDriver::pcProgram);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Part::set_instrument(uint b) {
|
|
|
|
_bank = (byte)(b>>8);
|
|
|
|
_program = (byte)b;
|
|
|
|
changed(SoundDriver::pcProgram);
|
|
|
|
}
|
|
|
|
|