Ticket #8460: kyra_sound_v2.patch

kyra/kyra.cpp

@@ -142 +142 @@
                 _system->initSize(320, 200);
         _system->endGFXTransaction();
 
-        int midiDrv = MidiDriver::detectMusicDriver(MDT_NATIVE | MDT_ADLIB | MDT_PREFER_NATIVE);
+        // for now we prefer MIDI-to-Adlib conversion over native midi
+        int midiDrv = MidiDriver::detectMusicDriver(MDT_NATIVE | MDT_ADLIB/* | MDT_PREFER_NATIVE*/);
         bool native_mt32 = (ConfMan.getBool("native_mt32") || (midiDrv == MD_MT32));
 
         MidiDriver *driver = MidiDriver::createMidi(midiDrv);
@@ -158 +159 @@
         assert(_midi);
         _midi->hasNativeMT32(native_mt32);
         _midi->setVolume(255);
-
+        
         _res = new Resource(this);
         assert(_res);
         _screen = new Screen(this, _system);
@@ -504 +505 @@
         _skipIntroFlag = true; // only true if user already played the game once
         _seq_copyViewOffs = true;
         _screen->setFont(Screen::FID_8_FNT);
-//      snd_kyraPlayTheme(0);
+        snd_playTheme(MIDI_INTRO, 2);
+        snd_setSoundEffectFile(MIDI_INTRO);
         setTalkCoords(144);
         for (int i = 0; i < ARRAYSIZE(introProcTable) && !seq_skipSequence(); ++i) {
                 (this->*introProcTable[i])();
@@ -947 +949 @@
                         }
                         break;
                 case 24: { // sound related
-                                seqData++;
-                                warning("Sequence opcode 24 skipped");
+                                uint8 param = *seqData++;
+                                waitTicks(3);
+                                snd_playSoundEffect(param);
                         }
                         break;
                 case 25: { // sound related
-                                seqData++;
-                                warning("Sequence opcode 25 skipped");
+                                uint8 param = *seqData++;
+                                snd_seqMessage(param);
                         }
                         break;
                 case 26:

kyra/kyra.h

@@ -88 +88 @@
 class Screen;
 
 class KyraEngine : public Engine {
+        friend class MusicPlayer;
 public:
 
         enum {
@@ -109 +110 @@
 
         typedef void (KyraEngine::*IntroProc)();
 
+        enum {
+                MIDI_INTRO = 0,
+                MIDI_KYRAMISC = 11
+        };
+
 protected:
 
         int go();
@@ -149 +155 @@
         uint16 wsa_getNumFrames(WSAMovieV1 *wsa) const;
         void wsa_play(WSAMovieV1 *wsa, int frameNum, int x, int y, int pageNum);
         void wsa_processFrame(WSAMovieV1 *wsa, int frameNum, uint8 *dst);
+
+        void snd_playTheme(int file, int track = 0);
+        void snd_playTrack(int track);
+        void snd_startTrack();
+        void snd_haltTrack();
+        void snd_setSoundEffectFile(int file);
+        void snd_playSoundEffect(int track);
+        void snd_seqMessage(int msg);
                 
         uint8 _game;
         bool _fastMode;

kyra/sound.cpp

@@ -22 +22 @@
 #include "common/stdafx.h"
 #include "kyra/resource.h"
 #include "kyra/sound.h"
+#include "common/system.h"
 
 namespace Kyra {
 
-MusicPlayer::MusicPlayer(MidiDriver* driver, KyraEngine* engine) {
+MusicPlayer::MusicPlayer(MidiDriver *driver, KyraEngine *engine) {
         _engine = engine;
         _driver = driver;
         _passThrough = false;
-        _isPlaying = _nativeMT32 = false;
-
-        memset(_channel, 0, sizeof(MidiChannel*) * 16);
-        memset(_channelVolume, 255, sizeof(uint8) * 16);
+        _eventFromMusic = false;
+        _fadeMusicOut = _sfxIsPlaying = false;
+        _isPlaying = _isLooping = _nativeMT32 = false;
+        _soundEffect = _parser = 0;
+        _soundEffectSource = _parserSource = 0;
+
+        memset(_channel, 0, sizeof(MidiChannel*) * 32);
+        memset(_channelVolume, 50, sizeof(uint8) * 16);
+        _channelVolume[10] = 100;
+        for (int i = 0; i < 16; ++i) {
+                _virChannel[i] = i;
+        }
         _volume = 0;
 
         int ret = open();
@@ -56 +65 @@
                 return;
 
         _volume = volume;
-        for (int i = 0; i < 16; ++i) {
+        for (int i = 0; i < 32; ++i) {
                 if (_channel[i]) {
-                        _channel[i]->volume(_channelVolume[i] * _volume / 255);
+                        if (i >= 16) {
+                                _channel[i]->volume(_channelVolume[i - 16] * _volume / 255);
+                        } else {
+                                _channel[i]->volume(_channelVolume[i] * _volume / 255);
+                        }
                 }
         }
 }
@@ -84 +97 @@
 
 void MusicPlayer::send(uint32 b) {
         if (_passThrough) {
+                if ((b & 0xFFF0) == 0x007BB0)
+                        return;
                 _driver->send(b);
                 return;
         }
 
         uint8 channel = (byte)(b & 0x0F);
+        if (((b & 0xFFF0) == 0x6FB0 || (b & 0xFFF0) == 0x6EB0) && channel != 9) {
+                if (_virChannel[channel] == channel) {
+                        _virChannel[channel] = channel + 16;
+                        if (!_channel[_virChannel[channel]])
+                                _channel[_virChannel[channel]] = _driver->allocateChannel();
+                        _channel[_virChannel[channel]]->volume(_channelVolume[channel] * _volume / 255);
+                }
+                return;
+        }
+
         if ((b & 0xFFF0) == 0x07B0) {
                 // Adjust volume changes by master volume
                 uint8 volume = (uint8)((b >> 16) & 0x7F);
@@ -104 +129 @@
                         return;
         }
 
-        if (!_channel[channel])
-                _channel[channel] = (channel == 9) ? _driver->getPercussionChannel() : _driver->allocateChannel();
-        if (_channel[channel])
-                _channel[channel]->send(b);
+        if (!_channel[_virChannel[channel]]) {
+                _channel[_virChannel[channel]] = (channel == 9) ? _driver->getPercussionChannel() : _driver->allocateChannel();
+                _channel[_virChannel[channel]]->volume(_channelVolume[channel] * _volume / 255);
+        }
+        if (_channel[_virChannel[channel]])
+                _channel[_virChannel[channel]]->send(b);
 }
 
 void MusicPlayer::metaEvent(byte type, byte *data, uint16 length) {
         switch (type) {
         case 0x2F:      // End of Track
-                _parser->jumpToTick(0);
+                if (_eventFromMusic) {
+                        if (!_isLooping) {
+                                _isPlaying = false;
+                        }
+
+                        // remap all channels
+                        for (int i = 0; i < 16; ++i) {
+                                _virChannel[i] = i;
+                        }
+
+                } else {
+                        _sfxIsPlaying = false;
+                }
                 break;
         default:
-                warning("Unhandled meta event: 0x%02x", type);
+                _driver->metaEvent(type, data, length);
                 break;
         }
 }
 
-void MusicPlayer::playMusic(const char* file) {
+void MusicPlayer::playMusic(const char *file) {
         uint32 size;
         uint8 *data = (_engine->resource())->fileData(file, &size);
 
@@ -133 +172 @@
         playMusic(data, size);
 }
 
-void MusicPlayer::playMusic(uint8* data, uint32 size) {
-        if (_isPlaying)
-                stopMusic();
+void MusicPlayer::playMusic(uint8 *data, uint32 size) {
+        stopMusic();
 
+        _parserSource = data;
         _parser = MidiParser::createParser_XMIDI();
         assert(_parser);
 
@@ -150 +189 @@
         _parser->setTrack(0);
         _parser->setMidiDriver(this);
         _parser->setTimerRate(getBaseTempo());
+        _parser->property(MidiParser::mpAutoLoop, false);
+}
+
+void MusicPlayer::loadSoundEffectFile(const char *file) {
+        uint32 size;
+        uint8 *data = (_engine->resource())->fileData(file, &size);
+
+        if (!data) {
+                warning("couldn't load '%s'", file);
+                return;
+        }
+
+        loadSoundEffectFile(data, size);
+}
+
+void MusicPlayer::loadSoundEffectFile(uint8 *data, uint32 size) {
+        stopSoundEffect();
+
+        _soundEffectSource = data;
+        _soundEffect = MidiParser::createParser_XMIDI();
+        assert(_soundEffect);
+
+        if (!_soundEffect->loadMusic(data, size)) {
+                warning("Error reading track!");
+                delete _parser;
+                _parser = 0;
+                return;
+        }
 
-        _isPlaying = true;
+        _soundEffect->setTrack(0);
+        _soundEffect->setMidiDriver(this);
+        _soundEffect->setTimerRate(getBaseTempo());
+        _soundEffect->property(MidiParser::mpAutoLoop, false);
 }
 
 void MusicPlayer::stopMusic() {
+        _isLooping = false;
         _isPlaying = false;
         if (_parser) {
                 _parser->unloadMusic();
                 delete _parser;
-                _parser = NULL;
+                _parser = 0;
+                delete [] _parserSource;
+                _parserSource = 0;
+        }
+}
+
+void MusicPlayer::stopSoundEffect() {
+        _sfxIsPlaying = false;
+        if (_soundEffect) {
+                _soundEffect->unloadMusic();
+                delete _soundEffect;
+                _soundEffect = 0;
+                delete [] _soundEffectSource;
+                _soundEffectSource = 0;
         }
 }
 
 void MusicPlayer::onTimer(void *refCon) {
         MusicPlayer *music = (MusicPlayer *)refCon;
-        if (music->_isPlaying)
-                music->_parser->onTimer();
+
+        // this should be set to the fadeToBlack value
+        const static uint32 musicFadeTime = 2 * 1000;
+        if (music->_fadeMusicOut && music->_fadeStartTime + musicFadeTime > music->_engine->_system->getMillis()) {
+                byte volume = (byte)((musicFadeTime - (music->_engine->_system->getMillis() - music->_fadeStartTime)) * 255 / musicFadeTime);
+                music->setVolume(volume);
+        } else if(music->_fadeStartTime) {
+                music->setVolume(255);
+                music->_fadeStartTime = 0;
+                music->_fadeMusicOut = false;
+        }
+
+        if (music->_isPlaying) {
+                if (music->_parser) {
+                        music->_eventFromMusic = true;
+                        music->_parser->onTimer();
+                }
+        }
+
+        if (music->_sfxIsPlaying) {
+                if (music->_soundEffect) {
+                        music->_eventFromMusic = false;
+                        music->_soundEffect->onTimer();
+                }
+        }
 }
 
-void MusicPlayer::playTrack(uint8 track) {
+void MusicPlayer::playTrack(uint8 track, bool loop) {
         if (_parser) {
                 _isPlaying = true;
+                _isLooping = loop;
                 _parser->setTrack(track);
                 _parser->jumpToTick(0);
+                _parser->setTempo(1);
+                _parser->property(MidiParser::mpAutoLoop, loop);
+        }
+}
+
+void MusicPlayer::playSoundEffect(uint8 track) {
+        if (_soundEffect) {
+                _sfxIsPlaying = true;
+                _soundEffect->setTrack(track);
+                _soundEffect->jumpToTick(0);
+                _soundEffect->property(MidiParser::mpAutoLoop, false);
+        }
+}
+
+void MusicPlayer::beginFadeOut() {
+        // this should be something like fade out...
+        _fadeMusicOut = true;
+        _fadeStartTime = _engine->_system->getMillis();
+}
+
+void KyraEngine::snd_playTheme(int file, int track) {
+        debug(9, "snd_playTheme(%d)", file);
+        switch(file) {
+                case MIDI_INTRO:
+                        _midi->playMusic("INTRO.XMI");
+                        break;
+
+                default:
+                        warning("Unkown music file: %d", file);
+                        break;
+        }
+
+        _midi->playTrack(track, false);
+}
+
+void KyraEngine::snd_playTrack(int track) {
+        debug(9, "snd_playTrack(%d)", track);
+        _midi->playTrack(track, false);
+}
+
+void KyraEngine::snd_setSoundEffectFile(int file) {
+        debug(9, "snd_setSoundEffectFile(%d)", file);
+        switch(file) {
+                case MIDI_INTRO:
+                        _midi->loadSoundEffectFile("INTRO.XMI");
+                        break;
+
+                case MIDI_KYRAMISC:
+                        _midi->loadSoundEffectFile("KYRAMISC.XMI");
+                        break;
+
+                default:
+                        break;
+        }
+}
+
+void KyraEngine::snd_playSoundEffect(int track) {
+        debug(9, "snd_playSoundEffect(%d)", track);
+        _midi->playSoundEffect(track);
+}
+
+void KyraEngine::snd_startTrack() {
+        _midi->startTrack();
+}
+
+void KyraEngine::snd_haltTrack() {
+        _midi->haltTrack();
+}
+
+void KyraEngine::snd_seqMessage(int msg) {
+        debug(9, "snd_seqMessage(%.02d)", msg);
+        switch(msg) {
+                case 0:
+                        // nothing to do here...
+                        break;
+
+                case 1:
+                        _midi->beginFadeOut();
+                        break;
+
+                case 56:
+                        snd_playTheme(MIDI_INTRO, 3);
+                        break;
+
+                case 57:
+                        snd_playTheme(MIDI_INTRO, 4);
+                        break;
+
+                case 58:
+                        snd_playTheme(MIDI_INTRO, 5);
+                        break;
+
+                default:
+                        warning("Unknown seq. message: %.02d", msg);
+                        break;
         }
 }
 

kyra/sound.h

@@ -29 +29 @@
 #include "kyra/kyra.h"
 
 namespace Kyra {
-        class MusicPlayer : public MidiDriver {
 
-        public:
+class MusicPlayer : public MidiDriver {
 
-                MusicPlayer(MidiDriver* driver, KyraEngine* engine);
-                ~MusicPlayer();
+public:
 
-                void setVolume(int volume);
-                int getVolume() { return _volume; }
+        MusicPlayer(MidiDriver *driver, KyraEngine *engine);
+        ~MusicPlayer();
 
-                void hasNativeMT32(bool nativeMT32) { _nativeMT32 = nativeMT32; }
+        void setVolume(int volume);
+        int getVolume() { return _volume; }
+
+        void hasNativeMT32(bool nativeMT32) { _nativeMT32 = nativeMT32; }
+        bool isMT32() { return _nativeMT32; }
+
+        void playMusic(const char* file);
+        void playMusic(uint8* data, uint32 size);
+        void stopMusic();
+
+        void playTrack(uint8 track, bool looping = true);
+        void haltTrack() { _isPlaying = false; }
+        void startTrack() { _isPlaying = true; }
+        void setPassThrough(bool b)     { _passThrough = b; }
+
+        void loadSoundEffectFile(const char* file);
+        void loadSoundEffectFile(uint8* data, uint32 size);
+        void stopSoundEffect();
+
+        void playSoundEffect(uint8 track);
+
+        void beginFadeOut();
+
+        //MidiDriver interface implementation
+        int open();
+        void close();
+        void send(uint32 b);
+        void metaEvent(byte type, byte *data, uint16 length);
+
+        void setTimerCallback(void *timerParam, void (*timerProc)(void *)) { }
+        uint32 getBaseTempo(void) { return _driver ? _driver->getBaseTempo() : 0; }
+
+        //Channel allocation functions
+        MidiChannel *allocateChannel()          { return 0; }
+        MidiChannel *getPercussionChannel()     { return 0; }
+
+protected:
+
+        static void onTimer(void *data);
+
+        MidiChannel* _channel[32];
+        int _virChannel[16];
+        uint8 _channelVolume[16];
+        MidiDriver* _driver;
+        bool _nativeMT32;
+        bool _passThrough;
+        uint8 _volume;
+        bool _isPlaying;
+        bool _sfxIsPlaying;
+        uint32 _fadeStartTime;
+        bool _fadeMusicOut;
+        bool _isLooping;
+        bool _eventFromMusic;
+        MidiParser *_parser;
+        byte *_parserSource;
+        MidiParser *_soundEffect;
+        byte *_soundEffectSource;
+        KyraEngine *_engine;
 
-                void playMusic(const char* file);
-                void playMusic(uint8* data, uint32 size);
-                void stopMusic();
+};
 
-                void playTrack(uint8 track);
-                void setPassThrough(bool b)     { _passThrough = b; }
-
-                //MidiDriver interface implementation
-                int open();
-                void close();
-                void send(uint32 b);
-                void metaEvent(byte type, byte *data, uint16 length);
-
-                void setTimerCallback(void *timerParam, void (*timerProc)(void *)) { }
-                uint32 getBaseTempo(void) { return _driver ? _driver->getBaseTempo() : 0; }
-
-                //Channel allocation functions
-                MidiChannel *allocateChannel()          { return 0; }
-                MidiChannel *getPercussionChannel()     { return 0; }
-
-        protected:
-
-                static void onTimer(void *data);
-
-                MidiChannel* _channel[16];
-                uint8 _channelVolume[16];
-                MidiDriver* _driver;
-                bool _nativeMT32;
-                bool _passThrough;
-                uint8 _volume;
-                bool _isPlaying;
-                MidiParser* _parser;
-                KyraEngine* _engine;
-
-        };
 } // end of namespace Kyra
 
 #endif

sound/midiparser_xmidi.cpp

@@ -53 +53 @@
         uint32 value = 0;
         int i;
 
-        for (i = 0; i < 4; ++i) {
+        // Kyra seems to handle it like this
+        // not only with 4 bytes at maximum
+        for (i = 0; true; ++i) {
                 if (pos[0] & 0x80)
                         break;
                 value += *pos++;