Ticket #8241: loom-adlib-sound.diff

scumm/resource.cpp

@@ -642 +642 @@
         _fileHandle.seek(fileOffs + _fileOffset, SEEK_SET);
 
         if (_features & GF_OLD_BUNDLE) {
-                size = _fileHandle.readUint16LE();
-                _fileHandle.seek(-2, SEEK_CUR);
+                if ((_features & GF_AFTER_V3)
+                    && type == rtSound) {
+                        return readSoundResourceSmallHeader(type, idx);
+                } else {
+                        size = _fileHandle.readUint16LE();
+                        _fileHandle.seek(-2, SEEK_CUR);
+                }
         } else if (_features & GF_SMALL_HEADER) {
                 if (!(_features & GF_SMALL_NAMES))
                         _fileHandle.seek(8, SEEK_CUR);
@@ -979 +984 @@
 
 int Scumm::readSoundResourceSmallHeader(int type, int idx) {
         uint32 pos, total_size, size, dw, tag;
-        uint32 best_size = 0, best_offs = 0;
+        uint32 ad_size = 0, ad_offs = 0;
+        uint32 wa_size = 0, wa_offs = 0;
 
         debug(4, "readSoundResourceSmallHeader(%s,%d)", resTypeFromId(type), idx);
 
         //if (_rescache->readResource(roomNr, type, idx))
         //              return 1;
 
-        total_size = size = _fileHandle.readUint32LE();
-        tag = _fileHandle.readUint16LE();
-        debug(4, "  tag='%c%c', size=%d",
-                                        (char) (tag & 0xff),
-                                        (char) ((tag >> 8) & 0xff), size);
-
-        pos = 6;
-        while (pos < total_size) {
-                size = _fileHandle.readUint32LE();
+        if ((_features & GF_OLD_BUNDLE)) {
+                wa_offs = _fileHandle.pos();
+                wa_size = _fileHandle.readUint16LE();
+                _fileHandle.seek(wa_size - 2, SEEK_CUR);
+                ad_offs = _fileHandle.pos();
+                ad_size = _fileHandle.readUint16LE();
+                _fileHandle.seek(4, SEEK_CUR);
+                total_size = wa_size + ad_size;
+        } else {
+                total_size = size = _fileHandle.readUint32LE();
                 tag = _fileHandle.readUint16LE();
                 debug(4, "  tag='%c%c', size=%d",
-                                        (char) (tag & 0xff),
-                                        (char) ((tag >> 8) & 0xff), size);
-                pos += size;
-
-                // MI1 and Indy3 uses one or more nested SO resources, which contains AD and WA
-                // resources.
-                if ((tag == 0x4441) && !(best_offs)) { // AD
-                                best_size = size;
-                                best_offs = _fileHandle.pos();
-                } else { // other AD, WA and nested SO resources
-                        if (tag == 0x4F53) {
-                                pos -= size;
-                                size = 6;
-                                pos += 6;
+                      (char) (tag & 0xff),
+                      (char) ((tag >> 8) & 0xff), size);
+                
+                pos = 6;
+                while (pos < total_size) {
+                        size = _fileHandle.readUint32LE();
+                        tag = _fileHandle.readUint16LE();
+                        debug(4, "  tag='%c%c', size=%d",
+                              (char) (tag & 0xff),
+                              (char) ((tag >> 8) & 0xff), size);
+                        pos += size;
+                        
+                        // MI1 and Indy3 uses one or more nested SO resources, which contains AD and WA
+                        // resources.
+                        if ((tag == 0x4441) && !(ad_offs)) { // AD
+                                ad_size = size;
+                                ad_offs = _fileHandle.pos() - 6;
+                        } else if ((tag == 0x4157) && !(wa_offs)) { // WA
+                                wa_size = size;
+                                wa_offs = _fileHandle.pos() - 6;
+                        } else { // other AD, WA and nested SO resources
+                                if (tag == 0x4F53) { // SO
+                                        pos -= size;
+                                        size = 6;
+                                        pos += 6;
+                                }
                         }
+                        _fileHandle.seek(size - 6, SEEK_CUR);
                 }
-                _fileHandle.seek(size - 6, SEEK_CUR);
         }
-
+                
         // AD resources have a header, instrument definitions and one MIDI track.
         // We build an 'ADL ' resource from that:
         //   8 bytes resource header
@@ -1028 +1047 @@
         //        - proper handling of the short (non-music, SFX) AD resources format
         //        - check the LE/BE handling for platforms other than PC
 
-        if (best_offs != 0) {
+        if (ad_offs != 0) {
                 byte *ptr, *track, *instr;
                 byte ticks, play_once;
                 byte music_type, num_instr;
 
-                _fileHandle.seek(best_offs - 6, SEEK_SET);
+                _fileHandle.seek(ad_offs, SEEK_SET);
+
+                ptr = createResource(type, idx, ad_size);
+                _fileHandle.read(ptr, ad_size);
+                size = ad_size;
+
+                if ((_features & GF_OLD_BUNDLE)) {
+                        ptr += 4;
+                        size -= 4;
+                } else {
+                        ptr += 6;
+                        size -= 6;
+                }
+                hexdump(ptr, size);
 
-                ptr = createResource(type, idx, best_size);
-                _fileHandle.read(ptr, best_size);
 
-                music_type = *(ptr + 8);        // 0x80: is music; otherwise not.
+                music_type = *(ptr + 2);        // 0x80: is music; otherwise not.
                 
                 if (music_type != 0x80) {
                         // It's an SFX; we don't know how to handle those yet
@@ -1049 +1079 @@
                 }
                 
                 // The "speed" of the song
-                ticks = *(ptr + 9);
+                ticks = *(ptr + 3);
                 
                 // Flag that tells us whether we should loop the song (0) or play it only once (1)
-                play_once = *(ptr + 10);
+                play_once = *(ptr + 4);
                 
                 // Number of instruments used
-                num_instr = *(ptr + 16);        // Normally 8
+                num_instr = *(ptr + 10);        // Normally 8
                 if (num_instr != 8)
                         warning("Sound %d has %d instruments, expected 8", idx, num_instr);
 
                 // copy the instrument data in another memory area
                 instr = (byte *)calloc(8 * 16, 1);
                 assert(instr);
-                memcpy(instr, ptr + 0x19, 8*16);
+                memcpy(instr, ptr + 0x13, 8*16);
 
                 // skip over the rest of the header and copy the MIDI data into a buffer
-                size = best_size;
-                ptr  += 0x19 + 8 * 16;
-                size -= 0x19 + 8 * 16;
+                ptr  += 0x13 + 8 * 16;
+                size -= 0x13 + 8 * 16;
                 CHECK_HEAP 
                 track = (byte *)calloc(size, 1);
                 if (track == NULL) {

scumm/scummvm.cpp

@@ -602 +602 @@
                 _imuseDigital = new IMuseDigital(this);
                 _imuse = NULL;
                 _playerV2 = NULL;
-        } else if ((_features & GF_OLD_BUNDLE) && !(_features & GF_AMIGA)) {
+        } else if ((_features & GF_OLD_BUNDLE) && !(_features & GF_AMIGA)
+                   && !(_features & GF_AFTER_V3) /* hack to make loom use imuse*/) {
                 _playerV2 = NULL;
                 if (!(_features & GF_AMIGA))
                         _playerV2 = new Player_V2(this);

scumm/sound.cpp

@@ -390 +390 @@
         
         }
         
-        if (_scumm->_features & GF_OLD_BUNDLE) {
+        if ((_scumm->_features & GF_OLD_BUNDLE)
+            && (_scumm->_features & GF_AFTER_V2)) {
                 // FIXME: support amiga sounds
                 uint16 amigatest;
                 amigatest = READ_LE_UINT16(ptr + 12);