Ticket #9358: compress_sci_raw_audio.patch

engines/sci/compress_sci.cpp

@@ -58 +58 @@
 
         _outputToDirectory = false;
 
-        _shorthelp = "Used to compress Sierra resource.aud/resource.sfx files. (NOT SCI32 compatible!)";
+        _shorthelp = "Used to compress Sierra resource.aud/.sfx and AUDIO001.002 files. (NOT SCI32 compatible!)";
         _helptext = "\nUsage: " + getName() + " [mode-params] [-o outputname] <inputname>\n";
 }
 
 // header is first 6 bytes read from file
 SciResourceDataType CompressSci::detectData(byte *header, bool compressMode) {
-        byte buffer[20];
         uint32 dataSize;
+        if (_rawAudio) {
+                // File is a raw audio file
+                dataSize = _rawAudioMap[_inputOffset];
+                _inputEndOffset = _inputOffset + dataSize;
+                return kSciResourceDataTypeRaw;
+        }
+        byte buffer[20];
         memcpy(&buffer, header, 6);
         if ((memcmp(buffer + 1, "RIFF", 4) == 0) || (memcmp(buffer + 1, "\x8d\x0bSOL", 4) == 0)) {
                 // Fixup for pharkas resource.sfx, several WAVE files contain a size thats not right (-1 byte)
@@ -220 +226 @@
 void CompressSci::compressData(SciResourceDataType dataType) {
         int orgDataSize = _inputEndOffset - _inputOffset;
         int newDataSize = 0;
-        byte *orgData = new byte[orgDataSize];
         byte *newData = 0;
 
         int sampleRate = 0;
@@ -230 +235 @@
         uint8 sampleBits = 8;
         byte sampleFlags = 0;
 
-        if (!orgData)
-                error("malloc error");
-
         switch (dataType) {
         case kSciResourceDataTypeWAVE:
                 print("WAVE found\n");
@@ -281 +283 @@
                 }
                 break;
         }
+        case kSciResourceDataTypeRaw:
+                sampleRate = 11025;
+                // No headers so just use the original data as sample data
+                sampleDataSize = orgDataSize;
+                sampleData = new byte[sampleDataSize];
+                if (!sampleData)
+                        error("malloc error");
+                _input.read_throwsOnError(sampleData, sampleDataSize);
+                break;
         case kSciResourceTypeTypeSync:
                 print("SYNC found at %lx\n", _inputOffset);
                 // Simply copy original data over
-                _input.read_throwsOnError(orgData, orgDataSize);
-                newData = orgData;
                 newDataSize = orgDataSize;
+                newData = new byte[newDataSize];
+                if (!newData)
+                        error("malloc error");
+                _input.read_throwsOnError(newData, newDataSize);
                 break;
         default:
                 error("Unsupported datatype");
@@ -305 +318 @@
                 Common::File tempfileEnc(TEMP_ENC, "rb");
                 newDataSize = tempfileEnc.size();
                 newData = new byte[newDataSize];
+                if (!newData)
+                        error("malloc error");
                 tempfileEnc.read_throwsOnError(newData, newDataSize);
                 tempfileEnc.close();
         }
 
         _output.write(newData, newDataSize);
+        delete[] newData;
+}
 
-        if ((newData) && (newData != orgData))
-                delete[] newData;
-        delete[] orgData;
+uint CompressSci::parseRawAudioMap() {
+        Common::Filename mapFileName = _inputPaths[0].path;
+        // Assume the map is in the same dir as the resource file
+        // and is called AUDIO001.MAP
+        mapFileName.setFullName("AUDIO001.MAP");
+        warning("Trying %s as resource map\n", mapFileName.getFullPath().data());
+        Common::File mapFile;
+        mapFile.open(mapFileName, "rb");
+        // Ten byte entries, the last one is fake
+        uint32 numEntries = (mapFile.size() / 10) - 1;
+        uint32 offset = 0;
+        uint32 size = 0;
+        for (uint32 i = 0; i < numEntries; i++) {
+                // shouldn't reach the fake entry but break if we do
+                if (mapFile.readUint16LE() == 0xffff) break;
+                // mask out the resource volume number
+                offset = mapFile.readUint32LE() & 0x0fffffff;
+                size = mapFile.readUint32LE();
+                _rawAudioMap[offset] = size;
+        }
+        mapFile.close();
+        return _rawAudioMap.size();
 }
 
 void CompressSci::execute() {
@@ -325 +361 @@
         _inputSize = _input.size();
 
         // First find out how many samples are in this file
-        //  We only support SOL audio and WAVE
-        //  We can't support games that use "raw" audio (would have to walk through audio map for those, which would
-        //   complicate this code - all talkie games that use this (kq5) don't use much space anyway, so not supporting
-        //   those isn't a big issue
 
+        _rawAudio = false;
         _input.seek(0, SEEK_SET);
         byte header[6];
 
@@ -343 +376 @@
                 error("This resource file is already FLAC-compressed, aborting...\n");
 
         int resourceCount = 0;
-        do {
-                recognizedDataType = detectData(header, false);
-                if (!recognizedDataType)
-                        error("Unsupported data at offset %lx", _inputOffset);
-                _input.seek(_inputEndOffset, SEEK_SET);
-                _inputOffset = _inputEndOffset;
-                resourceCount++;
-                // We abort even, if file position is one below size because of pharkas resource.sfx
-                if (_inputOffset >= _inputSize - 1)
-                        break;
+        if (_input.size() == 0x05C9B000 or _input.size() == 0x0160E000) {
+                warning("Size matches KQ5 or Jones in the Fast Lane audio file, assuming raw audio\n");
+                _rawAudio = true;
+                resourceCount = parseRawAudioMap();
+        } else {
+                do {
+                        recognizedDataType = detectData(header, false);
+                        if (!recognizedDataType)
+                                error("Unsupported data at offset %lx", _inputOffset);
+                        _input.seek(_inputEndOffset, SEEK_SET);
+                        _inputOffset = _inputEndOffset;
+                        resourceCount++;
+                        // We abort even, if file position is one below size because of pharkas resource.sfx
+                        if (_inputOffset >= _inputSize - 1)
+                                break;
 
-                _input.read_throwsOnError(&header, 6);
-        } while (true);
+                        _input.read_throwsOnError(&header, 6);
+                } while (true);
+        }
 
         // This case happens on pharkas resource.sfx
         if (_inputOffset != _inputSize)
@@ -394 +433 @@
                 _input.seek(_inputOffset, SEEK_SET);
                 compressData(recognizedDataType);
 
+                // raw files are 0-padded to 2048 bytes
+                if (recognizedDataType == kSciResourceDataTypeRaw and _inputEndOffset % 2048)
+                        _inputEndOffset = (((_inputEndOffset >> 11) + 1) << 11) & 0xffffffff;
+
                 // Seek inputfile to the end of the data
                 _input.seek(_inputEndOffset, SEEK_SET);
                 // Seek outputfile to mapping table

engines/sci/compress_sci.h

@@ -24 +24 @@
 #define COMPRESS_SCI_H
 
 #include "compress.h"
+#include <map>
 
 enum SciResourceDataType {
         kSciResourceDataTypeUnknown     = 0,
         kSciResourceDataTypeWAVE        = 1,
         kSciResourceDataTypeSOL         = 2,
-        kSciResourceTypeTypeSync        = 3
+        kSciResourceTypeTypeSync        = 3,
+        kSciResourceDataTypeRaw         = 4
 };
 
 class CompressSci : public CompressionTool {
@@ -41 +43 @@
 protected:
         SciResourceDataType detectData(byte *header, bool compressMode);
         void compressData(SciResourceDataType dataType);
+        uint parseRawAudioMap();
 
         Common::File _input, _output;
         int _inputOffset;
         int _inputEndOffset;
         int _inputSize;
         int _outputOffset;
+        bool _rawAudio;
+        std::map<uint32,uint32> _rawAudioMap;
 };
 
 #endif