Ticket #9058: opl-experiment.diff

sound/softsynth/adlib.cpp

@@ -60 +60 @@
         AdlibInstrument() { memset(this, 0, sizeof(AdlibInstrument)); }
 };
 
+class AdlibSoundcard {
+private:
+        FM_OPL *_opl;
+        byte *_adlib_reg_cache;
+        uint16 channel_table_2[9];
+        uint16 curnote_table[9];
+
+        byte adlib_get_reg_value(byte reg) {
+                return _adlib_reg_cache[reg];
+        }
+
+public:
+        AdlibSoundcard(int rate);
+        ~AdlibSoundcard();
+
+        void adlib_key_off(int chan);
+        void adlib_note_on(int chan, byte note, int mod);
+        void adlib_note_on_ex(int chan, byte note, int mod);
+        int adlib_get_reg_value_param(int chan, byte param);
+        void adlib_setup_channel(int chan, AdlibInstrument *instr, byte vol_1, byte vol_2);
+        void adlib_set_param(int channel, byte param, int value);
+        void adlib_key_onoff(int channel);
+        void adlib_write(byte reg, byte value);
+        void adlib_playnote(int channel, int note);
+
+        void generateSamples(int16 *data, int len);
+};
+
 class AdlibPart : public MidiChannel {
         friend class MidiDriver_ADLIB;
 
@@ -575 +603 @@
         int getRate() const { return _mixer->getOutputRate(); }
 
 private:
+        int16 *_sampleBuffer;
+        int _sampleBufferLen;
+
         bool _scummSmallHeader; // FIXME: This flag controls a special mode for SCUMM V3 games
 
-        FM_OPL *_opl;
-        byte *_adlib_reg_cache;
+        int _numCards;
+        AdlibSoundcard *_cards[2];
 
         int _adlib_timer_counter;
 
-        uint16 channel_table_2[9];
         int _voice_index;
         int _timer_p;
         int _timer_q;
-        uint16 curnote_table[9];
-        AdlibVoice _voices[9];
+
+        int _numVoices;
+        AdlibVoice *_voices;
         AdlibPart _parts[32];
         AdlibPercussionChannel _percussion;
 
@@ -601 +632 @@
         void adlib_note_on_ex(int chan, byte note, int mod);
         int adlib_get_reg_value_param(int chan, byte data);
         void adlib_setup_channel(int chan, AdlibInstrument * instr, byte vol_1, byte vol_2);
-        byte adlib_get_reg_value(byte reg) {
-                return _adlib_reg_cache[reg];
-        }
         void adlib_set_param(int channel, byte param, int value);
         void adlib_key_onoff(int channel);
-        void adlib_write(byte reg, byte value);
-        void adlib_playnote(int channel, int note);
 
         AdlibVoice *allocate_voice(byte pri);
 
@@ -625 +651 @@
         void mc_key_on(AdlibVoice *voice, AdlibInstrument *instr, byte note, byte velocity);
 };
 
+// An emulated Adlib sound card
+
+AdlibSoundcard::AdlibSoundcard(int rate) {
+        _opl = makeAdlibOPL(rate);
+
+        _adlib_reg_cache = (byte *)calloc(256, 1);
+
+        for (int i = 0; i < ARRAYSIZE(curnote_table); ++i) {
+                curnote_table[i] = 0;
+        }
+
+        adlib_write(1, 0x20);
+        adlib_write(8, 0x40);
+        adlib_write(0xBD, 0x00);
+}
+
+AdlibSoundcard::~AdlibSoundcard() {
+        OPLDestroy(_opl);
+        free(_adlib_reg_cache);
+}
+
+void AdlibSoundcard::adlib_key_off(int chan) {
+        byte reg = chan + 0xB0;
+        adlib_write(reg, adlib_get_reg_value(reg) & ~0x20);
+}
+
+void AdlibSoundcard::adlib_note_on(int chan, byte note, int mod) {
+        int code;
+        assert(chan >= 0 && chan < 9);
+        code = (note << 7) + mod;
+        curnote_table[chan] = code;
+        adlib_playnote(chan, (int16)channel_table_2[chan] + code);
+}
+
+void AdlibSoundcard::adlib_note_on_ex(int channel, byte note, int mod) {
+        int code;
+        assert(channel >= 0 && channel < 9);
+        code = (note << 7) + mod;
+        curnote_table[channel] = code;
+        channel_table_2[channel] = 0;
+        adlib_playnote(channel, code);
+}
+
+int AdlibSoundcard::adlib_get_reg_value_param(int chan, byte param) {
+        const AdlibSetParams *as;
+        byte val;
+        byte channel;
+
+        assert(chan >= 0 && chan < 9);
+
+        if (param <= 12) {
+                channel = channel_mappings_2[chan];
+        } else if (param <= 25) {
+                param -= 13;
+                channel = channel_mappings[chan];
+        } else if (param <= 27) {
+                param -= 13;
+                channel = chan;
+        } else if (param == 28) {
+                return 0xF;
+        } else if (param == 29) {
+                return 0x17F;
+        } else {
+                return 0;
+        }
+
+        as = &adlib_setparam_table[param];
+        val = adlib_get_reg_value(channel + as->a);
+        val &= as->c;
+        val >>= as->b;
+        if (as->d)
+                val = as->d - val;
+
+        return val;
+}
+
+void AdlibSoundcard::adlib_setup_channel(int chan, AdlibInstrument *instr, byte vol_1, byte vol_2) {
+        byte channel;
+
+        assert(chan >= 0 && chan < 9);
+
+        channel = channel_mappings[chan];
+        adlib_write(channel + 0x20, instr->mod_characteristic);
+        adlib_write(channel + 0x40, (instr->mod_scalingOutputLevel | 0x3F) - vol_1 );
+        adlib_write(channel + 0x60, 0xff & (~instr->mod_attackDecay));
+        adlib_write(channel + 0x80, 0xff & (~instr->mod_sustainRelease));
+        adlib_write(channel + 0xE0, instr->mod_waveformSelect);
+
+        channel = channel_mappings_2[chan];
+        adlib_write(channel + 0x20, instr->car_characteristic);
+        adlib_write(channel + 0x40, (instr->car_scalingOutputLevel | 0x3F) - vol_2 );
+        adlib_write(channel + 0x60, 0xff & (~instr->car_attackDecay));
+        adlib_write(channel + 0x80, 0xff & (~instr->car_sustainRelease));
+        adlib_write(channel + 0xE0, instr->car_waveformSelect);
+
+        adlib_write((byte)chan + 0xC0, instr->feedback);
+}
+
+void AdlibSoundcard::adlib_set_param(int channel, byte param, int value) {
+        const AdlibSetParams *as;
+        byte reg;
+
+        assert(channel >= 0 && channel < 9);
+
+        if (param <= 12) {
+                reg = channel_mappings_2[channel];
+        } else if (param <= 25) {
+                param -= 13;
+                reg = channel_mappings[channel];
+        } else if (param <= 27) {
+                param -= 13;
+                reg = channel;
+        } else if (param == 28 || param == 29) {
+                if (param == 28)
+                        value -= 15;
+                else
+                        value -= 383;
+                value <<= 4;
+                channel_table_2[channel] = value;
+                adlib_playnote(channel, curnote_table[channel] + value);
+                return;
+        } else {
+                return;
+        }
+
+        as = &adlib_setparam_table[param];
+        if (as->d)
+                value = as->d - value;
+        reg += as->a;
+        adlib_write(reg, (adlib_get_reg_value(reg) & ~as->c) | (((byte)value) << as->b));
+}
+
+void AdlibSoundcard::adlib_key_onoff(int channel) {
+        byte val;
+        byte reg = channel + 0xB0;
+        assert(channel >= 0 && channel < 9);
+
+        val = adlib_get_reg_value(reg);
+        adlib_write(reg, val & ~0x20);
+        adlib_write(reg, val | 0x20);
+}
+
+void AdlibSoundcard::adlib_write(byte reg, byte value) {
+        if (_adlib_reg_cache[reg] == value)
+                return;
+#ifdef DEBUG_ADLIB
+        debug(6, "%10d: adlib_write[%x] = %x", tick, reg, value);
+#endif
+        _adlib_reg_cache[reg] = value;
+
+        OPLWriteReg(_opl, reg, value);
+}
+
+void AdlibSoundcard::adlib_playnote(int channel, int note) {
+        byte old, oct, notex;
+        int note2;
+        int i;
+
+        note2 = (note >> 7) - 4;
+        note2 = (note2 < 128) ? note2 : 0;
+
+        oct = (note2 / 12);
+        if (oct > 7)
+                oct = 7 << 2;
+        else
+                oct <<= 2;
+        notex = note2 % 12 + 3;
+
+        old = adlib_get_reg_value(channel + 0xB0);
+        if (old & 0x20) {
+                old &= ~0x20;
+                if (oct > old) {
+                        if (notex < 6) {
+                                notex += 12;
+                                oct -= 4;
+                        }
+                } else if (oct < old) {
+                        if (notex > 11) {
+                                notex -= 12;
+                                oct += 4;
+                        }
+                }
+        }
+
+        i = (notex << 3) + ((note >> 4) & 0x7);
+        adlib_write(channel + 0xA0, note_to_f_num[i]);
+        adlib_write(channel + 0xB0, oct | 0x20);
+}
+
+void AdlibSoundcard::generateSamples(int16 *data, int len) {    
+        YM3812UpdateOne(_opl, data, len);
+}
+
 // MidiChannel method implementations
 
 void AdlibPart::init(MidiDriver_ADLIB *owner, byte channel) {
@@ -868 +1087 @@
 
         _scummSmallHeader = false;
 
-        _adlib_reg_cache = 0;
-
         _adlib_timer_counter = 0;
         _voice_index = 0;
-        for (i = 0; i < ARRAYSIZE(curnote_table); ++i) {
-                curnote_table[i] = 0;
-        }
 
         for (i = 0; i < ARRAYSIZE(_parts); ++i) {
                 _parts[i].init(this, i + ((i >= 9) ? 1 : 0));
@@ -890 +1104 @@
 
         MidiDriver_Emulated::open();
 
+        _sampleBuffer = 0;
+        _sampleBufferLen = 0;
+
         int i;
         AdlibVoice *voice;
 
-        for (i = 0, voice = _voices; i != ARRAYSIZE(_voices); i++, voice++) {
+        _numCards = 2;
+
+        if (_numCards > ARRAYSIZE(_cards))
+                _numCards = ARRAYSIZE(_cards);
+
+        _numVoices = 9 * _numCards;
+        _voices = new AdlibVoice[_numVoices];
+
+        for (i = 0; i < _numCards; i++) {
+                _cards[i] = new AdlibSoundcard(getRate());
+        }
+
+        for (i = 0, voice = _voices; i != _numVoices; i++, voice++) {
                 voice->_channel = i;
                 voice->_s11a.s10 = &voice->_s10b;
                 voice->_s11b.s10 = &voice->_s10a;
         }
 
-        _adlib_reg_cache = (byte *)calloc(256, 1);
-
-        _opl = makeAdlibOPL(getRate());
-
-        adlib_write(1, 0x20);
-        adlib_write(8, 0x40);
-        adlib_write(0xBD, 0x00);
         create_lookup_table();
 
         _mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
@@ -920 +1142 @@
 
         _mixer->stopHandle(_mixerSoundHandle);
 
-        uint i;
-        for (i = 0; i < ARRAYSIZE(_voices); ++i) {
+        int i;
+        for (i = 0; i < _numVoices; ++i) {
                 if (_voices[i]._part)
                         mc_off(&_voices[i]);
         }
 
         // Turn off the OPL emulation
-        OPLDestroy(_opl);
+        for (i = 0; i < _numCards; ++i) {
+                delete _cards[i];
+        }
+
+        delete[] _voices;
+        free(_sampleBuffer);
+        _sampleBufferLen = 0;
 //      YM3812Shutdown();
-
-        free(_adlib_reg_cache);
 }
 
 void MidiDriver_ADLIB::send(uint32 b) {
@@ -1028 +1254 @@
 
 // All the code brought over from IMuseAdlib
 
-void MidiDriver_ADLIB::adlib_write(byte reg, byte value) {
-        if (_adlib_reg_cache[reg] == value)
-                return;
-#ifdef DEBUG_ADLIB
-        debug(6, "%10d: adlib_write[%x] = %x", tick, reg, value);
-#endif
-        _adlib_reg_cache[reg] = value;
-
-        OPLWriteReg(_opl, reg, value);
-}
-
 void MidiDriver_ADLIB::generateSamples(int16 *data, int len) {
         memset(data, 0, sizeof(int16) * len);
-        YM3812UpdateOne(_opl, data, len);
+        if (_numCards == 0) {
+                _cards[0]->generateSamples(data, len);
+        } else {
+                if (len > _sampleBufferLen) {
+                        _sampleBufferLen = len;
+                        _sampleBuffer = (int16 *)realloc(_sampleBuffer, _sampleBufferLen * sizeof(int16));
+                }
+                for (int i = 0; i < _numCards; i++) {
+                        memset(_sampleBuffer, 0, len);
+                        _cards[i]->generateSamples(_sampleBuffer, len);
+
+                        for (int j = 0; j < len; j++) {
+                                int val = data[j] + _sampleBuffer[j];
+                                if (val > 0x7fff)
+                                        val = 0x7fff;
+                                data[j] = val;
+                        }
+                }
+        }
 }
 
 void MidiDriver_ADLIB::onTimer() {
@@ -1055 +1288 @@
                 tick++;
 #endif
                 voice = _voices;
-                for (i = 0; i != ARRAYSIZE(_voices); i++, voice++) {
+                for (i = 0; i != _numVoices; i++, voice++) {
                         if (!voice->_part)
                                 continue;
                         if (voice->_duration && (voice->_duration -= 0x11) <= 0) {
@@ -1133 +1366 @@
                 adlib_key_onoff(voice->_channel);
 }
 
-void MidiDriver_ADLIB::adlib_key_off(int chan){
-        byte reg = chan + 0xB0;
-        adlib_write(reg, adlib_get_reg_value(reg) & ~0x20);
+void MidiDriver_ADLIB::adlib_key_off(int chan) {
+        int card = chan / 9;
+        int channel = chan % 9;
+
+        _cards[card]->adlib_key_off(channel);
 }
 
 byte MidiDriver_ADLIB::struct10_ontimer(Struct10 *s10, Struct11 *s11) {
@@ -1182 +1417 @@
 }
 
 void MidiDriver_ADLIB::adlib_set_param(int channel, byte param, int value) {
-        const AdlibSetParams *as;
-        byte reg;
+        int card = channel / 9;
+        int chan = channel % 9;
 
-        assert(channel >= 0 && channel < 9);
-
-        if (param <= 12) {
-                reg = channel_mappings_2[channel];
-        } else if (param <= 25) {
-                param -= 13;
-                reg = channel_mappings[channel];
-        } else if (param <= 27) {
-                param -= 13;
-                reg = channel;
-        } else if (param == 28 || param == 29) {
-                if (param == 28)
-                        value -= 15;
-                else
-                        value -= 383;
-                value <<= 4;
-                channel_table_2[channel] = value;
-                adlib_playnote(channel, curnote_table[channel] + value);
-                return;
-        } else {
-                return;
-        }
-
-        as = &adlib_setparam_table[param];
-        if (as->d)
-                value = as->d - value;
-        reg += as->a;
-        adlib_write(reg, (adlib_get_reg_value(reg) & ~as->c) | (((byte)value) << as->b));
+        _cards[card]->adlib_set_param(chan, param, value);
 }
 
 void MidiDriver_ADLIB::adlib_key_onoff(int channel) {
-        byte val;
-        byte reg = channel + 0xB0;
-        assert(channel >= 0 && channel < 9);
+        int card = channel / 9;
+        int chan = channel % 9;
 
-        val = adlib_get_reg_value(reg);
-        adlib_write(reg, val & ~0x20);
-        adlib_write(reg, val | 0x20);
+        _cards[card]->adlib_key_onoff(chan);
 }
 
 void MidiDriver_ADLIB::struct10_setup(Struct10 *s10) {
@@ -1274 +1479 @@
         s10->speed_lo_counter = 0;
 }
 
-void MidiDriver_ADLIB::adlib_playnote(int channel, int note) {
-        byte old, oct, notex;
-        int note2;
-        int i;
-
-        note2 = (note >> 7) - 4;
-        note2 = (note2 < 128) ? note2 : 0;
-
-        oct = (note2 / 12);
-        if (oct > 7)
-                oct = 7 << 2;
-        else
-                oct <<= 2;
-        notex = note2 % 12 + 3;
-
-        old = adlib_get_reg_value(channel + 0xB0);
-        if (old & 0x20) {
-                old &= ~0x20;
-                if (oct > old) {
-                        if (notex < 6) {
-                                notex += 12;
-                                oct -= 4;
-                        }
-                } else if (oct < old) {
-                        if (notex > 11) {
-                                notex -= 12;
-                                oct += 4;
-                        }
-                }
-        }
-
-        i = (notex << 3) + ((note >> 4) & 0x7);
-        adlib_write(channel + 0xA0, note_to_f_num[i]);
-        adlib_write(channel + 0xB0, oct | 0x20);
-}
-
 int MidiDriver_ADLIB::random_nr(int a) {
         static byte _rand_seed = 1;
         if (_rand_seed & 1) {
@@ -1349 +1518 @@
         AdlibVoice *ac, *best = NULL;
         int i;
 
-        for (i = 0; i < 9; i++) {
-                if (++_voice_index >= 9)
+        for (i = 0; i < _numVoices; i++) {
+                if (++_voice_index >= _numVoices)
                         _voice_index = 0;
                 ac = &_voices[_voice_index];
                 if (!ac->_part)
@@ -1368 +1537 @@
                 return NULL;
 
         if (best)
+{
+printf("Evicted %d\n", best - _voices);
                 mc_off(best);
+}
         return best;
 }
 
@@ -1435 +1607 @@
 }
 
 void MidiDriver_ADLIB::adlib_setup_channel(int chan, AdlibInstrument *instr, byte vol_1, byte vol_2) {
-        byte channel;
+        int card = chan / 9;
+        int channel = chan % 9;
 
-        assert(chan >= 0 && chan < 9);
+        _cards[card]->adlib_setup_channel(channel, instr, vol_1, vol_2);
+}
 
-        channel = channel_mappings[chan];
-        adlib_write(channel + 0x20, instr->mod_characteristic);
-        adlib_write(channel + 0x40, (instr->mod_scalingOutputLevel | 0x3F) - vol_1 );
-        adlib_write(channel + 0x60, 0xff & (~instr->mod_attackDecay));
-        adlib_write(channel + 0x80, 0xff & (~instr->mod_sustainRelease));
-        adlib_write(channel + 0xE0, instr->mod_waveformSelect);
+void MidiDriver_ADLIB::adlib_note_on_ex(int chan, byte note, int mod) {
+        int card = chan / 9;
+        int channel = chan % 9;
 
-        channel = channel_mappings_2[chan];
-        adlib_write(channel + 0x20, instr->car_characteristic);
-        adlib_write(channel + 0x40, (instr->car_scalingOutputLevel | 0x3F) - vol_2 );
-        adlib_write(channel + 0x60, 0xff & (~instr->car_attackDecay));
-        adlib_write(channel + 0x80, 0xff & (~instr->car_sustainRelease));
-        adlib_write(channel + 0xE0, instr->car_waveformSelect);
-
-        adlib_write((byte)chan + 0xC0, instr->feedback);
+        _cards[card]->adlib_note_on_ex(channel, note, mod);
 }
 
-void MidiDriver_ADLIB::adlib_note_on_ex(int chan, byte note, int mod)
-{
-        int code;
-        assert(chan >= 0 && chan < 9);
-        code = (note << 7) + mod;
-        curnote_table[chan] = code;
-        channel_table_2[chan] = 0;
-        adlib_playnote(chan, code);
-}
-
 void MidiDriver_ADLIB::mc_init_stuff(AdlibVoice *voice, Struct10 * s10,
                                                                         Struct11 * s11, byte flags, InstrumentExtra * ie) {
         AdlibPart *part = voice->_part;
@@ -1530 +1684 @@
 }
 
 int MidiDriver_ADLIB::adlib_get_reg_value_param(int chan, byte param) {
-        const AdlibSetParams *as;
-        byte val;
-        byte channel;
+        int card = chan / 9;
+        int channel = chan % 9;
 
-        assert(chan >= 0 && chan < 9);
-
-        if (param <= 12) {
-                channel = channel_mappings_2[chan];
-        } else if (param <= 25) {
-                param -= 13;
-                channel = channel_mappings[chan];
-        } else if (param <= 27) {
-                param -= 13;
-                channel = chan;
-        } else if (param == 28) {
-                return 0xF;
-        } else if (param == 29) {
-                return 0x17F;
-        } else {
-                return 0;
-        }
-
-        as = &adlib_setparam_table[param];
-        val = adlib_get_reg_value(channel + as->a);
-        val &= as->c;
-        val >>= as->b;
-        if (as->d)
-                val = as->d - val;
-
-        return val;
+        return _cards[card]->adlib_get_reg_value_param(channel, param);
 }
 
 void MidiDriver_ADLIB::adlib_note_on(int chan, byte note, int mod) {
-        int code;
-        assert(chan >= 0 && chan < 9);
-        code = (note << 7) + mod;
-        curnote_table[chan] = code;
-        adlib_playnote(chan, (int16) channel_table_2[chan] + code);
+        int card = chan / 9;
+        int channel = chan % 9;
+
+        _cards[card]->adlib_note_on(channel, note, mod);
 }