Ticket #8620: kyra_fmtowns_music.patch

File kyra_fmtowns_music.patch, 43.3 KB (added by lordhoto, 14 years ago)

updated patch

  • sound/softsynth/ym2612.cpp

     
    2323 * $Id$
    2424 */
    2525
    26 #include "sound/softsynth/emumidi.h"
    27 
    2826#include <math.h>
    2927
     28#include "sound/softsynth/ym2612.h"
    3029#include "common/util.h"
    3130
    3231////////////////////////////////////////
     
    4241static int *keyscaleTable = 0;
    4342static int *attackOut = 0;
    4443
    45 ////////////////////////////////////////
    46 //
    47 // Class declarations
    48 //
    49 ////////////////////////////////////////
    5044
    51 class Operator2612;
    52 class Voice2612;
    53 class MidiChannel_YM2612;
    54 class MidiDriver_YM2612;
    55 
    56 class Operator2612 {
    57 protected:
    58         Voice2612 *_owner;
    59         enum State { _s_ready, _s_attacking, _s_decaying, _s_sustaining, _s_releasing };
    60         State _state;
    61         int32 _currentLevel;
    62         int _frequency;
    63         uint32 _phase;
    64         int _lastOutput;
    65         int _feedbackLevel;
    66         int _detune;
    67         int _multiple;
    68         int32 _totalLevel;
    69         int _keyScale;
    70         int _velocity;
    71         int _specifiedTotalLevel;
    72         int _specifiedAttackRate;
    73         int _specifiedDecayRate;
    74         int _specifiedSustainLevel;
    75         int _specifiedSustainRate;
    76         int _specifiedReleaseRate;
    77         int _tickCount;
    78         int _attackTime;
    79         int32 _decayRate;
    80         int32 _sustainLevel;
    81         int32 _sustainRate;
    82         int32 _releaseRate;
    83 
    84 public:
    85         Operator2612 (Voice2612 *owner);
    86         ~Operator2612();
    87         void feedbackLevel(int level);
    88         void setInstrument(byte const *instrument);
    89         void velocity(int velo);
    90         void keyOn();
    91         void keyOff();
    92         void frequency(int freq);
    93         void nextTick(const int *phaseShift, int *outbuf, int buflen);
    94         bool inUse() { return (_state != _s_ready); }
    95 };
    96 
    97 class Voice2612 {
    98 public:
    99         Voice2612 *next;
    100         uint16 _rate;
    101 
    102 protected:
    103         Operator2612 *_opr[4];
    104         int _velocity;
    105         int _control7;
    106         int _note;
    107         int _frequencyOffs;
    108         int _frequency;
    109         int _algorithm;
    110 
    111         int *_buffer;
    112         int _buflen;
    113 
    114 public:
    115         Voice2612();
    116         ~Voice2612();
    117         void setControlParameter(int control, int value);
    118         void setInstrument(byte const *instrument);
    119         void velocity(int velo);
    120         void nextTick(int *outbuf, int buflen);
    121         void noteOn(int n, int onVelo);
    122         bool noteOff(int note);
    123         void pitchBend(int value);
    124         void recalculateFrequency();
    125 };
    126 
    127 class MidiChannel_YM2612 : public MidiChannel {
    128 protected:
    129         uint16 _rate;
    130         Voice2612 *_voices;
    131         Voice2612 *_next_voice;
    132 
    133 public:
    134         void removeAllVoices();
    135         void nextTick(int *outbuf, int buflen);
    136         void rate(uint16 r);
    137 
    138 public:
    139         MidiChannel_YM2612();
    140         virtual ~MidiChannel_YM2612();
    141 
    142         // MidiChannel interface
    143         MidiDriver *device() { return 0; }
    144         byte getNumber() { return 0; }
    145         void release() { }
    146         void send(uint32 b) { }
    147         void noteOff(byte note);
    148         void noteOn(byte note, byte onVelo);
    149         void programChange(byte program) { }
    150         void pitchBend(int16 value);
    151         void controlChange(byte control, byte value);
    152         void pitchBendFactor(byte value) { }
    153         void sysEx_customInstrument(uint32 type, const byte *instr);
    154 };
    155 
    156 class MidiDriver_YM2612 : public MidiDriver_Emulated {
    157 protected:
    158         MidiChannel_YM2612 *_channel[16];
    159 
    160         int _next_voice;
    161         int _volume;
    162 
    163 protected:
    164         static void createLookupTables();
    165         void nextTick(int16 *buf1, int buflen);
    166         int volume(int val = -1) { if (val >= 0) _volume = val; return _volume; }
    167         void rate(uint16 r);
    168 
    169         void generateSamples(int16 *buf, int len);
    170 
    171 public:
    172         MidiDriver_YM2612(Audio::Mixer *mixer);
    173         virtual ~MidiDriver_YM2612();
    174 
    175         int open();
    176         void close();
    177         void send(uint32 b);
    178         void send(byte channel, uint32 b); // Supports higher than channel 15
    179         uint32 property(int prop, uint32 param) { return 0; }
    180 
    181         void setPitchBendRange(byte channel, uint range) { }
    182         void sysEx(const byte *msg, uint16 length);
    183 
    184         MidiChannel *allocateChannel() { return 0; }
    185         MidiChannel *getPercussionChannel() { return 0; }
    186 
    187 
    188         // AudioStream API
    189         bool isStereo() const { return true; }
    190         int getRate() const { return _mixer->getOutputRate(); }
    191 };
    192 
    19345////////////////////////////////////////
    19446//
    19547// Operator2612 implementation
     
    726578        int i;
    727579        for (i = 0; i < ARRAYSIZE(_channel); i++)
    728580                delete _channel[i];
    729         delete sintbl;
    730         delete powtbl;
    731         delete frequencyTable;
    732         delete keycodeTable;
    733         delete keyscaleTable;
    734         delete attackOut;
    735         sintbl = powtbl = frequencyTable = keycodeTable = keyscaleTable = attackOut = 0;
     581        removeLookupTables();
    736582}
    737583
    738584int MidiDriver_YM2612::open() {
     
    896742        }
    897743}
    898744
     745void MidiDriver_YM2612::removeLookupTables() {
     746        delete [] sintbl;
     747        delete [] powtbl;
     748        delete [] frequencyTable;
     749        delete [] keycodeTable;
     750        delete [] keyscaleTable;
     751        delete [] attackOut;
     752        sintbl = powtbl = frequencyTable = keycodeTable = keyscaleTable = attackOut = 0;
     753}
     754
    899755////////////////////////////////////////
    900756//
    901757// MidiDriver_YM2612 factory
     
    905761MidiDriver *MidiDriver_YM2612_create(Audio::Mixer *mixer) {
    906762        return new MidiDriver_YM2612(mixer);
    907763}
     764
  • engines/kyra/sound_towns.cpp

     
    2929#include "sound/audiocd.h"
    3030#include "sound/audiostream.h"
    3131
     32#include "common/util.h"
     33#include <math.h>
     34
    3235namespace Kyra {
    3336
     37enum EuD_ChannelState { _s_ready, _s_attacking, _s_decaying, _s_sustaining, _s_releasing };
     38
     39class MidiChannel_EuD : public MidiChannel {
     40public:
     41        MidiChannel_EuD() {}
     42        ~MidiChannel_EuD() {}
     43
     44        virtual void nextTick(int32 *outbuf, int buflen) = 0;
     45        virtual void rate(uint16 r) = 0;
     46
     47protected:
     48        uint16 _rate;
     49};
     50
     51class MidiChannel_EuD_FM : public MidiChannel_EuD {
     52public:
     53        MidiChannel_EuD_FM();
     54        virtual ~MidiChannel_EuD_FM();
     55
     56        void nextTick(int32 *outbuf, int buflen);
     57        void rate(uint16 r);
     58
     59        // MidiChannel interface
     60        MidiDriver *device() { return 0; }
     61        byte getNumber() { return 0; }
     62        void release() { }
     63        void send(uint32 b) { }
     64        void noteOff(byte note);
     65        void noteOn(byte note, byte onVelo);
     66        void programChange(byte program) {}
     67        void pitchBend(int16 value);
     68        void controlChange(byte control, byte value);
     69        void pitchBendFactor(byte value) { }
     70        void sysEx_customInstrument(uint32 unused, const byte *instr);
     71
     72protected:
     73        Voice2612 *_voice;
     74};
     75
     76class MidiChannel_EuD_WAVE : public MidiChannel_EuD {
     77public:
     78        void nextTick(int32 *outbuf, int buflen);
     79        void rate(uint16 r);
     80
     81        MidiChannel_EuD_WAVE();
     82        virtual ~MidiChannel_EuD_WAVE();
     83
     84        // MidiChannel interface
     85        MidiDriver *device() { return 0; }
     86        byte getNumber() { return 0; }
     87        void release() { }
     88        void send(uint32 b) { }
     89        void noteOff(byte note);
     90        void noteOn(byte note, byte onVelo);
     91        void programChange(byte program) {}
     92        void pitchBend(int16 value);
     93        void controlChange(byte control, byte value);
     94        void pitchBendFactor(byte value) { }
     95        void sysEx_customInstrument(uint32 type, const byte *instr);
     96
     97protected:
     98        void velocity(int velo);
     99        void panPosition(int8 pan);
     100        void evpNextTick();
     101
     102        int _ctrl7_volume;
     103        int16 _velocity;
     104        int16 _note;
     105        int32 _frequencyOffs;
     106        float _phase;
     107        int8 _current;
     108
     109        struct Voice {
     110                char name[9];
     111                uint16 split[8];
     112                uint32 id[8];
     113                struct Snd {
     114                        char name[9];
     115                        int32 id;
     116                        int32 numSamples;
     117                        int32 loopStart;
     118                        int32 loopLength;
     119                        int32 samplingRate;
     120                        int32 keyOffset;
     121                        int32 keyNote;
     122                        int8 *_samples;
     123                } * _snd[8];
     124                struct Env {
     125                        EuD_ChannelState state;
     126                        int32 currentLevel;
     127                        int32 rate;
     128                        int32 tickCount;
     129                        int32 totalLevel;
     130                        int32 attackRate;
     131                        int32 decayRate;
     132                        int32 sustainLevel;
     133                        int32 sustainRate;
     134                        int32 releaseLevel;
     135                        int32 releaseRate;
     136                        int32 rootKeyOffset;
     137                        int32 size;
     138                } * _env[8];
     139        } * _voice;
     140};
     141
     142class MidiParser_EuD : public MidiParser {
     143public:
     144        MidiParser_EuD();
     145
     146        bool loadMusic (byte *data, uint32 unused = 0);
     147        void setTempo(uint32 tempo);
     148protected:
     149        void parseNextEvent (EventInfo &info);
     150        void resetTracking();
     151
     152        byte * _enable;
     153        byte * _mode;
     154        byte * _channel;
     155        byte * _adjVelo;
     156        int8 * _adjNote;
     157
     158        uint8 _firstBaseTickStep;
     159        uint8 _nextBaseTickStep;
     160        uint8 _initialTempo;
     161        uint32 _baseTick;
     162};
     163
     164class FMT_EuphonyDriver : public MidiDriver_Emulated {
     165public:
     166        FMT_EuphonyDriver(Audio::Mixer *mixer);
     167        virtual ~FMT_EuphonyDriver();
     168
     169        int open();
     170        void close();
     171        void send(uint32 b);
     172        void send(byte channel, uint32 b);
     173        uint32 property(int prop, uint32 param) { return 0; }
     174
     175        void setPitchBendRange(byte channel, uint range) { }
     176        //void sysEx(const byte *msg, uint16 length);
     177        void loadFmInstruments(const byte *instr);
     178        void loadWaveInstruments(const byte *instr);
     179
     180        MidiChannel *allocateChannel() { return 0; }
     181        MidiChannel *getPercussionChannel() { return 0; }
     182
     183        void assignFmChannel(uint8 midiChannelNumber, uint8 fmChannelNumber);
     184        void assignWaveChannel(uint8 midiChannelNumber, uint8 waveChannelNumber);
     185        void removeChannel(uint8 midiChannelNumber);
     186
     187        // AudioStream API
     188        bool isStereo() const { return true; }
     189        int getRate() const { return _mixer->getOutputRate(); }
     190
     191protected:
     192        void nextTick(int16 *buf1, int buflen);
     193        int volume(int val = -1) { if (val >= 0) _volume = val; return _volume; }
     194        void rate(uint16 r);
     195
     196        void generateSamples(int16 *buf, int len);
     197
     198        MidiChannel_EuD_FM *_fChannel[6];
     199        MidiChannel_EuD_WAVE *_wChannel[8];
     200        MidiChannel_EuD * _channel[16];
     201
     202        int _volume;
     203
     204        uint8 *_fmInstruments;
     205        uint8 *_waveInstruments;
     206        int8 * _waveSounds[10];
     207};
     208
     209MidiChannel_EuD_FM::MidiChannel_EuD_FM() {
     210        _voice = new Voice2612;
     211}
     212
     213MidiChannel_EuD_FM::~MidiChannel_EuD_FM() {
     214        delete _voice;
     215}
     216
     217void MidiChannel_EuD_FM::noteOn(byte note, byte onVelo) {
     218        _voice->noteOn(note, onVelo);
     219}
     220
     221void MidiChannel_EuD_FM::noteOff(byte note) {
     222        _voice->noteOff(note);
     223}
     224
     225void MidiChannel_EuD_FM::controlChange(byte control, byte value) {
     226        if (control == 121) {
     227                // Reset controller
     228                delete _voice;
     229                _voice = new Voice2612;
     230        } else if (control == 10) {
     231                // pan position
     232        } else {
     233                _voice->setControlParameter(control, value);
     234        }
     235}
     236
     237void MidiChannel_EuD_FM::sysEx_customInstrument(uint32, const byte *fmInst) {
     238        _voice->_rate = _rate;
     239        _voice->setInstrument(fmInst);
     240}
     241
     242void MidiChannel_EuD_FM::pitchBend(int16 value) {
     243        _voice->pitchBend(value);
     244}
     245
     246void MidiChannel_EuD_FM::nextTick(int32 *outbuf, int buflen) {
     247        _voice->nextTick((int*) outbuf, buflen);
     248}
     249
     250void MidiChannel_EuD_FM::rate(uint16 r) {
     251        _rate = r;
     252        _voice->_rate = r;
     253}
     254
     255MidiChannel_EuD_WAVE::MidiChannel_EuD_WAVE() {
     256        _voice = new Voice;
     257        for (uint8 i = 0; i < 8; i++) {
     258                _voice->_env[i] = new Voice::Env;
     259                _voice->_snd[i] = 0;
     260        }
     261
     262        _ctrl7_volume = 127;
     263        velocity(0);
     264        _frequencyOffs = 0x2000;
     265        _current = -1;
     266}
     267
     268MidiChannel_EuD_WAVE::~MidiChannel_EuD_WAVE() {
     269        for (uint8 i = 0; i < 8; i++) {
     270                if (_voice->_snd[i])
     271                        delete _voice->_snd[i];
     272                delete _voice->_env[i];
     273        }
     274        delete _voice;
     275}
     276
     277void MidiChannel_EuD_WAVE::noteOn(byte note, byte onVelo) {
     278        _note = note;
     279        velocity(onVelo);
     280        _phase = 0;
     281
     282        for (_current = 0; _current < 7; _current++) {
     283                if (note <=     _voice->split[_current])
     284                        break;
     285        }
     286
     287        _voice->_env[_current]->state = _s_attacking;
     288        _voice->_env[_current]->currentLevel = 0;
     289        _voice->_env[_current]->rate = _rate;
     290        _voice->_env[_current]->tickCount = 0;
     291}
     292
     293void MidiChannel_EuD_WAVE::noteOff(byte note) {
     294    if (_current == -1)
     295                return;
     296        if (_voice->_env[_current]->state == _s_ready)
     297                return;
     298
     299        _voice->_env[_current]->state = _s_releasing;
     300        _voice->_env[_current]->releaseLevel = _voice->_env[_current]->currentLevel;
     301        _voice->_env[_current]->tickCount = 0;
     302}
     303
     304void MidiChannel_EuD_WAVE::controlChange(byte control, byte value) {
     305        switch (control) {
     306                case 0x07:
     307                        // volume
     308                        _ctrl7_volume = value;
     309                        break;
     310                case 0x0A:
     311                        // pan position
     312                        break;
     313                case 0x79:
     314                // Reset controller
     315                        for (uint8 i = 0; i < 8; i++) {
     316                                if (_voice->_snd[i])
     317                                        delete _voice->_snd[i];
     318                                delete _voice->_env[i];
     319                        }
     320                        delete _voice;
     321                        _voice = new Voice;
     322                        for (uint8 i = 0; i < 8; i++) {
     323                                _voice->_env[i] = new Voice::Env;
     324                                _voice->_snd[i] = 0;
     325                        }
     326                        break;
     327                case 0x7B:
     328                        noteOff(_note);
     329                        break;
     330                default:
     331                        break;
     332        }
     333}
     334
     335void MidiChannel_EuD_WAVE::sysEx_customInstrument(uint32 type, const byte *fmInst) {
     336        if (type == 0x80) {
     337                for (uint8 i = 0; i < 8; i++) {
     338                        byte ** pos = (byte **) fmInst;
     339                        for (uint8 ii = 0; ii < 10; ii++) {
     340                                if (_voice->id[i] == *(pos[ii] + 8)) {
     341                                        if (!_voice->_snd[i])
     342                                                _voice->_snd[i] = new Voice::Snd;
     343                                        memset (_voice->_snd[i]->name, 0, 9);
     344                                        memcpy (_voice->_snd[i]->name, (const char*) pos[ii], 8);
     345                                        _voice->_snd[i]->id = READ_LE_UINT32(pos[ii] + 8);
     346                                        _voice->_snd[i]->numSamples = READ_LE_UINT32(pos[ii] + 12);
     347                                        _voice->_snd[i]->loopStart = READ_LE_UINT32(pos[ii] + 16);
     348                                        _voice->_snd[i]->loopLength = READ_LE_UINT32(pos[ii] + 20);
     349                                        _voice->_snd[i]->samplingRate = READ_LE_UINT16(pos[ii] + 24);
     350                                        _voice->_snd[i]->keyOffset = READ_LE_UINT16(pos[ii] + 26);
     351                                        _voice->_snd[i]->keyNote = *(uint8*)(pos[ii] + 28);
     352                                        _voice->_snd[i]->_samples = (int8*)(pos[ii] + 32);
     353                                }
     354                        }
     355                }
     356        } else {
     357                memset (_voice->name, 0, 9);
     358                memcpy (_voice->name, (const char*) fmInst, 8);
     359
     360                for (uint8 i = 0; i < 8; i++) {
     361                        _voice->split[i] = READ_LE_UINT16(fmInst + 16 + 2 * i);
     362                        _voice->id[i] = READ_LE_UINT32(fmInst + 32 + 4 * i);
     363                        _voice->_snd[i] = 0;
     364                        _voice->_env[i]->state = _s_ready;
     365                        _voice->_env[i]->currentLevel = 0;
     366                        _voice->_env[i]->totalLevel = *(fmInst + 64 + 8 * i);
     367                        _voice->_env[i]->attackRate = *(fmInst + 65 + 8 * i) * 10;
     368                        _voice->_env[i]->decayRate = *(fmInst + 66 + 8 * i) * 10;
     369                        _voice->_env[i]->sustainLevel = *(fmInst + 67 + 8 * i);
     370                        _voice->_env[i]->sustainRate = *(fmInst + 68 + 8 * i) * 20;
     371                        _voice->_env[i]->releaseRate = *(fmInst + 69 + 8 * i) * 10;
     372                        _voice->_env[i]->rootKeyOffset = *(fmInst + 70 + 8 * i);
     373                }
     374        }
     375}
     376
     377void MidiChannel_EuD_WAVE::pitchBend(int16 value) {
     378        _frequencyOffs = value;
     379}
     380
     381void MidiChannel_EuD_WAVE::nextTick(int32 *outbuf, int buflen) {
     382        if (_current == -1 || !_voice->_snd[_current] || !_voice->_env[_current]->state || !_velocity) {
     383                velocity(0);
     384                _current = -1;
     385                return;
     386        }
     387
     388        float phaseStep = SoundTowns::semitoneAndSampleRate_to_sampleStep(_note, _voice->_snd[_current]->keyNote -
     389                _voice->_env[_current]->rootKeyOffset, _voice->_snd[_current]->samplingRate, _rate, _frequencyOffs);
     390
     391        int32 looplength = _voice->_snd[_current]->loopLength;
     392        int32 numsamples = _voice->_snd[_current]->numSamples;
     393        int8 * samples = _voice->_snd[_current]->_samples;
     394
     395        for (int i = 0; i < buflen; i++) {
     396                if (looplength > 0) {
     397                        while (_phase >= numsamples)
     398                                _phase -= looplength;
     399                } else {
     400                        if (_phase >= numsamples) {
     401                                velocity(0);
     402                                _current = -1;
     403                                break;
     404                        }
     405                }
     406
     407                int32 output;
     408
     409                int32 phase0 = int32(_phase);
     410                int32 phase1 = int32(_phase + 1);
     411                if (phase1 >= numsamples)
     412                        phase1 -= looplength;
     413                float weight0 = _phase - phase0;
     414                float weight1 = phase1 - _phase;
     415                output = int32(samples[phase0] * weight0 + samples[phase1] * weight1);
     416
     417                output *= _velocity;
     418                output <<= 1;
     419
     420                evpNextTick();
     421                output *= _voice->_env[_current]->currentLevel;
     422                output >>= 7;
     423                output *= _ctrl7_volume;
     424                output >>= 7;
     425
     426                output *= 185;
     427                output >>= 8;
     428                outbuf[i] += output;
     429                _phase += phaseStep;
     430        }
     431}
     432
     433void MidiChannel_EuD_WAVE::evpNextTick() {
     434        switch (_voice->_env[_current]->state) {
     435                case _s_ready:
     436                        _voice->_env[_current]->currentLevel = 0;
     437                        return;
     438
     439                case _s_attacking:
     440                        if (_voice->_env[_current]->attackRate == 0)
     441                                _voice->_env[_current]->currentLevel = _voice->_env[_current]->totalLevel;
     442                        else if (_voice->_env[_current]->attackRate >= 1270)
     443                                _voice->_env[_current]->currentLevel = 0;
     444                        else
     445                                _voice->_env[_current]->currentLevel = (_voice->_env[_current]->totalLevel *
     446                                        _voice->_env[_current]->tickCount++ * 1000) /
     447                                                (_voice->_env[_current]->attackRate * _voice->_env[_current]->rate);
     448
     449                        if (_voice->_env[_current]->currentLevel >= _voice->_env[_current]->totalLevel) {
     450                                _voice->_env[_current]->currentLevel = _voice->_env[_current]->totalLevel;
     451                                _voice->_env[_current]->state = _s_decaying;
     452                                _voice->_env[_current]->tickCount = 0;
     453                        }
     454                        break;
     455
     456                case _s_decaying:
     457                        if (_voice->_env[_current]->decayRate == 0)
     458                                _voice->_env[_current]->currentLevel = _voice->_env[_current]->sustainLevel;
     459                        else if (_voice->_env[_current]->decayRate >= 1270)
     460                                _voice->_env[_current]->currentLevel = _voice->_env[_current]->totalLevel;
     461                        else {
     462                                _voice->_env[_current]->currentLevel = _voice->_env[_current]->totalLevel;
     463                                _voice->_env[_current]->currentLevel -= ((_voice->_env[_current]->totalLevel -
     464                                        _voice->_env[_current]->sustainLevel) * _voice->_env[_current]->tickCount++ * 1000) /
     465                                                (_voice->_env[_current]->decayRate * _voice->_env[_current]->rate);
     466                        }
     467
     468                        if (_voice->_env[_current]->currentLevel <= _voice->_env[_current]->sustainLevel) {
     469                                _voice->_env[_current]->currentLevel = _voice->_env[_current]->sustainLevel;
     470                                _voice->_env[_current]->state = _s_sustaining;
     471                                _voice->_env[_current]->tickCount = 0;
     472                        }
     473                        break;
     474
     475                        case _s_sustaining:
     476                                if (_voice->_env[_current]->sustainRate == 0)
     477                                        _voice->_env[_current]->currentLevel = 0;
     478                                else if (_voice->_env[_current]->sustainRate >= 2540)
     479                                        _voice->_env[_current]->currentLevel = _voice->_env[_current]->sustainLevel;
     480                                else {
     481                                        _voice->_env[_current]->currentLevel = _voice->_env[_current]->sustainLevel;
     482                                        _voice->_env[_current]->currentLevel -= (_voice->_env[_current]->sustainLevel *
     483                                                _voice->_env[_current]->tickCount++ * 1000) / (_voice->_env[_current]->sustainRate *
     484                                                        _voice->_env[_current]->rate);
     485                                }
     486
     487                                if (_voice->_env[_current]->currentLevel <= 0) {
     488                                        _voice->_env[_current]->currentLevel = 0;
     489                                        _voice->_env[_current]->state = _s_ready;
     490                                        _voice->_env[_current]->tickCount = 0;
     491                                }
     492                                break;
     493
     494                        case _s_releasing:
     495                                if (_voice->_env[_current]->releaseRate == 0)
     496                                        _voice->_env[_current]->currentLevel = 0;
     497                                else if (_voice->_env[_current]->releaseRate >= 1270)
     498                                        _voice->_env[_current]->currentLevel = _voice->_env[_current]->releaseLevel;
     499                                else {
     500                                        _voice->_env[_current]->currentLevel = _voice->_env[_current]->releaseLevel;
     501                                        _voice->_env[_current]->currentLevel -= (_voice->_env[_current]->releaseLevel *
     502                                                _voice->_env[_current]->tickCount++ * 1000) / (_voice->_env[_current]->releaseRate *
     503                                                        _voice->_env[_current]->rate);
     504                                }
     505
     506                                if (_voice->_env[_current]->currentLevel <= 0) {
     507                                        _voice->_env[_current]->currentLevel = 0;
     508                                        _voice->_env[_current]->state = _s_ready;
     509                                }
     510                                break;
     511
     512                        default:
     513                        break;
     514        }
     515}
     516
     517void MidiChannel_EuD_WAVE::rate(uint16 r) {
     518        _rate = r;
     519}
     520
     521void MidiChannel_EuD_WAVE::velocity(int velo) {
     522        _velocity = velo;
     523}
     524
     525FMT_EuphonyDriver::FMT_EuphonyDriver(Audio::Mixer *mixer)
     526        : MidiDriver_Emulated(mixer) {
     527
     528        MidiDriver_YM2612::createLookupTables();
     529
     530        _volume = 255;
     531        for (uint8 i = 0; i < 6; i++)
     532                _channel[i] = _fChannel[i] = new MidiChannel_EuD_FM;
     533        for (uint8 i = 0; i < 8; i++)
     534                _channel[i + 6] = _wChannel[i] = new MidiChannel_EuD_WAVE;
     535        _channel[14] = _channel[15] = 0;
     536
     537        _fmInstruments = _waveInstruments = 0;
     538        memset(_waveSounds, 0, sizeof(uint8*) * 10);
     539
     540        rate(getRate());
     541}
     542
     543FMT_EuphonyDriver::~FMT_EuphonyDriver() {
     544        for (int i = 0; i < 6; i++)
     545                delete _fChannel[i];
     546        for (int i = 0; i < 8; i++)
     547                delete _wChannel[i];
     548
     549        MidiDriver_YM2612::removeLookupTables();
     550
     551        if (_fmInstruments) {
     552                delete [] _fmInstruments;
     553                _fmInstruments = 0;
     554        }
     555
     556        if (_waveInstruments) {
     557                delete [] _waveInstruments;
     558                _waveInstruments = 0;
     559        }
     560
     561        for (int i = 0; i < 10; i++) {
     562                if (_waveSounds[i]) {
     563                        delete [] _waveSounds[i];
     564                        _waveSounds[i] = 0;
     565                }
     566        }
     567}
     568
     569int FMT_EuphonyDriver::open() {
     570        if (_isOpen)
     571                return MERR_ALREADY_OPEN;
     572
     573        MidiDriver_Emulated::open();
     574
     575        _mixer->playInputStream(Audio::Mixer::kMusicSoundType, &_mixerSoundHandle,
     576                this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true);
     577        return 0;
     578}
     579
     580void FMT_EuphonyDriver::close() {
     581        if (!_isOpen)
     582                return;
     583        _isOpen = false;
     584        _mixer->stopHandle(_mixerSoundHandle);
     585}
     586
     587void FMT_EuphonyDriver::send(uint32 b) {
     588        send(b & 0xF, b & 0xFFFFFFF0);
     589}
     590
     591void FMT_EuphonyDriver::send(byte chan, uint32 b) {
     592        //byte param3 = (byte) ((b >> 24) & 0xFF);
     593
     594        byte param2 = (byte) ((b >> 16) & 0xFF);
     595        byte param1 = (byte) ((b >>  8) & 0xFF);
     596        byte cmd    = (byte) (b & 0xF0);
     597        if (chan > ARRAYSIZE(_channel))
     598                return;
     599
     600        switch (cmd) {
     601        case 0x80:// Note Off
     602                if (_channel[chan])
     603                        _channel[chan]->noteOff(param1);
     604                break;
     605        case 0x90: // Note On
     606                if (_channel[chan])
     607                        _channel[chan]->noteOn(param1, param2);
     608                break;
     609        case 0xA0: // Aftertouch
     610                break; // Not supported.
     611        case 0xB0: // Control Change
     612                if (param1 == 0x79) {
     613                        for (int i = 0; i < 15; i++) {
     614                                if (_channel[i]) {
     615                                        _channel[i]->controlChange(param1, param2);
     616                                        _channel[i]->programChange(0);
     617                                }
     618                        }
     619                } else if (param1 == 0x7B) {
     620                        for (int i = 0; i < 15; i++) {
     621                                if (_channel[i])
     622                                        _channel[i]->controlChange(param1, param2);
     623                        }
     624                } else {
     625                        if (_channel[chan])
     626                                _channel[chan]->controlChange(param1, param2);
     627                }
     628                break;
     629        case 0xC0: // Program Change
     630        for (int i = 0; i < 6; i++) {
     631                        if (_channel[chan] == _fChannel[i]) {
     632                                _channel[chan]->sysEx_customInstrument(0, _fmInstruments + param1 * 0x30);
     633                                break;
     634                        }
     635                }
     636                for (int i = 0; i < 8; i++) {
     637                        if (_channel[chan] == _wChannel[i]) {
     638                                _channel[chan]->sysEx_customInstrument(0, _waveInstruments + param1 * 0x80);
     639                                _channel[chan]->sysEx_customInstrument(0x80, (const byte*) _waveSounds);
     640                                break;
     641                        }
     642                }
     643                break;
     644        case 0xD0: // Channel Pressure
     645                break; // Not supported.
     646        case 0xE0: // Pitch Bend
     647                if (_channel[chan])
     648                        _channel[chan]->pitchBend((param1 | (param2 << 7)) - 0x2000);
     649                break;
     650        default:
     651                warning("FMT_EuphonyDriver: Unknown send() command 0x%02X", cmd);
     652        }
     653}
     654
     655void FMT_EuphonyDriver::loadFmInstruments(const byte *instr) {
     656        if (_fmInstruments)
     657                delete [] _fmInstruments;
     658        _fmInstruments = new uint8[0x1800];
     659        memcpy(_fmInstruments, instr, 0x1800);
     660}
     661
     662void FMT_EuphonyDriver::loadWaveInstruments(const byte *instr) {
     663        if (_waveInstruments)
     664                delete [] _waveInstruments;
     665        _waveInstruments = new uint8[0x1000];
     666        memcpy(_waveInstruments, instr, 0x1000);
     667
     668        const uint8 *pos = (const uint8 *)(instr + 0x1000);
     669
     670        for (uint8 i = 0; i < 10; i++) {
     671                if (_waveSounds[i])
     672                        delete [] _waveSounds[i];
     673                uint32 numsamples = READ_LE_UINT32(pos + 0x0C);
     674                _waveSounds[i] = new int8[numsamples + 0x20];
     675        memcpy(_waveSounds[i], pos, 0x20);
     676                pos += 0x20;
     677                for (uint32 ii = 0; ii < numsamples; ii++) {
     678                        uint8 s = *(pos + ii);
     679                        s = (s < 0x80) ? 0x80 - s : s;
     680                        _waveSounds[i][ii + 0x20] = s ^ 0x80;
     681                }
     682                pos += numsamples;
     683        }
     684}
     685
     686
     687void FMT_EuphonyDriver::assignFmChannel(uint8 midiChannelNumber, uint8 fmChannelNumber) {
     688        _channel[midiChannelNumber] = _fChannel[fmChannelNumber];
     689}
     690
     691void FMT_EuphonyDriver::assignWaveChannel(uint8 midiChannelNumber, uint8 waveChannelNumber) {
     692        _channel[midiChannelNumber] = _wChannel[waveChannelNumber];
     693}
     694
     695void FMT_EuphonyDriver::removeChannel(uint8 midiChannelNumber) {
     696        _channel[midiChannelNumber] = 0;
     697}
     698
     699void FMT_EuphonyDriver::generateSamples(int16 *data, int len) {
     700        memset(data, 0, 2 * sizeof(int16) * len);
     701        nextTick(data, len);
     702}
     703
     704void FMT_EuphonyDriver::nextTick(int16 *buf1, int buflen) {
     705        int32 *buf0 = (int32 *)buf1;
     706
     707        for (int i = 0; i < ARRAYSIZE(_channel); i++) {
     708                if (_channel[i])
     709                        _channel[i]->nextTick(buf0, buflen);
     710        }
     711
     712        for (int i = 0; i < buflen; ++i) {
     713                buf1[i*2] = buf1[i*2+1] =((buf0[i] * volume()) >> 9) & 0xffff;
     714        }
     715}
     716
     717void FMT_EuphonyDriver::rate(uint16 r)
     718{
     719        for (uint8 i = 0; i < 16; i++) {
     720                if (_channel[i])
     721                        _channel[i]->rate(r);
     722        }
     723}
     724
     725MidiParser_EuD::MidiParser_EuD() : MidiParser() {
     726}
     727
     728void MidiParser_EuD::parseNextEvent(EventInfo &info) {
     729        byte *pos = _position._play_pos;
     730
     731        while (true) {
     732                byte cmd = *pos;
     733                byte evt = (cmd & 0xF0);
     734
     735                if (evt == 0x90) {
     736                        byte chan = pos[1];
     737
     738                        if (_enable[chan]) {
     739                                uint16 tick = (pos[2] | ((uint16) pos[3] << 7)) + _baseTick;
     740                                info.start = pos + 6;
     741                                uint32 last = _position._last_event_tick;
     742                                info.delta = (tick < last) ? 0 : (tick - last);
     743
     744                                info.event = 0x90 | _channel[chan];
     745                                info.length = pos[7] | (pos[8] << 4);
     746
     747                                int8 note = (int8) pos[4];
     748                                if (_adjNote[chan]) {
     749                                        note = (note & 0x7f) & _adjNote[chan];
     750                                        if (note > 0x7c)
     751                                                note -= 0x0c;
     752                                        else if (note < 0)
     753                                                note += 0x0c;
     754                                }
     755                                info.basic.param1 = (byte) note;
     756
     757                                uint8 onVelo = (pos[5] & 0x7f) + _adjVelo[chan];
     758                                if (onVelo > 0x7f)
     759                                        onVelo = 0x7f;
     760                                if (onVelo < 1)
     761                                        onVelo = 1;
     762                                info.basic.param2 = onVelo;
     763
     764                                pos += 12;
     765                                break;
     766                        } else {
     767                                pos += 6;
     768                        }
     769                } else if (evt == 0xB0 || evt == 0xC0 || evt == 0xe0) {
     770                        byte chan = pos[1];
     771
     772                        if (_enable[chan]) {
     773                                info.start = pos;
     774                                uint16 tick = (pos[2] | ((uint16) pos[3] << 7)) + _baseTick;
     775                                uint32 last = _position._last_event_tick;
     776                                info.delta = (tick < last) ? 0 : (tick - last);
     777                                info.event = evt | _channel[chan];
     778                                info.length = 0;
     779                                info.basic.param1 = pos[4];
     780                                info.basic.param2 = pos[5];
     781                                pos += 6;
     782                                break;
     783                        } else {
     784                                pos += 6;
     785                        }
     786                } else if (cmd == 0xF2) {
     787                        static uint16 tickTable [] = { 0x180, 0xC0, 0x80, 0x60, 0x40, 0x30, 0x20, 0x18 };
     788                        _baseTick += tickTable[_nextBaseTickStep >> 4] * ((_nextBaseTickStep & 0x0f) + 1);
     789                        _nextBaseTickStep = pos[1];
     790                        pos += 6;
     791                } else if (cmd == 0xF8) {
     792                        uint16 tempo = pos[4] | (pos[5] << 7);
     793                        setTempo(tempo);
     794                        pos += 6;
     795                } else if (cmd == 0xFD || cmd == 0xFE) {
     796                        // End of track.
     797                        if (_autoLoop)
     798                                pos = info.start = _tracks[0];
     799                        else
     800                                info.start = pos;
     801
     802                        uint32 last = _position._last_event_tick;
     803                        uint16 tick = (pos[2] | ((uint16) pos[3] << 7)) + _baseTick;
     804                        info.delta = (tick < last) ? 0 : (tick - last);
     805                        info.event = 0xFF;
     806                        info.ext.type = 0x2F;
     807                        info.ext.data = pos;
     808                        break;
     809                } else {
     810                        error("Unknown Euphony music event 0x%02X", (int) cmd);
     811                        memset(&info, 0, sizeof(info));
     812                        pos = 0;
     813                        break;
     814                }
     815        }
     816        _position._play_pos = pos;
     817}
     818
     819bool MidiParser_EuD::loadMusic(byte *data, uint32) {
     820        unloadMusic();
     821
     822        _enable = data + 0x354;
     823        _mode = data + 0x374;
     824        _channel = data + 0x394;
     825        _adjVelo = data + 0x3B4;
     826        _adjNote = (int8*) data + 0x3D4;
     827
     828        _firstBaseTickStep = data[0x804];
     829        _initialTempo = (data[0x805] > 0xfc) ? 0x5a : data[0x805];
     830
     831        _num_tracks = 1;
     832        _ppqn = 120;
     833        _tracks[0] = data + 0x806;
     834
     835        resetTracking();
     836        setTrack (0);
     837
     838        return true;
     839}
     840
     841void MidiParser_EuD::setTempo(uint32 tempo) {
     842        if (tempo)
     843                MidiParser::setTempo(60000000 / tempo);
     844}
     845
     846void MidiParser_EuD::resetTracking() {
     847        MidiParser::resetTracking();
     848
     849        _nextBaseTickStep = _firstBaseTickStep;
     850        _baseTick = 0;
     851        setTempo(_initialTempo);
     852}
     853
    34854SoundTowns::SoundTowns(KyraEngine *engine, Audio::Mixer *mixer) : Sound(engine, mixer), _lastTrack(-1),
    35         _currentSFX(0), _sfxFileData(0), _sfxFileIndex((uint)-1), _sfxWDTable(0) {
     855         _currentSFX(0), _sfxFileData(0), _sfxFileIndex((uint)-1), _sfxWDTable(0), _parser(0), _musicTrackData(0) {
     856
     857        _driver = new FMT_EuphonyDriver(_mixer);
     858        int ret = open();
     859        if (ret != MERR_ALREADY_OPEN && ret != 0) {
     860                error("couldn't open midi driver");
     861        }
    36862}
    37863
    38864SoundTowns::~SoundTowns() {
    39865        AudioCD.stop();
     866        haltTrack();
    40867        delete [] _sfxFileData;
    41         stopSoundEffect();
     868
     869        Common::StackLock lock(_mutex);
     870        _driver->setTimerCallback(0, 0);
     871        close();
     872
     873        if (_musicTrackData)
     874                delete [] _musicTrackData;
     875
     876        _driver = 0;
    42877}
    43878
    44879bool SoundTowns::init() {
    45880        _engine->checkCD();
    46881        int unused = 0;
    47882        _sfxWDTable = _engine->staticres()->loadRawData(kKyra1TownsSFXTable, unused);
    48         return true;
     883
     884        return loadInstruments();
    49885}
    50886
    51887void SoundTowns::process() {
     
    131967
    132968        int trackNum = tTable[track].track;
    133969        bool loop = tTable[track].loop;
    134         // could be that if the trackNum is -1, the music should be stopped
    135         // instead of letting the old music play on
    136         if (trackNum == -1 || trackNum == _lastTrack)
     970
     971        if (track == _lastTrack && _musicEnabled)
    137972                return;
    138973
    139974        haltTrack();
    140         AudioCD.play(trackNum+1, loop ? -1 : 1, 0, 0);
    141         AudioCD.updateCD();
    142975
    143         _lastTrack = trackNum;
     976        if (_musicEnabled == 2 && trackNum != -1) {
     977                AudioCD.play(trackNum+1, loop ? -1 : 1, 0, 0);
     978                AudioCD.updateCD();
     979        } else if (_musicEnabled) {
     980                playEuphonyTrack(tTable[track].fileOffset, loop);
     981        }
     982
     983        _lastTrack = track;
    144984}
    145985
    146986void SoundTowns::haltTrack() {
    147987        _lastTrack = -1;
    148988        AudioCD.stop();
    149989        AudioCD.updateCD();
     990        if (_parser) {
     991                Common::StackLock lock(_mutex);
     992
     993                _parser->setTrack(0);
     994                _parser->jumpToTick(0);
     995
     996                _parser->unloadMusic();
     997                delete _parser;
     998                _parser = 0;
     999
     1000                setVolume(255);
     1001        }
    1501002}
    1511003
    1521004void SoundTowns::loadSoundFile(uint file) {
     
    1571009        _sfxFileData = _engine->resource()->fileData(soundFilename(file), 0);
    1581010}
    1591011
    160 void SoundTowns::stopSoundEffect() {
    161         _sfxIsPlaying = false; 
    162         _mixer->stopHandle(_sfxHandle);
    163 }
    164 
    1651012void SoundTowns::playSoundEffect(uint8 track) {
    1661013        if (!_sfxEnabled || !_sfxFileData)
    1671014                return;
    1681015
    169         _sfxIsPlaying = true;
    170        
    171         uint8 pitch = 0x3c;
    172         if (_sfxFileIndex == 5) {               
     1016        if (track == 0 || track == 10) {
     1017                _mixer->stopHandle(_sfxHandle);
     1018                return;
     1019        } else if (track == 1) {
     1020                // sfx fadeout
     1021                _mixer->stopHandle(_sfxHandle);
     1022                return;
     1023        }
     1024
     1025        uint8 note = 0x3c;
     1026        if (_sfxFileIndex == 5) {
    1731027                if (track == 0x10) {
    174                         pitch = 0x3e;
     1028                        note = 0x3e;
    1751029                        track = 0x0f;
    1761030                } else if (track == 0x11) {
    177                         pitch = 0x40;
     1031                        note = 0x40;
    1781032                        track = 0x0f;
    1791033                } else if (track == 0x12) {
    180                         pitch = 0x41;
     1034                        note = 0x41;
    1811035                        track = 0x0f;
    1821036                }
    1831037        }
     
    1941048                uint32 outBufferSize;
    1951049                uint32 unused2;
    1961050                uint32 unused3;
    197                 uint32 unknown1;
    198                 uint32 pitch;
     1051                uint32 rate;
     1052                uint32 rootNoteOffs;
    1991053        } *sfxHeader = (SfxHeader*)(fileBody + offset);
    2001054
    2011055        uint32 sfxHeaderID = TO_LE_32(sfxHeader->id);
    2021056        uint32 sfxHeaderInBufferSize = TO_LE_32(sfxHeader->inBufferSize);
    2031057        uint32 sfxHeaderOutBufferSize = TO_LE_32(sfxHeader->outBufferSize);
    204         sfxHeader->pitch = TO_LE_32(sfxHeader->pitch);
     1058        uint32 sfxRootNoteOffs = TO_LE_32(sfxHeader->rootNoteOffs);
     1059        uint32 sfxRate = TO_LE_32(sfxHeader->rate);
    2051060
    2061061        uint32 playbackBufferSize = (sfxHeaderID == 1) ? sfxHeaderInBufferSize : sfxHeaderOutBufferSize;
    2071062
    208         stopSoundEffect();
    2091063        uint8 *sfxPlaybackBuffer = (uint8 *)malloc(playbackBufferSize);
    2101064        memset(sfxPlaybackBuffer, 0x80, playbackBufferSize);
    2111065
     
    2201074                uint32 sfx_BtTable_Offset = 0;
    2211075                uint32 sfx_WdTable_Offset = 0;
    2221076                uint32 sfx_WdTable_Number = 5;
    223                
     1077
    2241078                for (uint32 i = 0; i < sfxHeaderInBufferSize; i++) {
    2251079                        sfx_WdTable_Offset = (sfx_WdTable_Number * 3 << 9) + sfxBody[i] * 6;
    2261080                        sfx_WdTable_Number = READ_LE_UINT16(_sfxWDTable + sfx_WdTable_Offset);
     
    2331087                }
    2341088        }
    2351089
    236         for (uint32 i = 0; i < playbackBufferSize; i++) {               
     1090        for (uint32 i = 0; i < playbackBufferSize; i++) {
    2371091                if (sfxPlaybackBuffer[i] < 0x80)
    2381092                        sfxPlaybackBuffer[i] = 0x80 - sfxPlaybackBuffer[i];
    2391093        }
    2401094
    2411095        playbackBufferSize -= 0x20;
    242         setPitch(sfxPlaybackBuffer, playbackBufferSize, sfxHeader->pitch, pitch);
    243        
    244         _currentSFX = Audio::makeLinearInputStream(sfxPlaybackBuffer, playbackBufferSize,
    245                 0x2b11,
    246                 Audio::Mixer::FLAG_UNSIGNED | Audio::Mixer::FLAG_LITTLE_ENDIAN | Audio::Mixer::FLAG_AUTOFREE,
    247                 0, 0);
     1096        uint32 outputRate = uint32(11025 * semitoneAndSampleRate_to_sampleStep(note, sfxRootNoteOffs, sfxRate, 11025, 0x2000));
     1097
     1098        _currentSFX = Audio::makeLinearInputStream(sfxPlaybackBuffer, playbackBufferSize,
     1099                outputRate, Audio::Mixer::FLAG_UNSIGNED | Audio::Mixer::FLAG_LITTLE_ENDIAN | Audio::Mixer::FLAG_AUTOFREE, 0, 0);
    2481100        _mixer->playInputStream(Audio::Mixer::kSFXSoundType, &_sfxHandle, _currentSFX);
    2491101}
    2501102
    251 void SoundTowns::setPitch(uint8 *&data, uint32 &size, int8 sourcePitch, int8 targetPitch) {
    252         if (sourcePitch == targetPitch)
    253                 return;
     1103void SoundTowns::beginFadeOut() {
     1104        //int vol = 255;
     1105        haltTrack();
     1106}
    2541107
    255         if (sourcePitch < 0)
    256                 sourcePitch = 0;
    257         if (sourcePitch > 119)
    258                 sourcePitch = 119;
    259         if (targetPitch < 0)
    260                 targetPitch = 0;
    261         if (targetPitch > 119)
    262                 targetPitch = 119;
    263        
     1108int SoundTowns::open() {
     1109        if (!_driver)
     1110                return 255;
     1111
     1112        int ret = _driver->open();
     1113        if (ret)
     1114                return ret;
     1115
     1116        _driver->setTimerCallback(this, &onTimer);
     1117        return 0;
     1118}
     1119
     1120void SoundTowns::close() {
     1121        if (_driver)
     1122                _driver->close();
     1123}
     1124
     1125void SoundTowns::send(uint32 b) {
     1126        _driver->send(b);
     1127}
     1128
     1129uint32 SoundTowns::getBaseTempo(void) {
     1130        return _driver ? _driver->getBaseTempo() : 0;
     1131}
     1132
     1133bool SoundTowns::loadInstruments() {
     1134        if (!_musicTrackData)
     1135                _musicTrackData = new uint8[0xC58A];
     1136
     1137        memset(_musicTrackData, 0, 0xC58A);
     1138        uint8 * twm = _engine->resource()->fileData("twmusic.pak", 0);
     1139        if (!twm)
     1140                return false;
     1141        Screen::decodeFrame4(twm, _musicTrackData, 0x8BF0);
     1142        _driver->loadFmInstruments(_musicTrackData + 8);
     1143
     1144        memset (_musicTrackData, 0, 0xC58A);
     1145        Screen::decodeFrame4(twm + 0x0CA0, _musicTrackData, 0xC58A);
     1146        delete [] twm;
     1147        _driver->loadWaveInstruments(_musicTrackData + 8);
     1148
     1149        return true;
     1150}
     1151
     1152void SoundTowns::playEuphonyTrack(uint32 offset, int loop) {
     1153        if (!_musicTrackData)
     1154                _musicTrackData = new uint8[0xC58A];
     1155
     1156        memset(_musicTrackData, 0, 0xC58A);
     1157        uint8 * twm = _engine->resource()->fileData("twmusic.pak", 0);
     1158        Screen::decodeFrame4(twm + 0x4b70 + offset, _musicTrackData, 0xC58A);
     1159        delete [] twm;
     1160
     1161        Common::StackLock lock(_mutex);
     1162
     1163        uint8 * used = _musicTrackData + 0x374;
     1164        uint8 * fchan = _musicTrackData + 0x6d4;
     1165        uint8 * wchan = _musicTrackData + 0x6dA;
     1166
     1167        for (uint8 i = 0; i < 6; i++) {
     1168                if (used[fchan[i]])
     1169                        _driver->assignFmChannel(fchan[i], i);
     1170        }
     1171
     1172        for (uint8 i = 0; i < 8; i++) {
     1173                if (used[wchan[i]])
     1174                        _driver->assignWaveChannel(wchan[i], i);
     1175        }
     1176
     1177        for (uint8 i = 0; i < 16; i++) {
     1178                if (!used[i])
     1179                        _driver->removeChannel(i);
     1180        }
     1181        _driver->send(0x79B0);
     1182
     1183        if (_parser)
     1184                delete _parser;
     1185
     1186        _parser = new MidiParser_EuD;
     1187        _parser->property(MidiParser::mpAutoLoop, loop);
     1188        _parser->loadMusic(_musicTrackData, 0);
     1189        _parser->jumpToTick(0);
     1190
     1191        _parser->setMidiDriver(this);
     1192        _parser->setTimerRate(getBaseTempo());
     1193}
     1194
     1195void SoundTowns::onTimer(void * data) {
     1196        SoundTowns *music = (SoundTowns *)data;
     1197        Common::StackLock lock(music->_mutex);
     1198        if (music->_parser)
     1199                music->_parser->onTimer();
     1200}
     1201
     1202float SoundTowns::semitoneAndSampleRate_to_sampleStep(int8 semiTone, int8 semiToneRootkey,
     1203        uint32 sampleRate, uint32 outputRate, int32 pitchWheel) {
     1204        if (semiTone < 0)
     1205                semiTone = 0;
     1206        if (semiTone > 119)
     1207                semiTone = 119;
     1208        if (semiTone < 0)
     1209                semiTone = 0;
     1210        if (semiTone > 119)
     1211                semiTone = 119;
     1212
    2641213        static const float noteFrq[] = {
    2651214                0004.13f, 0004.40f, 0004.64f, 0004.95f, 0005.16f, 0005.50f, 0005.80f, 0006.19f, 0006.60f, 0006.86f,
    2661215                0007.43f, 0007.73f, 0008.25f, 0008.80f, 0009.28f, 0009.90f, 0010.31f, 0011.00f, 0011.60f, 0012.38f,
     
    2761225                2376.00f, 2534.40f, 2640.00f, 2816.00f, 2970.40f, 3168.00f, 3379.20f, 3520.00f, 3801.60f, 3960.00f
    2771226        };
    2781227
    279         const float inc = noteFrq[targetPitch] / noteFrq[sourcePitch];
     1228        float pwModifier = (pitchWheel - 0x2000) / 0x2000;
     1229        int8 d = pwModifier ? (pwModifier < 0 ? -1 : 1) : 0;
     1230        float rateshift = (noteFrq[semiTone] - ((noteFrq[semiTone] -
     1231                noteFrq[semiTone + d]) * pwModifier * d)) / noteFrq[semiToneRootkey];
    2801232
    281         uint32 estimatedSize = (uint32)(((float) size / inc) + 1);
    282         uint32 exactSize = 0;
    283         uint8 * tmp = new uint8[estimatedSize];
    284         memset(tmp, 0x80, estimatedSize);
    285 
    286         int last = 0;
    287         for (float i = 0; i < size; i += inc) {
    288                 int cur = (int) i;
    289                 if (cur == last + 2)
    290                         tmp[exactSize++] = (data[last] + data[cur - 1] + data[cur]) / 3;
    291                 else if (cur == last)
    292                         tmp[exactSize++] = (data[cur] + data[cur + 1]) / 2;
    293                 else
    294                         tmp[exactSize++] = data[cur];
    295                 last = (int) i;
    296         }
    297 
    298     size = MIN(exactSize, estimatedSize);
    299         delete[] data;
    300         data = tmp;
     1233        return (float) sampleRate * 10.0f * rateshift / outputRate;
    3011234}
    3021235
    3031236const uint8 SoundTowns::_sfxBTTable[256] = {
  • engines/kyra/gui.cpp

     
    3838        // Most settings already have sensible defaults. This one, however, is
    3939        // specific to the Kyra engine.
    4040        ConfMan.registerDefault("walkspeed", 2);
     41        ConfMan.registerDefault("cdaudio", _flags.platform == Common::kPlatformFMTowns);
    4142}
    4243
    4344void KyraEngine::readSettings() {
     
    5556                _configTextspeed = 2;   // Fast
    5657
    5758        _configWalkspeed = ConfMan.getInt("walkspeed");
    58         _configMusic = ConfMan.getBool("music_mute") ? 0 : 1;
     59        _configMusic = ConfMan.getBool("music_mute") ? 0 : ((ConfMan.getBool("cdaudio") && _flags.platform == Common::kPlatformFMTowns) ? 2 : 1);       
    5960        _configSounds = ConfMan.getBool("sfx_mute") ? 0 : 1;
    6061
    6162        _sound->enableMusic(_configMusic);
     
    9697        ConfMan.setInt("talkspeed", talkspeed);
    9798        ConfMan.setInt("walkspeed", _configWalkspeed);
    9899        ConfMan.setBool("music_mute", _configMusic == 0);
     100        ConfMan.setBool("cdaudio", _configMusic == 2);
    99101        ConfMan.setBool("sfx_mute", _configSounds == 0);
    100102
    101103        switch (_configVoice) {
     
    563565        _textSpeedString = _guiStrings[25 + offsetOptions];
    564566        _onString =  _guiStrings[20 + offsetOn];
    565567        _offString =  _guiStrings[21 + offset];
     568        _onCDString = _guiStrings[21];
    566569}
    567570
    568571int KyraEngine::buttonMenuCallback(Button *caller) {
     
    12141217void KyraEngine::gui_setupControls(Menu &menu) {
    12151218        debugC(9, kDebugLevelGUI, "KyraEngine::gui_setupControls()");
    12161219
    1217         if (_configMusic)
    1218                 menu.item[0].itemString = _onString; //"On"
    1219         else
    1220                 menu.item[0].itemString = _offString; //"Off"
     1220        switch (_configMusic) {
     1221                case 0:
     1222                        menu.item[0].itemString = _offString; //"Off"
     1223                        break;
     1224                case 1:
     1225                        menu.item[0].itemString = _onString; //"On"
     1226                        break;
     1227                case 2:
     1228                        menu.item[0].itemString = _onCDString; //"On + CD"
     1229                        break;
     1230        }
    12211231
    12221232        if (_configSounds)
    12231233                menu.item[1].itemString = _onString; //"On"
     
    12991309        debugC(9, kDebugLevelGUI, "KyraEngine::gui_controlsChangeMusic()");
    13001310        processMenuButton(button);
    13011311
    1302         _configMusic = !_configMusic;
     1312        _configMusic = ++_configMusic % (_flags.platform == Common::kPlatformFMTowns ? 3 : 2);
    13031313        gui_setupControls(_menu[5]);
    13041314        return 0;
    13051315}
  • engines/kyra/sound.h

     
    4949#include "common/file.h"
    5050#include "common/mutex.h"
    5151
    52 #include "sound/mididrv.h"
    5352#include "sound/midiparser.h"
    5453#include "sound/mixer.h"
     54#include "sound/softsynth/ym2612.h"
    5555
    5656#include "kyra/kyra.h"
    5757
     
    8484
    8585        virtual void beginFadeOut() = 0;
    8686
    87         void enableMusic(bool enable) { _musicEnabled = enable; }
    88         bool musicEnabled() const { return _musicEnabled; }
     87        void enableMusic(int enable) { _musicEnabled = enable; }
     88        int musicEnabled() const { return _musicEnabled; }
    8989        void enableSFX(bool enable) { _sfxEnabled = enable; }
    9090        bool sfxEnabled() const { return _sfxEnabled; }
    9191
     
    9393        void voiceUnload() {}
    9494        bool voiceIsPlaying();
    9595        void voiceStop();
    96        
     96
    9797protected:
    9898        const char *soundFilename(uint file) { return (file < _soundFileListSize) ? _soundFileList[file] : ""; }
    99         bool _musicEnabled;
     99        int _musicEnabled;
    100100        bool _sfxEnabled;
    101101
    102102        KyraEngine *_engine;
     
    129129
    130130        void setVolume(int volume);
    131131        int getVolume();
    132        
     132
    133133        void loadSoundFile(uint file);
    134        
     134
    135135        void playTrack(uint8 track);
    136136        void haltTrack();
    137        
     137
    138138        void playSoundEffect(uint8 track);
    139        
     139
    140140        void beginFadeOut();
    141141private:
    142142        void play(uint8 track);
     
    231231        Common::Mutex _mutex;
    232232};
    233233
    234 class SoundTowns : public Sound {
     234class FMT_EuphonyDriver;
     235class SoundTowns : public MidiDriver, public Sound {
    235236public:
    236237        SoundTowns(KyraEngine *engine, Audio::Mixer *mixer);
    237238        ~SoundTowns();
     
    249250
    250251        void playSoundEffect(uint8);
    251252
    252         void beginFadeOut() { /* TODO */ }
     253        void beginFadeOut();
     254
     255        //MidiDriver interface implementation
     256        int open();
     257        void close();
     258        void send(uint32 b);
     259        void metaEvent(byte type, byte *data, uint16 length) {}
     260
     261        void setTimerCallback(void *timerParam, void (*timerProc)(void *)) { }
     262        uint32 getBaseTempo(void);
     263
     264        //Channel allocation functions
     265        MidiChannel *allocateChannel()          { return 0; }
     266        MidiChannel *getPercussionChannel()     { return 0; }
     267
     268        static float semitoneAndSampleRate_to_sampleStep(int8 semiTone, int8 semiToneRootkey,
     269                uint32 sampleRate, uint32 outputRate, int32 pitchWheel);
    253270private:
    254         void stopSoundEffect();
    255         void setPitch(uint8 *&data, uint32 &size, int8 sourcePitch, int8 targetPitch);
     271        bool loadInstruments();
     272        void playEuphonyTrack(uint32 offset, int loop);
    256273
     274        static void onTimer(void *data);
     275
    257276        int _lastTrack;
    258277        Audio::AudioStream *_currentSFX;
    259278        Audio::SoundHandle _sfxHandle;
     279
    260280        int _currentTrackTable;
    261         bool _sfxIsPlaying;
    262281        uint _sfxFileIndex;
    263282        uint8 *_sfxFileData;
    264283
     284        FMT_EuphonyDriver * _driver;
     285        MidiParser * _parser;
     286        uint8 *_musicTrackData;
     287
     288        Common::Mutex _mutex;
     289
    265290        static const char *_sfxFiles[];
    266291        static const int _sfxFilenum;
    267292        static const uint8 _sfxBTTable[256];
    268         const uint8 *_sfxWDTable;       
     293        const uint8 *_sfxWDTable;
    269294};
    270295
    271296class MixedSoundDriver : public Sound {
     
    300325        ~SoundDigital();
    301326
    302327        bool init();
    303        
     328
    304329        int playSound(Common::File *fileHandle, bool loop = false, bool fadeIn = false, int channel = -1);
    305330        bool isPlaying(int channel);
    306331        void stopSound(int channel);
  • engines/kyra/kyra.h

     
    790790
    791791        uint8 _configTextspeed;
    792792        uint8 _configWalkspeed;
    793         bool _configMusic;
     793        int _configMusic;
    794794        bool _configSounds;
    795795        uint8 _configVoice;
    796796
     
    891891        const char *_textSpeedString;
    892892        const char *_onString;
    893893        const char *_offString;
     894        const char *_onCDString;
    894895               
    895896        int _itemList_Size;
    896897        int _takenList_Size;
  • engines/kyra/resource.cpp

     
    8888                for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
    8989                        Common::String filename = file->name();
    9090                        filename.toUppercase();
     91
     92                        // No real PAK file!
     93                        if (filename == "TWMUSIC.PAK")
     94                                continue;
     95
    9196                        if (filename.hasSuffix("PAK") || filename.hasSuffix("APK")) {
    9297                                if (!loadPakFile(file->name())) {
    9398                                        error("couldn't open pakfile '%s'", file->name().c_str());
  • engines/kyra/sound.cpp

     
    3737
    3838Sound::Sound(KyraEngine *engine, Audio::Mixer *mixer)
    3939        : _engine(engine), _mixer(mixer), _currentVocFile(0), _vocHandle(), _compressHandle(),
    40         _musicEnabled(true), _sfxEnabled(true), _soundFileList(0), _soundFileListSize(0) {
     40        _musicEnabled(1), _sfxEnabled(true), _soundFileList(0), _soundFileListSize(0) {
    4141}
    4242
    4343Sound::~Sound() {
     
    450450
    451451void KyraEngine::snd_playSoundEffect(int track) {
    452452        debugC(9, kDebugLevelMain | kDebugLevelSound, "KyraEngine::snd_playSoundEffect(%d)", track);
    453         if (_flags.platform == Common::kPlatformFMTowns) {
    454                 if (track == 49) {
    455                         snd_playWanderScoreViaMap(56, 1);
    456                         return;
    457                 } else if (track == 0 || track == 1 || track == 10) {
    458                         // I don't know what's supposed to happen here, but calling playSoundEffect will lead to crash
    459                         return;
    460                 }
     453        if (_flags.platform == Common::kPlatformFMTowns && track == 49) {
     454                snd_playWanderScoreViaMap(56, 1);
     455                return;
    461456        }
    462457        _sound->playSoundEffect(track);
    463458}