libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-04-03 23:31:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

and more cleanup ....

Browse Source 
svn-id: r6719
This commit is contained in:
Paweł Kołodziejski 2003-03-06 18:30:44 +00:00
parent 093428ae9a
commit a8c3057875
25 changed files with 1151 additions and 1297 deletions

11
backends/fs/fs.h

@ -148,14 +148,12 @@ public:
*/
class FSList : ScummVM::List<FilesystemNode *> {
public:
~FSList()
{
~FSList() {
for (int i = 0; i < _size; i++)
delete _data[i];
}
void push_back(const FilesystemNode& element)
{
void push_back(const FilesystemNode &element) {
ensureCapacity(_size + 1);
// Determine where to insert the item.
// TODO this is inefficient, should use binary search instead
@ -163,13 +161,12 @@ public:
while (i < _size && *_data[i] < element)
i++;
if (i < _size)
memmove(&_data[i+1], &_data[i], (_size - i) * sizeof(FilesystemNode *));
memmove(&_data[i + 1], &_data[i], (_size - i) * sizeof(FilesystemNode *));
_data[i] = element.clone();
_size++;
}
const FilesystemNode& operator [](int idx) const
{
const FilesystemNode& operator [](int idx) const {
assert(idx >= 0 && idx < _size);
return *_data[idx];
}

1
backends/fs/posix/posix-fs.cpp

@ -141,7 +141,6 @@ const char *lastPathComponent(const ScummVM::String &str) {
}
FilesystemNode *POSIXFilesystemNode::parent() const {
POSIXFilesystemNode *p = new POSIXFilesystemNode();
// Root node is its own parent. Still we can't just return this

16
backends/fs/windows/windows-fs.cpp

@ -186,22 +186,22 @@ FSList *WindowsFilesystemNode::listDir(ListMode mode) const {
}
const char *lastPathComponent(const ScummVM::String &str) {
const char *start = str.c_str();
const char *cur = start + str.size() - 2;
const char *start = str.c_str();
const char *cur = start + str.size() - 2;
while (cur > start && *cur != '\\') {
--cur;
}
while (cur > start && *cur != '\\') {
--cur;
}
return cur+1;
return cur + 1;
}
FilesystemNode *WindowsFilesystemNode::parent() const {
assert(_isValid || _isPseudoRoot);
WindowsFilesystemNode *p = new WindowsFilesystemNode();
if (!_isPseudoRoot && _path.size() > 3) {
const char *start = _path.c_str();
const char *end = lastPathComponent(_path);
const char *start = _path.c_str();
const char *end = lastPathComponent(_path);
p->_path = String(start, end - start);
p->_isValid = true;

195
backends/midi/adlib.cpp

@ -431,8 +431,7 @@ const byte volume_table[] = {
62, 63, 63, 63
};
static int lookup_volume(int a, int b)
{
static int lookup_volume(int a, int b) {
if (b == 0)
return 0;
@ -458,8 +457,7 @@ static int lookup_volume(int a, int b)
}
}
static void create_lookup_table()
{
static void create_lookup_table() {
int i, j;
int sum;
@ -476,8 +474,6 @@ static void create_lookup_table()
typedef void TimerCallback (void *);
////////////////////////////////////////
//
// Adlib MIDI driver
@ -570,34 +566,28 @@ private:
static void premix_proc(void *param, int16 *buf, uint len);
};
// MidiChannel method implementations
void AdlibPart::init (MidiDriver_ADLIB *owner, byte channel) {
_owner = owner;
_channel = channel;
}
MidiDriver *AdlibPart::device()
{
MidiDriver *AdlibPart::device() {
return _owner;
}
void AdlibPart::noteOff (byte note)
{
void AdlibPart::noteOff (byte note) {
_owner->part_key_off (this, note);
}
void AdlibPart::noteOn (byte note, byte velocity)
{
void AdlibPart::noteOn (byte note, byte velocity) {
_owner->part_key_on (this, note, velocity);
}
void AdlibPart::programChange (byte program)
{
if (program > 127) return;
void AdlibPart::programChange (byte program) {
if (program > 127)
return;
uint i;
uint count = 0;
@ -609,8 +599,7 @@ void AdlibPart::programChange (byte program)
_owner->part_set_instrument (this, (AdlibInstrument *) &map_gm_to_fm [program]);
}
void AdlibPart::pitchBend (int16 bend)
{
void AdlibPart::pitchBend (int16 bend) {
MidiChannelAdl *mc;
_pitchbend = bend;
@ -620,8 +609,7 @@ void AdlibPart::pitchBend (int16 bend)
}
}
void AdlibPart::controlChange (byte control, byte value)
{
void AdlibPart::controlChange (byte control, byte value) {
switch (control) {
case 1: modulationWheel (value); break;
case 7: volume (value); break;
@ -640,8 +628,7 @@ void AdlibPart::controlChange (byte control, byte value)
}
}
void AdlibPart::modulationWheel (byte value)
{
void AdlibPart::modulationWheel (byte value) {
MidiChannelAdl *mc;
_modwheel = value;
@ -653,8 +640,7 @@ void AdlibPart::modulationWheel (byte value)
}
}
void AdlibPart::volume (byte value)
{
void AdlibPart::volume (byte value) {
MidiChannelAdl *mc;
_vol_eff = value;
@ -666,8 +652,7 @@ void AdlibPart::volume (byte value)
}
}
void AdlibPart::pitchBendFactor (byte value)
{
void AdlibPart::pitchBendFactor (byte value) {
MidiChannelAdl *mc;
_pitchbend_factor = value;
@ -677,8 +662,7 @@ void AdlibPart::pitchBendFactor (byte value)
}
}
void AdlibPart::detune (byte value)
{
void AdlibPart::detune (byte value) {
MidiChannelAdl *mc;
_detune_eff = value;
@ -688,13 +672,11 @@ void AdlibPart::detune (byte value)
}
}
void AdlibPart::priority (byte value)
{
void AdlibPart::priority (byte value) {
_pri_eff = value;
}
void AdlibPart::sustain (bool value)
{
void AdlibPart::sustain (bool value) {
MidiChannelAdl *mc;
_pedal = value;
@ -706,23 +688,18 @@ void AdlibPart::sustain (bool value)
}
}
void AdlibPart::allNotesOff()
{
void AdlibPart::allNotesOff() {
while (_mc)
_owner->mc_off (_mc);
}
void AdlibPart::sysEx_customInstrument (uint32 type, byte *instr)
{
void AdlibPart::sysEx_customInstrument (uint32 type, byte *instr) {
_owner->sysEx_customInstrument (this, type, instr);
}
// MidiDriver method implementations
MidiDriver_ADLIB::MidiDriver_ADLIB()
{
MidiDriver_ADLIB::MidiDriver_ADLIB() {
uint i;
for (i = 0; i < ARRAYSIZE(_parts); ++i) {
_parts[i].init (this, i);
@ -731,8 +708,7 @@ MidiDriver_ADLIB::MidiDriver_ADLIB()
_isOpen = false;
}
int MidiDriver_ADLIB::open ()
{
int MidiDriver_ADLIB::open() {
if (_isOpen)
return MERR_ALREADY_OPEN;
_isOpen = true;
@ -765,8 +741,7 @@ int MidiDriver_ADLIB::open ()
return 0;
}
void MidiDriver_ADLIB::close()
{
void MidiDriver_ADLIB::close() {
uint i;
for (i = 0; i < ARRAYSIZE(_midi_channels); ++i) {
if (_midi_channels [i]._part)
@ -779,8 +754,7 @@ void MidiDriver_ADLIB::close()
_isOpen = false;
}
void MidiDriver_ADLIB::send (uint32 b)
{
void MidiDriver_ADLIB::send (uint32 b) {
//byte param3 = (byte) ((b >> 24) & 0xFF);
byte param2 = (byte) ((b >> 16) & 0xFF);
byte param1 = (byte) ((b >> 8) & 0xFF);
@ -790,13 +764,16 @@ void MidiDriver_ADLIB::send (uint32 b)
switch (cmd) {
case 0x80:// Note Off
part_key_off (part, param1); break;
part_key_off (part, param1);
break;
case 0x90: // Note On
part_key_on (part, param1, param2); break;
part_key_on (part, param1, param2);
break;
case 0xA0: // Aftertouch
break; // Not supported.
case 0xB0: // Control Change
part->controlChange (param1, param2); break;
part->controlChange (param1, param2);
break;
case 0xC0: // Program Change
if (chan != 9)
part->programChange (param1);
@ -804,7 +781,8 @@ void MidiDriver_ADLIB::send (uint32 b)
case 0xD0: // Channel Pressure
break; // Not supported.
case 0xE0: // Pitch Bend
part->pitchBend ((param1 | (param2 << 7)) - 0x2000); break;
part->pitchBend ((param1 | (param2 << 7)) - 0x2000);
break;
case 0xF0: // SysEx
// We should never get here! SysEx information has to be
// sent via high-level semantic methods.
@ -816,8 +794,7 @@ void MidiDriver_ADLIB::send (uint32 b)
}
}
uint32 MidiDriver_ADLIB::property (int prop, uint32 param)
{
uint32 MidiDriver_ADLIB::property (int prop, uint32 param) {
switch (prop) {
case PROP_SMALLHEADER: // Indicates older game, use different operator volume algorithm
_game_SmallHeader = (param > 0);
@ -827,42 +804,37 @@ uint32 MidiDriver_ADLIB::property (int prop, uint32 param)
return 0;
}
void MidiDriver_ADLIB::setPitchBendRange (byte channel, uint range)
{
void MidiDriver_ADLIB::setPitchBendRange (byte channel, uint range) {
MidiChannelAdl *mc;
AdlibPart *part = &_parts [channel];
part->_pitchbend_factor = range;
for (mc = part->_mc; mc; mc = mc->_next) {
adlib_note_on(mc->_channel, mc->_note + part->_transpose_eff,
(part->_pitchbend * part->_pitchbend_factor >> 6) + part->_detune_eff);
(part->_pitchbend * part->_pitchbend_factor >> 6) + part->_detune_eff);
}
}
void MidiDriver_ADLIB::sysEx_customInstrument (byte channel, uint32 type, byte *instr)
{
void MidiDriver_ADLIB::sysEx_customInstrument (byte channel, uint32 type, byte *instr) {
sysEx_customInstrument (&_parts [channel], type, instr);
}
void MidiDriver_ADLIB::sysEx_customInstrument (AdlibPart *part, uint32 type, byte *instr)
{
void MidiDriver_ADLIB::sysEx_customInstrument (AdlibPart *part, uint32 type, byte *instr) {
if (type == 'ADL ') {
AdlibInstrument *i = &part->_part_instr;
memcpy(i, instr, sizeof(AdlibInstrument));
}
}
void MidiDriver_ADLIB::setTimerCallback (void *timer_param, void (*timer_proc) (void *))
{
void MidiDriver_ADLIB::setTimerCallback (void *timer_param, void (*timer_proc) (void *)) {
_timer_proc = (TimerCallback *) timer_proc;
_timer_param = timer_param;
}
MidiChannel *MidiDriver_ADLIB::allocateChannel()
{
MidiChannel *MidiDriver_ADLIB::allocateChannel() {
AdlibPart *part;
uint i;
for (i = 0; i < ARRAYSIZE(_parts); ++i) {
part = &_parts[i];
if (!part->_allocated) {
@ -873,22 +845,17 @@ MidiChannel *MidiDriver_ADLIB::allocateChannel()
return NULL;
}
MidiDriver *MidiDriver_ADLIB_create()
{
MidiDriver *MidiDriver_ADLIB_create() {
return new MidiDriver_ADLIB();
}
// All the code brought over from IMuseAdlib
void MidiDriver_ADLIB::premix_proc(void *param, int16 *buf, uint len)
{
void MidiDriver_ADLIB::premix_proc(void *param, int16 *buf, uint len) {
((MidiDriver_ADLIB *) param)->generate_samples(buf, len);
}
void MidiDriver_ADLIB::adlib_write(byte port, byte value)
{
void MidiDriver_ADLIB::adlib_write(byte port, byte value) {
if (_adlib_reg_cache[port] == value)
return;
_adlib_reg_cache[port] = value;
@ -896,8 +863,7 @@ void MidiDriver_ADLIB::adlib_write(byte port, byte value)
OPLWriteReg(_opl, port, value);
}
void MidiDriver_ADLIB::generate_samples(int16 *data, int len)
{
void MidiDriver_ADLIB::generate_samples(int16 *data, int len) {
int step;
if (!_opl) {
@ -921,13 +887,11 @@ void MidiDriver_ADLIB::generate_samples(int16 *data, int len)
} while (len -= step);
}
void MidiDriver_ADLIB::reset_tick()
{
void MidiDriver_ADLIB::reset_tick() {
_next_tick = 88;
}
void MidiDriver_ADLIB::on_timer()
{
void MidiDriver_ADLIB::on_timer() {
MidiChannelAdl *mc;
int i;
@ -952,8 +916,7 @@ void MidiDriver_ADLIB::on_timer()
}
}
void MidiDriver_ADLIB::mc_off(MidiChannelAdl * mc2)
{
void MidiDriver_ADLIB::mc_off(MidiChannelAdl * mc2) {
MidiChannelAdl *mc = (MidiChannelAdl *)mc2, *tmp;
adlib_key_off(mc->_channel);
@ -969,8 +932,7 @@ void MidiDriver_ADLIB::mc_off(MidiChannelAdl * mc2)
mc->_part = NULL;
}
void MidiDriver_ADLIB::mc_inc_stuff(MidiChannelAdl *mc, Struct10 * s10, Struct11 * s11)
{
void MidiDriver_ADLIB::mc_inc_stuff(MidiChannelAdl *mc, Struct10 *s10, Struct11 *s11) {
byte code;
AdlibPart *part = mc->_part;
@ -981,15 +943,15 @@ void MidiDriver_ADLIB::mc_inc_stuff(MidiChannelAdl *mc, Struct10 * s10, Struct11
case 0:
mc->_vol_2 = s10->start_value + s11->modify_val;
adlib_set_param(mc->_channel, 0,
volume_table[lookup_table[mc->_vol_2]
[part->_vol_eff >> 2]]);
volume_table[lookup_table[mc->_vol_2]
[part->_vol_eff >> 2]]);
break;
case 13:
mc->_vol_1 = s10->start_value + s11->modify_val;
if (mc->_twochan) {
adlib_set_param(mc->_channel, 13,
volume_table[lookup_table[mc->_vol_1]
[part->_vol_eff >> 2]]);
volume_table[lookup_table[mc->_vol_1]
[part->_vol_eff >> 2]]);
} else {
adlib_set_param(mc->_channel, 13, mc->_vol_1);
}
@ -1002,7 +964,7 @@ void MidiDriver_ADLIB::mc_inc_stuff(MidiChannelAdl *mc, Struct10 * s10, Struct11
break;
default:
adlib_set_param(mc->_channel, s11->param,
s10->start_value + s11->modify_val);
s10->start_value + s11->modify_val);
break;
}
}
@ -1011,14 +973,12 @@ void MidiDriver_ADLIB::mc_inc_stuff(MidiChannelAdl *mc, Struct10 * s10, Struct11
adlib_key_onoff(mc->_channel);
}
void MidiDriver_ADLIB::adlib_key_off(int chan)
{
void MidiDriver_ADLIB::adlib_key_off(int chan){
byte port = chan + 0xB0;
adlib_write(port, adlib_read(port) & ~0x20);
}
byte MidiDriver_ADLIB::struct10_ontimer(Struct10 * s10, Struct11 * s11)
{
byte MidiDriver_ADLIB::struct10_ontimer(Struct10 *s10, Struct11 *s11) {
byte result = 0;
int i;
@ -1061,8 +1021,7 @@ byte MidiDriver_ADLIB::struct10_ontimer(Struct10 * s10, Struct11 * s11)
return result;
}
void MidiDriver_ADLIB::adlib_set_param(int channel, byte param, int value)
{
void MidiDriver_ADLIB::adlib_set_param(int channel, byte param, int value) {
const AdlibSetParams *as;
byte port;
@ -1096,8 +1055,7 @@ void MidiDriver_ADLIB::adlib_set_param(int channel, byte param, int value)
adlib_write(port, (adlib_read(port) & ~as->c) | (((byte)value) << as->b));
}
void MidiDriver_ADLIB::adlib_key_onoff(int channel)
{
void MidiDriver_ADLIB::adlib_key_onoff(int channel) {
byte val;
byte port = channel + 0xB0;
assert(channel >= 0 && channel < 9);
@ -1107,8 +1065,7 @@ void MidiDriver_ADLIB::adlib_key_onoff(int channel)
adlib_write(port, val | 0x20);
}
void MidiDriver_ADLIB::struct10_setup(Struct10 * s10)
{
void MidiDriver_ADLIB::struct10_setup(Struct10 *s10) {
int b, c, d, e, f, g, h;
byte t;
@ -1157,8 +1114,7 @@ void MidiDriver_ADLIB::struct10_setup(Struct10 * s10)
s10->speed_lo_counter = 0;
}
void MidiDriver_ADLIB::adlib_playnote(int channel, int note)
{
void MidiDriver_ADLIB::adlib_playnote(int channel, int note) {
byte old, oct, notex;
int note2;
int i;
@ -1189,8 +1145,7 @@ void MidiDriver_ADLIB::adlib_playnote(int channel, int note)
adlib_write(channel + 0xB0, oct | 0x20);
}
int MidiDriver_ADLIB::random_nr(int a)
{
int MidiDriver_ADLIB::random_nr(int a) {
static byte _rand_seed = 1;
if (_rand_seed & 1) {
_rand_seed >>= 1;
@ -1201,8 +1156,7 @@ int MidiDriver_ADLIB::random_nr(int a)
return _rand_seed * a >> 8;
}
void MidiDriver_ADLIB::part_key_off (AdlibPart *part, byte note)
{
void MidiDriver_ADLIB::part_key_off (AdlibPart *part, byte note) {
MidiChannelAdl *mc;
for (mc = part->_mc; mc; mc = mc->_next) {
@ -1215,8 +1169,7 @@ void MidiDriver_ADLIB::part_key_off (AdlibPart *part, byte note)
}
}
void MidiDriver_ADLIB::part_key_on (AdlibPart *part, byte note, byte velocity)
{
void MidiDriver_ADLIB::part_key_on (AdlibPart *part, byte note, byte velocity) {
MidiChannelAdl *mc;
mc = allocate_midichan(part->_pri_eff);
@ -1227,8 +1180,7 @@ void MidiDriver_ADLIB::part_key_on (AdlibPart *part, byte note, byte velocity)
mc_key_on(mc, note, velocity);
}
MidiChannelAdl *MidiDriver_ADLIB::allocate_midichan(byte pri)
{
MidiChannelAdl *MidiDriver_ADLIB::allocate_midichan(byte pri) {
MidiChannelAdl *ac, *best = NULL;
int i;
@ -1251,8 +1203,7 @@ MidiChannelAdl *MidiDriver_ADLIB::allocate_midichan(byte pri)
return best;
}
void MidiDriver_ADLIB::link_mc (AdlibPart *part, MidiChannelAdl *mc)
{
void MidiDriver_ADLIB::link_mc (AdlibPart *part, MidiChannelAdl *mc) {
mc->_part = part;
mc->_next = (MidiChannelAdl *)part->_mc;
part->_mc = mc;
@ -1262,8 +1213,7 @@ void MidiDriver_ADLIB::link_mc (AdlibPart *part, MidiChannelAdl *mc)
mc->_next->_prev = mc;
}
void MidiDriver_ADLIB::mc_key_on (MidiChannelAdl * mc2, byte note, byte velocity)
{
void MidiDriver_ADLIB::mc_key_on (MidiChannelAdl *mc2, byte note, byte velocity) {
MidiChannelAdl *mc = (MidiChannelAdl *)mc2;
AdlibPart *part = mc->_part;
AdlibInstrument *instr = &part->_part_instr;
@ -1309,8 +1259,7 @@ void MidiDriver_ADLIB::mc_key_on (MidiChannelAdl * mc2, byte note, byte velocity
}
}
void MidiDriver_ADLIB::adlib_setup_channel(int chan, AdlibInstrument * instr, byte vol_1, byte vol_2)
{
void MidiDriver_ADLIB::adlib_setup_channel(int chan, AdlibInstrument *instr, byte vol_1, byte vol_2) {
byte port;
assert(chan >= 0 && chan < 9);
@ -1348,10 +1297,8 @@ void MidiDriver_ADLIB::adlib_note_on_ex(int chan, byte note, int mod)
}
void MidiDriver_ADLIB::mc_init_stuff (MidiChannelAdl *mc, Struct10 * s10,
Struct11 * s11, byte flags, InstrumentExtra * ie)
{
Struct11 * s11, byte flags, InstrumentExtra * ie) {
AdlibPart *part = mc->_part;
s11->modify_val = 0;
s11->flag0x40 = flags & 0x40;
s10->loop = flags & 0x20;
@ -1387,8 +1334,7 @@ void MidiDriver_ADLIB::mc_init_stuff (MidiChannelAdl *mc, Struct10 * s10,
struct10_init(s10, ie);
}
void MidiDriver_ADLIB::struct10_init(Struct10 * s10, InstrumentExtra * ie)
{
void MidiDriver_ADLIB::struct10_init(Struct10 *s10, InstrumentExtra *ie) {
s10->active = 1;
s10->cur_val = 0;
s10->modwheel_last = 31;
@ -1408,8 +1354,7 @@ void MidiDriver_ADLIB::struct10_init(Struct10 * s10, InstrumentExtra * ie)
struct10_setup(s10);
}
int MidiDriver_ADLIB::adlib_read_param(int chan, byte param)
{
int MidiDriver_ADLIB::adlib_read_param(int chan, byte param) {
const AdlibSetParams *as;
byte val;
byte port;
@ -1442,8 +1387,7 @@ int MidiDriver_ADLIB::adlib_read_param(int chan, byte param)
return val;
}
void MidiDriver_ADLIB::adlib_note_on(int chan, byte note, int mod)
{
void MidiDriver_ADLIB::adlib_note_on(int chan, byte note, int mod) {
int code;
assert(chan >= 0 && chan < 9);
code = (note << 7) + mod;
@ -1451,8 +1395,7 @@ void MidiDriver_ADLIB::adlib_note_on(int chan, byte note, int mod)
adlib_playnote(chan, channel_table_2[chan] + code);
}
void MidiDriver_ADLIB::part_set_instrument(AdlibPart *part, AdlibInstrument * instr)
{
void MidiDriver_ADLIB::part_set_instrument(AdlibPart *part, AdlibInstrument *instr) {
AdlibInstrument *i = &part->_part_instr;
memcpy(i, instr, sizeof(AdlibInstrument));
}

20
backends/midi/alsa.cpp

@ -70,8 +70,7 @@ MidiDriver_ALSA::MidiDriver_ALSA()
{
}
int MidiDriver_ALSA::open()
{
int MidiDriver_ALSA::open() {
char *var;
unsigned int caps;
@ -128,16 +127,13 @@ int MidiDriver_ALSA::open()
return 0;
}
void MidiDriver_ALSA::close()
{
void MidiDriver_ALSA::close() {
_isOpen = false;
if (seq_handle)
snd_seq_close(seq_handle);
}
void MidiDriver_ALSA::send(uint32 b)
{
void MidiDriver_ALSA::send(uint32 b) {
unsigned int midiCmd[4];
ev.type = SND_SEQ_EVENT_OSS;
@ -168,7 +164,6 @@ void MidiDriver_ALSA::send(uint32 b)
snd_seq_ev_set_pgmchange(&ev, chanID, midiCmd[1]);
send_event(0);
break;
case 0xE0:{
// long theBend = ((((long)midiCmd[1] + (long)(midiCmd[2] << 7))) - 0x2000) / 4;
// snd_seq_ev_set_pitchbend(&ev, chanID, theBend);
@ -186,8 +181,7 @@ void MidiDriver_ALSA::send(uint32 b)
}
}
int MidiDriver_ALSA::parse_addr(char *arg, int *client, int *port)
{
int MidiDriver_ALSA::parse_addr(char *arg, int *client, int *port) {
char *p;
if (isdigit(*arg)) {
@ -205,8 +199,7 @@ int MidiDriver_ALSA::parse_addr(char *arg, int *client, int *port)
return 0;
}
void MidiDriver_ALSA::send_event(int do_flush)
{
void MidiDriver_ALSA::send_event(int do_flush) {
snd_seq_ev_set_direct(&ev);
snd_seq_ev_set_source(&ev, my_port);
snd_seq_ev_set_dest(&ev, seq_client, seq_port);
@ -216,8 +209,7 @@ void MidiDriver_ALSA::send_event(int do_flush)
snd_seq_flush_output(seq_handle);
}
MidiDriver *MidiDriver_ALSA_create()
{
MidiDriver *MidiDriver_ALSA_create() {
return new MidiDriver_ALSA();
}

15
backends/midi/coreaudio.cpp

@ -50,8 +50,7 @@ private:
};
int MidiDriver_CORE::open()
{
int MidiDriver_CORE::open() {
if (au_output != NULL)
return MERR_ALREADY_OPEN;
@ -90,8 +89,7 @@ int MidiDriver_CORE::open()
return 0;
}
void MidiDriver_CORE::close()
{
void MidiDriver_CORE::close() {
// Stop the output
AudioOutputUnitStop(au_output);
@ -100,8 +98,7 @@ void MidiDriver_CORE::close()
CloseComponent(au_MusicDevice);
}
void MidiDriver_CORE::send(uint32 b)
{
void MidiDriver_CORE::send(uint32 b) {
unsigned char first_byte, seccond_byte, status_byte;
status_byte = (b & 0x000000FF);
first_byte = (b & 0x0000FF00) >> 8;
@ -115,13 +112,11 @@ void MidiDriver_CORE::send(uint32 b)
MusicDeviceMIDIEvent(au_MusicDevice, status_byte, first_byte, seccond_byte, 0);
}
void MidiDriver_CORE::sysEx(byte *msg, uint16 length)
{
void MidiDriver_CORE::sysEx(byte *msg, uint16 length) {
MusicDeviceSysEx(au_MusicDevice, msg, length);
}
MidiDriver *MidiDriver_CORE_create()
{
MidiDriver *MidiDriver_CORE_create() {
return new MidiDriver_CORE();
}

6
backends/midi/null.cpp

@ -30,13 +30,11 @@ public:
void send(uint32 b) { }
};
int MidiDriver_NULL::open()
{
int MidiDriver_NULL::open() {
warning("Music not enabled - MIDI support selected with no MIDI driver available. Try Adlib");
return 0;
}
MidiDriver *MidiDriver_NULL_create()
{
MidiDriver *MidiDriver_NULL_create() {
return new MidiDriver_NULL();
}

17
backends/midi/quicktime.cpp

@ -64,13 +64,11 @@ private:
byte _pitchbend_range [16];
};
MidiDriver_QT::MidiDriver_QT()
{
MidiDriver_QT::MidiDriver_QT() {
qtNoteAllocator = NULL;
}
int MidiDriver_QT::open()
{
int MidiDriver_QT::open() {
ComponentResult qtErr = noErr;
int i;
@ -129,8 +127,7 @@ void MidiDriver_QT::close()
}
}
void MidiDriver_QT::send(uint32 b)
{
void MidiDriver_QT::send(uint32 b) {
MusicMIDIPacket midPacket;
unsigned char *midiCmd = midPacket.data;
midPacket.length = 3;
@ -214,7 +211,7 @@ void MidiDriver_QT::send(uint32 b)
// mysterious reasons the actual factor we have to use is more like 1/32 or 3/64.
// Maybe the QT docs are right, and
_pitchbend[chanID] = ((uint16) midiCmd[1] | (uint16) (midiCmd[2] << 7));
long theBend = ((long) _pitchbend[chanID] - 0x2000) * _pitchbend_range[chanID] / 32;
long theBend = ((long) _pitchbend[chanID] - 0x2000) * _pitchbend_range[chanID] / 32;
NASetController(qtNoteAllocator, qtNoteChannel[chanID], kControllerPitchBend, theBend);
}
@ -227,8 +224,7 @@ void MidiDriver_QT::send(uint32 b)
}
}
void MidiDriver_QT::setPitchBendRange (byte channel, uint range)
{
void MidiDriver_QT::setPitchBendRange (byte channel, uint range) {
if (_pitchbend_range[channel] == range)
return;
_pitchbend_range[channel] = range;
@ -238,8 +234,7 @@ void MidiDriver_QT::setPitchBendRange (byte channel, uint range)
NASetController(qtNoteAllocator, qtNoteChannel[channel], kControllerPitchBend, theBend);
}
MidiDriver *MidiDriver_QT_create()
{
MidiDriver *MidiDriver_QT_create() {
return new MidiDriver_QT();
}

22
backends/midi/windows.cpp

@ -49,13 +49,12 @@ public:
void sysEx (byte *msg, uint16 length);
};
int MidiDriver_WIN::open()
{
int MidiDriver_WIN::open() {
if (_isOpen)
return MERR_ALREADY_OPEN;
_streamEvent = CreateEvent (NULL, true, true, NULL);
MMRESULT res = midiOutOpen((HMIDIOUT *) &_mo, MIDI_MAPPER, (unsigned long) _streamEvent, 0, CALLBACK_EVENT);
MMRESULT res = midiOutOpen((HMIDIOUT *)&_mo, MIDI_MAPPER, (unsigned long) _streamEvent, 0, CALLBACK_EVENT);
if (res != MMSYSERR_NOERROR) {
check_error(res);
return MERR_DEVICE_NOT_AVAILABLE;
@ -65,8 +64,7 @@ int MidiDriver_WIN::open()
return 0;
}
void MidiDriver_WIN::close()
{
void MidiDriver_WIN::close() {
_isOpen = false;
check_error(midiOutClose(_mo));
CloseHandle (_streamEvent);
@ -100,7 +98,7 @@ void MidiDriver_WIN::sysEx (byte *msg, uint16 length)
midiOutUnprepareHeader (_mo, &_streamHeader, sizeof (_streamHeader));
_streamBuffer [0] = 0xFF;
memcpy (&_streamBuffer[1], msg, length);
memcpy(&_streamBuffer[1], msg, length);
_streamBuffer [length+1] = 0xF7;
_streamHeader.lpData = (char *) _streamBuffer;
@ -115,17 +113,16 @@ void MidiDriver_WIN::sysEx (byte *msg, uint16 length)
return;
}
ResetEvent (_streamEvent);
ResetEvent(_streamEvent);
result = midiOutLongMsg (_mo, &_streamHeader, sizeof (_streamHeader));
if (result != MMSYSERR_NOERROR) {
check_error (result);
SetEvent (_streamEvent);
check_error(result);
SetEvent(_streamEvent);
return;
}
}
void MidiDriver_WIN::check_error(MMRESULT result)
{
void MidiDriver_WIN::check_error(MMRESULT result) {
char buf[200];
if (result != MMSYSERR_NOERROR) {
midiOutGetErrorText(result, buf, 200);
@ -133,8 +130,7 @@ void MidiDriver_WIN::check_error(MMRESULT result)
}
}
MidiDriver *MidiDriver_WIN_create()
{
MidiDriver *MidiDriver_WIN_create() {
return new MidiDriver_WIN();
}

4
backends/null/null.cpp

@ -63,7 +63,7 @@ uint32 OSystem_NULL::get_ticks() {
#ifdef UNIX
struct timeval tv;
gettimeofday(&tv, NULL);
a = tv.tv_sec * 1000 + tv.tv_usec/1000;
a = tv.tv_sec * 1000 + tv.tv_usec / 1000;
#endif
return a;
@ -74,7 +74,7 @@ void OSystem_NULL::delay_msecs(uint msecs) {
Sleep(msecs);
#endif
#ifdef UNIX
usleep(msecs*1000);
usleep(msecs * 1000);
#endif
}

623
backends/sdl/fb2opengl.h

@ -42,400 +42,395 @@
#endif
class FB2GL {
private:
// Framebuffer for 8 bpp
unsigned char ogl_fb[256][256];
unsigned char ogl_fbb[256][64];
// Framebuffer for RGBA
unsigned char ogl_fb1[256][256][4];
unsigned char ogl_fb2[256][64][4];
// Framebuffer for the blit function (SDL Blitting)
unsigned char fb1[256*256*4]; // Enough room for RGBA
unsigned char fb2[64*256*4]; // Enough room for RGBA
// Texture(s)
GLuint texture;
GLuint textureb;
// Display list
GLuint dlist;
// Color Table (256 colors, RGB)
char ogl_ctable[256][3];
char ogl_temp_ctable[256][3]; // Support for OpenGL 1.1
char flags;
void maketex();
void makedlist(int xf, int yf);
public:
SDL_Surface *screen;
FB2GL() {
flags=0;
screen=NULL;
}
int init(int width, int height, int xfix, int yfix, char _flags);
void update(void *fb, int width, int height, int pitch, int xskip, int yskip);
void palette(int index, int r, int g, int b);
void setPalette(int first, int ncolors);
void blit16(SDL_Surface *fb, int num_rect, SDL_Rect *rectlist, int xskip, int yskip);
void display();
private:
// Framebuffer for 8 bpp
unsigned char ogl_fb[256][256];
unsigned char ogl_fbb[256][64];
// Framebuffer for RGBA
unsigned char ogl_fb1[256][256][4];
unsigned char ogl_fb2[256][64][4];
// Framebuffer for the blit function (SDL Blitting)
unsigned char fb1[256 * 256 * 4]; // Enough room for RGBA
unsigned char fb2[64 * 256 * 4]; // Enough room for RGBA
// Texture(s)
GLuint texture;
GLuint textureb;
// Display list
GLuint dlist;
// Color Table (256 colors, RGB)
char ogl_ctable[256][3];
char ogl_temp_ctable[256][3]; // Support for OpenGL 1.1
char flags;
void maketex();
void makedlist(int xf, int yf);
public:
SDL_Surface *screen;
FB2GL() {
flags = 0;
screen = NULL;
}
int init(int width, int height, int xfix, int yfix, char _flags);
void update(void *fb, int width, int height, int pitch, int xskip, int yskip);
void palette(int index, int r, int g, int b);
void setPalette(int first, int ncolors);
void blit16(SDL_Surface *fb, int num_rect, SDL_Rect *rectlist, int xskip, int yskip);
void display();
};
void FB2GL::maketex()
{
glGenTextures(0,&texture);
glBindTexture(GL_TEXTURE_2D,texture);
void FB2GL::maketex() {
glGenTextures(0,&texture);
glBindTexture(GL_TEXTURE_2D,texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
// Bilinear filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Bilinear filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
/*
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
*/
if (flags & FB2GL_RGBA) {
glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,256,256,0,GL_RGBA, GL_UNSIGNED_BYTE, ogl_fb1);
}
else {
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX,256,256,0,GL_COLOR_INDEX, GL_UNSIGNED_BYTE, ogl_fb);
}
if (flags & FB2GL_320) {
glGenTextures(1,&textureb);
glBindTexture(GL_TEXTURE_2D,textureb);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
// Bilinear filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
/*
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
*/
if (flags & FB2GL_RGBA) {
glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,64,256,0,GL_RGBA,
GL_UNSIGNED_BYTE, ogl_fb2);
}
else {
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX,64,256,0,GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, ogl_fbb);
}
}
if (flags & FB2GL_RGBA) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, ogl_fb1);
}
else {
glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX, 256, 256, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, ogl_fb);
}
if (flags & FB2GL_320) {
glGenTextures(1, &textureb);
glBindTexture(GL_TEXTURE_2D, textureb);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
// Bilinear filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
/*
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
*/
if (flags & FB2GL_RGBA) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 256, 0, GL_RGBA,
GL_UNSIGNED_BYTE, ogl_fb2);
}
else {
glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX, 64, 256, 0, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, ogl_fbb);
}
}
}
void FB2GL::makedlist(int xf, int yf)
{
double xfix=(double)xf/128; // 128 = 256/2 (half texture => 0.0 to 1.0)
double yfix=(double)yf/128;
// End of 256x256 (from -1.0 to 1.0)
double texend = (double)96/160; // 160=320/2 (== 0.0), 256-160=96.
if (glIsList(dlist))
glDeleteLists(dlist,1);
dlist=glGenLists(1);
glNewList(dlist,GL_COMPILE);
void FB2GL::makedlist(int xf, int yf) {
double xfix = (double)xf / 128; // 128 = 256/2 (half texture => 0.0 to 1.0)
double yfix = (double)yf / 128;
// End of 256x256 (from -1.0 to 1.0)
double texend = (double)96 / 160; // 160=320/2 (== 0.0), 256-160=96.
glEnable(GL_TEXTURE_2D);
if (glIsList(dlist))
glDeleteLists(dlist, 1);
glBindTexture(GL_TEXTURE_2D, texture);
dlist=glGenLists(1);
glNewList(dlist, GL_COMPILE);
if (!(flags & FB2GL_320)) { // Normal 256x256
glBegin(GL_QUADS);
glTexCoord2f(0.0,1.0); glVertex2f(-1.0,-1.0-yfix); // upper left
glTexCoord2f(0.0,0.0); glVertex2f(-1.0,1.0); // lower left
glTexCoord2f(1.0,0.0); glVertex2f(1.0+xfix,1.0); // lower right
glTexCoord2f(1.0,1.0); glVertex2f(1.0+xfix,-1.0-yfix); // upper right
glEnd();
}
else { // 320x256
glEnable(GL_TEXTURE_2D);
// First, the 256x256 texture
glBegin(GL_QUADS);
glTexCoord2f(0.0,1.0); glVertex2f(-1.0,-1.0-yfix); // upper left
glTexCoord2f(0.0,0.0); glVertex2f(-1.0,1.0); // lower left
glTexCoord2f(1.0,0.0); glVertex2f(texend+xfix,1.0); // lower right
glTexCoord2f(1.0,1.0); glVertex2f(texend+xfix,-1.0-yfix); // upper right
glEnd();
glBindTexture(GL_TEXTURE_2D, texture);
// 64x256
glBindTexture(GL_TEXTURE_2D, textureb);
if (!(flags & FB2GL_320)) { // Normal 256x256
glBegin(GL_QUADS);
glTexCoord2f(0.0, 1.0); glVertex2f(-1.0, -1.0 - yfix); // upper left
glTexCoord2f(0.0, 0.0); glVertex2f(-1.0, 1.0); // lower left
glTexCoord2f(1.0, 0.0); glVertex2f(1.0 + xfix, 1.0); // lower right
glTexCoord2f(1.0, 1.0); glVertex2f(1.0 + xfix, -1.0 - yfix); // upper right
glEnd();
}
else { // 320x256
glBegin(GL_QUADS);
glTexCoord2f(0.0,1.0); glVertex2f(texend+xfix,-1.0-yfix); // upper left
glTexCoord2f(0.0,0.0); glVertex2f(texend+xfix,1.0); // lower left
glTexCoord2f(1.0,0.0); glVertex2f(1.0+xfix,1.0); // lower right
glTexCoord2f(1.0,1.0); glVertex2f(1.0+xfix,-1.0-yfix); // upper right
glEnd();
}
// First, the 256x256 texture
glBegin(GL_QUADS);
glTexCoord2f(0.0, 1.0); glVertex2f( -1.0, -1.0 - yfix); // upper left
glTexCoord2f(0.0, 0.0); glVertex2f(-1.0, 1.0); // lower left
glTexCoord2f(1.0, 0.0); glVertex2f(texend + xfix, 1.0); // lower right
glTexCoord2f(1.0, 1.0); glVertex2f(texend + xfix, -1.0 - yfix); // upper right
glEnd();
glDisable(GL_TEXTURE_2D);
// 64x256
glBindTexture(GL_TEXTURE_2D, textureb);
glEndList();
glBegin(GL_QUADS);
glTexCoord2f(0.0, 1.0); glVertex2f(texend + xfix, -1.0 - yfix); // upper left
glTexCoord2f(0.0, 0.0); glVertex2f(texend + xfix, 1.0); // lower left
glTexCoord2f(1.0, 0.0); glVertex2f(1.0 + xfix, 1.0); // lower right
glTexCoord2f(1.0, 1.0); glVertex2f(1.0 + xfix, -1.0 - yfix); // upper right
glEnd();
}
glDisable(GL_TEXTURE_2D);
glEndList();
}
int FB2GL::init(int width, int height, int xfix, int yfix, char _flags)
{
char gl_ext[4096];
gl_ext[0]='\0';
int FB2GL::init(int width, int height, int xfix, int yfix, char _flags) {
char gl_ext[4096];
gl_ext[0]='\0';
flags = _flags;
// Fullscreen?
if (!screen) {
screen = SDL_SetVideoMode(width, height, (flags & FB2GL_16BIT? 16: 0),
SDL_HWPALETTE | SDL_HWSURFACE | SDL_OPENGL | SDL_GL_DOUBLEBUFFER |
(flags & FB2GL_FS? SDL_FULLSCREEN: 0));
}
flags = _flags;
fprintf(stderr,"Screen BitsPerPixel: %d\n",screen->format->BitsPerPixel);
if (!screen) {
fprintf(stderr, "Couldn't start video res %dx%d\n", width, height);
return 0;
}
// Fullscreen?
if (!screen) {
screen = SDL_SetVideoMode(width, height, (flags & FB2GL_16BIT ? 16: 0),
SDL_HWPALETTE | SDL_HWSURFACE | SDL_OPENGL | SDL_GL_DOUBLEBUFFER |
(flags & FB2GL_FS? SDL_FULLSCREEN: 0));
}
warning("Screen BitsPerPixel: %d\n",screen->format->BitsPerPixel);
if (!screen) {
fprintf(stderr, "Couldn't start video res %dx%d\n", width, height);
return 0;
}
if (!(flags & FB2GL_RGBA)) { // Check for Paletted Texture Extension
strcpy(gl_ext, (char *)glGetString(GL_EXTENSIONS));
if (!(flags & FB2GL_RGBA)) { // Check for Paletted Texture Extension
strcpy(gl_ext, (char *)glGetString(GL_EXTENSIONS));
fprintf(stderr,"gl_ext= %s\n",gl_ext);
if ( strstr( gl_ext , "GL_EXT_paletted_texture") )
glEnable(GL_EXT_paletted_texture);
else {
fprintf(stderr,"Your OpenGL version doesn't support paletted texture\n");
return 0;
}
}
if (width>0 && height>0)
maketex();
makedlist(xfix, yfix);
if ( strstr( gl_ext , "GL_EXT_paletted_texture") )
glEnable(GL_EXT_paletted_texture);
else {
fprintf(stderr,"Your OpenGL version doesn't support paletted texture\n");
return 0;
}
}
if (width>0 && height>0)
maketex();
makedlist(xfix, yfix);
/* glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glAlphaFunc(GL_GREATER,0);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);*/
return 1;
/* glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glAlphaFunc(GL_GREATER,0);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);*/
return 1;
}
void FB2GL::display()
{
glCallList(dlist);
SDL_GL_SwapBuffers();
glCallList(dlist);
SDL_GL_SwapBuffers();
}
void FB2GL::update(void *fb, int w, int h, int pitch, int xskip, int yskip) {
unsigned char *fb1=(unsigned char *)fb;
int x,y,scr_pitch,byte=0;
unsigned char *fb1=(unsigned char *)fb;
int x,y,scr_pitch,byte=0;
if (flags & FB2GL_PITCH) scr_pitch=pitch;
else {
scr_pitch=w*pitch;
byte = pitch; // Bytes perl pixel (for RGBA mode)
}
if (flags & FB2GL_PITCH) scr_pitch=pitch;
else {
scr_pitch=w*pitch;
byte = pitch; // Bytes perl pixel (for RGBA mode)
}
if (flags & FB2GL_RGBA) {
if (flags & FB2GL_EXPAND) { // Expand the 8 bit fb into a RGB fb
for (y=yskip; y<h; y++) {
if (flags & FB2GL_RGBA) {
if (flags & FB2GL_EXPAND) { // Expand the 8 bit fb into a RGB fb
for (y=yskip; y<h; y++) {
for (x=xskip; x<w; x++) {
if (x<256) {
ogl_fb1[y][x][0] = ogl_ctable[*(fb1+x)][0];
ogl_fb1[y][x][1] = ogl_ctable[*(fb1+x)][1];
ogl_fb1[y][x][2] = ogl_ctable[*(fb1+x)][2];
ogl_fb1[y][x][3] = 255;
}
else {
ogl_fb2[y][x-256][0] = ogl_ctable[*(fb1+x)][0];
ogl_fb2[y][x-256][1] = ogl_ctable[*(fb1+x)][1];
ogl_fb2[y][x-256][2] = ogl_ctable[*(fb1+x)][2];
ogl_fb2[y][x-256][3] = 255;
}
if (x<256) {
ogl_fb1[y][x][0] = ogl_ctable[*(fb1+x)][0];
ogl_fb1[y][x][1] = ogl_ctable[*(fb1+x)][1];
ogl_fb1[y][x][2] = ogl_ctable[*(fb1+x)][2];
ogl_fb1[y][x][3] = 255;
}
else {
ogl_fb2[y][x-256][0] = ogl_ctable[*(fb1+x)][0];
ogl_fb2[y][x-256][1] = ogl_ctable[*(fb1+x)][1];
ogl_fb2[y][x-256][2] = ogl_ctable[*(fb1+x)][2];
ogl_fb2[y][x-256][3] = 255;
}
}
fb1 += scr_pitch;
}
}
else { // No expansion
for (y=yskip; y<h; y++) {
}
}
else { // No expansion
for (y=yskip; y<h; y++) {
for (x=xskip; x<w; x++) {
if (x<256) {
ogl_fb1[y-yskip][x-xskip][0] = *(fb1+(x*byte));
ogl_fb1[y-yskip][x-xskip][1] = *(fb1+(x*byte)+1);
ogl_fb1[y-yskip][x-xskip][2] = *(fb1+(x*byte)+2);
}
else {
ogl_fb2[y-yskip][x-256][0] = *(fb1+(x*byte));
ogl_fb2[y-yskip][x-256][1] = *(fb1+(x*byte)+1);
ogl_fb2[y-yskip][x-256][2] = *(fb1+(x*byte)+2);
}
if (x<256) {
ogl_fb1[y-yskip][x-xskip][0] = *(fb1+(x*byte));
ogl_fb1[y-yskip][x-xskip][1] = *(fb1+(x*byte)+1);
ogl_fb1[y-yskip][x-xskip][2] = *(fb1+(x*byte)+2);
}
else {
ogl_fb2[y-yskip][x-256][0] = *(fb1+(x*byte));
ogl_fb2[y-yskip][x-256][1] = *(fb1+(x*byte)+1);
ogl_fb2[y-yskip][x-256][2] = *(fb1+(x*byte)+2);
}
}
fb1 += scr_pitch;
}
}
}
}
// Update 256x256 texture
glBindTexture(GL_TEXTURE_2D,texture);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,256-xskip,256-yskip,GL_RGBA,
// Update 256x256 texture
glBindTexture(GL_TEXTURE_2D,texture);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,256-xskip,256-yskip,GL_RGBA,
GL_UNSIGNED_BYTE,ogl_fb1);
if (flags & FB2GL_320) {
// Update 64x256 texture
glBindTexture(GL_TEXTURE_2D,textureb);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,64-xskip,256-yskip,GL_RGBA,
if (flags & FB2GL_320) {
// Update 64x256 texture
glBindTexture(GL_TEXTURE_2D,textureb);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,64-xskip,256-yskip,GL_RGBA,
GL_UNSIGNED_BYTE,ogl_fb2);
}
}
}
else { // non RGBA (paletted)
}
else { // non RGBA (paletted)
for (y=0; y<h; y++)
for (x=0; x<w; x++) {
for (y=0; y<h; y++)
for (x=0; x<w; x++) {
if (x<256) {
ogl_fb[ y ][ x ] = *(fb1 + (y)*scr_pitch + x);
ogl_fb[ y ][ x ] = *(fb1 + (y)*scr_pitch + x);
}
else {
ogl_fbb[ y ][ x - 256 ] = *(fb1 + y*scr_pitch + x);
ogl_fbb[ y ][ x - 256 ] = *(fb1 + y*scr_pitch + x);
}
}
}
// Update 256x256 texture
glBindTexture(GL_TEXTURE_2D,texture);
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,256-xskip,256-yskip,
// Update 256x256 texture
glBindTexture(GL_TEXTURE_2D,texture);
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,256-xskip,256-yskip,
GL_COLOR_INDEX, GL_UNSIGNED_BYTE,ogl_fb);
if (flags & FB2GL_320) {
// Update 64x256 texture
glBindTexture(GL_TEXTURE_2D,textureb);
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,64-xskip,256-yskip,
GL_COLOR_INDEX, GL_UNSIGNED_BYTE,ogl_fbb);
}
if (flags & FB2GL_320) {
// Update 64x256 texture
glBindTexture(GL_TEXTURE_2D,textureb);
glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,64-xskip,256-yskip,
GL_COLOR_INDEX, GL_UNSIGNED_BYTE,ogl_fbb);
}
}
}
display();
display();
}
void FB2GL::blit16(SDL_Surface *fb, int num_rect, SDL_Rect *rect, int xskip, int yskip) {
int x, y, i;
int rx, ry, rw, rh;
int xend=0, yend=0;
int pitch = fb->pitch/2; // 16 bit pointer access (not char *)
int tex1_w = 0, tex2_w = 0, tex2_x = 0;
int x, y, i;
int rx, ry, rw, rh;
int xend=0, yend=0;
int pitch = fb->pitch/2; // 16 bit pointer access (not char *)
int tex1_w = 0, tex2_w = 0, tex2_x = 0;
for (i=0; i<num_rect; i++) {
tex1_w = tex2_w = tex2_x = 0;
rx = rect[i].x;
ry = rect[i].y;
rw = rect[i].w;
rh = rect[i].h;
xend = rx + rw;
yend = ry + rh;
if (xend > fb->w) continue;
if (yend > fb->h) continue;
for (i=0; i<num_rect; i++) {
tex1_w = tex2_w = tex2_x = 0;
rx = rect[i].x;
ry = rect[i].y;
rw = rect[i].w;
rh = rect[i].h;
xend = rx + rw;
yend = ry + rh;
if (xend > fb->w) continue;
if (yend > fb->h) continue;
if (rx < 256) { // Begins before the end of the 1st texture
if (xend >= 256) { // Ends after the first texture
if (rx < 256) { // Begins before the end of the 1st texture
if (xend >= 256) { // Ends after the first texture
tex2_w = xend-256; // For the 2nd texture
tex1_w = rw - tex2_w; // For the 1st texture
}
else tex1_w = rw;
}
else {
tex2_w = rw;
tex2_x = rx - 256;
}
}
else tex1_w = rw;
}
else {
tex2_w = rw;
tex2_x = rx - 256;
}
for (y = ry; y < yend; y++) {
for (x = rx; x < xend; x++) {
if (x < 256 && tex1_w) {
int pos = (x-rx+(y-ry)*tex1_w)*4; // RGBA
SDL_GetRGB(((Uint16 *)fb->pixels)[x+y*(pitch)],fb->format,
&fb1[pos],
&fb1[pos+1],
&fb1[pos+2]);
for (y = ry; y < yend; y++) {
for (x = rx; x < xend; x++) {
if (x < 256 && tex1_w) {
int pos = (x-rx+(y-ry)*tex1_w)*4; // RGBA
SDL_GetRGB(((Uint16 *)fb->pixels)[x+y*(pitch)],fb->format,
&fb1[pos],
&fb1[pos+1],
&fb1[pos+2]);
}
else if (x >= 256 && tex2_w) {
int rx2 = rx < 256? 256: rx;
int pos = (x-rx2+(y-ry)*tex2_w)*4; // RGBA
SDL_GetRGB(((Uint16 *)fb->pixels)[x+y*(pitch)],fb->format,
&fb2[pos],
&fb2[pos+1],
&fb2[pos+2]);
int rx2 = rx < 256? 256: rx;
int pos = (x-rx2+(y-ry)*tex2_w)*4; // RGBA
SDL_GetRGB(((Uint16 *)fb->pixels)[x+y*(pitch)],fb->format,
&fb2[pos],
&fb2[pos+1],
&fb2[pos+2]);
}
}
}
}
}
if (tex1_w > 0) {
// Update 256x256 texture
glBindTexture(GL_TEXTURE_2D,texture);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,rx+xskip,ry+yskip,tex1_w,rh,GL_RGBA,
GL_UNSIGNED_BYTE,fb1);
}
if (tex2_w > 0) { // What was left for this texture
// Update 64x256 texture
glBindTexture(GL_TEXTURE_2D,textureb);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,tex2_x+xskip,ry+yskip,tex2_w,rh,GL_RGBA,
GL_UNSIGNED_BYTE,fb2);
}
}
if (tex1_w > 0) {
// Update 256x256 texture
glBindTexture(GL_TEXTURE_2D,texture);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,rx+xskip,ry+yskip,tex1_w,rh,GL_RGBA,
GL_UNSIGNED_BYTE,fb1);
}
if (tex2_w > 0) { // What was left for this texture
// Update 64x256 texture
glBindTexture(GL_TEXTURE_2D,textureb);
glFlush();
glTexSubImage2D(GL_TEXTURE_2D,0,tex2_x+xskip,ry+yskip,tex2_w,rh,GL_RGBA,
GL_UNSIGNED_BYTE,fb2);
}
}
}
void FB2GL::palette(int i, int r, int g, int b) {
if (flags & FB2GL_EXPAND) {
ogl_temp_ctable[i][0]=r;
ogl_temp_ctable[i][1]=g;
ogl_temp_ctable[i][2]=b;
}
else { // Paletted texture
ogl_ctable[i][0]=r;
ogl_ctable[i][1]=g;
ogl_ctable[i][2]=b;
}
if (flags & FB2GL_EXPAND) {
ogl_temp_ctable[i][0]=r;
ogl_temp_ctable[i][1]=g;
ogl_temp_ctable[i][2]=b;
}
else { // Paletted texture
ogl_ctable[i][0]=r;
ogl_ctable[i][1]=g;
ogl_ctable[i][2]=b;
}
}
void FB2GL::setPalette(int f, int n) {
char temp[256][3];
int i;
char temp[256][3];
int i;
if (flags & FB2GL_EXPAND) {
for (i=f; i<n; i++) {
ogl_ctable[i][0] = ogl_temp_ctable[i][0];
ogl_ctable[i][1] = ogl_temp_ctable[i][1];
ogl_ctable[i][2] = ogl_temp_ctable[i][2];
}
}
else { // Paletted texture
glBindTexture(GL_TEXTURE_2D,texture);
glGetColorTable(GL_TEXTURE_2D,GL_RGB,GL_UNSIGNED_BYTE,&temp);
if (flags & FB2GL_EXPAND) {
for (i=f; i<n; i++) {
ogl_ctable[i][0] = ogl_temp_ctable[i][0];
ogl_ctable[i][1] = ogl_temp_ctable[i][1];
ogl_ctable[i][2] = ogl_temp_ctable[i][2];
}
}
else { // Paletted texture
glBindTexture(GL_TEXTURE_2D,texture);
glGetColorTable(GL_TEXTURE_2D,GL_RGB,GL_UNSIGNED_BYTE,&temp);
for (i=f; i<n; i++) {
temp[i][0] = ogl_ctable[i][0];
temp[i][1] = ogl_ctable[i][1];
temp[i][2] = ogl_ctable[i][2];
}
for (i=f; i<n; i++) {
temp[i][0] = ogl_ctable[i][0];
temp[i][1] = ogl_ctable[i][1];
temp[i][2] = ogl_ctable[i][2];
}
glColorTable(GL_TEXTURE_2D,GL_RGB,256,GL_RGB,GL_UNSIGNED_BYTE,&temp);
glColorTable(GL_TEXTURE_2D,GL_RGB,256,GL_RGB,GL_UNSIGNED_BYTE,&temp);
if (flags & FB2GL_320) {
glBindTexture(GL_TEXTURE_2D,textureb);
glColorTable(GL_TEXTURE_2D,GL_RGB,256,GL_RGB,GL_UNSIGNED_BYTE,&temp);
}
if (flags & FB2GL_320) {
glBindTexture(GL_TEXTURE_2D,textureb);
glColorTable(GL_TEXTURE_2D,GL_RGB,256,GL_RGB,GL_UNSIGNED_BYTE,&temp);
}
}
}
}

217
backends/sdl/sdl-common.cpp

@ -73,7 +73,7 @@ OSystem *OSystem_SDL_Common::create(int gfx_mode, bool full_screen) {
#ifndef MACOSX // Work around a bug in OS X
// Clean up on exit
atexit_proc_installed = true;
atexit(atexit_proc);
atexit(atexit_proc);
#endif
// enable joystick
@ -95,21 +95,18 @@ OSystem_SDL_Common::OSystem_SDL_Common()
_cdrom(0), _dirty_checksums(0),
_mouseVisible(false), _mouseDrawn(false), _mouseData(0),
_mouseHotspotX(0), _mouseHotspotY(0),
_currentShakePos(0), _newShakePos(0)
{
_currentShakePos(0), _newShakePos(0) {
// allocate palette storage
_currentPalette = (SDL_Color*)calloc(sizeof(SDL_Color), 256);
_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
// allocate the dirty rect storage
_mouseBackup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
_mouseBackup = (byte *)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
// reset mouse state
memset(&km, 0, sizeof(km));
}
OSystem_SDL_Common::~OSystem_SDL_Common()
{
OSystem_SDL_Common::~OSystem_SDL_Common() {
if (_dirty_checksums)
free(_dirty_checksums);
free(_currentPalette);
@ -117,17 +114,16 @@ OSystem_SDL_Common::~OSystem_SDL_Common()
}
void OSystem_SDL_Common::init_size(uint w, uint h) {
// Avoid redundant res changes
if ((int)w == _screenWidth && (int)h == _screenHeight)
return;
_screenWidth = w;
_screenHeight = h;
CKSUM_NUM = (_screenWidth*_screenHeight/(8*8));
CKSUM_NUM = (_screenWidth * _screenHeight / (8 * 8));
if (_dirty_checksums)
free(_dirty_checksums);
_dirty_checksums = (uint32*)calloc(CKSUM_NUM*2, sizeof(uint32));
_dirty_checksums = (uint32 *)calloc(CKSUM_NUM * 2, sizeof(uint32));
unload_gfx_mode();
load_gfx_mode();
@ -145,18 +141,33 @@ void OSystem_SDL_Common::copy_rect(const byte *buf, int pitch, int x, int y, int
return;
if (((uint32)buf & 3) == 0 && pitch == _screenWidth && x==0 && y==0 &&
w==_screenWidth && h==_screenHeight && _mode_flags&DF_WANT_RECT_OPTIM) {
w==_screenWidth && h==_screenHeight && _mode_flags&DF_WANT_RECT_OPTIM) {
/* Special, optimized case for full screen updates.
* It tries to determine what areas were actually changed,
* and just updates those, on the actual display. */
add_dirty_rgn_auto(buf);
} else {
/* Clip the coordinates */
if (x < 0) { w+=x; buf-=x; x = 0; }
if (y < 0) { h+=y; buf-=y*pitch; y = 0; }
if (w > _screenWidth-x) { w = _screenWidth - x; }
if (h > _screenHeight-y) { h = _screenHeight - y; }
if (x < 0) {
w += x;
buf -= x;
x = 0;
}
if (y < 0) {
h += y;
buf -= y * pitch;
y = 0;
}
if (w > _screenWidth - x) {
w = _screenWidth - x;
}
if (h > _screenHeight - y) {
h = _screenHeight - y;
}
if (w <= 0 || h <= 0)
return;
@ -183,7 +194,6 @@ void OSystem_SDL_Common::copy_rect(const byte *buf, int pitch, int x, int y, int
void OSystem_SDL_Common::move_screen(int dx, int dy, int height) {
if ((dx == 0) && (dy == 0))
return;
@ -227,7 +237,6 @@ void OSystem_SDL_Common::add_dirty_rect(int x, int y, int w, int h) {
_forceFull = true;
else {
SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++];
// Extend the dirty region by 1 pixel for scalers
// that "smear" the screen, e.g. 2xSAI
if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) {
@ -238,10 +247,22 @@ void OSystem_SDL_Common::add_dirty_rect(int x, int y, int w, int h) {
}
// clip
if (x < 0) { w+=x; x=0; }
if (y < 0) { h+=y; y=0; }
if (w > _screenWidth-x) { w = _screenWidth - x; }
if (h > _screenHeight-y) { h = _screenHeight - y; }
if (x < 0) {
w += x; x = 0;
}
if (y < 0) {
h += y;
y=0;
}
if (w > _screenWidth - x) {
w = _screenWidth - x;
}
if (h > _screenHeight - y) {
h = _screenHeight - y;
}
r->x = x;
r->y = y;
@ -250,18 +271,19 @@ void OSystem_SDL_Common::add_dirty_rect(int x, int y, int w, int h) {
}
}
#define ROL(a,n) a = (a<<(n)) | (a>>(32-(n)))
#define DOLINE(x) a ^= ((uint32*)buf)[0+(x)*(_screenWidth/4)]; b ^= ((uint32*)buf)[1+(x)*(_screenWidth/4)]
#define ROL(a,n) a = (a << (n)) | (a >> (32 - (n)))
#define DOLINE(x) a ^= ((uint32*)buf)[0 + (x) * (_screenWidth / 4)]; b ^= ((uint32 *)buf)[1 + (x) * (_screenWidth / 4)]
void OSystem_SDL_Common::mk_checksums(const byte *buf) {
uint32 *sums = _dirty_checksums;
uint x,y;
const uint last_x = (uint)_screenWidth/8;
const uint last_y = (uint)_screenHeight/8;
const uint last_x = (uint)_screenWidth / 8;
const uint last_y = (uint)_screenHeight / 8;
/* the 8x8 blocks in buf are enumerated starting in the top left corner and
* reading each line at a time from left to right */
for(y=0; y != last_y; y++, buf+=_screenWidth*(8-1))
for(x=0; x != last_x; x++, buf+=8) {
for(y = 0; y != last_y; y++, buf += _screenWidth * (8 - 1))
for(x=0; x != last_x; x++, buf += 8) {
uint32 a = x;
uint32 b = y;
@ -270,8 +292,8 @@ void OSystem_SDL_Common::mk_checksums(const byte *buf) {
DOLINE(4); ROL(a,13); ROL(b,11);
DOLINE(6); ROL(a,13); ROL(b,11);
a*=0xDEADBEEF;
b*=0xBAADF00D;
a *= 0xDEADBEEF;
b *= 0xBAADF00D;
DOLINE(1); ROL(a,13); ROL(b,11);
DOLINE(3); ROL(a,13); ROL(b,11);
@ -279,15 +301,14 @@ void OSystem_SDL_Common::mk_checksums(const byte *buf) {
DOLINE(7); ROL(a,13); ROL(b,11);
/* output the checksum for this block */
*sums++=a+b;
*sums++ = a + b;
}
}
#undef DOLINE
#undef ROL
void OSystem_SDL_Common::add_dirty_rgn_auto(const byte *buf) {
assert( ((uint32)buf & 3) == 0);
assert(((uint32)buf & 3) == 0);
/* generate a table of the checksums */
mk_checksums(buf);
@ -304,18 +325,18 @@ void OSystem_SDL_Common::add_dirty_rgn_auto(const byte *buf) {
int x,y,w;
uint32 *ck = _dirty_checksums;
for(y=0; y!=_screenHeight/8; y++) {
for(x=0; x!=_screenWidth/8; x++,ck++) {
for(y = 0; y!=_screenHeight / 8; y++) {
for(x = 0; x!=_screenWidth / 8; x++,ck++) {
if (ck[0] != ck[CKSUM_NUM]) {
/* found a dirty 8x8 block, now go as far to the right as possible,
and at the same time, unmark the dirty status by setting old to new. */
w=0;
do {
ck[w+CKSUM_NUM] = ck[w];
ck[w + CKSUM_NUM] = ck[w];
w++;
} while (x+w != _screenWidth/8 && ck[w] != ck[w+CKSUM_NUM]);
add_dirty_rect(x*8, y*8, w*8, 8);
} while (x + w != _screenWidth / 8 && ck[w] != ck[w + CKSUM_NUM]);
add_dirty_rect(x * 8, y * 8, w * 8, 8);
if (_forceFull)
goto get_out;
@ -338,18 +359,18 @@ void OSystem_SDL_Common::kbd_mouse() {
km.x_down_count = 2;
}
if (km.y_down_count == 1) {
km.y_down_time = time;
km.y_down_time = time;
km.y_down_count = 2;
}
if (km.x_vel || km.y_vel) {
if (km.x_down_count) {
if (time > km.x_down_time + km.delay_time*12) {
if (time > km.x_down_time + km.delay_time * 12) {
if (km.x_vel > 0)
km.x_vel++;
else
km.x_vel--;
} else if (time > km.x_down_time + km.delay_time*8) {
} else if (time > km.x_down_time + km.delay_time * 8) {
if (km.x_vel > 0)
km.x_vel = 5;
else
@ -357,12 +378,12 @@ void OSystem_SDL_Common::kbd_mouse() {
}
}
if (km.y_down_count) {
if (time > km.y_down_time + km.delay_time*12) {
if (time > km.y_down_time + km.delay_time * 12) {
if (km.y_vel > 0)
km.y_vel++;
else
km.y_vel--;
} else if (time > km.y_down_time + km.delay_time*8) {
} else if (time > km.y_down_time + km.delay_time * 8) {
if (km.y_vel > 0)
km.y_vel = 5;
else
@ -412,7 +433,7 @@ bool OSystem_SDL_Common::show_mouse(bool visible) {
return last;
}
void OSystem_SDL_Common::set_mouse_pos(int x, int y) {
if (x != _mouseCurState.x || y != _mouseCurState.y) {
_mouseCurState.x = x;
@ -427,7 +448,6 @@ void OSystem_SDL_Common::warp_mouse(int x, int y) {
}
void OSystem_SDL_Common::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
assert(0 <= w && w <= MAX_MOUSE_W);
assert(0 <= h && h <= MAX_MOUSE_H);
_mouseCurState.w = w;
@ -436,23 +456,23 @@ void OSystem_SDL_Common::set_mouse_cursor(const byte *buf, uint w, uint h, int h
_mouseHotspotX = hotspot_x;
_mouseHotspotY = hotspot_y;
_mouseData = (byte*)buf;
_mouseData = (byte *)buf;
undraw_mouse();
}
void OSystem_SDL_Common::set_shake_pos(int shake_pos) {
_newShakePos = shake_pos;
}
uint32 OSystem_SDL_Common::get_msecs() {
return SDL_GetTicks();
}
void OSystem_SDL_Common::delay_msecs(uint msecs) {
SDL_Delay(msecs);
}
void *OSystem_SDL_Common::create_thread(ThreadProc *proc, void *param) {
return SDL_CreateThread(proc, param);
}
@ -472,7 +492,7 @@ static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode)
}
return key;
}
bool OSystem_SDL_Common::poll_event(Event *event) {
SDL_Event ev;
int axis;
@ -579,7 +599,7 @@ bool OSystem_SDL_Common::poll_event(Event *event) {
default:
break;
}
return true;
}
@ -589,7 +609,7 @@ bool OSystem_SDL_Common::poll_event(Event *event) {
event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
switch(ev.key.keysym.sym){
case SDLK_LEFT:
case SDLK_LEFT:
if (km.x_vel < 0) {
km.x_vel = 0;
km.x_down_count = 0;
@ -717,7 +737,7 @@ bool OSystem_SDL_Common::poll_event(Event *event) {
}
}
return true;
case SDL_JOYAXISMOTION:
axis = ev.jaxis.value;
if ( axis > JOY_DEADZONE) {
@ -728,7 +748,7 @@ bool OSystem_SDL_Common::poll_event(Event *event) {
event->event_code = EVENT_MOUSEMOVE;
} else
axis = 0;
if ( ev.jaxis.axis == JOY_XAXIS) {
#ifdef JOY_ANALOG
km.x_vel = axis/2000;
@ -748,11 +768,11 @@ bool OSystem_SDL_Common::poll_event(Event *event) {
axis = -axis;
#endif
#ifdef JOY_ANALOG
km.y_vel = -axis/2000;
km.y_vel = -axis / 2000;
km.y_down_count = 0;
#else
if (axis != 0) {
km.y_vel = (-axis > 0) ? 1:-1;
km.y_vel = (-axis > 0) ? 1: -1;
km.y_down_count = 1;
} else {
km.y_vel = 0;
@ -760,7 +780,7 @@ bool OSystem_SDL_Common::poll_event(Event *event) {
}
#endif
}
return true;
return true;
case SDL_QUIT:
quit();
@ -772,7 +792,6 @@ bool OSystem_SDL_Common::set_sound_proc(void *param, SoundProc *proc, byte forma
SDL_AudioSpec desired;
/* only one format supported at the moment */
desired.freq = SAMPLES_PER_SEC;
desired.format = AUDIO_S16SYS;
desired.channels = 2;
@ -818,13 +837,13 @@ uint32 OSystem_SDL_Common::property(int param, Property *value) {
return 0;
}
void OSystem_SDL_Common::quit() {
if(_cdrom) {
SDL_CDStop(_cdrom);
SDL_CDClose(_cdrom);
}
unload_gfx_mode();
unload_gfx_mode();
exit(0);
}
@ -868,10 +887,9 @@ void OSystem_SDL_Common::draw_mouse() {
_mouseOldState.h = h;
// Draw the mouse cursor; backup the covered area in "bak"
if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
error("SDL_LockSurface failed: %s.\n", SDL_GetError());
// Mark as dirty
add_dirty_rect(x, y, w, h);
@ -897,10 +915,10 @@ void OSystem_SDL_Common::draw_mouse() {
}
} else {
uint16 *bak = (uint16*)_mouseBackup; // Surface used to backup the area obscured by the mouse
uint16 *bak = (uint16 *)_mouseBackup; // Surface used to backup the area obscured by the mouse
uint16 *dst; // Surface we are drawing into
dst = (uint16 *)_tmpscreen->pixels + (y+1) * _tmpScreenWidth + (x+1);
dst = (uint16 *)_tmpscreen->pixels + (y + 1) * _tmpScreenWidth + (x + 1);
while (h > 0) {
int width = w;
while (width > 0) {
@ -916,11 +934,10 @@ void OSystem_SDL_Common::draw_mouse() {
dst += _tmpScreenWidth - w;
h--;
}
}
SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
// Finally, set the flag to indicate the mouse has been drawn
_mouseDrawn = true;
}
@ -940,9 +957,8 @@ void OSystem_SDL_Common::undraw_mouse() {
int x, y;
if (!_overlayVisible) {
byte *dst, *bak = _mouseBackup;
// No need to do clipping here, since draw_mouse() did that already
dst = (byte *)_screen->pixels + old_mouse_y * _screenWidth + old_mouse_x;
for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _screenWidth) {
@ -956,7 +972,7 @@ void OSystem_SDL_Common::undraw_mouse() {
uint16 *dst, *bak = (uint16 *)_mouseBackup;
// No need to do clipping here, since draw_mouse() did that already
dst = (uint16 *)_tmpscreen->pixels + (old_mouse_y+1) * _tmpScreenWidth + (old_mouse_x+1);
dst = (uint16 *)_tmpscreen->pixels + (old_mouse_y + 1) * _tmpScreenWidth + (old_mouse_x + 1);
for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _tmpScreenWidth) {
for (x = 0; x < old_mouse_w; ++x) {
dst[x] = bak[x];
@ -972,7 +988,6 @@ void OSystem_SDL_Common::undraw_mouse() {
void OSystem_SDL_Common::stop_cdrom() { /* Stop CD Audio in 1/10th of a second */
cd_stop_time = SDL_GetTicks() + 100;
cd_num_loops = 0;
}
void OSystem_SDL_Common::play_cdrom(int track, int num_loops, int start_frame, int end_frame) {
@ -983,7 +998,7 @@ void OSystem_SDL_Common::play_cdrom(int track, int num_loops, int start_frame, i
return;
if (end_frame > 0)
end_frame+=5;
end_frame +=5;
cd_track = track;
cd_num_loops = num_loops;
@ -1009,7 +1024,7 @@ bool OSystem_SDL_Common::poll_cdrom() {
void OSystem_SDL_Common::update_cdrom() {
if (!_cdrom)
return;
if (cd_stop_time != 0 && SDL_GetTicks() >= cd_stop_time) {
SDL_CDStop(_cdrom);
cd_num_loops = 0;
@ -1098,8 +1113,7 @@ void OSystem_SDL_Common::delete_mutex(void *mutex) {
SDL_DestroyMutex((SDL_mutex *) mutex);
}
void OSystem_SDL_Common::show_overlay()
{
void OSystem_SDL_Common::show_overlay() {
// hide the mouse
undraw_mouse();
@ -1107,8 +1121,7 @@ void OSystem_SDL_Common::show_overlay()
clear_overlay();
}
void OSystem_SDL_Common::hide_overlay()
{
void OSystem_SDL_Common::hide_overlay() {
// hide the mouse
undraw_mouse();
@ -1116,8 +1129,7 @@ void OSystem_SDL_Common::hide_overlay()
_forceFull = true;
}
void OSystem_SDL_Common::clear_overlay()
{
void OSystem_SDL_Common::clear_overlay() {
if (!_overlayVisible)
return;
@ -1144,8 +1156,7 @@ int16 OSystem_SDL_Common::get_width() {
return _screenWidth;
}
void OSystem_SDL_Common::grab_overlay(int16 *buf, int pitch)
{
void OSystem_SDL_Common::grab_overlay(int16 *buf, int pitch) {
if (!_overlayVisible)
return;
@ -1169,8 +1180,7 @@ void OSystem_SDL_Common::grab_overlay(int16 *buf, int pitch)
SDL_UnlockSurface(_tmpscreen);
}
void OSystem_SDL_Common::copy_rect_overlay(const int16 *buf, int pitch, int x, int y, int w, int h)
{
void OSystem_SDL_Common::copy_rect_overlay(const int16 *buf, int pitch, int x, int y, int w, int h) {
if (!_overlayVisible)
return;
@ -1178,13 +1188,28 @@ void OSystem_SDL_Common::copy_rect_overlay(const int16 *buf, int pitch, int x, i
return;
// Clip the coordinates
if (x < 0) { w+=x; buf-=x; x = 0; }
if (y < 0) { h+=y; buf-=y*pitch; y = 0; }
if (w > _screenWidth-x) { w = _screenWidth - x; }
if (h > _screenHeight-y) { h = _screenHeight - y; }
if (x < 0) {
w += x;
buf -= x;
x = 0;
}
if (y < 0) {
h += y; buf -= y * pitch;
y = 0;
}
if (w > _screenWidth - x) {
w = _screenWidth - x;
}
if (h > _screenHeight-y) {
h = _screenHeight - y;
}
if (w <= 0 || h <= 0)
return;
// Mark the modified region as dirty
cksum_valid = false;
add_dirty_rect(x, y, w, h);
@ -1195,9 +1220,9 @@ void OSystem_SDL_Common::copy_rect_overlay(const int16 *buf, int pitch, int x, i
if (SDL_LockSurface(_tmpscreen) == -1)
error("SDL_LockSurface failed: %s.\n", SDL_GetError());
int16 *dst = (int16 *)_tmpscreen->pixels + (y+1) * _tmpScreenWidth + (x+1);
int16 *dst = (int16 *)_tmpscreen->pixels + (y + 1) * _tmpScreenWidth + (x + 1);
do {
memcpy(dst, buf, w*2);
memcpy(dst, buf, w * 2);
dst += _tmpScreenWidth;
buf += pitch;
} while (--h);
@ -1205,12 +1230,10 @@ void OSystem_SDL_Common::copy_rect_overlay(const int16 *buf, int pitch, int x, i
SDL_UnlockSurface(_tmpscreen);
}
int16 OSystem_SDL_Common::RBGToColor(uint8 r, uint8 g, uint8 b)
{
int16 OSystem_SDL_Common::RBGToColor(uint8 r, uint8 g, uint8 b) {
return SDL_MapRGB(_tmpscreen->format, r, g, b);
}
void OSystem_SDL_Common::colorToRBG(int16 color, uint8 &r, uint8 &g, uint8 &b)
{
void OSystem_SDL_Common::colorToRBG(int16 color, uint8 &r, uint8 &g, uint8 &b) {
SDL_GetRGB(color, _tmpscreen->format, &r, &g, &b);
}

18
backends/sdl/sdl-common.h

@ -57,29 +57,29 @@ public:
// backend of the mouse cursor's current position, this function
// actually moves the cursor to the specified position.
void warp_mouse(int x, int y);
// Set the bitmap that's used when drawing the cursor.
void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
// Shaking is used in SCUMM. Set current shake position.
void set_shake_pos(int shake_pos);
// Get the number of milliseconds since the program was started.
uint32 get_msecs();
// Delay for a specified amount of milliseconds
void delay_msecs(uint msecs);
// Create a thread
void *create_thread(ThreadProc *proc, void *param);
// Get the next event.
// Returns true if an event was retrieved.
bool poll_event(Event *event);
// Set function that generates samples
bool set_sound_proc(void *param, SoundProc *proc, byte sound);
// Poll CD status
// Returns true if cd audio is playing
bool poll_cdrom();
@ -183,7 +183,7 @@ protected:
// joystick
SDL_Joystick *_joystick;
bool _mouseVisible;
bool _mouseDrawn;
byte *_mouseData;

28
backends/sdl/sdl.cpp

@ -140,7 +140,6 @@ normal_mode:;
if (_screen == NULL)
error("_screen failed");
//
// Create the surface that contains the scaled graphics in 16 bit mode
//
@ -161,9 +160,9 @@ normal_mode:;
Init_2xSaI(565);
// Need some extra bytes around when using 2xSaI
uint16 *tmp_screen = (uint16*)calloc(_tmpScreenWidth*(_screenHeight+3), sizeof(uint16));
uint16 *tmp_screen = (uint16 *)calloc(_tmpScreenWidth * (_screenHeight + 3), sizeof(uint16));
_tmpscreen = SDL_CreateRGBSurfaceFrom(tmp_screen,
_tmpScreenWidth, _screenHeight + 3, 16, _tmpScreenWidth*2,
_tmpScreenWidth, _screenHeight + 3, 16, _tmpScreenWidth * 2,
_hwscreen->format->Rmask,
_hwscreen->format->Gmask,
_hwscreen->format->Bmask,
@ -171,13 +170,12 @@ normal_mode:;
if (_tmpscreen == NULL)
error("_tmpscreen failed");
// keyboard cursor control, some other better place for it?
km.x_max = _screenWidth * _scaleFactor - 1;
km.y_max = _screenHeight * _scaleFactor - 1;
km.delay_time = 25;
km.last_time = 0;
}
void OSystem_SDL::unload_gfx_mode() {
@ -230,12 +228,11 @@ void OSystem_SDL::hotswap_gfx_mode() {
}
void OSystem_SDL::update_screen() {
assert(_hwscreen != NULL);
// If the shake position changed, fill the dirty area with blackness
if (_currentShakePos != _newShakePos) {
SDL_Rect blackrect = {0, 0, _screenWidth*_scaleFactor, _newShakePos*_scaleFactor};
SDL_Rect blackrect = {0, 0, _screenWidth * _scaleFactor, _newShakePos * _scaleFactor};
SDL_FillRect(_hwscreen, &blackrect, 0);
_currentShakePos = _newShakePos;
@ -270,11 +267,11 @@ void OSystem_SDL::update_screen() {
// Only draw anything if necessary
if (_num_dirty_rects > 0) {
SDL_Rect *r;
uint32 srcPitch, dstPitch;
SDL_Rect *last_rect = _dirty_rect_list + _num_dirty_rects;
// Convert appropriate parts of the 8bpp image into 16bpp
if (!_overlayVisible) {
SDL_Rect dst;
@ -286,7 +283,7 @@ void OSystem_SDL::update_screen() {
error("SDL_BlitSurface failed: %s", SDL_GetError());
}
}
SDL_LockSurface(_tmpscreen);
SDL_LockSurface(_hwscreen);
@ -300,11 +297,11 @@ void OSystem_SDL::update_screen() {
dst_h = r->h;
if (dst_h > _screenHeight - dst_y)
dst_h = _screenHeight - dst_y;
dst_y *= _scaleFactor;
_scaler_proc((byte*)_tmpscreen->pixels + (r->x*2+2) + (r->y+1)*srcPitch, srcPitch, NULL,
(byte*)_hwscreen->pixels + r->x*2*_scaleFactor + dst_y*dstPitch, dstPitch, r->w, dst_h);
_scaler_proc((byte *)_tmpscreen->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch, NULL,
(byte *)_hwscreen->pixels + r->x * 2 * _scaleFactor + dst_y * dstPitch, dstPitch, r->w, dst_h);
}
r->x *= _scaleFactor;
@ -332,7 +329,6 @@ void OSystem_SDL::update_screen() {
}
uint32 OSystem_SDL::property(int param, Property *value) {
if (param == PROP_TOGGLE_FULLSCREEN) {
assert(_hwscreen != 0);
_full_screen ^= true;
@ -358,8 +354,6 @@ uint32 OSystem_SDL::property(int param, Property *value) {
return 1;
}
return OSystem_SDL_Common::property(param, value);
}

123
backends/sdl/sdl_gl.cpp

@ -108,14 +108,14 @@ void OSystem_SDL_OpenGL::load_gfx_mode() {
//
gl_flags = FB2GL_320 | FB2GL_RGBA | FB2GL_16BIT;
if (_full_screen) {
gl_flags |= (FB2GL_FS);
_glScreenStart = 0;
if (_full_screen) {
gl_flags |= (FB2GL_FS);
_glScreenStart = 0;
}
// 640x480 screen resolution
fb2gl.init(640,480,0,_glScreenStart? 15: 70,gl_flags);
fb2gl.init(640, 480, 0,_glScreenStart? 15: 70,gl_flags);
SDL_SetGamma(1.25,1.25,1.25);
SDL_SetGamma(1.25, 1.25, 1.25);
//
@ -123,9 +123,9 @@ void OSystem_SDL_OpenGL::load_gfx_mode() {
//
// Need some extra bytes around when using 2xSaI
uint16 *tmp_screen = (uint16*)calloc(_tmpScreenWidth*(_screenHeight+3),sizeof(uint16));
uint16 *tmp_screen = (uint16 *)calloc(_tmpScreenWidth * (_screenHeight + 3),sizeof(uint16));
_tmpscreen = SDL_CreateRGBSurfaceFrom(tmp_screen,
_tmpScreenWidth, _screenHeight + 3, 16, _tmpScreenWidth*2,
_tmpScreenWidth, _screenHeight + 3, 16, _tmpScreenWidth * 2,
Rmask,
Gmask,
Bmask,
@ -144,16 +144,15 @@ void OSystem_SDL_OpenGL::load_gfx_mode() {
tmpBlackRect.y = 0;
tmpBlackRect.w = _screenWidth;
tmpBlackRect.h = 256-_screenHeight-_glScreenStart;
if (_tmpscreen == NULL)
error("_tmpscreen failed");
// keyboard cursor control, some other better place for it?
km.x_max = _screenWidth * _scaleFactor - 1;
km.y_max = _screenHeight * _scaleFactor - 1;
km.delay_time = 25;
km.last_time = 0;
}
void OSystem_SDL_OpenGL::unload_gfx_mode() {
@ -163,20 +162,19 @@ void OSystem_SDL_OpenGL::unload_gfx_mode() {
}
if (_tmpscreen) {
free((uint16*)_tmpscreen->pixels);
free((uint16 *)_tmpscreen->pixels);
SDL_FreeSurface(_tmpscreen);
_tmpscreen = NULL;
}
}
void OSystem_SDL_OpenGL::update_screen() {
// If the shake position changed, fill the dirty area with blackness
if (_currentShakePos != _newShakePos) {
SDL_Rect blackrect = {0, _glScreenStart, _screenWidth, _newShakePos+_glScreenStart};
SDL_FillRect(tmpSurface, &blackrect, 0);
fb2gl.blit16(tmpSurface,1,&blackrect,0,0);
fb2gl.blit16(tmpSurface, 1, &blackrect, 0, 0);
_currentShakePos = _newShakePos;
@ -227,13 +225,14 @@ void OSystem_SDL_OpenGL::update_screen() {
}
// Almost the same thing as SDL_UpdateRects
fb2gl.blit16(_tmpscreen,_num_dirty_rects,_dirty_rect_list,0,
_currentShakePos+_glScreenStart);
fb2gl.blit16(_tmpscreen, _num_dirty_rects, _dirty_rect_list, 0,
_currentShakePos+_glScreenStart);
tmpBlackRect.h = 256 - _screenHeight - _glScreenStart - _currentShakePos;
tmpBlackRect.h = 256-_screenHeight-_glScreenStart-_currentShakePos;
SDL_FillRect(tmpSurface, &tmpBlackRect, 0);
fb2gl.blit16(tmpSurface,1,&tmpBlackRect,0,_screenHeight+_glScreenStart+_currentShakePos);
fb2gl.blit16(tmpSurface, 1, &tmpBlackRect, 0,_screenHeight
+ _glScreenStart+_currentShakePos);
fb2gl.display();
}
@ -243,67 +242,61 @@ void OSystem_SDL_OpenGL::update_screen() {
}
uint32 OSystem_SDL_OpenGL::property(int param, Property *value) {
int i;
if (param == PROP_TOGGLE_FULLSCREEN) {
_full_screen ^= true;
SDL_WM_ToggleFullScreen(fb2gl.screen);
return 1;
}
else if (param == PROP_SET_GFX_MODE) {
SDL_Rect full = {0,0,_screenWidth,_screenHeight};
SDL_Rect full = {0, 0, _screenWidth, _screenHeight};
glPopMatrix();
switch(value->gfx_mode) {
case 0: // Bilinear Filtering (on/off)
_glBilinearFilter ^= true;
for (int i=0; i<2; i++) {
glBindTexture(GL_TEXTURE_2D,i);
if (_glBilinearFilter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR);
}
else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
}
}
break;
case 1: // Don't fit the whole screen
fb2gl.init(0,0,0,15,gl_flags);
_glScreenStart = 20;
SDL_FillRect(tmpSurface,&tmpBlackRect,0);
fb2gl.blit16(tmpSurface,1,&tmpBlackRect,0,0);
break;
case 2: // Fit the whole screen
fb2gl.init(0,0,0,70,gl_flags);
_glScreenStart = 0;
break;
default: // Zooming
glPushMatrix();
/* SDL_FillRect(tmpSurface, &full, 0);
fb2gl.blit16(tmpSurface,1,&full,0,_glScreenStart);
fb2gl.display();
double x = (double)((_mouseCurState.x)
- (_screenWidth/2)) / (_screenWidth/2);
double y = (double)((_mouseCurState.y)
- (_screenHeight/2)) / (_screenHeight/2);
glTranslatef(-x,y,0);
case 0: // Bilinear Filtering (on/off)
_glBilinearFilter ^= true;
for (i = 0; i < 2; i++) {
glBindTexture(GL_TEXTURE_2D, i);
if (_glBilinearFilter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
}
break;
case 1: // Don't fit the whole screen
fb2gl.init(0, 0, 0, 15, gl_flags);
_glScreenStart = 20;
SDL_FillRect(tmpSurface, &tmpBlackRect, 0);
fb2gl.blit16(tmpSurface, 1, &tmpBlackRect, 0, 0);
break;
case 2: // Fit the whole screen
fb2gl.init(0, 0, 0, 70, gl_flags);
_glScreenStart = 0;
break;
default: // Zooming
glPushMatrix();
/* SDL_FillRect(tmpSurface, &full, 0);
fb2gl.blit16(tmpSurface, 1, &full,0, _glScreenStart);
fb2gl.display();
double x = (double)((_mouseCurState.x)
- (_screenWidth / 2)) / (_screenWidth / 2);
double y = (double)((_mouseCurState.y)
- (_screenHeight / 2)) / (_screenHeight / 2);
glTranslatef(-x, y, 0);
*/
glScalef(1.0+(double)(value->gfx_mode-1)/10,
1.0+(double)(value->gfx_mode-1)/10,
0);
glScalef(1.0 + (double)(value->gfx_mode - 1) / 10,
1.0 + (double)(value->gfx_mode - 1) / 10, 0);
};
fb2gl.blit16(_tmpscreen,1,&full,0,_glScreenStart);
fb2gl.blit16(_tmpscreen, 1, &full, 0, _glScreenStart);
fb2gl.display();
return 1;
}
return OSystem_SDL_Common::property(param, value);
}

763
sound/fmopl.cpp

File diff suppressed because it is too large Load Diff

18
sound/fmopl.h

@ -76,10 +76,10 @@ typedef struct fm_opl_channel {
int op1_out[2]; /* slot1 output for selfeedback */
/* phase generator state */
uint block_fnum; /* block+fnum */
uint block_fnum; /* block+fnum */
uint8 kcode; /* key code : KeyScaleCode */
uint fc; /* Freq. Increment base */
uint ksl_base; /* KeyScaleLevel Base step */
uint fc; /* Freq. Increment base */
uint ksl_base; /* KeyScaleLevel Base step */
uint8 keyon; /* key on/off flag */
} OPL_CH;
@ -139,14 +139,14 @@ void OPLBuildTables(int ENV_BITS_PARAM, int EG_ENT_PARAM);
FM_OPL *OPLCreate(int type, int clock, int rate);
void OPLDestroy(FM_OPL *OPL);
void OPLSetTimerHandler(FM_OPL *OPL,OPL_TIMERHANDLER TimerHandler,int channelOffset);
void OPLSetIRQHandler(FM_OPL *OPL,OPL_IRQHANDLER IRQHandler,int param);
void OPLSetUpdateHandler(FM_OPL *OPL,OPL_UPDATEHANDLER UpdateHandler,int param);
void OPLSetTimerHandler(FM_OPL *OPL, OPL_TIMERHANDLER TimerHandler, int channelOffset);
void OPLSetIRQHandler(FM_OPL *OPL, OPL_IRQHANDLER IRQHandler, int param);
void OPLSetUpdateHandler(FM_OPL *OPL, OPL_UPDATEHANDLER UpdateHandler, int param);
void OPLResetChip(FM_OPL *OPL);
int OPLWrite(FM_OPL *OPL,int a,int v);
unsigned char OPLRead(FM_OPL *OPL,int a);
int OPLTimerOver(FM_OPL *OPL,int c);
int OPLWrite(FM_OPL *OPL, int a, int v);
unsigned char OPLRead(FM_OPL *OPL, int a);
int OPLTimerOver(FM_OPL *OPL, int c);
void OPLWriteReg(FM_OPL *OPL, int r, int v);
void YM3812UpdateOne(FM_OPL *OPL, int16 *buffer, int length);
#endif

30
sound/mididrv.cpp

@ -31,18 +31,13 @@
#include "common/engine.h" // for warning/error/debug
#include "common/util.h" // for ARRAYSIZE
/* Default (empty) property method */
uint32 MidiDriver::property(int prop, uint32 param)
{
uint32 MidiDriver::property(int prop, uint32 param) {
return 0;
}
/* retrieve a string representation of an error code */
const char *MidiDriver::getErrorName(int error_code)
{
const char *MidiDriver::getErrorName(int error_code) {
static const char *const midi_errors[] = {
"No error",
"Cannot connect",
@ -66,22 +61,20 @@ public:
int open();
void close();
void send(uint32 b);
void sysEx (byte *msg, uint16 length);
void sysEx(byte *msg, uint16 length);
private:
bool _isOpen;
int device, _device_num;
};
MidiDriver_SEQ::MidiDriver_SEQ()
{
MidiDriver_SEQ::MidiDriver_SEQ() {
_isOpen = false;
device = 0;
_device_num = 0;
}
int MidiDriver_SEQ::open()
{
int MidiDriver_SEQ::open() {
if (_isOpen)
return MERR_ALREADY_OPEN;
_isOpen = true;
@ -109,15 +102,12 @@ int MidiDriver_SEQ::open()
return 0;
}
void MidiDriver_SEQ::close()
{
void MidiDriver_SEQ::close() {
::close(device);
_isOpen = false;
}
void MidiDriver_SEQ::send(uint32 b)
{
void MidiDriver_SEQ::send(uint32 b) {
unsigned char buf[256];
int position = 0;
@ -158,8 +148,7 @@ void MidiDriver_SEQ::send(uint32 b)
write(device, buf, position);
}
void MidiDriver_SEQ::sysEx (byte *msg, uint16 length)
{
void MidiDriver_SEQ::sysEx (byte *msg, uint16 length) {
if (length > 254) {
warning ("Cannot send SysEx block - data too large");
return;
@ -188,8 +177,7 @@ void MidiDriver_SEQ::sysEx (byte *msg, uint16 length)
write (device, buf, position);
}
MidiDriver *MidiDriver_SEQ_create()
{
MidiDriver *MidiDriver_SEQ_create() {
return new MidiDriver_SEQ();
}

6
sound/mididrv.h

@ -45,7 +45,6 @@ public:
PROP_SMALLHEADER = 2
};
// Open the midi driver.
// Returns 0 if successful, otherwise an error code.
virtual int open() = 0;
@ -83,8 +82,6 @@ public:
virtual MidiChannel *getPercussionChannel() = 0;
};
class MidiChannel {
public:
virtual MidiDriver *device() = 0;
@ -114,8 +111,6 @@ public:
virtual void sysEx_customInstrument (uint32 type, byte *instr) = 0;
};
// MIDI Driver Types
enum {
MD_AUTO = 0,
@ -131,7 +126,6 @@ enum {
MD_ADLIB = 10
};
// Factory functions, for faster compile
extern MidiDriver *MidiDriver_NULL_create();
extern MidiDriver *MidiDriver_ADLIB_create();

35
sound/midistreamer.cpp

@ -24,20 +24,19 @@
#include "common/util.h"
MidiStreamer::MidiStreamer (MidiDriver *target) :
_target (target),
_stream_proc (0),
_stream_param (0),
_isOpen (false),
_paused (false),
_event_count (0),
_event_index (0),
_tempo (500000), // 120 BPM = 500,000 microseconds between each beat
_ticks_per_beat (96),
_delay (0)
_target (target),
_stream_proc (0),
_stream_param (0),
_isOpen (false),
_paused (false),
_event_count (0),
_event_index (0),
_tempo (500000), // 120 BPM = 500,000 microseconds between each beat
_ticks_per_beat (96),
_delay (0)
{ }
void MidiStreamer::set_stream_callback (void *param, StreamCallback *sc)
{
void MidiStreamer::set_stream_callback (void *param, StreamCallback *sc) {
_stream_param = param;
_stream_proc = sc;
@ -51,8 +50,7 @@ void MidiStreamer::timer_thread (void *param) {
((MidiStreamer *) param)->on_timer();
}
void MidiStreamer::on_timer()
{
void MidiStreamer::on_timer() {
if (_paused || !_stream_proc)
return;
@ -80,8 +78,7 @@ void MidiStreamer::on_timer()
} // end while
}
int MidiStreamer::open()
{
int MidiStreamer::open() {
if (_isOpen)
close();
@ -99,8 +96,7 @@ int MidiStreamer::open()
return 0;
}
void MidiStreamer::close()
{
void MidiStreamer::close() {
if (!_isOpen)
return;
@ -116,8 +112,7 @@ void MidiStreamer::close()
_paused = true;
}
uint32 MidiStreamer::property (int prop, uint32 param)
{
uint32 MidiStreamer::property (int prop, uint32 param) {
switch (prop) {
// 16-bit time division according to standard midi specification

4
sound/midistreamer.h

@ -35,7 +35,7 @@ class MidiStreamer {
public:
// Called whenever more MIDI commands need to be generated.
// Return 0 to tell MidiStreamer that end of stream was reached.
typedef int StreamCallback (void *param, MidiEvent * ev, int num);
typedef int StreamCallback (void *param, MidiEvent *ev, int num);
// Special events that can be inserted in a MidiEvent.
// event = (ME_xxx<<24) | <24-bit data associated with event>
@ -51,7 +51,7 @@ private:
bool _isOpen;
bool _paused;
MidiEvent _events [64];
MidiEvent _events[64];
int _event_count;
int _event_index;

123
sound/mixer.cpp

@ -37,7 +37,7 @@ SoundMixer::~SoundMixer() {
free(_volumeTable);
}
void SoundMixer::unInsert(Channel * chan) {
void SoundMixer::unInsert(Channel *chan) {
for (int i = 0; i != NUM_CHANNELS; i++) {
if (_channels[i] == chan) {
if (_handles[i]) {
@ -51,10 +51,10 @@ void SoundMixer::unInsert(Channel * chan) {
error("SoundMixer::channel_deleted chan not found");
}
int SoundMixer::append(int index, void * sound, uint32 size, uint rate, byte flags) {
int SoundMixer::append(int index, void *sound, uint32 size, uint rate, byte flags) {
_syst->lock_mutex(_mutex);
Channel * chan = _channels[index];
Channel *chan = _channels[index];
if (!chan) {
debug(2, "Trying to stream to an unexistant streamer : %d", index);
playStream(NULL, index, sound, size, rate, flags);
@ -69,7 +69,7 @@ int SoundMixer::append(int index, void * sound, uint32 size, uint rate, byte fla
return 1;
}
int SoundMixer::insertAt(PlayingSoundHandle * handle, int index, Channel * chan) {
int SoundMixer::insertAt(PlayingSoundHandle *handle, int index, Channel *chan) {
if(index == -1) {
for (int i = _beginSlots; i != NUM_CHANNELS; i++)
if (_channels[i] == NULL) { index = i; break; }
@ -88,7 +88,7 @@ int SoundMixer::insertAt(PlayingSoundHandle * handle, int index, Channel * chan)
return index;
}
int SoundMixer::playRaw(PlayingSoundHandle * handle, void * sound, uint32 size, uint rate, byte flags) {
int SoundMixer::playRaw(PlayingSoundHandle *handle, void *sound, uint32 size, uint rate, byte flags) {
for (int i = _beginSlots; i != NUM_CHANNELS; i++) {
if (_channels[i] == NULL) {
return insertAt(handle, i, new ChannelRaw(this, sound, size, rate, flags, -1));
@ -99,7 +99,7 @@ int SoundMixer::playRaw(PlayingSoundHandle * handle, void * sound, uint32 size,
return -1;
}
int SoundMixer::playRaw(PlayingSoundHandle * handle, void * sound, uint32 size, uint rate, byte flags, int id) {
int SoundMixer::playRaw(PlayingSoundHandle *handle, void *sound, uint32 size, uint rate, byte flags, int id) {
for (int i = _beginSlots; i != NUM_CHANNELS; i++) {
if (_channels[i] == NULL) {
return insertAt(handle, i, new ChannelRaw(this, sound, size, rate, flags, id));
@ -110,8 +110,8 @@ int SoundMixer::playRaw(PlayingSoundHandle * handle, void * sound, uint32 size,
return -1;
}
int SoundMixer::playStream(PlayingSoundHandle * handle, int idx, void * sound, uint32 size,
uint rate, byte flags, int32 timeout, int32 buffer_size) {
int SoundMixer::playStream(PlayingSoundHandle *handle, int idx, void *sound, uint32 size,
uint rate, byte flags, int32 timeout, int32 buffer_size) {
return insertAt(handle, idx, new ChannelStream(this, sound, size, rate, flags, timeout, buffer_size));
}
@ -124,7 +124,7 @@ void SoundMixer::beginSlots(int index) {
}
#ifdef USE_MAD
int SoundMixer::playMP3(PlayingSoundHandle * handle, void *sound, uint32 size, byte flags) {
int SoundMixer::playMP3(PlayingSoundHandle *handle, void *sound, uint32 size, byte flags) {
for (int i = _beginSlots; i != NUM_CHANNELS; i++) {
if (_channels[i] == NULL) {
return insertAt(handle, i, new ChannelMP3(this, sound, size, flags));
@ -134,7 +134,7 @@ int SoundMixer::playMP3(PlayingSoundHandle * handle, void *sound, uint32 size, b
warning("SoundMixer::out of mixer slots");
return -1;
}
int SoundMixer::playMP3CDTrack(PlayingSoundHandle * handle, File * file, mad_timer_t duration) {
int SoundMixer::playMP3CDTrack(PlayingSoundHandle *handle, File *file, mad_timer_t duration) {
/* Stop the previously playing CD track (if any) */
for (int i = _beginSlots; i != NUM_CHANNELS; i++) {
if (_channels[i] == NULL) {
@ -148,7 +148,7 @@ int SoundMixer::playMP3CDTrack(PlayingSoundHandle * handle, File * file, mad_tim
#endif
#ifdef USE_VORBIS
int SoundMixer::playVorbis(PlayingSoundHandle * handle, OggVorbis_File * ov_file, int duration, bool is_cd_track) {
int SoundMixer::playVorbis(PlayingSoundHandle *handle, OggVorbis_File *ov_file, int duration, bool is_cd_track) {
for (int i = _beginSlots; i != NUM_CHANNELS; i++) {
if (_channels[i] == NULL) {
return insertAt(handle, i, new ChannelVorbis(this, ov_file, duration, is_cd_track));
@ -185,15 +185,13 @@ void SoundMixer::mix(int16 *buf, uint len) {
_syst->unlock_mutex(_mutex);
}
void SoundMixer::onGenerateSamples(void * s, byte * samples, int len) {
void SoundMixer::onGenerateSamples(void *s, byte *samples, int len) {
((SoundMixer *)s)->mix((int16 *)samples, len >> 2);
}
bool SoundMixer::bindToSystem(OSystem * syst) {
bool SoundMixer::bindToSystem(OSystem *syst) {
uint rate = (uint) syst->property(OSystem::PROP_GET_SAMPLE_RATE, 0);
_outputRate = rate;
_syst = syst;
_mutex = _syst->create_mutex();
@ -230,7 +228,7 @@ bool SoundMixer::hasActiveChannel() {
return false;
}
void SoundMixer::setupPremix(void * param, PremixProc * proc) {
void SoundMixer::setupPremix(void *param, PremixProc *proc) {
_premixParam = param;
_premixProc = proc;
}
@ -267,12 +265,12 @@ bool SoundMixer::Channel::soundFinished() {
return false;
}
void SoundMixer::Channel::append(void * sound, uint32 size) {
void SoundMixer::Channel::append(void *sound, uint32 size) {
error("append method should never be called on something else than a _STREAM mixer ");
}
/* RAW mixer */
SoundMixer::ChannelRaw::ChannelRaw(SoundMixer * mixer, void * sound, uint32 size, uint rate, byte flags, int id) {
SoundMixer::ChannelRaw::ChannelRaw(SoundMixer *mixer, void *sound, uint32 size, uint rate, byte flags, int id) {
_id = id;
_mixer = mixer;
_flags = flags;
@ -300,7 +298,6 @@ SoundMixer::ChannelRaw::ChannelRaw(SoundMixer * mixer, void * sound, uint32 size
}
}
/*
* Class that performs cubic interpolation on integer data.
* It is expected that the data is equidistant, i.e. all have the same
@ -312,14 +309,12 @@ protected:
int a, b, c, d;
public:
CubicInterpolator(int a0, int b0, int c0) : x0(2 * a0 - b0), x1(a0), x2(b0), x3(c0)
{
CubicInterpolator(int a0, int b0, int c0) : x0(2 * a0 - b0), x1(a0), x2(b0), x3(c0) {
// We use a simple linear interpolation for x0
updateCoefficients();
}
inline void feedData()
{
inline void feedData() {
x0 = x1;
x1 = x2;
x2 = x3;
@ -327,8 +322,7 @@ public:
updateCoefficients();
}
inline void feedData(int xNew)
{
inline void feedData(int xNew) {
x0 = x1;
x1 = x2;
x2 = x3;
@ -337,8 +331,7 @@ public:
}
/* t must be a 16.16 fixed point number between 0 and 1 */
inline int interpolate(uint32 fpPos)
{
inline int interpolate(uint32 fpPos) {
int result = 0;
int t = fpPos >> 8;
result = (a * t + b) >> 8;
@ -350,8 +343,7 @@ public:
}
protected:
inline void updateCoefficients()
{
inline void updateCoefficients() {
a = ((-x0 * 2) + (x1 * 5) - (x2 * 4) + x3);
b = ((x0 + x2 - (2 * x1)) * 6) << 8;
c = ((-4 * x0) + x1 + (x2 * 4) - x3) << 8;
@ -370,12 +362,12 @@ static inline int clamped_add_16(int a, int b) {
return val;
}
static int16 * mix_signed_mono_8(int16 * data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte * s_end, bool reverse_stereo) {
static int16 *mix_signed_mono_8(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
uint32 fp_pos = *fp_pos_ptr;
byte *s = *s_ptr;
uint len = *len_ptr;
int inc = 1, result;
CubicInterpolator interp(vol_tab[*s], vol_tab[*(s + 1)], vol_tab[*(s + 2)]);
@ -409,12 +401,12 @@ static int16 * mix_signed_mono_8(int16 * data, uint * len_ptr, byte ** s_ptr, ui
return data;
}
static int16 * mix_unsigned_mono_8(int16 * data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte * s_end, bool reverse_stereo) {
static int16 *mix_unsigned_mono_8(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
uint32 fp_pos = *fp_pos_ptr;
byte *s = *s_ptr;
uint len = *len_ptr;
int inc = 1, result;
CubicInterpolator interp(vol_tab[*s ^ 0x80], vol_tab[*(s + 1) ^ 0x80], vol_tab[*(s + 2) ^ 0x80]);
@ -448,18 +440,18 @@ static int16 * mix_unsigned_mono_8(int16 * data, uint * len_ptr, byte ** s_ptr,
return data;
}
static int16 * mix_signed_stereo_8(int16 * data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte *s_end, bool reverse_stereo) {
static int16 *mix_signed_stereo_8(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
warning("Mixing stereo signed 8 bit is not supported yet ");
return data;
}
static int16 * mix_unsigned_stereo_8(int16 * data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte * s_end, bool reverse_stereo) {
static int16 *mix_unsigned_stereo_8(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
uint32 fp_pos = *fp_pos_ptr;
byte *s = *s_ptr;
uint len = *len_ptr;
int inc = 1;
CubicInterpolator left(vol_tab[*s ^ 0x80], vol_tab[*(s + 2) ^ 0x80], vol_tab[*(s + 4) ^ 0x80]);
CubicInterpolator right(vol_tab[*(s + 1) ^ 0x80], vol_tab[*(s + 3) ^ 0x80], vol_tab[*(s + 5) ^ 0x80]);
@ -501,8 +493,8 @@ static int16 * mix_unsigned_stereo_8(int16 * data, uint * len_ptr, byte ** s_ptr
return data;
}
static int16 * mix_signed_mono_16(int16 * data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte * s_end, bool reverse_stereo) {
static int16 *mix_signed_mono_16(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
uint32 fp_pos = *fp_pos_ptr;
unsigned char volume = ((int)vol_tab[1]) / 8;
byte *s = *s_ptr;
@ -526,14 +518,14 @@ static int16 * mix_signed_mono_16(int16 * data, uint * len_ptr, byte ** s_ptr, u
return data;
}
static int16 *mix_unsigned_mono_16(int16 *data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte * s_end, bool reverse_stereo) {
static int16 *mix_unsigned_mono_16(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
warning("Mixing mono unsigned 16 bit is not supported yet ");
return data;
}
static int16 *mix_signed_stereo_16(int16 * data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte * s_end, bool reverse_stereo) {
static int16 *mix_signed_stereo_16(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
uint32 fp_pos = *fp_pos_ptr;
unsigned char volume = ((int)vol_tab[1]) / 8;
byte *s = *s_ptr;
@ -562,16 +554,16 @@ static int16 *mix_signed_stereo_16(int16 * data, uint * len_ptr, byte ** s_ptr,
return data;
}
static int16 * mix_unsigned_stereo_16(int16 * data, uint * len_ptr, byte ** s_ptr, uint32 * fp_pos_ptr,
int fp_speed, const int16 * vol_tab, byte * s_end, bool reverse_stereo) {
static int16 *mix_unsigned_stereo_16(int16 *data, uint *len_ptr, byte **s_ptr, uint32 *fp_pos_ptr,
int fp_speed, const int16 *vol_tab, byte *s_end, bool reverse_stereo) {
warning("Mixing stereo unsigned 16 bit is not supported yet ");
return data;
}
static int16 * (*mixer_helper_table[8]) (int16 * data, uint * len_ptr, byte ** s_ptr,
uint32 * fp_pos_ptr, int fp_speed, const int16 * vol_tab,
byte * s_end, bool reverse_stereo) = {
static int16 *(*mixer_helper_table[8]) (int16 *data, uint *len_ptr, byte **s_ptr,
uint32 *fp_pos_ptr, int fp_speed, const int16 *vol_tab,
byte *s_end, bool reverse_stereo) = {
mix_signed_mono_8, mix_unsigned_mono_8,
mix_signed_stereo_8, mix_unsigned_stereo_8,
mix_signed_mono_16, mix_unsigned_mono_16,
@ -585,7 +577,7 @@ static int16 mixer_element_size[] = {
4, 4
};
void SoundMixer::ChannelRaw::mix(int16 * data, uint len) {
void SoundMixer::ChannelRaw::mix(int16 *data, uint len) {
byte *s, *s_org = NULL;
uint32 fp_pos;
byte *end;
@ -657,7 +649,7 @@ void SoundMixer::ChannelRaw::realDestroy() {
#define WARP_WORKAROUND 50000
SoundMixer::ChannelStream::ChannelStream(SoundMixer * mixer, void * sound, uint32 size, uint rate,
SoundMixer::ChannelStream::ChannelStream(SoundMixer *mixer, void *sound, uint32 size, uint rate,
byte flags, int32 timeout, int32 buffer_size) {
_mixer = mixer;
_flags = flags;
@ -681,7 +673,7 @@ SoundMixer::ChannelStream::ChannelStream(SoundMixer * mixer, void * sound, uint3
_rate = rate;
}
void SoundMixer::ChannelStream::append(void * data, uint32 len) {
void SoundMixer::ChannelStream::append(void *data, uint32 len) {
byte *new_end = _endOfData + len;
byte *cur_pos = _pos; /* This is just to prevent the variable to move during the tests :-) */
if (new_end > (_ptr + _bufferSize)) {
@ -705,11 +697,11 @@ void SoundMixer::ChannelStream::append(void * data, uint32 len) {
_endOfData = new_end;
}
void SoundMixer::ChannelStream::mix(int16 * data, uint len) {
void SoundMixer::ChannelStream::mix(int16 *data, uint len) {
uint32 fp_pos;
const uint32 fp_speed = _fpSpeed;
const int16 * vol_tab = _mixer->_volumeTable;
byte * end_of_data = _endOfData;
const int16 *vol_tab = _mixer->_volumeTable;
byte *end_of_data = _endOfData;
if (_toBeDestroyed) {
realDestroy();
@ -734,7 +726,7 @@ void SoundMixer::ChannelStream::mix(int16 * data, uint len) {
int wrap_offset = 0;
// see if we will wrap
if (_pos + (mixer_element_size[_flags & 0x07] * len) > _endOfBuffer) {
if (_pos + (mixer_element_size[_flags & 0x07] * len) > _endOfBuffer) {
wrap_offset = _pos + (mixer_element_size[_flags & 0x07] * len) - _endOfBuffer;
debug(9, "using wrap workaround for %d bytes", wrap_offset);
memcpy(_endOfBuffer, _ptr, wrap_offset);
@ -766,7 +758,7 @@ void SoundMixer::ChannelStream::realDestroy() {
}
#ifdef USE_MAD
SoundMixer::ChannelMP3::ChannelMP3(SoundMixer * mixer, void * sound, uint size, byte flags) {
SoundMixer::ChannelMP3::ChannelMP3(SoundMixer *mixer, void *sound, uint size, byte flags) {
_mixer = mixer;
_flags = flags;
_posInFrame = 0xFFFFFFFF;
@ -812,7 +804,7 @@ static inline int scale_sample(mad_fixed_t sample) {
return sample >> (MAD_F_FRACBITS + 1 - 16);
}
void SoundMixer::ChannelMP3::mix(int16 * data, uint len) {
void SoundMixer::ChannelMP3::mix(int16 *data, uint len) {
mad_fixed_t const * ch;
const int16 * vol_tab = _mixer->_volumeTable;
unsigned char volume = ((int)vol_tab[1]) / 8;
@ -885,7 +877,7 @@ void SoundMixer::ChannelMP3::realDestroy() {
#define MP3CD_BUFFERING_SIZE 131072
SoundMixer::ChannelMP3CDMusic::ChannelMP3CDMusic(SoundMixer * mixer, File * file,
SoundMixer::ChannelMP3CDMusic::ChannelMP3CDMusic(SoundMixer *mixer, File *file,
mad_timer_t duration){
_mixer = mixer;
_file = file;
@ -905,7 +897,7 @@ SoundMixer::ChannelMP3CDMusic::ChannelMP3CDMusic(SoundMixer * mixer, File * file
mad_synth_init(&_synth);
}
void SoundMixer::ChannelMP3CDMusic::mix(int16 * data, uint len) {
void SoundMixer::ChannelMP3CDMusic::mix(int16 *data, uint len) {
mad_fixed_t const *ch;
mad_timer_t frame_duration;
unsigned char volume = _mixer->_musicVolume / 8;
@ -1022,7 +1014,7 @@ void SoundMixer::ChannelMP3CDMusic::realDestroy() {
#endif
#ifdef USE_VORBIS
SoundMixer::ChannelVorbis::ChannelVorbis(SoundMixer * mixer, OggVorbis_File * ov_file, int duration, bool is_cd_track) {
SoundMixer::ChannelVorbis::ChannelVorbis(SoundMixer *mixer, OggVorbis_File *ov_file, int duration, bool is_cd_track) {
_mixer = mixer;
_ov_file = ov_file;
@ -1036,7 +1028,7 @@ SoundMixer::ChannelVorbis::ChannelVorbis(SoundMixer * mixer, OggVorbis_File * ov
_toBeDestroyed = false;
}
void SoundMixer::ChannelVorbis::mix(int16 * data, uint len) {
void SoundMixer::ChannelVorbis::mix(int16 *data, uint len) {
if (_toBeDestroyed) {
realDestroy();
return;
@ -1109,8 +1101,7 @@ void SoundMixer::ChannelVorbis::realDestroy() {
}
bool SoundMixer::ChannelVorbis::soundFinished() {
return _eof_flag || (_end_pos > 0 &&
ov_pcm_tell(_ov_file) >= _end_pos);
return _eof_flag || (_end_pos > 0 && ov_pcm_tell(_ov_file) >= _end_pos);
}
#endif

84
sound/mixer.h

@ -56,8 +56,8 @@ private:
};
class ChannelRaw : public Channel {
SoundMixer * _mixer;
void * _ptr;
SoundMixer *_mixer;
void *_ptr;
uint32 _pos;
uint32 _size;
uint32 _fpSpeed;
@ -68,18 +68,18 @@ private:
uint32 _loop_size;
public:
ChannelRaw(SoundMixer * mixer, void * sound, uint32 size, uint rate, byte flags, int id);
ChannelRaw(SoundMixer *mixer, void *sound, uint32 size, uint rate, byte flags, int id);
void mix(int16 * data, uint len);
void mix(int16 *data, uint len);
void realDestroy();
};
class ChannelStream : public Channel {
SoundMixer * _mixer;
byte * _ptr;
byte * _endOfData;
byte * _endOfBuffer;
byte * _pos;
SoundMixer *_mixer;
byte *_ptr;
byte *_endOfData;
byte *_endOfBuffer;
byte *_pos;
uint32 _fpSpeed;
uint32 _fpPos;
uint32 _bufferSize;
@ -89,17 +89,17 @@ private:
byte _flags;
public:
ChannelStream(SoundMixer * mixer, void * sound, uint32 size, uint rate, byte flags, int32 timout, int32 buffer_size);
ChannelStream(SoundMixer *mixer, void *sound, uint32 size, uint rate, byte flags, int32 timout, int32 buffer_size);
void append(void * sound, uint32 size);
void mix(int16 * data, uint len);
void append(void *sound, uint32 size);
void mix(int16 *data, uint len);
void realDestroy();
};
#ifdef USE_MAD
class ChannelMP3 : public Channel {
SoundMixer * _mixer;
SoundMixer *_mixer;
void *_ptr;
struct mad_stream _stream;
struct mad_frame _frame;
@ -111,16 +111,16 @@ private:
byte _flags;
public:
ChannelMP3(SoundMixer * mixer, void *sound, uint size, byte flags);
ChannelMP3(SoundMixer *mixer, void *sound, uint size, byte flags);
void mix(int16 * data, uint len);
void mix(int16 *data, uint len);
void realDestroy();
};
class ChannelMP3CDMusic:public Channel {
SoundMixer * _mixer;
void * _ptr;
SoundMixer *_mixer;
void *_ptr;
struct mad_stream _stream;
struct mad_frame _frame;
struct mad_synth _synth;
@ -128,14 +128,14 @@ private:
uint32 _size;
uint32 _bufferSize;
mad_timer_t _duration;
File * _file;
File *_file;
bool _initialized;
public:
ChannelMP3CDMusic(SoundMixer * mixer, File * file, mad_timer_t duration);
ChannelMP3CDMusic(SoundMixer *mixer, File *file, mad_timer_t duration);
void mix(int16 * data, uint len);
void mix(int16 *data, uint len);
void realDestroy();
bool soundFinished();
};
@ -144,31 +144,31 @@ private:
#ifdef USE_VORBIS
class ChannelVorbis : public Channel {
SoundMixer * _mixer;
OggVorbis_File * _ov_file;
SoundMixer *_mixer;
OggVorbis_File *_ov_file;
int _end_pos;
bool _eof_flag, _is_cd_track;
public:
ChannelVorbis(SoundMixer * mixer, OggVorbis_File * ov_file, int duration, bool is_cd_track);
ChannelVorbis(SoundMixer *mixer, OggVorbis_File *ov_file, int duration, bool is_cd_track);
void mix(int16 * data, uint len);
void mix(int16 *data, uint len);
void realDestroy();
bool soundFinished();
};
#endif
static void onGenerateSamples(void * s, byte * samples, int len);
static void onGenerateSamples(void *s, byte *samples, int len);
public:
typedef void PremixProc (void * param, int16 * data, uint len);
typedef void PremixProc (void *param, int16 *data, uint len);
OSystem * _syst;
void * _mutex;
OSystem *_syst;
void *_mutex;
uint _outputRate;
int16 * _volumeTable;
int16 *_volumeTable;
int _musicVolume;
bool _paused;
@ -177,20 +177,20 @@ public:
NUM_CHANNELS = 16
};
void * _premixParam;
PremixProc * _premixProc;
void *_premixParam;
PremixProc *_premixProc;
Channel * _channels[NUM_CHANNELS];
PlayingSoundHandle * _handles[NUM_CHANNELS];
Channel *_channels[NUM_CHANNELS];
PlayingSoundHandle *_handles[NUM_CHANNELS];
int _beginSlots;
SoundMixer();
~SoundMixer();
int insertAt(PlayingSoundHandle * handle, int index, Channel * chan);
void append(void * data, uint32 len);
void unInsert(Channel * chan);
int insertAt(PlayingSoundHandle *handle, int index, Channel *chan);
void append(void *data, uint32 len);
void unInsert(Channel *chan);
void beginSlots(int index);
// start playing a raw sound
@ -204,16 +204,16 @@ public:
FLAG_REVERSE_STEREO = 32, // sound should be reverse stereo
FLAG_LOOP = 64 // loop the audio
};
int playRaw(PlayingSoundHandle * handle, void * sound, uint32 size, uint rate, byte flags);
int playRaw(PlayingSoundHandle * handle, void * sound, uint32 size, uint rate, byte flags, int id);
int playStream(PlayingSoundHandle * handle, int index, void * sound, uint32 size, uint rate,
int playRaw(PlayingSoundHandle *handle, void *sound, uint32 size, uint rate, byte flags);
int playRaw(PlayingSoundHandle *handle, void *sound, uint32 size, uint rate, byte flags, int id);
int playStream(PlayingSoundHandle *handle, int index, void *sound, uint32 size, uint rate,
byte flags, int32 timeout = 3, int32 buffer_size = 2000000);
#ifdef USE_MAD
int playMP3(PlayingSoundHandle * handle, void * sound, uint32 size, byte flags);
int playMP3CDTrack(PlayingSoundHandle * handle, File * file, mad_timer_t duration);
int playMP3(PlayingSoundHandle *handle, void *sound, uint32 size, byte flags);
int playMP3CDTrack(PlayingSoundHandle *handle, File *file, mad_timer_t duration);
#endif
#ifdef USE_VORBIS
int playVorbis(PlayingSoundHandle * handle, OggVorbis_File * ov_file, int duration, bool is_cd_track);
int playVorbis(PlayingSoundHandle *handle, OggVorbis_File *ov_file, int duration, bool is_cd_track);
#endif
/* Premix procedure, useful when using fmopl adlib */

65
sound/mpu401.cpp

@ -24,40 +24,58 @@
#include "common/util.h" // for ARRAYSIZE
void MidiChannel_MPU401::init (MidiDriver_MPU401 *owner, byte channel)
{
void MidiChannel_MPU401::init(MidiDriver_MPU401 *owner, byte channel) {
_owner = owner;
_channel = channel;
_allocated = false;
}
MidiDriver *MidiChannel_MPU401::device() { return _owner; }
void MidiChannel_MPU401::noteOff (byte note) { _owner->send(note << 8 | 0x80 | _channel); }
void MidiChannel_MPU401::noteOn (byte note, byte velocity) { _owner->send (velocity << 16 | note << 8 | 0x90 | _channel); }
void MidiChannel_MPU401::programChange (byte program) { _owner->send(program << 8 | 0xC0 | _channel); }
void MidiChannel_MPU401::pitchBend (int16 bend) { _owner->send((((bend + 0x2000) >> 7) & 0x7F) << 16 | ((bend + 0x2000) & 0x7F) << 8 | 0xE0 | _channel); }
void MidiChannel_MPU401::controlChange (byte control, byte value) { _owner->send(value << 16 | control << 8 | 0xB0 | _channel); }
void MidiChannel_MPU401::pitchBendFactor (byte value) { _owner->setPitchBendRange (_channel, value); }
void MidiChannel_MPU401::sysEx_customInstrument (uint32 type, byte *instr) { _owner->sysEx_customInstrument (_channel, type, instr); }
MidiDriver *MidiChannel_MPU401::device() {
return _owner;
}
void MidiChannel_MPU401::noteOff (byte note) {
_owner->send(note << 8 | 0x80 | _channel);
}
MidiDriver_MPU401::MidiDriver_MPU401() : MidiDriver()
{
void MidiChannel_MPU401::noteOn(byte note, byte velocity) {
_owner->send (velocity << 16 | note << 8 | 0x90 | _channel);
}
void MidiChannel_MPU401::programChange(byte program) {
_owner->send(program << 8 | 0xC0 | _channel);
}
void MidiChannel_MPU401::pitchBend(int16 bend) {
_owner->send((((bend + 0x2000) >> 7) & 0x7F) << 16 | ((bend + 0x2000) & 0x7F) << 8 | 0xE0 | _channel);
}
void MidiChannel_MPU401::controlChange(byte control, byte value) {
_owner->send(value << 16 | control << 8 | 0xB0 | _channel);
}
void MidiChannel_MPU401::pitchBendFactor(byte value) {
_owner->setPitchBendRange (_channel, value);
}
void MidiChannel_MPU401::sysEx_customInstrument(uint32 type, byte *instr) {
_owner->sysEx_customInstrument (_channel, type, instr);
}
MidiDriver_MPU401::MidiDriver_MPU401() : MidiDriver() {
uint i;
for (i = 0; i < ARRAYSIZE(_midi_channels); ++i) {
_midi_channels [i].init (this, i);
}
}
MidiChannel *MidiDriver_MPU401::allocateChannel()
{
MidiChannel *MidiDriver_MPU401::allocateChannel() {
MidiChannel_MPU401 *chan;
uint i;
for (i = 0; i < ARRAYSIZE(_midi_channels); ++i) {
if (i == 9) continue;
if (i == 9)
continue;
chan = &_midi_channels[i];
if (!chan->_allocated) {
chan->allocate();
@ -67,24 +85,21 @@ MidiChannel *MidiDriver_MPU401::allocateChannel()
return NULL;
}
void MidiDriver_MPU401::setTimerCallback (void *timer_param, void (*timer_proc) (void *))
{
void MidiDriver_MPU401::setTimerCallback (void *timer_param, void (*timer_proc) (void *)) {
if (!_timer_proc || !timer_proc) {
_timer_proc = (TimerCallback *) timer_proc;
_timer_param = timer_param;
if (!_started_thread && timer_proc)
g_system->create_thread (midi_driver_thread, this);
g_system->create_thread(midi_driver_thread, this);
_started_thread = true;
}
}
#if !defined(__MORPHOS__)
int MidiDriver_MPU401::midi_driver_thread(void *param)
{
int MidiDriver_MPU401::midi_driver_thread(void *param) {
MidiDriver_MPU401 *mid = (MidiDriver_MPU401 *)param;
int old_time, cur_time;
old_time = g_system->get_msecs();
for (;;) {

4
sound/mpu401.h

@ -87,8 +87,8 @@ private:
public:
MidiDriver_MPU401();
void setTimerCallback (void *timer_param, void (*timer_proc) (void *));
uint32 getBaseTempo (void) { return 0x4A0000; }
void setTimerCallback(void *timer_param, void (*timer_proc) (void *));
uint32 getBaseTempo(void) { return 0x4A0000; }
MidiChannel *allocateChannel();
MidiChannel *getPercussionChannel() { return &_midi_channels [9]; }