/* ScummVM Tools * * ScummVM Tools is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * */ /* resource.aud/resource.sfx compressor */ #include #include "compress.h" #include "common/endian.h" #include "sound/audiostream.h" #include "sound/wave.h" #include "compress_sci.h" // data-format of resource.aud/resource.sfx: // just multiple SOL-Audio/WAVE files appended to each other // SCI1.1 also have resource id and headersize PER resource entry (but in WAVE resources) // at least kq6 resource.aud contains several raw lipsync resources w/o a real sync resource before that. Identifying those // raw lipsync resources isn't possible, because there is no header at all. // The resource data is accessed directly by offset referenced inside a map resource. That's why we need to add an additional // offset to offset mapping table right at the start of the file. We also include the compression type as first 4 bytes // This code CURRENTLY DOES NOT SUPPORT SCI2.1+ GAMES! In those games the current code will actually destroy the content of // the samples, because SCI32 used a different scheme for decoding. I don't know yet how to detect SCI32 games easily // without having resourcemanager. #define TEMP_RAW "tempfile.raw" #define TEMP_ENC "tempfile.enc" CompressSci::CompressSci(const std::string &name) : CompressionTool(name, TOOLTYPE_COMPRESSION) { _supportsProgressBar = true; ToolInput input1; input1.format = "resource.*"; _inputPaths.push_back(input1); _outputToDirectory = false; _shorthelp = "Used to compress Sierra resource.aud/.sfx and AUDIO001.002 files. (NOT SCI32 compatible!)"; _helptext = "\nUsage: " + getName() + " [mode-params] [-o outputname] \n"; } // header is first 6 bytes read from file SciResourceDataType CompressSci::detectData(byte *header, bool compressMode) { 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); // Fixup for pharkas resource.sfx, several WAVE files contain a size thats not right (-1 byte) int offset = 0; if (memcmp(buffer + 1, "RIFF", 4) == 0) { offset = 5; } else if ((memcmp(buffer + 1, "\x8d\x0bSOL\x00", 6) == 0) || (memcmp(buffer + 1, "\x8d\x0cSOL\x00", 6) == 0)) { offset = 7; } if (offset) { for (int i = 0; i < offset; i++) buffer[i] = buffer[i + 1]; _input.read_throwsOnError(&buffer[offset], 1); _inputOffset++; warning("WAVE resource position adjusted at %lx", _inputOffset); } if (memcmp(buffer, "RIFF", 4) == 0) { // WAVE files begin with // "RIFF" [size of following data:DWORD] _input.read_throwsOnError(&buffer[6], 2); dataSize = READ_LE_UINT32(buffer + 4); _inputEndOffset = _inputOffset + 8 + dataSize; return kSciResourceDataTypeWAVE; } if (memcmp(buffer, "\x8d\x0bSOL\x00", 6) == 0) { // SOL files begin with // 0x8D 0x0B/0x0C "SOL" 0x00 [samplerate:WORD] [flags:BYTE] [size of following data after header:DWORD] // 0x0C variant have an additional byte inbetween data and [size of] _input.read_throwsOnError(&buffer[6], 7); dataSize = READ_LE_UINT32(buffer + 9); _inputEndOffset = _inputOffset + 13 + dataSize; return kSciResourceDataTypeSOL; } if (memcmp(buffer, "\x8d\x0cSOL\x00", 6) == 0) { // see above _input.read_throwsOnError(&buffer[6], 8); dataSize = READ_LE_UINT32(buffer + 9); // HACK: LSL6 resource.aud has a SOL that specifies incorrect dataSize, we fix it here if ((_inputOffset == 102350599) && (dataSize == 122232)) dataSize--; if ((_inputOffset == 270400453) && (dataSize == 118721)) dataSize--; _inputEndOffset = _inputOffset + 14 + dataSize; return kSciResourceDataTypeSOL; } // No audio data found, if we are at offset 0 of the file -> exit w/ error message if (!_inputOffset) error("Input file doesn't seem to be a valid sci audio resource file"); uint32 searchForward = 0; bool noSignature = false; if (memcmp(buffer, "\x8e\x00", 2) == 0) { // sync resource, we expect SOL audio with a resourceid afterwards searchForward = 10000; } // We didn't find anything useful, though this may be a valid file after all - kq6 resource.aud contains "raw-data" // lip-sync data w/o the actual sync data if (!searchForward) { searchForward = 2048; if (!compressMode) warning("possibly raw lipsync data found at offset %lx", _input.pos()); noSignature = true; } int originalOffset = _input.pos(); byte syncBuffer[10000]; uint32 syncPos = 0; _input.read_throwsOnError(&syncBuffer, searchForward); while (true) { if (syncPos + 5 == searchForward) { if (noSignature) error("no SOL audio after possible raw lipsync data at %lx", originalOffset); else error("no SOL audio after sync resource at %lx", originalOffset); } if (syncBuffer[syncPos] == 0x8D) { if (memcmp(&syncBuffer[syncPos + 1], "\x0cSOL\x00", 5) == 0) break; if (memcmp(&syncBuffer[syncPos + 1], "\x0bSOL\x00", 5) == 0) break; } syncPos++; } _inputEndOffset = _inputOffset + 6 + syncPos; return kSciResourceTypeTypeSync; } static const uint16 tableDPCM16[128] = { 0x0000, 0x0008, 0x0010, 0x0020, 0x0030, 0x0040, 0x0050, 0x0060, 0x0070, 0x0080, 0x0090, 0x00A0, 0x00B0, 0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0100, 0x0110, 0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170, 0x0180, 0x0190, 0x01A0, 0x01B0, 0x01C0, 0x01D0, 0x01E0, 0x01F0, 0x0200, 0x0208, 0x0210, 0x0218, 0x0220, 0x0228, 0x0230, 0x0238, 0x0240, 0x0248, 0x0250, 0x0258, 0x0260, 0x0268, 0x0270, 0x0278, 0x0280, 0x0288, 0x0290, 0x0298, 0x02A0, 0x02A8, 0x02B0, 0x02B8, 0x02C0, 0x02C8, 0x02D0, 0x02D8, 0x02E0, 0x02E8, 0x02F0, 0x02F8, 0x0300, 0x0308, 0x0310, 0x0318, 0x0320, 0x0328, 0x0330, 0x0338, 0x0340, 0x0348, 0x0350, 0x0358, 0x0360, 0x0368, 0x0370, 0x0378, 0x0380, 0x0388, 0x0390, 0x0398, 0x03A0, 0x03A8, 0x03B0, 0x03B8, 0x03C0, 0x03C8, 0x03D0, 0x03D8, 0x03E0, 0x03E8, 0x03F0, 0x03F8, 0x0400, 0x0440, 0x0480, 0x04C0, 0x0500, 0x0540, 0x0580, 0x05C0, 0x0600, 0x0640, 0x0680, 0x06C0, 0x0700, 0x0740, 0x0780, 0x07C0, 0x0800, 0x0900, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000 }; static const byte tableDPCM8[8] = {0, 1, 2, 3, 6, 10, 15, 21}; template inline T CLIP (T v, T amin, T amax) { if (v < amin) return amin; else if (v > amax) return amax; else return v; } static void deDPCM16(byte *soundBuf, byte *inputBuf, uint32 n) { int16 *out = (int16 *) soundBuf; int32 s = 0; for (uint32 i = 0; i < n; i++) { byte b = *inputBuf++; if (b & 0x80) s -= tableDPCM16[b & 0x7f]; else s += tableDPCM16[b]; s = CLIP(s, -32768, 32767); *out++ = (uint16)s; } } static void deDPCM8Nibble(byte *soundBuf, int32 &s, byte b) { if (b & 8) { // TODO: Can't include it currently because i have yet no idea how to identifiy sci2.1+ easily // #ifdef ENABLE_SCI32 // // SCI2.1 reverses the order of the table values here // if (getSciVersion() >= SCI_VERSION_2_1) // s -= tableDPCM8[b & 7]; // else // #endif s -= tableDPCM8[7 - (b & 7)]; } else s += tableDPCM8[b & 7]; s = CLIP(s, 0, 255); *soundBuf = s; } static void deDPCM8(byte *soundBuf, byte *inputBuf, uint32 n) { int32 s = 0x80; for (uint i = 0; i < n; i++) { byte b = *inputBuf++; deDPCM8Nibble(soundBuf++, s, b >> 4); deDPCM8Nibble(soundBuf++, s, b & 0xf); } } // Will compress dataType at current offset in inputfile to outputfile using requested codec void CompressSci::compressData(SciResourceDataType dataType) { int orgDataSize = _inputEndOffset - _inputOffset; int newDataSize = 0; byte *newData = 0; int sampleRate = 0; byte *sampleData = 0; int sampleDataSize = 0; bool sampleIsStereo = false; uint8 sampleBits = 8; byte sampleFlags = 0; switch (dataType) { case kSciResourceDataTypeWAVE: print("WAVE found"); if (!Audio::loadWAVFromStream(_input, sampleDataSize, sampleRate, sampleFlags)) error("Unable to read WAV at offset %lx", _inputOffset); sampleData = new byte[sampleDataSize]; _input.read_throwsOnError(sampleData, sampleDataSize); if (sampleFlags & Audio::Mixer::FLAG_16BITS) sampleBits = 16; if (sampleFlags & Audio::Mixer::FLAG_STEREO) sampleIsStereo = true; break; case kSciResourceDataTypeSOL: { _input.readByte(); byte headerSize = _input.readByte(); _input.readUint32LE(); // Skip over "SOL" 0x00 sampleRate = _input.readUint16LE(); sampleFlags = _input.readByte(); sampleDataSize = _input.readUint32LE(); if (headerSize == 0x0C) _input.readByte(); // Now we read SOL datastream sampleData = new byte[sampleDataSize]; _input.read_throwsOnError(sampleData, sampleDataSize); //bool dataUnsigned = false; if (sampleFlags & 0x04) sampleBits = 16; //if (sampleFlags & 0x08) // dataUnsigned = true; if (sampleFlags & 0x01) { // SOL datastream is compressed, we need to uncompress it byte *uncompressedData = new byte[sampleDataSize * 2]; if (sampleBits == 16) deDPCM16(uncompressedData, sampleData, sampleDataSize); else deDPCM8(uncompressedData, sampleData, sampleDataSize); delete[] sampleData; sampleData = uncompressedData; sampleDataSize *= 2; } break; } case kSciResourceDataTypeRaw: sampleRate = 11025; // No headers so just use the original data as sample data sampleDataSize = orgDataSize; sampleData = new byte[sampleDataSize]; _input.read_throwsOnError(sampleData, sampleDataSize); break; case kSciResourceTypeTypeSync: print("SYNC found at %lx", _inputOffset); // Simply copy original data over newDataSize = orgDataSize; newData = new byte[newDataSize]; _input.read_throwsOnError(newData, newDataSize); break; default: error("Unsupported datatype"); } if (sampleData) { // Write sample data to temporary raw file Common::File tempfileRaw(TEMP_RAW, "wb"); tempfileRaw.write(sampleData, sampleDataSize); tempfileRaw.close(); delete[] sampleData; // Now compress temporary raw file setRawAudioType(true, sampleIsStereo, sampleBits); encodeAudio(TEMP_RAW, true, sampleRate, TEMP_ENC, _format); // And copy encoded file into output-file Common::File tempfileEnc(TEMP_ENC, "rb"); newDataSize = tempfileEnc.size(); newData = new byte[newDataSize]; tempfileEnc.read_throwsOnError(newData, newDataSize); tempfileEnc.close(); } _output.write(newData, newDataSize); delete[] newData; } 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"); print("Trying %s as resource map", mapFileName.getFullPath().data()); Common::File mapFile; mapFile.open(mapFileName, "rb"); uint32 offset = 0; // Ten byte entries, the last is fake, stop when it's reached while (mapFile.readUint16LE() != 0xffff) { // mask out the resource volume number offset = mapFile.readUint32LE() & 0x0fffffff; _rawAudioMap[offset] = mapFile.readUint32LE(); } mapFile.close(); return _rawAudioMap.size(); } void CompressSci::execute() { Common::Filename infile = _inputPaths[0].path; Common::Filename outfile = _outputPath; SciResourceDataType recognizedDataType; _input.open(infile, "rb"); _inputSize = _input.size(); _rawAudio = false; // First find out how many samples are in this file _input.seek(0, SEEK_SET); byte header[6]; _inputOffset = 0; _input.read_throwsOnError(&header, 6); if (memcmp(header, "MP3 ", 4) == 0) error("This resource file is already MP3-compressed, aborting..."); if (memcmp(header, "OGG ", 4) == 0) error("This resource file is already OGG-compressed, aborting..."); if (memcmp(header, "FLAC", 4) == 0) error("This resource file is already FLAC-compressed, aborting..."); int resourceCount = 0; if (_input.size() == 97103872 || _input.size() == 23126016) { print("Size matches KQ5 or Jones in the Fast Lane audio file, assuming raw audio"); _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); } // This case happens on pharkas resource.sfx if (_inputOffset != _inputSize) warning("resource file has additional byte before end-of-file"); print("Valid sci audio resource file. Found %d resources", resourceCount); if (outfile.empty()) error("please specify an output file"); // Now write basic output file header _output.open(outfile, "wb"); // Compression ID switch (_format) { case AUDIO_MP3: _output.writeUint32BE(MKID_BE('MP3 ')); break; case AUDIO_VORBIS: _output.writeUint32BE(MKID_BE('OGG ')); break; case AUDIO_FLAC: _output.writeUint32BE(MKID_BE('FLAC')); break; default: throw ToolException("Unknown audio format!"); } // Resource count _output.writeUint32LE(resourceCount); // Offset mapping table for (int resourceNo = 0; resourceNo < resourceCount; resourceNo++) { _output.writeUint32LE(0); // Original offset _output.writeUint32LE(0); // New offset } // Now actually compress the file _input.seek(0, SEEK_SET); for (int resourceNo = 0; resourceNo < resourceCount; resourceNo++) { _inputOffset = _input.pos(); _outputOffset = _output.pos(); _input.read_throwsOnError(&header, 6); recognizedDataType = detectData(header, true); assert(recognizedDataType); _input.seek(_inputOffset, SEEK_SET); compressData(recognizedDataType); // raw files are 0-padded to 2048 bytes if (_rawAudio) _inputEndOffset = (((_inputEndOffset - 1) >> 11) + 1) << 11; // Seek inputfile to the end of the data _input.seek(_inputEndOffset, SEEK_SET); // Seek outputfile to mapping table _output.seek(8 + resourceNo * 8, SEEK_SET); // And write offset translations _output.writeUint32LE(_inputOffset); _output.writeUint32LE(_outputOffset); // Seek to end of file _output.seek(0, SEEK_END); updateProgress(resourceNo, resourceCount); } // And some clean-up :-) Common::removeFile(TEMP_RAW); Common::removeFile(TEMP_ENC); } #ifdef STANDALONE_MAIN int main(int argc, char *argv[]) { CompressSci sci(argv[0]); return sci.run(argc, argv); } #endif