libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-04-11 03:01:01 +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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
backends/fs/fs.h
View File

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

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

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

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

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

195
backends/midi/adlib.cpp
View File

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

20
backends/midi/alsa.cpp
View File

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

15
backends/midi/coreaudio.cpp
View File

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

6
backends/midi/null.cpp
View File

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

17
backends/midi/quicktime.cpp
View File

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

22
backends/midi/windows.cpp
View File

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

4
backends/null/null.cpp
View File

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

623
backends/sdl/fb2opengl.h
View File

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

217
backends/sdl/sdl-common.cpp
View File

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

18
backends/sdl/sdl-common.h
View File

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

28
backends/sdl/sdl.cpp
View File

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

123
backends/sdl/sdl_gl.cpp
View File

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

763
sound/fmopl.cpp
View File

File diff suppressed because it is too large Load Diff

18
sound/fmopl.h
View File

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

30
sound/mididrv.cpp
View File

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

6
sound/mididrv.h
View File

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

35
sound/midistreamer.cpp
View File

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

4
sound/midistreamer.h
View File

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

123
sound/mixer.cpp
View File

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

84
sound/mixer.h
View File

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

65
sound/mpu401.cpp
View File

@ -24,40 +24,58 @@
#include "common/util.h" // for ARRAYSIZE #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; _owner = owner;
_channel = channel; _channel = channel;
_allocated = false; _allocated = false;
} }
MidiDriver *MidiChannel_MPU401::device() { return _owner; } MidiDriver *MidiChannel_MPU401::device() {
void MidiChannel_MPU401::noteOff (byte note) { _owner->send(note << 8 | 0x80 | _channel); } return _owner;
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); }
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; uint i;
for (i = 0; i < ARRAYSIZE(_midi_channels); ++i) { for (i = 0; i < ARRAYSIZE(_midi_channels); ++i) {
_midi_channels [i].init (this, i); _midi_channels [i].init (this, i);
} }
} }
MidiChannel *MidiDriver_MPU401::allocateChannel() {
MidiChannel *MidiDriver_MPU401::allocateChannel()
{
MidiChannel_MPU401 *chan; MidiChannel_MPU401 *chan;
uint i; uint i;
for (i = 0; i < ARRAYSIZE(_midi_channels); ++i) { for (i = 0; i < ARRAYSIZE(_midi_channels); ++i) {
if (i == 9) continue; if (i == 9)
continue;
chan = &_midi_channels[i]; chan = &_midi_channels[i];
if (!chan->_allocated) { if (!chan->_allocated) {
chan->allocate(); chan->allocate();
@ -67,24 +85,21 @@ MidiChannel *MidiDriver_MPU401::allocateChannel()
return NULL; 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) { if (!_timer_proc || !timer_proc) {
_timer_proc = (TimerCallback *) timer_proc; _timer_proc = (TimerCallback *) timer_proc;
_timer_param = timer_param; _timer_param = timer_param;
if (!_started_thread && timer_proc) if (!_started_thread && timer_proc)
g_system->create_thread (midi_driver_thread, this); g_system->create_thread(midi_driver_thread, this);
_started_thread = true; _started_thread = true;
} }
} }
#if !defined(__MORPHOS__) #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; MidiDriver_MPU401 *mid = (MidiDriver_MPU401 *)param;
int old_time, cur_time; int old_time, cur_time;
old_time = g_system->get_msecs(); old_time = g_system->get_msecs();
for (;;) { for (;;) {

4
sound/mpu401.h
View File

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