Ticket #5476: psp-pix2-source13.patch

backends/platform/psp/input.cpp

@@ -33 +33 @@
 
 #include "backends/platform/psp/psppixelformat.h"
 #include "backends/platform/psp/input.h"
+#include "gui/message.h"
 
 // Defines for working with PSP buttons
 #define CHANGED(x)       (_buttonsChanged & (x))
@@ -45 +46 @@
 #define PSP_TRIGGERS (PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER)
 
 #define PAD_CHECK_TIME  53
+#define CONTROL_MODE_CHANGE_TIME        2000
 
 void InputHandler::init() {
         sceCtrlSetSamplingCycle(0);     // set sampling to vsync. n = n usecs
         sceCtrlSetSamplingMode(1);  // analog
+        _lastControlModeChangeTime=0;
 }
 
 bool InputHandler::getAllInputs(Common::Event &event) {
@@ -106 +109 @@
 
         int newDpadX = 0, newDpadY = 0;
         bool haveEvent = false;
-
-        if (DOWN(PSP_CTRL_UP)) {
-                newDpadY++;
-                if (DOWN(PSP_CTRL_RTRIGGER))    // Shifting causes diagonals
+        
+        if(_lolControlMode) {
+                //alternative controls for Lands Of Lore control mode
+                
+                //don't need diagonals......
+                        if (DOWN(PSP_CTRL_UP)) {
+                                newDpadY++;
+                        }
+                        if (DOWN(PSP_CTRL_RIGHT)) {
+                                newDpadX++;
+                        }
+                        if (DOWN(PSP_CTRL_DOWN)) {
+                                newDpadY--;
+                        }
+                        if (DOWN(PSP_CTRL_LEFT)) {
+                                newDpadX--;
+                        }       
+        
+                if(DOWN(PSP_CTRL_SQUARE)) { //if square pressed the d-pad maps to the four fight buttons
+                        if (_dpadX == 0 && _dpadY == 0) {               // We were in the middle so we pressed dpad
+                                event.type = Common::EVENT_KEYDOWN;
+                                event.kbd.keycode = translateDpadLol(newDpadX, newDpadY, true);
+                                event.kbd.ascii = event.kbd.keycode + 33;       // Get ascii
+                                haveEvent = true;       
+                                _dpadX = newDpadX;
+                                _dpadY = newDpadY;
+                        } else if (newDpadX == 0 && newDpadY == 0) {// We're now centered so we unpressed dpad
+                                event.type = Common::EVENT_KEYUP;
+                                event.kbd.keycode = translateDpadLol(_dpadX, _dpadY, true);
+                                event.kbd.ascii = event.kbd.keycode + 33;       // Get ascii
+                                haveEvent = true;
+                                _dpadX = newDpadX;
+                                _dpadY = newDpadY;
+                        } else {        // we moved from one pressed dpad direction to another one
+                                event.type = Common::EVENT_KEYUP;
+                                event.kbd.keycode = translateDpadLol(_dpadX, _dpadY, true);
+                                event.kbd.ascii = event.kbd.keycode + 33;       // Get ascii
+                                haveEvent = true;
+                                _dpadX = 0;
+                                _dpadY = 0;
+                        }                       
+                }  else { // If square not pressed then dpad maps to movement controls.
+                        if (newDpadX != _dpadX || newDpadY != _dpadY) {
+                                if (_dpadX == 0 && _dpadY == 0) {               // We were in the middle so we pressed dpad
+                                        event.type = Common::EVENT_KEYDOWN;
+                                        event.kbd.keycode = translateDpadLol(newDpadX, newDpadY, false);
+                                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';        // Get ascii
+                                        _dpadX = newDpadX;
+                                        _dpadY = newDpadY;
+                                } else if (newDpadX == 0 && newDpadY == 0) {// We're now centered so we unpressed dpad
+                                        event.type = Common::EVENT_KEYUP;
+                                        event.kbd.keycode = translateDpadLol(_dpadX, _dpadY, false);
+                                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
+                                        _dpadX = newDpadX;
+                                        _dpadY = newDpadY;
+                                } else {        // we moved from one pressed dpad direction to another one
+                                        event.type = Common::EVENT_KEYUP;       // first release the last dpad direction
+                                        event.kbd.keycode = translateDpadLol(_dpadX, _dpadY, false);
+                                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
+                                        _dpadX = 0; // so that we'll pick up a new dpad movement the next round
+                                        _dpadY = 0;
+                                }               
+                                PSP_DEBUG_PRINT("Keypad event. DpadX[%d], DpadY[%d]\n", _dpadX, _dpadY);
+                                haveEvent = true;
+                        }               
+                }
+        } else {
+                if (DOWN(PSP_CTRL_UP)) {
+                        newDpadY++;
+                        if (DOWN(PSP_CTRL_RTRIGGER))    // Shifting causes diagonals
+                                newDpadX++;
+                }
+                if (DOWN(PSP_CTRL_RIGHT)) {
                         newDpadX++;
-        }
-        if (DOWN(PSP_CTRL_RIGHT)) {
-                newDpadX++;
-                if (DOWN(PSP_CTRL_RTRIGGER))
+                        if (DOWN(PSP_CTRL_RTRIGGER))
+                                newDpadY--;
+                }
+                if (DOWN(PSP_CTRL_DOWN)) {
                         newDpadY--;
-        }
-        if (DOWN(PSP_CTRL_DOWN)) {
-                newDpadY--;
-                if (DOWN(PSP_CTRL_RTRIGGER))
+                        if (DOWN(PSP_CTRL_RTRIGGER))
+                                newDpadX--;
+                }
+                if (DOWN(PSP_CTRL_LEFT)) {
                         newDpadX--;
-        }
-        if (DOWN(PSP_CTRL_LEFT)) {
-                newDpadX--;
-                if (DOWN(PSP_CTRL_RTRIGGER))
-                        newDpadY++;
-        }
-
-        if (newDpadX != _dpadX || newDpadY != _dpadY) {
-                if (_dpadX == 0 && _dpadY == 0) {               // We were in the middle so we pressed dpad
-                        event.type = Common::EVENT_KEYDOWN;
-                        event.kbd.keycode = translateDpad(newDpadX, newDpadY);
-                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';        // Get ascii
-                        _dpadX = newDpadX;
-                        _dpadY = newDpadY;
-                } else if (newDpadX == 0 && newDpadY == 0) {// We're now centered so we unpressed dpad
-                        event.type = Common::EVENT_KEYUP;
-                        event.kbd.keycode = translateDpad(_dpadX, _dpadY);
-                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
-                        _dpadX = newDpadX;
-                        _dpadY = newDpadY;
-                } else {        // we moved from one pressed dpad direction to another one
-                        event.type = Common::EVENT_KEYUP;       // first release the last dpad direction
-                        event.kbd.keycode = translateDpad(_dpadX, _dpadY);
-                        event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
-                        _dpadX = 0; // so that we'll pick up a new dpad movement the next round
-                        _dpadY = 0;
+                        if (DOWN(PSP_CTRL_RTRIGGER))
+                                newDpadY++;
                 }
-
-                PSP_DEBUG_PRINT("Keypad event. DpadX[%d], DpadY[%d]\n", _dpadX, _dpadY);
-                haveEvent = true;
-        }
-
+        
+                if (newDpadX != _dpadX || newDpadY != _dpadY) {
+                        if (_dpadX == 0 && _dpadY == 0) {               // We were in the middle so we pressed dpad
+                                event.type = Common::EVENT_KEYDOWN;
+                                event.kbd.keycode = translateDpad(newDpadX, newDpadY);
+                                event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';        // Get ascii
+                                _dpadX = newDpadX;
+                                _dpadY = newDpadY;
+                        } else if (newDpadX == 0 && newDpadY == 0) {// We're now centered so we unpressed dpad
+                                event.type = Common::EVENT_KEYUP;
+                                event.kbd.keycode = translateDpad(_dpadX, _dpadY);
+                                event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
+                                _dpadX = newDpadX;
+                                _dpadY = newDpadY;
+                        } else {        // we moved from one pressed dpad direction to another one
+                                event.type = Common::EVENT_KEYUP;       // first release the last dpad direction
+                                event.kbd.keycode = translateDpad(_dpadX, _dpadY);
+                                event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0';
+                                _dpadX = 0; // so that we'll pick up a new dpad movement the next round
+                                _dpadY = 0;
+                        }
+        
+                        PSP_DEBUG_PRINT("Keypad event. DpadX[%d], DpadY[%d]\n", _dpadX, _dpadY);
+                        haveEvent = true;
+                }
+        }       
         return haveEvent;
 }
-
+        
 inline Common::KeyCode InputHandler::translateDpad(int x, int y) {
         DEBUG_ENTER_FUNC();
         Common::KeyCode key;
@@ -184 +253 @@
         return key;
 }
 
+inline Common::KeyCode InputHandler::translateDpadLol(int x, int y, bool fight) {
+        DEBUG_ENTER_FUNC();
+        Common::KeyCode key;
+        if(fight) {
+                if (x == -1) key = Common::KEYCODE_F1;
+                else if (x == 1) key = Common::KEYCODE_F3;
+                else if (y == 1) key = Common::KEYCODE_F2;
+                else if (y == -1) key = Common::KEYCODE_F4;
+        } else {
+                if (x == -1) key = Common::KEYCODE_KP7;
+                else if (x == 1) key = Common::KEYCODE_KP9;
+                else if (y == 1) key = Common::KEYCODE_KP8;
+                else if (y == -1) key = Common::KEYCODE_KP2;
+        }
+        return key;
+}
 
+
 bool InputHandler::getButtonEvent(Common::Event &event, SceCtrlData &pad) {
         DEBUG_ENTER_FUNC();
         bool haveEvent = false;
 
-        if (PRESSED(PSP_CTRL_SELECT))
-                _keyboard->setVisible(true);
+        //Change to LOL mode if square,triangle,X & O pressed simultaneouly.
+        //Only change if no other buttons are pressed to avoid sticking keys.
 
-        else if (CHANGED(PSP_4BUTTONS | PSP_TRIGGERS | PSP_CTRL_START)) {
-                if (CHANGED(PSP_CTRL_CROSS)) {
-                        event.type = DOWN(PSP_CTRL_CROSS) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP;
-                        event.mouse.x = _cursor->getX();        // Could this have to do with SCI enter problem?
-                        event.mouse.y = _cursor->getY();
-                        PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "LButtonDown" : "LButtonUp");
-                } else if (CHANGED(PSP_CTRL_CIRCLE)) {
-                        event.type = DOWN(PSP_CTRL_CIRCLE) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP;
-                        event.mouse.x = _cursor->getX();
-                        event.mouse.y = _cursor->getY();
+        if(DOWN(PSP_CTRL_CROSS) && DOWN(PSP_CTRL_SQUARE) && DOWN(PSP_CTRL_CIRCLE) && DOWN(PSP_CTRL_TRIANGLE) && !DOWN(PSP_CTRL_LEFT)  && !DOWN(PSP_CTRL_DOWN) && !DOWN(PSP_CTRL_UP) && !DOWN(PSP_CTRL_RIGHT) && !DOWN(PSP_CTRL_LTRIGGER) && !DOWN(PSP_CTRL_START)) {
+                uint32 time = g_system->getMillis();
+                //Only change mode if enough time passed since last change
+                if(time -_lastControlModeChangeTime > CONTROL_MODE_CHANGE_TIME) {
+                        if(_lolControlMode) {
+                                _lolControlMode=false;
+                                _lastControlModeChangeTime=time;        
+                                GUI::TimedMessageDialog dialog("Normal Button Mode", 1500);
+                                dialog.runModal();
+                        } else {
+                                _lolControlMode=true;
+                                _lastControlModeChangeTime=time;
+                                //send keyup for . which is mapped to square in normal mode
+                                event.type = Common::EVENT_KEYUP;
+                                event.kbd.keycode = Common::KEYCODE_PERIOD;
+                                event.kbd.ascii = '.';
+                                haveEvent=true;
+        
+                                GUI::TimedMessageDialog dialog("1st Person Button Mode", 1500);
+                                dialog.runModal();
+                        }                       
+                        return haveEvent;
+                }
+        }
+        if(_lolControlMode) {
+                        if (PRESSED(PSP_CTRL_SELECT))
+                        _keyboard->setVisible(true);
+        
+                else if (CHANGED(PSP_4BUTTONS | PSP_TRIGGERS | PSP_CTRL_START)) {
+                        if (CHANGED(PSP_CTRL_CROSS)) {
+                                event.type = DOWN(PSP_CTRL_CROSS) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP;
+                                event.mouse.x = _cursor->getX();        // Could this have to do with SCI enter problem?
+                                event.mouse.y = _cursor->getY();
+                                PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "LButtonDown" : "LButtonUp");
+                        } else if (CHANGED(PSP_CTRL_CIRCLE)) {
+                                event.type = DOWN(PSP_CTRL_CIRCLE) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP;
+                                event.mouse.x = _cursor->getX();
+                                event.mouse.y = _cursor->getY();
                         PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "RButtonDown" : "RButtonUp");
-                } else {
-                        //any of the other buttons.
-                        event.type = _buttonsChanged & pad.Buttons ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
-                        event.kbd.ascii = 0;
-                        event.kbd.flags = 0;
-
-                        if (CHANGED(PSP_CTRL_LTRIGGER)) {
-                                event.kbd.keycode = Common::KEYCODE_ESCAPE;
-                                event.kbd.ascii = 27;
-                        } else if (CHANGED(PSP_CTRL_START)) {
-                                event.kbd.keycode = Common::KEYCODE_F5;
-                                event.kbd.ascii = Common::ASCII_F5;
-                                if (DOWN(PSP_CTRL_RTRIGGER)) {
-                                        event.kbd.flags |= Common::KBD_CTRL;    // Main menu to allow RTL
+                        } else {
+                                //any of the other buttons.
+                                event.type = _buttonsChanged & pad.Buttons ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
+                                event.kbd.ascii = 0;
+                                event.kbd.flags = 0;
+        
+                                if (CHANGED(PSP_CTRL_LTRIGGER)) {
+                                        event.kbd.keycode = Common::KEYCODE_KP4;
+                                        event.kbd.ascii = Common::KEYCODE_KP4;
+                                } else if (CHANGED(PSP_CTRL_SQUARE)) { //need to keyup movement/fighting keys to make certain they don't get stuck
+                                        if(DOWN(PSP_CTRL_SQUARE)) {
+                                                _dpadX = 0;
+                                                _dpadY = 0;
+                                                if(DOWN(PSP_CTRL_UP)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_KP8;
+                                                        event.kbd.ascii = Common::KEYCODE_KP8;
+                                                } else if(DOWN(PSP_CTRL_LEFT)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_KP4;
+                                                        event.kbd.ascii = Common::KEYCODE_KP4;
+                                                } else if(DOWN(PSP_CTRL_RIGHT)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_KP6;
+                                                        event.kbd.ascii = Common::KEYCODE_KP6;
+                                                } else if(DOWN(PSP_CTRL_DOWN)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_KP2;
+                                                        event.kbd.ascii = Common::KEYCODE_KP2;
+                                                } else return haveEvent;
+                                        } else {
+                                                _dpadX = 0;
+                                                _dpadY = 0;
+                                                if(DOWN(PSP_CTRL_UP)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_F2;
+                                                        event.kbd.ascii = Common::ASCII_F2;
+                                                } else if(DOWN(PSP_CTRL_LEFT)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_F1;
+                                                        event.kbd.ascii = Common::ASCII_F1;
+                                                } else if(DOWN(PSP_CTRL_RIGHT)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_F3;
+                                                        event.kbd.ascii = Common::ASCII_F3;
+                                                } else if(DOWN(PSP_CTRL_DOWN)) {
+                                                        event.type = Common::EVENT_KEYUP;
+                                                        event.kbd.keycode = Common::KEYCODE_F4;
+                                                        event.kbd.ascii = Common::ASCII_F4;
+                                                } else return haveEvent;
+                                        }
                                 }
-                        } else if (CHANGED(PSP_CTRL_SQUARE)) {
-                                event.kbd.keycode = Common::KEYCODE_PERIOD;
-                                event.kbd.ascii = '.';
-                        } else if (CHANGED(PSP_CTRL_TRIANGLE)) {
-                                event.kbd.keycode = Common::KEYCODE_RETURN;
-                                event.kbd.ascii = '\r';
-                        } else if (DOWN(PSP_CTRL_RTRIGGER)) {                   // An event
-                                event.kbd.flags |= Common::KBD_SHIFT;
+                                else if (CHANGED(PSP_CTRL_RTRIGGER)) {                  // An event
+                                        event.kbd.keycode = Common::KEYCODE_KP6;
+                                        event.kbd.ascii = Common::KEYCODE_KP6;
+                                } else if (CHANGED(PSP_CTRL_TRIANGLE)) {
+                                        event.kbd.keycode = Common::KEYCODE_RETURN;
+                                        event.kbd.ascii = '\r';
+                                } else if (CHANGED(PSP_CTRL_START)) {
+                                        event.kbd.keycode = Common::KEYCODE_ESCAPE;
+                                        event.kbd.ascii = 27;
+                                }
+                                PSP_DEBUG_PRINT("Ascii[%d]. Key %s.\n", event.kbd.ascii, event.type == Common::EVENT_KEYDOWN ? "down" : "up");
                         }
-                        PSP_DEBUG_PRINT("Ascii[%d]. Key %s.\n", event.kbd.ascii, event.type == Common::EVENT_KEYDOWN ? "down" : "up");
+                
+                        haveEvent = true;
+                }       
+        }
+        else
+        {
+                if (PRESSED(PSP_CTRL_SELECT))
+                        _keyboard->setVisible(true);
+        
+                else if (CHANGED(PSP_4BUTTONS | PSP_TRIGGERS | PSP_CTRL_START)) {
+                        if (CHANGED(PSP_CTRL_CROSS)) {
+                                event.type = DOWN(PSP_CTRL_CROSS) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP;
+                                event.mouse.x = _cursor->getX();        // Could this have to do with SCI enter problem?
+                                event.mouse.y = _cursor->getY();
+                                PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "LButtonDown" : "LButtonUp");
+                        } else if (CHANGED(PSP_CTRL_CIRCLE)) {
+                                event.type = DOWN(PSP_CTRL_CIRCLE) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP;
+                                event.mouse.x = _cursor->getX();
+                                event.mouse.y = _cursor->getY();
+                        PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "RButtonDown" : "RButtonUp");
+                        } else {
+                                //any of the other buttons.
+                                event.type = _buttonsChanged & pad.Buttons ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
+                                event.kbd.ascii = 0;
+                                event.kbd.flags = 0;
+        
+                                if (CHANGED(PSP_CTRL_LTRIGGER)) {
+                                        event.kbd.keycode = Common::KEYCODE_ESCAPE;
+                                        event.kbd.ascii = 27;
+                                } else if (CHANGED(PSP_CTRL_START)) {
+                                        event.kbd.keycode = Common::KEYCODE_F5;
+                                        event.kbd.ascii = Common::ASCII_F5;
+                                        if (DOWN(PSP_CTRL_RTRIGGER)) {
+                                                event.kbd.flags |= Common::KBD_CTRL;    // Main menu to allow RTL
+                                        }
+                                } else if (CHANGED(PSP_CTRL_SQUARE)) {
+                                        event.kbd.keycode = Common::KEYCODE_PERIOD;
+                                        event.kbd.ascii = '.';
+                                } else if (CHANGED(PSP_CTRL_TRIANGLE)) {
+                                                event.kbd.keycode = Common::KEYCODE_RETURN;
+                                        event.kbd.ascii = '\r';
+                                } else if (DOWN(PSP_CTRL_RTRIGGER)) {                   // An event
+                                        event.kbd.flags |= Common::KBD_SHIFT;
+                                }
+                                PSP_DEBUG_PRINT("Ascii[%d]. Key %s.\n", event.kbd.ascii, event.type == Common::EVENT_KEYDOWN ? "down" : "up");
+                        }
+                
+                        haveEvent = true;
                 }
-
-                haveEvent = true;
         }
-
         return haveEvent;
 }
 
@@ -254 +452 @@
                 PSP_DEBUG_PRINT("raw x[%d], y[%d]\n", analogStepX, analogStepY);
 
                 // If no movement then this has no effect
-                if (DOWN(PSP_CTRL_RTRIGGER)) {
+                if ((!_lolControlMode && DOWN(PSP_CTRL_RTRIGGER)) || (_lolControlMode && DOWN(PSP_CTRL_SQUARE))) {
                         // Fine control mode for analog
                         if (analogStepX != 0) {
                                 if (analogStepX > 0)

backends/platform/psp/input.h

@@ -51 +51 @@
         uint32 _buttonsChanged;
         int32 _dpadX, _dpadY;
         int32 _accelX, _accelY;
+        uint32 _lastControlModeChangeTime;
+        bool _lolControlMode;
 
+
         bool getEvent(Common::Event &event, SceCtrlData &pad);
         bool getDpadEvent(Common::Event &event, SceCtrlData &pad);
         bool getButtonEvent(Common::Event &event, SceCtrlData &pad);
         bool getNubEvent(Common::Event &event, SceCtrlData &pad);
         int32 modifyNubAxisMotion(int32 input);
         Common::KeyCode translateDpad(int x, int y);
+        Common::KeyCode translateDpadLol(int x, int y, bool fight);
 };
 
 #endif /* PSP_INPUT_H */

configure

@@ -87 +87 @@
 add_engine drascula "Drascula: The Vampire Strikes Back" yes
 add_engine gob "Gobli*ns" yes
 add_engine groovie "Groovie" yes "groovie2"
-add_engine groovie2 "Groovie 2 games" no
-add_engine hugo "Hugo Trilogy" no
+add_engine groovie2 "Groovie 2 games" yes
+add_engine hugo "Hugo Trilogy" yes
 add_engine kyra "Legend of Kyrandia" yes "lol"
-add_engine lol "Lands of Lore" no
+add_engine lol "Lands of Lore" yes
 add_engine lure "Lure of the Temptress" yes
-add_engine m4 "M4/MADS" no
+add_engine m4 "M4/MADS" yes
 add_engine made "MADE" yes
-add_engine mohawk "Mohawk" no
+add_engine mohawk "Mohawk" yes
 add_engine parallaction "Parallaction" yes
 add_engine queen "Flight of the Amazon Queen" yes
 add_engine saga "SAGA" yes "ihnm saga2"
 add_engine ihnm "IHNM" yes
-add_engine saga2 "SAGA 2 games" no
+add_engine saga2 "SAGA 2 games" yes
 add_engine sci "SCI" yes "sci32"
-add_engine sci32 "SCI32 games" no
+add_engine sci32 "SCI32 games" yes
 add_engine sky "Beneath a Steel Sky" yes
 add_engine sword1 "Broken Sword" yes
 add_engine sword2 "Broken Sword II" yes
@@ -166 +166 @@
 _nasmpath="$PATH"
 NASMFLAGS=""
 NASM=""
-
-# Directories for installing ScummVM.
-# This list is closely based on what GNU autoconf does,
-# although the default value for datadir differs.
-# Like GNU autoconf, we distinguish datadir and datarootdir
-# to make it possible to change e.g. the location of the
-# man pages independently of that of the engine data files,
-# which are placed inside $datadir/scummvm
-exec_prefix=NONE
-prefix=NONE
-bindir='${exec_prefix}/bin'
-datarootdir='${prefix}/share'
-datadir='${datarootdir}/scummvm'
-docdir='${datarootdir}/doc/scummvm'
-libdir='${exec_prefix}/lib'
-#localedir='${datarootdir}/locale'
-mandir='${datarootdir}/man'
-
+_prefix=/usr/pspdev/local
 # For cross compiling
 _host=""
 _host_cpu=""

engines/agos/midi.cpp

@@ -29 +29 @@
 #include "common/system.h"
 
 #include "agos/agos.h"
+#include "sound/audiocd.h"
 
 namespace AGOS {
 
@@ -96 +97 @@
 }
 
 void MidiPlayer::send(uint32 b) {
+
         if (!_current)
                 return;
 
@@ -208 +210 @@
         if (track == _currentTrack)
                 return;
 
+        AudioCD.stop();
+        AudioCD.play(_music.cdtracks[track], _loopTrack ? -1 : 1 , 0, 0);
+
         if (_music.num_songs > 0) {
                 if (track >= _music.num_songs)
                         return;
@@ -225 +230 @@
                 parser->property (MidiParser::mpMalformedPitchBends, 1);
                 parser->setMidiDriver(this);
                 parser->setTimerRate(_driver->getBaseTempo());
+                if(AudioCD.isPlaying()) parser->_dontplayme=true;
+                else parser->_dontplayme=false;
                 if (!parser->loadMusic(_music.songs[track], _music.song_sizes[track])) {
                         printf ("Error reading track!\n");
                         delete parser;
@@ -239 +246 @@
                         _mutex.unlock();
                         return;
                 }
+                if(AudioCD.isPlaying()) _music.parser->_dontplayme=true;
+                else _music.parser->_dontplayme=false;
                 _currentTrack = (byte)track;
                 _current = &_music;
                 _music.parser->jumpToTick(0);
@@ -250 +259 @@
 
 void MidiPlayer::stop() {
         Common::StackLock lock(_mutex);
+        AudioCD.stop();
 
         if (_music.parser) {
                 _current = &_music;
@@ -288 +298 @@
 
         _musicVolume = musicVol;
         _sfxVolume = sfxVol;
+        g_system->getMixer()->setVolumeForSoundType(g_system->getMixer()->kMusicSoundType,musicVol);
 
         // Now tell all the channels this.
         Common::StackLock lock(_mutex);
@@ -322 +333 @@
 
 void MidiPlayer::queueTrack(int track, bool loop) {
         _mutex.lock();
-        if (_currentTrack == 255) {
+        if (_currentTrack == 255 && !AudioCD.isPlaying()) {
                 _mutex.unlock();
                 setLoop(loop);
                 startTrack(track);
@@ -523 +534 @@
         }
 }
 
-void MidiPlayer::loadXMIDI(Common::File *in, bool sfx) {
+
+void MidiPlayer::loadXMIDI(Common::File *in, bool sfx, uint8 cdtrack) {
         Common::StackLock lock(_mutex);
         MusicInfo *p = sfx ? &_sfx : &_music;
         clearConstructs(*p);
 
+        uint8 si2xmis[][16]={{0},{9,10,11},{4,5,6,7,8},{12},{13},{14},{15},{16},{17,9,10,11},{18,16},
+                                                {19,20,21},{22},{23,24,25},{29},{1,2},{30},{29,31,32},{1,2},{29,31,32},{33,34},
+                                                {35,36},{37,38},{39,40},{41,42},{43,44},{45,46,47,48},{26,27,28},{49,50,51,52,53},{54},{55,56,57,58},
+                                                {59,60},{61},{62,63,64,65},{65,62,64,63},{65,62,64,63},{66},{67},{68},{69},{70},
+                                                {71,72},{73,74},{75},{76,77},{78},{79},{80},{81},{82,83,84,85,86},{86,87,88},
+                                                {114},{115,116},{116},{117},{118,119},{120},{121},{122},{123},{124},
+                                                {89},{90,91},{92,93},{94,91,95},{96},{97},{98,99},{98,100},{98,101},{98,101},
+                                                {98,101},{102},{98,101},{103},{104,105,106},{107},{108},{109},{110,111,112},{113},
+                                                {125,126},{127},{128},{129,130,131},{132,133},{134,135},{136},{137},{138},{138,139},
+                                                {3},{140,141},{142},{143},{144}
+        };
+
+        if(cdtrack!=0) {
+                for(int a=0;a<sizeof(p->cdtracks);a++) {
+                        p->cdtracks[a]=si2xmis[cdtrack][a];
+                }
+        }
+
         char buf[4];
         uint32 pos = in->pos();
         uint32 size = 4;

engines/agos/midi.h

@@ -42 +42 @@
         byte num_songs;           // For Type 1 SMF resources
         byte *songs[16];          // For Type 1 SMF resources
         uint32 song_sizes[16];    // For Type 1 SMF resources
+        uint8 cdtracks[16];
 
         MidiChannel *channel[16]; // Dynamic remapping of channels to resolve conflicts
         byte volume[16];          // Current channel volume
 
+
         MusicInfo() { clear(); }
         void clear() {
                 parser = 0; data = 0; num_songs = 0;
                 memset(songs, 0, sizeof(songs));
                 memset(song_sizes, 0, sizeof(song_sizes));
                 memset(channel, 0, sizeof(channel));
+                memset(cdtracks, 0, sizeof(cdtracks));
         }
 };
 
@@ -94 +97 @@
 
         void loadSMF(Common::File *in, int song, bool sfx = false);
         void loadMultipleSMF(Common::File *in, bool sfx = false);
-        void loadXMIDI(Common::File *in, bool sfx = false);
+        void loadXMIDI(Common::File *in, bool sfx = false, uint8 cdtrack = 0);
         void loadS1D(Common::File *in, bool sfx = false);
 
         void mapMT32toGM(bool map);

engines/agos/res_snd.cpp

@@ -122 +122 @@
         char buf[4];
 
         stopMusic();
-
         _gameFile->seek(_gameOffsetsPtr[_musicIndexBase + music - 1], SEEK_SET);
         _gameFile->read(buf, 4);
         if (!memcmp(buf, "FORM", 4)) {
                 _gameFile->seek(_gameOffsetsPtr[_musicIndexBase + music - 1], SEEK_SET);
-                _midi.loadXMIDI(_gameFile);
+                _midi.loadXMIDI(_gameFile,false,music);
         } else {
                 _gameFile->seek(_gameOffsetsPtr[_musicIndexBase + music - 1], SEEK_SET);
                 _midi.loadMultipleSMF(_gameFile);

engines/cruise/sound.cpp

@@ -33 +33 @@
 #include "sound/audiostream.h"
 #include "sound/fmopl.h"
 #include "sound/mods/soundfx.h"
+#include "sound/audiocd.h"
 
 namespace Cruise {
 
@@ -652 +653 @@
 void PCSoundFxPlayer::play() {
         debug(9, "PCSoundFxPlayer::play()");
         if (_sfxData) {
+                //attempt to use cd audio first
+                AudioCD.stop();
+                Common::String mystring=_musicName;
+
+                if(mystring=="CORP9") AudioCD.play(9, -1, 0, 0);
+                if(mystring=="CORP2") AudioCD.play(2, -1, 0, 0);
+                if(mystring=="CORP6") AudioCD.play(6, -1, 0, 0);
+                if(mystring=="CORP13") AudioCD.play(13, -1, 0, 0);
+                if(mystring=="CORP1") AudioCD.play(1, -1, 0, 0);
+                if(mystring=="CORP7") AudioCD.play(7, -1, 0, 0);
+
+                //not supported at this moment but here in case I get around to it
+                if(mystring=="CORP3") AudioCD.play(3, -1, 0, 0);
+                if(mystring=="CORP4") AudioCD.play(4, -1, 0, 0);
+                if(mystring=="CORP5") AudioCD.play(5, -1, 0, 0);
+                if(mystring=="CORP8") AudioCD.play(8, -1, 0, 0);
+                if(mystring=="CORP10") AudioCD.play(10, -1, 0, 0);
+                if(mystring=="CORP11") AudioCD.play(11, -1, 0, 0);
+                if(mystring=="CORP12") AudioCD.play(12, -1, 0, 0);
+                if(AudioCD.isPlaying()){
+                        //_playing=true;
+                        return;
+                }
+                
                 for (int i = 0; i < NUM_CHANNELS; ++i) {
                         _instrumentsChannelTable[i] = -1;
                 }
@@ -665 +690 @@
 }
 
 void PCSoundFxPlayer::stop() {
+        AudioCD.stop();
         if (_playing || _fadeOutCounter != 0) {
                 _fadeOutCounter = 0;
                 _playing = false;
@@ -677 +703 @@
 }
 
 void PCSoundFxPlayer::fadeOut() {
+        AudioCD.stop();
         if (_playing) {
                 _fadeOutCounter = 1;
                 _playing = false;

engines/groovie/music.cpp

@@ -47 +47 @@
 
 void MusicPlayer::playSong(uint32 fileref) {
         Common::StackLock lock(_mutex);
+        AudioCD.stop();
+        int doIloop=-1;
+        //if(loop) doIloop=-1;
+        int cdtrack=fileref-19455;
+        if (cdtrack==1) cdtrack=100; //used to avoid confusion with real audio cd track
+        /*switch(fileref) {
+                case 0x4c39:
+                        cdtrack=58;
+                        break;
+                case 0x4c3f:
+                        cdtrack=64;
+                        break;
+        }       */
+        if(cdtrack>0&&cdtrack<200)      AudioCD.play(cdtrack,doIloop,0,0);
+        if(AudioCD.isPlaying())
+        {
+                _isPlaying=true;
+                return;
+        }
 
         // Set the volumes
         _fadingEndVolume = 100;
@@ -338 +357 @@
 void MusicPlayerMidi::endTrack() {
         debugC(3, kGroovieDebugMIDI | kGroovieDebugAll, "Groovie::Music: endTrack()");
         unload();
+        AudioCD.stop();
 }
 
 void MusicPlayerMidi::onTimerInternal() {

engines/kyra/debugger.cpp

@@ -51 +51 @@
         DCmd_Register("queryflag",                      WRAP_METHOD(Debugger, cmd_queryFlag));
         DCmd_Register("timers",                         WRAP_METHOD(Debugger, cmd_listTimers));
         DCmd_Register("settimercountdown",      WRAP_METHOD(Debugger, cmd_setTimerCountdown));
+        DCmd_Register("play",   WRAP_METHOD(Debugger, cmd_play));
+        DCmd_Register("loadsf", WRAP_METHOD(Debugger, cmd_loadsf));
 }
 
 bool Debugger::cmd_setScreenDebug(int argc, const char **argv) {
@@ -68 +70 @@
         return true;
 }
 
+bool Debugger::cmd_play(int argc, const char **argv) {
+                int val = atoi(argv[1]);
+                _vm->sound()->playTrack(val);
+        return true;
+}
+
+bool Debugger::cmd_loadsf(int argc, const char **argv) {
+                //char* val = atoi(argv[1]);
+                _vm->sound()->loadSoundFile(argv[1]);
+        return true;
+}
 bool Debugger::cmd_loadPalette(int argc, const char **argv) {
         Palette palette(_vm->screen()->getPalette(0).getNumColors());
 

engines/kyra/debugger.h

@@ -51 +51 @@
         bool cmd_toggleFlag(int argc, const char **argv);
         bool cmd_queryFlag(int argc, const char **argv);
         bool cmd_listTimers(int argc, const char **argv);
+        bool cmd_play(int argc, const char **argv);
+        bool cmd_loadsf(int argc, const char **argv);
         bool cmd_setTimerCountdown(int argc, const char **argv);
 };
 

engines/kyra/sound_adlib.cpp

@@ -48 +48 @@
 #include "sound/mixer.h"
 #include "sound/fmopl.h"
 #include "sound/audiostream.h"
+#include "sound/audiocd.h"
 
 // Basic AdLib Programming:
 // http://www.gamedev.net/reference/articles/article446.asp
@@ -2301 +2302 @@
 void SoundAdLibPC::haltTrack() {
         unk1();
         unk2();
+        AudioCD.stop();
         //_vm->_system->delayMillis(3 * 60);
 }
 
@@ -2309 +2311 @@
 }
 
 void SoundAdLibPC::playSoundEffect(uint8 track) {
+
         if (_sfxEnabled)
-                play(track);
+        {
+                char filenamebuffer[25];
+                DigitalTrack dTrack=getDigitalEffectsTrack(track);
+                sprintf(filenamebuffer, "track%i", dTrack.track);
+
+                if(dTrack.track!=0) {
+                        _mixer->stopHandle(_fxHandle);
+                        voicePlay(filenamebuffer,&_fxHandle,255,true);
+                        _currentSoundEffect = filenamebuffer;
+                }
+                if(!_mixer->isSoundHandleActive(_fxHandle)) play(track,true);           
+        }
 }
 
-void SoundAdLibPC::play(uint8 track) {
+void SoundAdLibPC::play(uint8 track, bool soundeffect) {
+        
+        if(soundeffect==false)
+        {
+                DigitalTrack dTrack = getDigitalMusicTrack(track);
+                bool loop = dTrack.loop;
+                uint8 tracktoplay = dTrack.track;
+                AudioCD.stop();
+        
+                if(tracktoplay != 0) {
+                        AudioCD.play(tracktoplay, loop ? -1 : 1, 0, 0);
+                }
+        
+                if(AudioCD.isPlaying()) return;
+        }
         uint16 soundId = 0;
 
         if (_v2)
@@ -2382 +2410 @@
 
 void SoundAdLibPC::loadSoundFile(uint file) {
         internalLoadFile(fileListEntry(file));
+        Common::String filename = fileListEntry(file);
+        filename.toLowercase();
+        _currentTrack = filename;
+        haltTrack();
 }
 
 void SoundAdLibPC::loadSoundFile(Common::String file) {
         internalLoadFile(file);
+        file.toLowercase();
+        _currentTrack = file;
+        haltTrack();
 }
 
 void SoundAdLibPC::internalLoadFile(Common::String file) {
@@ -2446 +2481 @@
         playSoundEffect(0);
 }
 
-} // End of namespace Kyra
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_introTracks[] = {
+        {0, false},  {0, false},  {1, false}, {2, false},  {3, true},   {4, true},
+        {0, false},  {0, false},  {0, false}, {0, false},  {0, false},  {0, false},
+        {0, false},  {0, false},  {0, false}, {0, false},  {0, false},  {0, false},
+        {0, false},  {0, false},  {0, false}, {0, false},  {50, false}, {51, false},
+        {52, false}, {53, false}, {0, false}, {54, false}, {55, false}, {0, false},
+        {56, false}, {57, false}, {0, false}, {58, false}, {59, false}, {60, false},
+        {61, false}, {62, false}, {63, false}
+};
 
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra1aTracks[] = {
+        {0, false},   {0, false},   {5, true},    {6, true},    {7, true},    {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false},
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra1bTracks[] = {
+        {0, false},   {0, false},   {9, true},    {10, false},  {11, true},   {45, true},
+        {12, false},  {13, false},  {14, true},   {15, false},  {0, false},   {8, false},
+        {0, false},   {16, true},   {17, true},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false},
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra2aTracks[] = {
+        {0, false},   {0, false},   {18, true},   {19, true},   {20, false},  {21, true},
+        {22, false},  {23, true},   {0, false},   {0, false},   {0, false},   {0, false}, 
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false}, 
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra3aTracks[] = {
+        {0, false},   {0, false},   {5, true},    {25, true},   {26, true},   {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false},
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra4aTracks[] = {
+        {0, false},   {0, false},   {27, true},   {28, true},   {47, false},  {48, false},
+        {49, false},  {29, false},  {30, true},   {64, false},  {0, false},   {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false}, 
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra4bTracks[] = {
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {31, true},   {65, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false},
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra5aTracks[] = {
+        {0, false},   {0, false},   {33, true},   {34, true},   {0, true},    {7, true},
+        {66, false},  {67, false},  {68, false},  {69, false},  {0, false},   {70, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false}, 
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false},
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyra5bTracks[] = {
+        {0, false},   {0, false},   {35, false},  {36, false},  {0, false},   {37, false},
+        {38, false},  {39, false},  {40, false},  {41, false},  {0, false},   {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false},
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_kyramiscTracks[] = {
+        {0, false},   {0, false},   {42, true},   {43, true},   {36, false},  {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {0, false},   {0, false},   {0, false},   {0, false},
+        {0, false},   {0, false},   {71, false},  {72, false},  {73, false},  {74, false}, 
+        {75, false},  {76, false},  {77, false},  {78, false},  {79, false},  {80, false}, 
+        {81, false},  {82, false},  {83, false},  {84, false},  {85, false},  {86, false},
+        {87, false},  {88, false},  {89, false},  {90, false},  {0, false},   {0, false},
+        {0, false},   {94, false},  {95, false},  {0, false},   {97, false},  {98, false},
+        {99, false},  {100, false}, {101, false}, {102, false}, {103, false}, {104, false},
+        {105, false}, {106, false}, {107, false}, {108, false}, {109, false}, {110, false}, 
+        {111, false}, {112, false}, {113, false}, {114, false}, {115, false}, {0, false},
+        {0, false},   {118, false}, {119, false}, {120, false}, {121, false}, {122, false},
+        {123, false}, {124, false}, {125, true},  {0, false},   {127, false}, {128, false},
+        {129, false}, {130, false}, {131, false}, {132, false}, {133, false}, {134, false},
+        {135, false}, {136, false}, {137, false}, {138, false}, {139, false}, {140, false},
+        {141, false}, {142, false}, {143, true},  {144, false}, {145, false}, {146, false},
+        {147, false}, {148, false}, {149, false}, {150, false}, {151, false}, {152, false},
+        {153, false}, {154, false}, {155, false}, {156, false}, {157, false}, {158, false}, 
+        {159, false}, {160, false}, {0, false},   {162, false}, {163, false}, {164, false},
+        {165, false}, {0, false},   {167, false}, {168, false}, {169, false}, {170, false}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2introTracks[] = {
+        {0, false},   {0, false},   {1, false},   {2, false},   {3, false},   {4, true},
+        {5, true},    {6, false},   {7, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test1Tracks[] = {
+        {0, false},   {0, false},   {8, true},    {9, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test2Tracks[] = {
+        {0, false},   {0, false},   {18, true},   {19, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test3Tracks[] = {
+        {0, false},   {0, false},   {20, true},   {21, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test4Tracks[] = {
+        {0, false},   {0, false},   {22, true},   {23, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test5Tracks[] = {
+        {0, false},   {0, false},   {24, false},  {25, false},  {26, false},   {27, false},
+        {28, true},   {29, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test6Tracks[] = {
+        {0, false},   {0, false},   {0, false},   {30, true},   {31, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test7Tracks[] = {
+        {0, false},   {0, false},   {32, true},   {33, true},  {34, false},   {35, true},
+        {36, false},  {37, false},  {38, false},  {39, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test8Tracks[] = {
+        {0, false},   {0, false},   {40, true},   {41, false}, {42, false},   {43, true},
+        {44, false},  {45, true},   {46, false},  {47, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test9Tracks[] = {
+        {0, false},   {0, false},   {48, true},   {49, false}, {50, true},   {51, true},
+        {52, true},   {53, true},   {54, true},   {55, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test10Tracks[] = {
+        {0, false},   {0, false},   {10, false},  {11, false}, {12, true},   {13, true},
+        {14, false},  {15, false},  {16, false},  {17, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test11Tracks[] = {
+        {0, false},   {0, false},   {56, true},   {57, false}, {58, false},  {59, true},
+        {60, true},   {61, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test12Tracks[] = {
+        {0, false},   {0, false},   {62, true},   {63, true},  {63, true},   {64, true},
+        {65, false},  {66, true},   {67, true},   {68, true},  {69, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test13Tracks[] = {
+        {0, false},   {0, false},   {70, true},   {71, false}, {72, false},  {73, true},
+        {74, true},   {75, false},  {76, true},   {77, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test14Tracks[] = {
+        {0, false},   {0, false},   {78,true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2test15Tracks[] = {
+        {0, false},   {0, false},   {79, true},   {80, false}, {81, true},   {82, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2finaleTracks[] = {
+        {0, false},   {0, false},   {0,false},    {83, true},   {84, false}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_k2effectTracks[] = {
+        {0, false},  {91, false},  {92, false},  {93, false},  {94, false},  {95, false},
+        {96, false},  {97, false},  {98, false},  {99, false},  {100, false}, {101, false},
+        {102, false}, {103, false}, {104, false}, {105, false}, {106, false}, {107, false},
+        {108, false}, {109, false}, {110, false}, {111, false}, {112, false}, {113, false},
+        {114, false}, {115, false}, {116, false}, {117, false}, {118, false}, {119, false},
+        {120, false}, {121, false}, {122, false}, {123, false}, {124, false}, {125, false},
+        {126, false}, {127, false}, {128, false}, {129, false}, {130, false}, {131, false},
+        {132, false}, {133, false}, {134, false}, {135, false}, {136, false}, {137, false},
+        {138, false}, {139, false}, {140, false}, {141, false}, {142, false}, {143, false},
+        {144, false}, {145, false}, {146, false}, {147, false}, {148, false}, {149, false},
+        {150, false}, {151, false}, {152, false}, {153, false}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lolintroTracks[] = {
+        {0, false},   {0, false},   {1,false}, {0, false},{0, false},{0, false},   {2, true},   {3, false}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore01aTracks[] = {
+        {0, false},   {0, false},   {4,true}, {5, true}, {6, true}, {7, true},   {8, false},
+        {9, true},   {10, false},   {11, false}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore01bTracks[] = {
+        {0, false},   {0, false},   {12,true}, {0, false}, {13, true}, {14, false},   {15, true},
+        {0, false},   {16, false},   {17, false}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore01cTracks[] = {
+        {0, false},   {0, false},   {18,false}, {19, true}, {20, true}, {21, true},   {22, true},
+        {23, true}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore01dTracks[] = {
+        {0, false},   {0, false},   {24,true}, {25, true}, {26, true}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore02aTracks[] = {
+        {0, false},   {0, false},   {27,true}, {28, true}, {29, true}, {30, true},   {31,false},
+        {32, false},   {33, false},   {34, true}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore03aTracks[] = {
+        {0, false},   {0, false},   {35,true}, {36, true}, {37, true}, {38, true},   {39,true}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore03bTracks[] = {
+        {0, false},   {0, false},   {40,false}, {41, false}, {42, false}, {43, false},   {44,false},
+        {45, false},   {46, false}
+};
+
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore04aTracks[] = {
+        {0, false},   {0, false},   {47, false}, {48, false}, {49, true}, {50, false},   {51,false},
+        {52, false},   {53, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore05aTracks[] = {
+        {0, false},   {0, false},   {54, false}, {55, true}, {56, true}, {57, false},   {58,true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore05bTracks[] = {
+        {0, false},   {0, false},   {59, true}, {60, false}, {61, false}, {62, true},   {63,true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore06aTracks[] = {
+        {0, false},   {0, false},   {64, true}, {65, false}, {66, true}, {67, true},   {68,false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore06bTracks[] = {
+        {0, false},   {0, false},   {69, true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore07aTracks[] = {
+        {0, false},   {0, false},   {70, false}, {71, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore08aTracks[] = {
+        {0, false},   {0, false},   {72, false}, {73, false}, {74, true}, {75, false},   {76,false},   {77,true}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lore08bTracks[] = {
+        {0, false},   {0, false},   {78, true}, {79, false}
+};
+const SoundAdLibPC::DigitalTrack SoundAdLibPC::_lorefinlTracks[] = {
+        {0, false},   {0, false},   {80, false}, {81, false}, {82, false}
+};
+
+SoundAdLibPC::DigitalTrack SoundAdLibPC::getDigitalMusicTrack(uint8 track) {
+          if (_vm->game() == GI_KYRA1) {
+                  if(_currentTrack == "kyra1a") return _kyra1aTracks[track];
+                  else if (_currentTrack == "kyra1b") return _kyra1bTracks[track];
+                  else if (_currentTrack == "kyra2a") return _kyra2aTracks[track];
+                  else if (_currentTrack == "kyra3a") return _kyra3aTracks[track];
+                  else if (_currentTrack == "kyra4a") return _kyra4aTracks[track];
+                  else if (_currentTrack == "kyra4b") return _kyra4bTracks[track];
+                  else if (_currentTrack == "kyra5a") return _kyra5aTracks[track];
+                  else if (_currentTrack == "kyra5b") return _kyra5bTracks[track];
+                  else if (_currentTrack == "kyramisc") return _kyramiscTracks[track];
+                  else if (_currentTrack == "intro") return _introTracks[track];
+           }
+          if (_vm->game() == GI_KYRA2) {
+                  if(_currentTrack == "k2intro") return _k2introTracks[track];
+                  else if (_currentTrack == "k2test1") return _k2test1Tracks[track];
+                  else if (_currentTrack == "k2test2") return _k2test2Tracks[track];
+                  else if (_currentTrack == "k2test3") return _k2test3Tracks[track];
+                  else if (_currentTrack == "k2test4") return _k2test4Tracks[track];
+                  else if (_currentTrack == "k2test5") return _k2test5Tracks[track];
+                  else if (_currentTrack == "k2test6") return _k2test6Tracks[track];
+                  else if (_currentTrack == "k2test7") return _k2test7Tracks[track];
+                  else if (_currentTrack == "k2test8") return _k2test8Tracks[track];
+                  else if (_currentTrack == "k2test9") return _k2test9Tracks[track];
+                  else if (_currentTrack == "k2test10") return _k2test10Tracks[track];
+                  else if (_currentTrack == "k2test11") return _k2test11Tracks[track];
+                  else if (_currentTrack == "k2test12") return _k2test12Tracks[track];
+                  else if (_currentTrack == "k2test13") return _k2test13Tracks[track];
+                  else if (_currentTrack == "k2test14") return _k2test14Tracks[track];
+                  else if (_currentTrack == "k2test15") return _k2test15Tracks[track];
+                  else if (_currentTrack == "k2finale") return _k2finaleTracks[track];
+           }
+           if (_vm->game() == GI_LOL) {
+                  if(_currentTrack == "loreintr") return _lolintroTracks[track];
+                  else if(_currentTrack == "lore01a") return _lore01aTracks[track];
+                  else if(_currentTrack == "lore01b") return _lore01bTracks[track];
+                  else if(_currentTrack == "lore01c") return _lore01cTracks[track];
+                  else if(_currentTrack == "lore01d") return _lore01dTracks[track];
+                  else if(_currentTrack == "lore02a") return _lore02aTracks[track];
+                  else if(_currentTrack == "lore03a") return _lore03aTracks[track];
+                  else if(_currentTrack == "lore03b") return _lore03bTracks[track];
+                  else if(_currentTrack == "lore04a") return _lore04aTracks[track];
+                  else if(_currentTrack == "lore05a") return _lore05aTracks[track];
+                  else if(_currentTrack == "lore05b") return _lore05bTracks[track];
+                  else if(_currentTrack == "lore06a") return _lore06aTracks[track];
+                  else if(_currentTrack == "lore06b") return _lore06bTracks[track];
+                  else if(_currentTrack == "lore07a") return _lore07aTracks[track];
+                  else if(_currentTrack == "lore08a") return _lore08aTracks[track];
+                  else if(_currentTrack == "lore08b") return _lore08bTracks[track];
+                  else if(_currentTrack == "lorefinl") return _lorefinlTracks[track];
+           }
+       return _introTracks[0]; //return empty track
+      
+ }
+
+SoundAdLibPC::DigitalTrack SoundAdLibPC::getDigitalEffectsTrack(uint8 track) {
+         if (_vm->game() == GI_KYRA1) {
+                return getDigitalMusicTrack(track);
+         }
+         if (_vm->game() == GI_KYRA2) {
+                return _introTracks[0];//hack for now since I can't be arsed to fix the fx
+         }
+         return _introTracks[0]; //return empty track
+}
+
+
+
+
+} // end of namespace Kyra
+

engines/kyra/sound_adlib.h

@@ -84 +84 @@
 private:
         void internalLoadFile(Common::String file);
 
-        void play(uint8 track);
+        void play(uint8 track, bool soundeffect=false);
 
         void unk1();
         void unk2();
@@ -97 +97 @@
         int _sfxPlayingSound;
 
         Common::String _soundFileLoaded;
+        Common::String _currentTrack;
+        Common::String _currentSoundEffect;
 
         uint8 _sfxPriority;
         uint8 _sfxFourthByteOfSong;
@@ -106 +108 @@
 
         static const int _kyra1NumSoundTriggers;
         static const int _kyra1SoundTriggers[];
+
+        Audio::SoundHandle _fxHandle;
+        
+        struct DigitalTrack {
+                const uint8 track;
+                const bool loop;
+        };
+
+        static const DigitalTrack _introTracks[];
+        static const DigitalTrack _kyra1aTracks[];
+        static const DigitalTrack _kyra1bTracks[];
+        static const DigitalTrack _kyra2aTracks[];
+        static const DigitalTrack _kyra3aTracks[];
+        static const DigitalTrack _kyra4aTracks[];
+        static const DigitalTrack _kyra4bTracks[];
+        static const DigitalTrack _kyra5aTracks[];
+        static const DigitalTrack _kyra5bTracks[];
+        static const DigitalTrack _kyramiscTracks[];
+        static const DigitalTrack _k2introTracks[];
+        static const DigitalTrack _k2test1Tracks[];
+        static const DigitalTrack _k2test2Tracks[];
+        static const DigitalTrack _k2test3Tracks[];
+        static const DigitalTrack _k2test4Tracks[];
+        static const DigitalTrack _k2test5Tracks[];
+        static const DigitalTrack _k2test6Tracks[];
+        static const DigitalTrack _k2test7Tracks[];
+        static const DigitalTrack _k2test8Tracks[];
+        static const DigitalTrack _k2test9Tracks[];
+        static const DigitalTrack _k2test10Tracks[];
+        static const DigitalTrack _k2test11Tracks[];
+        static const DigitalTrack _k2test12Tracks[];
+        static const DigitalTrack _k2test13Tracks[];
+        static const DigitalTrack _k2test14Tracks[];
+        static const DigitalTrack _k2test15Tracks[];
+        static const DigitalTrack _k2finaleTracks[];
+        static const DigitalTrack _k2effectTracks[];
+
+        static const DigitalTrack _lolintroTracks[];
+        static const DigitalTrack _lore01aTracks[];
+        static const DigitalTrack _lore01bTracks[];             
+        static const DigitalTrack _lore01cTracks[];             
+        static const DigitalTrack _lore01dTracks[];
+        static const DigitalTrack _lore02aTracks[];             
+        static const DigitalTrack _lore03aTracks[];     
+        static const DigitalTrack _lore03bTracks[];     
+        static const DigitalTrack _lore04aTracks[];     
+        static const DigitalTrack _lore05aTracks[];
+        static const DigitalTrack _lore05bTracks[];     
+        static const DigitalTrack _lore06aTracks[];     
+        static const DigitalTrack _lore06bTracks[];     
+        static const DigitalTrack _lore07aTracks[];     
+        static const DigitalTrack _lore08aTracks[];     
+        static const DigitalTrack _lore08bTracks[];     
+        static const DigitalTrack _lorefinlTracks[];    
+        DigitalTrack getDigitalMusicTrack(uint8 track);
+        DigitalTrack getDigitalEffectsTrack(uint8 track);
 };
 
 } // End of namespace Kyra

engines/kyra/sound_lol.cpp

@@ -30 +30 @@
 #include "kyra/resource.h"
 
 #include "sound/audiostream.h"
+#include "sound/audiocd.h"
 
 namespace Kyra {
 

engines/lure/debugger.cpp

@@ -35 +35 @@
 #include "lure/room.h"
 #include "lure/scripts.h"
 #include "lure/strings.h"
+#include "lure/sound.h"
 
 namespace Lure {
 
@@ -53 +54 @@
         DCmd_Register("strings",                        WRAP_METHOD(Debugger, cmd_saveStrings));
         DCmd_Register("debug",                          WRAP_METHOD(Debugger, cmd_debug));
         DCmd_Register("script",                         WRAP_METHOD(Debugger, cmd_script));
+        DCmd_Register("playsound",                      WRAP_METHOD(Debugger, cmd_playSounds));
 }
 
 static int strToInt(const char *s) {
@@ -115 +117 @@
         return true;
 }
 
+bool Debugger::cmd_playSounds(int argc, const char **argv) {
+        int a=strToInt(argv[1]);
+        Sound.killSounds();
+        Sound.musicInterface_Play(a,0);
+        return true;
+}
+
 bool Debugger::cmd_listRooms(int argc, const char **argv) {
         RoomDataList &rooms = Resources::getReference().roomData();
         StringData &strings = StringData::getReference();

engines/lure/debugger.h

@@ -49 +49 @@
         bool cmd_saveStrings(int argc, const char **argv);
         bool cmd_debug(int argc, const char **argv);
         bool cmd_script(int argc, const char **argv);
+        bool cmd_playSounds(int argc, const char **argv);
 };
 
 extern const char *directionList[5];

engines/lure/sound.cpp

@@ -33 +33 @@
 #include "common/config-manager.h"
 #include "common/endian.h"
 #include "sound/midiparser.h"
+#include "sound/audiocd.h"
+#include "sound/mixer.h"
+#include "sound/audiostream.h"
 
 DECLARE_SINGLETON(Lure::SoundManager)
 
@@ -41 +44 @@
 //#define SOUND_CROP_CHANNELS
 
 SoundManager::SoundManager() {
+        currentSection=1;
         Disk &disk = Disk::getReference();
         _soundMutex = g_system->createMutex();
+        _mixer = g_system->getMixer();
 
         int index;
         _descs = disk.getEntry(SOUND_DESC_RESOURCE_ID);
@@ -83 +88 @@
 SoundManager::~SoundManager() {
         if (_driver)
                 _driver->setTimerCallback(this, NULL);
+        _mixer->stopAll();
 
         removeSounds();
         _activeSounds.clear();
@@ -134 +140 @@
 
 
 void SoundManager::loadSection(uint16 sectionId) {
+
         debugC(ERROR_BASIC, kLureDebugSounds, "SoundManager::loadSection = %xh", sectionId);
         killSounds();
+        if( sectionId==ROLAND_MAIN_SOUND_RESOURCE_ID || sectionId==ADLIB_MAIN_SOUND_RESOURCE_ID)
+        {
+                currentSection=1;
+        }
+        else
+        {
+                currentSection=0;
+        }
 
         if (_soundData) {
                 delete _soundData;
@@ -325 +340 @@
                         return rec;
                 }
         }
+        if(AudioCD.isPlaying())
+                {
+                        if(AudioCD.getStatus().track==soundNumber || AudioCD.getStatus().track+128==soundNumber)
+                        {
+                                SoundDescResource *rec=new SoundDescResource();
+                                rec->soundNumber=soundNumber;
+                                return rec;
+                        }
+                }
+                for (int channel = 0; channel < ARRAYSIZE(_sounds); ++channel) 
+                {
+                        if(_mixer->isSoundHandleActive(_sounds[channel].handle) && _sounds[channel].tracknumber==soundNumber)
+                        {
+                                SoundDescResource *rec=new SoundDescResource();
+                                rec->soundNumber=soundNumber;
+                                rec->channel=channel;
+                                return rec;
+                        }
+                }
 
         // Signal that sound wasn't found
         debugC(ERROR_INTERMEDIATE, kLureDebugSounds, "SoundManager::findSound - sound not found");
@@ -364 +398 @@
 
                 ++i;
         }
+        _mixer->pauseAll(true);
+
 }
 
 void SoundManager::restoreSounds() {
@@ -382 +418 @@
 
                 ++i;
         }
+        _mixer->pauseAll(false);
 }
 
 void SoundManager::fadeOut() {
         debugC(ERROR_BASIC, kLureDebugSounds, "SoundManager::fadeOut");
 
         // Fade out all the active sounds
-        musicInterface_TidySounds();
 
         bool inProgress = true;
         while (inProgress)
@@ -421 +457 @@
 void SoundManager::musicInterface_Play(uint8 soundNumber, uint8 channelNumber, uint8 numChannels) {
         debugC(ERROR_INTERMEDIATE, kLureDebugSounds, "musicInterface_Play soundNumber=%d, channel=%d",
                 soundNumber, channelNumber);
+
+        bool foundDigital=false;
+
+        uint8 sn=soundNumber;
+        if(currentSection!=0) sn+=10;
+        bool isMusic = (sn & 0x80)!= 0;
+        while(sn>127)
+        {
+                sn-=128;
+        }
+        uint8 soundNum = soundNumber & 0x7f;
+
+
+        debugC(ERROR_DETAILED, kLureDebugSounds, "MidiMusic::PlayMusic playing sound %d", soundNumber);
+        /*if(isMusic)
+        {
+                //if its music I'm going to try to play it using the audiocd player
+                AudioCD.stop();
+                AudioCD.play(sn,1,0,0);
+                if(AudioCD.isPlaying()) foundDigital=true;
+        }
+        else
+        {*/
+                //if it isn't then it must be sfx so I want to play it through digital audio instead.
+                //I'm using 4 channels here which I'm assuming is overkill but I'm guessing
+
+                char trackName[16];
+                sprintf(trackName, "track%d", sn);
+
+                _mixer->stopHandle(_sounds[channelNumber].handle);
+                _sounds[channelNumber].tracknumber=-1;
+
+                _sounds[channelNumber].stream =0;
+                bool loops=false;
+                if(soundNumber==153) loops=true;
+                _sounds[channelNumber].stream = Audio::SeekableAudioStream::openStreamFile(trackName);
+                if (_sounds[channelNumber].stream != 0) {
+                        //found a channel - play the fx
+                        Audio::Timestamp start = Audio::Timestamp(0, 0, 75);
+                        Audio::Timestamp end = 0 ? Audio::Timestamp(0, 0 + 0, 75) : _sounds[channelNumber].stream->getLength();
+
+                        _mixer->playStream(Audio::Mixer::kSFXSoundType, &_sounds[channelNumber].handle,
+                                Audio::makeLoopingAudioStream(_sounds[channelNumber].stream,start ,end , (loops) ? 0 : 1));
+                        _sounds[channelNumber].tracknumber=soundNumber;
+                        foundDigital=true;
+                } 
+//      }
+        if(foundDigital) return;
+
+
+
+
         Game &game = Game::getReference();
 
         if (!_soundData)
                 error("Sound section has not been specified");
 
-        uint8 soundNum = soundNumber & 0x7f;
         if (soundNum > _soundsTotal)
                 error("Invalid sound index %d requested", soundNum);
 
@@ -434 +521 @@
                 // Only play sounds if a sound driver is active
                 return;
 
-        bool isMusic = (soundNumber & 0x80) != 0;
-
         if (!game.soundFlag())
                 // Don't play sounds if sound is turned off
                 return;
@@ -466 +551 @@
         musicInterface_TidySounds();
         uint8 soundNum = soundNumber & 0x7f;
 
+        if(AudioCD.getStatus().track==soundNumber) AudioCD.stop();
+        if(AudioCD.getStatus().track+128==soundNumber) AudioCD.stop();
+
+        for (int channel = 0; channel < ARRAYSIZE(_sounds); ++channel) 
+        {
+                if (_sounds[channel].tracknumber==soundNumber) 
+                {
+                        _mixer->stopHandle(_sounds[channel].handle);
+                        _sounds[channel].tracknumber=-1;
+                }
+        }
+
         g_system->lockMutex(_soundMutex);
         MusicListIterator i;
         for (i = _playingSounds.begin(); i != _playingSounds.end(); ++i) {
@@ -498 +595 @@
         }
         g_system->unlockMutex(_soundMutex);
 
+        if(AudioCD.isPlaying() && (AudioCD.getStatus().track==soundNumber||AudioCD.getStatus().track+128==soundNumber))
+        {
+                result=true;
+        }
+        for (int channel = 0; channel < ARRAYSIZE(_sounds); ++channel) 
+        {
+                if(_sounds[channel].tracknumber==soundNumber && _mixer->isSoundHandleActive(_sounds[channel].handle) )
+                {
+                        result=true;
+                }
+        }
         return result;
 }
 
@@ -517 +625 @@
                         music->setVolume(volume);
         }
         g_system->unlockMutex(_soundMutex);
+
+        if(_mixer->isSoundHandleActive(_sounds[channelNum].handle) )
+        {
+                _mixer->setChannelVolume(_sounds[channelNum].handle, volume);
+        }
+
+
 }
 
 // musicInterface_KillAll
@@ -532 +647 @@
                 MidiMusic *music = (*i).get();
                 music->stopMusic();
         }
+        AudioCD.stop();
 
+        for (int channel = 0; channel < ARRAYSIZE(_sounds); ++channel) 
+        {
+                _mixer->stopHandle(_sounds[channel].handle);
+                _sounds[channel].tracknumber=-1;
+        }
+
         _playingSounds.clear();
         _activeSounds.clear();
         g_system->unlockMutex(_soundMutex);
@@ -680 +802 @@
 }
 
 void MidiMusic::playMusic() {
-        debugC(ERROR_DETAILED, kLureDebugSounds, "MidiMusic::PlayMusic playing sound %d", _soundNumber);
-        _parser->loadMusic(_soundData, _soundSize);
-        _parser->setTrack(0);
+                _parser->loadMusic(_soundData, _soundSize);
+                _parser->setTrack(0);
         _isPlaying = true;
 }
 

engines/lure/sound.h

@@ -68 +68 @@
 
         bool _passThrough;
 
+
 public:
         MidiMusic(MidiDriver *driver, ChannelEntry channels[NUM_CHANNELS],
                  uint8 channelNum, uint8 soundNum, bool isMus, uint8 numChannels, void *soundData, uint32 size);
@@ -128 +129 @@
         Common::MutexRef _soundMutex;
         bool _paused;
 
+        Audio::Mixer *_mixer;
+
+        struct SoundFX {
+                Audio::SoundHandle handle;
+
+                int tracknumber;
+                Audio::SeekableAudioStream *stream;
+        } _sounds[16];
+
+
         uint _musicVolume;
         uint _sfxVolume;
 
@@ -175 +186 @@
         void musicInterface_KillAll();
         void musicInterface_ContinuePlaying();
         void musicInterface_TrashReverb();
+        int currentSection;
 };
 
 } // End of namespace Lure

engines/m4/midi.cpp

@@ -29 +29 @@
 #include "m4/m4.h"
 #include "m4/midi.h"
 #include "common/stream.h"
+#include "sound/audiocd.h"
 
 namespace M4 {
 
@@ -145 +146 @@
 
 void MidiPlayer::playMusic(const char *name, int32 vol, bool loop, int32 trigger, int32 scene) {
         stopMusic();
+        AudioCD.stop();
 
         char fullname[144];
         _vm->res()->changeExtension(fullname, name, "HMP");
@@ -159 +161 @@
         _vm->res()->toss(fullname);
         _vm->res()->purge();
 
-        if (_midiData) {
+        //support for CD Audio - not very efficient but just need to add a list of filenames for each game
+        //should really use game check also in case of duplicate file names but won't be an issue
+        //unless someone dumps a load of music into the game directory
+
+        char* nameArray[]={"name1","name2"};
+        for(int a=0;a<sizeof(nameArray);a++)
+        {
+                if(nameArray[a]==name) AudioCD.play(a,loop?-1:1,0,0); 
+        }
+
+        if (_midiData && !AudioCD.isPlaying()) {
                 /*
                 FILE *out = fopen("music.mid", "wb");
                 fwrite(_midiData, smfSize, 1, out);
@@ -176 +188 @@
 
 void MidiPlayer::stopMusic() {
         Common::StackLock lock(_mutex);
+        AudioCD.stop();
 
         _isPlaying = false;
         if (_parser) {

engines/made/music.cpp

@@ -1 @@
-/* ScummVM - Graphic Adventure Engine
+ /* ScummVM - Graphic Adventure Engine
  *
  * ScummVM is the legal property of its developers, whose names
  * are too numerous to list here. Please refer to the COPYRIGHT
@@ -34 +34 @@
 #include "common/file.h"
 
 #include "made/music.h"
+#include "sound/audiocd.h"
 
 namespace Made {
 
@@ -202 +203 @@
 }
 
 void MusicPlayer::stop() {
+        AudioCD.stop();
         Common::StackLock lock(_mutex);
 
         _isPlaying = false;
@@ -212 +214 @@
 }
 
 void MusicPlayer::pause() {
+        AudioCD.stop();
         setVolume(-1);
         _isPlaying = false;
 }

engines/made/scriptfuncs.cpp

@@ -273 +273 @@
 
         if (_vm->getGameID() == GID_RTZ) {
                 if (musicNum > 0) {
+
                         _musicRes = _vm->_res->getXmidi(musicNum);
                         if (_musicRes)
-                                _vm->_music->playXMIDI(_musicRes);
+                        {
+                                //AudioCD.stop();
+                /*      int loops[50]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
+                //              AudioCD.play(musicNum,loops[musicNum],0,0);
+                                //if(!AudioCD.isPlaying()) */
+                                        _vm->_music->playXMIDI(_musicRes);
+                        }
+
                 }
         } else {
                 // HACK: music number 2 in LGOP2 is file MT32SET.TON, which
@@ -287 +299 @@
                         return 0;
                 if (musicNum > 0) {
                         _musicRes = _vm->_res->getMidi(musicNum);
-                        if (_musicRes)
-                                _vm->_music->playSMF(_musicRes);
+                        if (_musicRes) {
+                                if(AudioCD.getStatus().track!=musicNum)
+                                {
+                                        AudioCD.stop();
+                                        int loops[50]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+                                                        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
+                                        AudioCD.play(musicNum,loops[musicNum],0,0);
+                                }
+                                if(!AudioCD.isPlaying()) _vm->_music->playSMF(_musicRes);
+                        }
                 }
         }
 

engines/saga/music.cpp

@@ -286 +286 @@
         } else {
                 realTrackNumber = resourceId + 1;
         }
+        if (_vm->getGameId() == GID_IHNM) {
+                        flags = MUSIC_LOOP;
+        }
 
         // Try to open standalone digital track
         char trackName[2][16];

engines/sci/sound/midiparser_sci.cpp

@@ -563 +563 @@
         case 0x9:
         case 0xA:
         case 0xE:
+                if(_pSnd->playSilent) info.event = info.channel() | 0x80;
                 info.basic.param1 = *(_position._play_pos++);
                 info.basic.param2 = *(_position._play_pos++);
                 if (info.command() == 0x9 && info.basic.param2 == 0)

engines/sci/sound/music.cpp

@@ -35 +35 @@
 #include "sci/engine/state.h"
 #include "sci/sound/midiparser_sci.h"
 #include "sci/sound/music.h"
+#include "sound/audiocd.h"
 
 namespace Sci {
 
@@ -256 +257 @@
                 if (track->digitalChannelNr != -1) {
                         byte *channelData = track->channels[track->digitalChannelNr].data;
                         delete pSnd->pStreamAud;
+                        delete pSnd->pStreamAud2;
                         byte flags = Audio::FLAG_UNSIGNED;
                         // Amiga SCI1 games had signed sound data
                         if (_soundVersion >= SCI_VERSION_1_EARLY && g_sci->getPlatform() == Common::kPlatformAmiga)
@@ -265 +267 @@
                                                                 track->digitalSampleSize - track->digitalSampleStart - endPart, 
                                                                 track->digitalSampleRate, flags, DisposeAfterUse::NO);
                         delete pSnd->pLoopStream;
+                        delete pSnd->pLoopStream2;
+                        pSnd->pLoopStream2=0;
                         pSnd->pLoopStream = 0;
                         pSnd->soundType = Audio::Mixer::kSFXSoundType;
                         pSnd->hCurrentAud = Audio::SoundHandle();
@@ -329 +333 @@
 }
 
 void SciMusic::soundPlay(MusicEntry *pSnd) {
+
         _mutex.lock();
 
         uint playListCount = _playList.size();
@@ -368 +373 @@
                 }
         }
 
+                
+        //Attempt to play using AudioCD sound
+        //If the CD Audio isn't already going then play with audiocd
+        pSnd->playSilent=false;
+        /*if(!AudioCD.isPlaying())
+        {
+                AudioCD.play(pSnd->resourceId,pSnd->loop,0,0);
+                if(AudioCD.isPlaying()) pSnd->playSilent=true;
+        }
+        else
+        {*/
+                //if its not priority 1 then try to play digitally as a sound effect
+                //I'm going to piggyback the existing audio functions and make my ogg behave like a SCI digital resource thus avoiding me doing any work....
+                char trackName[16];
+                sprintf(trackName, "track%d", pSnd->resourceId);
+                Audio::SeekableAudioStream *_cdSoundStream;
+                if(pSnd->status==kSoundPaused)
+                {
+                        _pMixer->pauseHandle(pSnd->hCurrentAud2,false); 
+                        pSnd->playSilent=true;
+                }
+                if(!_pMixer->isSoundHandleActive(pSnd->hCurrentAud2))
+                {
+                        if(_cdSoundStream=Audio::SeekableAudioStream::openStreamFile(trackName))
+                        {
+        
+                                pSnd->length=_cdSoundStream->getLength().msecs();
+                                pSnd->pStreamAud2 = _cdSoundStream;
+                                                if (pSnd->loop > 1) {
+                                pSnd->pLoopStream2 = new Audio::LoopingAudioStream(pSnd->pStreamAud2,
+                                                                                                                                pSnd->loop, DisposeAfterUse::NO
+                                                                                                                                );
+                                _pMixer->playStream(pSnd->soundType, &pSnd->hCurrentAud2,
+                                                                                pSnd->pLoopStream2, -1, pSnd->volume*2, 0,
+                                                                                DisposeAfterUse::NO);
+                        } else {
+                                _pMixer->playStream(pSnd->soundType, &pSnd->hCurrentAud2,
+                                        pSnd->pStreamAud2, -1, pSnd->volume*2, 0,
+                                                                                DisposeAfterUse::NO);
+                        }
+                                        //_pMidiDrv->setVolume(vol);
+                        pSnd->playSilent=true;
+                        }
+                }
+        //}
         if (pSnd->pStreamAud) {
                 if (!_pMixer->isSoundHandleActive(pSnd->hCurrentAud)) {
                         // Sierra SCI ignores volume set when playing samples via kDoSound
@@ -411 +461 @@
 }
 
 void SciMusic::soundStop(MusicEntry *pSnd) {
+
+        if(pSnd&&pSnd->pStreamAud2)
+        {
+                int32 timeelapsed=_pMixer->getSoundElapsedTime(pSnd->hCurrentAud2);
+
+                if(pSnd->loop<=1&&pSnd->length-timeelapsed<4000&&_pMixer->isSoundHandleActive(pSnd->hCurrentAud2))
+                {
+                        return;
+                }
+                //checks to see if less than 4 seconds left in sample and carries on playing it if there are
+        }
         SoundStatus previousStatus = pSnd->status;
+        if(pSnd->resourceId==AudioCD.getStatus().track) AudioCD.stop();
         pSnd->status = kSoundStopped;
         if (_soundVersion <= SCI_VERSION_0_LATE)
                 pSnd->isQueued = false;
         if (pSnd->pStreamAud)
                 _pMixer->stopHandle(pSnd->hCurrentAud);
+        //if(_pMixer->getSoundElapsedTime(pSnd->hCurrentAud2)<pSnd->pStreamAud2->);
+        if (pSnd->pStreamAud2)
+                _pMixer->stopHandle(pSnd->hCurrentAud2);
 
         if (pSnd->pMidiParser) {
                 _mutex.lock();
@@ -438 +503 @@
         if (pSnd->pStreamAud) {
                 // we simply ignore volume changes for samples, because sierra sci also
                 //  doesn't support volume for samples via kDoSound
-        } else if (pSnd->pMidiParser) {
+        }
+        if (pSnd->pStreamAud2) {
+                _pMixer->setChannelVolume(pSnd->hCurrentAud2, volume * 2); // Mixer is 0-255, SCI is 0-127
+        }
+        if (pSnd->pMidiParser) {
                 _mutex.lock();
                 pSnd->pMidiParser->mainThreadBegin();
                 pSnd->pMidiParser->setVolume(volume);
@@ -481 +550 @@
                 delete pSnd->pLoopStream;
                 pSnd->pLoopStream = 0;
         }
+        if (pSnd->pStreamAud2) {
+                _pMixer->stopHandle(pSnd->hCurrentAud2);
+                delete pSnd->pStreamAud2;
+                pSnd->pStreamAud2 = NULL;
+                delete pSnd->pLoopStream2;
+                pSnd->pLoopStream2 = 0;
+        }
 
         _mutex.lock();
         uint sz = _playList.size(), i;
@@ -514 +590 @@
         pSnd->status = kSoundPaused;
         if (pSnd->pStreamAud) {
                 _pMixer->pauseHandle(pSnd->hCurrentAud, true);
-        } else {
-                if (pSnd->pMidiParser) {
+        } else
+        {
+        if (pSnd->pStreamAud2) {
+                _pMixer->pauseHandle(pSnd->hCurrentAud2, true);
+        }
+        if (pSnd->pMidiParser) {
                         _mutex.lock();
                         pSnd->pMidiParser->mainThreadBegin();
                         pSnd->pMidiParser->pause();
@@ -536 +616 @@
         if (pSnd->pStreamAud) {
                 _pMixer->pauseHandle(pSnd->hCurrentAud, false);
                 pSnd->status = kSoundPlaying;
-        } else {
+        } else 
+        {
+        if (pSnd->pStreamAud2) {
+                _pMixer->pauseHandle(pSnd->hCurrentAud2, false);
+                pSnd->status = kSoundPlaying;
+        }else {
                 soundPlay(pSnd);
-        }
+        }}
 }
 
 void SciMusic::soundToggle(MusicEntry *pSnd, bool pause) {
@@ -665 +750 @@
         soundType = Audio::Mixer::kMusicSoundType;
 
         pStreamAud = 0;
+        pStreamAud2 = 0;
         pLoopStream = 0;
+        pLoopStream2 = 0;
         pMidiParser = 0;
 }
 
@@ -706 +793 @@
                         fadeStep = 0;
                         fadeCompleted = true;
                 }
-
+                
                 // Only process MIDI streams in this thread, not digital sound effects
                 if (pMidiParser) {
                         pMidiParser->setVolume(volume);

engines/sci/sound/music.h

@@ -87 +87 @@
         bool fadeSetVolume;
         bool fadeCompleted;
         bool stopAfterFading;
+        bool playSilent;
+        uint32 length;
 
         SoundStatus status;
 
@@ -105 +107 @@
         Audio::LoopingAudioStream *pLoopStream;
         Audio::SoundHandle hCurrentAud;
 
+
+        Audio::RewindableAudioStream *pStreamAud2;
+        Audio::LoopingAudioStream *pLoopStream2;
+        Audio::SoundHandle hCurrentAud2;
+
 public:
         MusicEntry();
         ~MusicEntry();
@@ -164 +171 @@
         }
 
         void updateAudioStreamTicker(MusicEntry *pSnd) {
-                assert(pSnd->pStreamAud != 0);
-                pSnd->ticker = (uint16)(_pMixer->getSoundElapsedTime(pSnd->hCurrentAud) * 0.06);
+                
+                if(pSnd->pStreamAud) pSnd->ticker = (uint16)(_pMixer->getSoundElapsedTime(pSnd->hCurrentAud) * 0.06);
+                if(pSnd->pStreamAud2) pSnd->ticker = (uint16)(_pMixer->getSoundElapsedTime(pSnd->hCurrentAud2) * 0.06);
         }
 
         MusicEntry *getSlot(reg_t obj);

engines/sci/sound/soundcmd.cpp

@@ -411 +411 @@
                         musicSlot->fadeSetVolume = false;
                 }
         } else if (musicSlot->pMidiParser) {
+
+                if(     musicSlot->pStreamAud2&&musicSlot->fadeSetVolume)
+                {
+                        _music->soundSetVolume(musicSlot, musicSlot->volume);
+                        musicSlot->fadeSetVolume = false;
+                }               
                 // Update MIDI slots
                 if (musicSlot->signal == 0) {
                         if (musicSlot->dataInc != readSelectorValue(_segMan, obj, SELECTOR(dataInc))) {

engines/scumm/imuse/imuse.cpp

@@ -575 +575 @@
         // to bug #780918.
 
         int i;
+
+        //HACK - I'm adding 99999 to the sound integer if its one I don't want to actually hear so I test for this here
+        bool dontplayme=false;
+        if(sound>99999)
+        {
+                sound-=99999;
+                dontplayme=true;
+        }
+
         ImTrigger *trigger = _snm_triggers;
         for (i = ARRAYSIZE(_snm_triggers); i; --i, ++trigger) {
                 if (trigger->sound && trigger->id && trigger->command[0] == 8 && trigger->command[1] == sound && getSoundStatus_internal (trigger->sound,true))
@@ -606 +615 @@
         if (!player)
                 return false;
 
+
         // WORKAROUND: This is to work around a problem at the Dino Bungie
         // Memorial.
         //
@@ -636 +646 @@
 
         player->clear();
         player->setOffsetNote(offset);
+        if(dontplayme) sound+=99999;
         return player->startSound(sound, driver, _direct_passthrough);
 }
 

engines/scumm/imuse/imuse_player.cpp

@@ -97 +97 @@
         void *ptr;
         int i;
 
+
+        //HACK - I'm adding 99999 to the sound integer if its one I don't want to actually hear so I test for this here
+        bool dontplayme=false;
+        if(sound>99999)
+        {
+                sound-=99999;
+                dontplayme=true;
+        }
+
         // Not sure what the old code was doing,
         // but we'll go ahead and do a similar check.
         ptr = _se->findStartOfSound(sound);
@@ -122 +131 @@
         _passThrough = passThrough;
 
         for (i = 0; i < ARRAYSIZE(_parameterFaders); ++i)
+        {
                 _parameterFaders[i].init();
+        }
         hook_clear();
-
+    if(dontplayme) sound+=99999;
         if (start_seq_sound(sound) != 0) {
                 _active = false;
                 _midi = NULL;
@@ -173 +184 @@
 }
 
 int Player::start_seq_sound(int sound, bool reset_vars) {
+        
+        //HACK - I'm adding 99999 to the sound integer if its one I don't want to actually hear so I test for this here
+        bool dontplayme=false;
+        if(sound>99999)
+        {
+                sound-=99999;
+                dontplayme=true;
+        }
+
         byte *ptr;
-
         if (reset_vars) {
                 _loop_to_beat = 1;
                 _loop_from_beat = 1;
@@ -204 +223 @@
         _parser->property(MidiParser::mpSmartJump, 1);
         _parser->loadMusic(ptr, 0);
         _parser->setTrack(_track_index);
+        if(dontplayme) _parser->_dontplayme=true;
+
+                
         setSpeed(reset_vars ? 128 : _speed);
 
         return 0;

engines/scumm/saveload.cpp

@@ -471 +471 @@
                 putState(819, 0);
         }
 
+
+        //HACK to stop adlib sound playing if cd audio patch is working
+        if (_game.id == GID_MONKEY_VGA && AudioCD.isPlaying()) {
+                int track=AudioCD.getStatus().track;
+                int numloops=AudioCD.getStatus().numLoops;
+                int currentcdsound=_sound->getCurrentCDSound();
+                _sound->stopAllSounds();
+                _sound->pauseSounds(false);
+                _sound->playCDTrack(track,numloops,0,0);
+                _sound->pauseSounds(true);
+                //_sound->_currentCDSound=currentcdsound;
+        }
+
+        if(_game.platform == Common::kPlatformPC && _game.version == 0x03 && _game.id == GID_LOOM)
+        {
+                int numloops=AudioCD.getStatus().numLoops;
+                int currentcdsound=_sound->getCurrentCDSound();
+                _sound->stopAllSounds();
+                _sound->pauseSounds(false);
+                _sound->playCDTrack(currentcdsound-32,numloops,0,0);
+                _sound->pauseSounds(true);
+                //_sound->_currentCDSound=currentcdsound;
+        }
+
         if (hdr.ver < VER(33) && _game.version >= 7) {
                 // For a long time, we didn't set these vars to default values.
                 VAR(VAR_DEFAULT_TALK_DELAY) = 60;
@@ -574 +598 @@
 
         _sound->pauseSounds(false);
 
+
         // WORKAROUND: Original save/load script ran this script
         // after game load, and o2_loadRoomWithEgo() does as well
         // this script starts character-dependent music

engines/scumm/scumm.cpp

@@ -1705 +1705 @@
                 break;
         }
 
+        //HACK to get the adlib version of Loom PC EGA to use the MT32 midi's.
+
+        if(_game.version == 3 && _game.platform == Common::kPlatformPC && _game.id== GID_LOOM)
+                _musicType = MDT_MIDI;
+
+
+
         if ((_game.id == GID_MONKEY_EGA || (_game.id == GID_LOOM && _game.version == 3))
            &&  (_game.platform == Common::kPlatformPC) && _musicType == MDT_MIDI) {
                 Common::String fileName;

engines/scumm/sound.cpp

@@ -168 +168 @@
         Audio::AudioStream *stream;
         int size = -1;
         int rate;
+        bool foundatrack=false;
 
         if (_vm->_game.id == GID_LOOM && _vm->_game.platform == Common::kPlatformPCEngine) {
                 if (soundID >= 13 && soundID <= 32) {
@@ -410 +411 @@
 
                 if (_vm->_game.id == GID_MONKEY_VGA || _vm->_game.id == GID_MONKEY_EGA
                         || (_vm->_game.id == GID_MONKEY && _vm->_game.platform == Common::kPlatformMacintosh)) {
+                        if (_vm->_game.id == GID_MONKEY_VGA)
+                        {
+                                static const int tracks[20]={0x0000006e,0x0000006c,0x00000068,0x00000065,0x00000064,0x00000073,0x00000097,0x00000070,0x00000072,0x00000071,0x00000067,0x00000066,0x00000069,0x0000006a,0x0000006b,0x0000006d,0x0000006f,0x00000074,0x00000075,0x00000076};
+                                static const int loop[20]={1,-1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,-1,-1,-1,1,-1};
+                                for (int a=0;a<20;a++)
+                                {
+        
+                                        if(soundID==tracks[a]) 
+                                        {       
+                                                playCDTrack(a+1,loop[a],0,0);
+                                                stopCDTimer();
+                                                foundatrack=true;
+                                                _currentCDSound=soundID;
+                                        }
+                                }
+                        }
+
                         // Works around the fact that in some places in MonkeyEGA/VGA,
                         // the music is never explicitly stopped.
                         // Rather it seems that starting a new music is supposed to
@@ -419 +437 @@
                                         _vm->_imuse->stopAllSounds();
                         }
                 }
+                else if(_vm->_game.platform == Common::kPlatformPC && _vm->_game.version == 0x03 && _vm->_game.id == GID_LOOM)
+                {
+                        int loop=1;
+                        if(soundID-32==11||soundID-32==31) loop=-1;
+                        if(soundID<133) 
+                        {
+                                playCDTrack(soundID-32,loop,0,0);
+                                stopCDTimer();
+                                foundatrack=true;
+                                _currentCDSound=soundID;
+                        }
+                }
 
                 if (_vm->_musicEngine) {
+                        if(foundatrack) soundID+=99999;
                         _vm->_musicEngine->startSound(soundID);
+
                 }
 
                 if (_vm->_townsPlayer)

engines/touche/resource.cpp

@@ -32 +32 @@
 #include "sound/decoders/vorbis.h"
 #include "sound/decoders/raw.h"
 #include "sound/audiostream.h"
+#include "sound/audiocd.h"
 
 #include "touche/midi.h"
 #include "touche/touche.h"
@@ -600 +601 @@
 }
 
 void ToucheEngine::res_loadMusic(int num) {
+        //dont loop 17,19,20,24
+        int loops=-1;
+        if(num==17 || num==19 || num==20 || num == 24) loops=1;
+        AudioCD.stop();
+        AudioCD.play(num,loops,0,0);
+        if(AudioCD.isPlaying()) return;
+
         debugC(9, kDebugResource, "ToucheEngine::res_loadMusic() num=%d", num);
         uint32 size;
         const uint32 offs = res_getDataOffset(kResourceTypeMusic, num, &size);

sound/midiparser.cpp

@@ -48 +48 @@
 _abort_parse(0) {
         memset(_active_notes, 0, sizeof(_active_notes));
         _next_event.start = NULL;
+_dontplayme=false;
         _next_event.delta = 0;
         _next_event.event = 0;
         _next_event.length = 0;
@@ -161 +162 @@
 void MidiParser::onTimer() {
         uint32 end_time;
         uint32 event_time;
-
         if (!_position._play_pos || !_driver)
                 return;
 
@@ -228 +228 @@
                         }
                         _driver->metaEvent(info.ext.type, info.ext.data, (uint16)info.length);
                 } else {
-                        if (info.command() == 0x8) {
+                        if (info.command() == 0x8 ) {
                                 activeNote(info.channel(), info.basic.param1, false);
                         } else if (info.command() == 0x9) {
                                 if (info.length > 0)
                                         hangingNote(info.channel(), info.basic.param1, info.length * _psec_per_tick - (end_time - event_time));
                                 else
                                         activeNote(info.channel(), info.basic.param1, true);
+                        }                       
+                        if(!_dontplayme)
+                        {
+                                sendToDriver(info.event, info.basic.param1, info.basic.param2);
                         }
-                        sendToDriver(info.event, info.basic.param1, info.basic.param2);
                 }
 
 
@@ -250 +253 @@
                 _position._play_time = end_time;
                 _position._play_tick = (_position._play_time - _position._last_event_time) / _psec_per_tick + _position._last_event_tick;
         }
+
 }
 
 void MidiParser::allNotesOff() {

sound/midiparser.h

@@ -363 +363 @@
                  */
                 mpCenterPitchWheelOnUnload = 4
         };
+        bool _dontplayme;
 
 public:
         typedef void (*XMidiCallbackProc)(byte eventData, void *refCon);

sound/mixer.h

@@ -68 +68 @@
 
                 kMusicSoundType = 1,
                 kSFXSoundType = 2,
-                kSpeechSoundType = 3
+                kSpeechSoundType = 3,
         };
 
         enum {