/* 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 <http://www.gnu.org/licenses/>.
 *
 */

/* resource.aud/resource.sfx compressor */

#include <stdlib.h>

#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] <inputname>\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<typename T> 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<int32>(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<int32>(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