/* 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
 * 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/>.
 *
 */

#include "awe/aifc_player.h"
#include "awe/detection.h"

namespace Awe {

static uint32 READ_IEEE754(const uint8 *p) {
	const uint32 m = READ_BE_UINT32(p + 2);
	const int exp = 30 - p[1];
	return (m >> exp);
}

AifcPlayer::AifcPlayer() {
}

bool AifcPlayer::play(int mixRate, const char *path, uint32 startOffset) {
	_ssndSize = 0;
	if (_f.open(path)) {
		_f.seek(startOffset);
		uint8 buf[12];
		_f.read(buf, sizeof(buf));
		if (memcmp(buf, "FORM", 4) == 0 && memcmp(buf + 8, "AIFC", 4) == 0) {
			const uint32 size = READ_BE_UINT32(buf + 4);
			for (uint32 offset = 12; offset + 8 < size; ) {
				_f.seek(startOffset + offset);
				_f.read(buf, 8);
				const uint32 sz = READ_BE_UINT32(buf + 4);
				if (memcmp(buf, "COMM", 4) == 0) {
					const int channels = _f.readUint16BE();
					_f.readUint32BE(); // samples per frame
					const int bits = _f.readUint16BE();
					_f.read(buf, 10);
					const int rate = READ_IEEE754(buf);
					if (channels != 2) {
						warning("Unsupported AIFF-C channels %d rate %d (%s)", channels, rate, path);
						break;
					}
					_f.read(buf, 4);
					if (memcmp(buf, "SDX2", 4) != 0) {
						warning("Unsupported compression");
						break;
					}
					debugC(kDebugSound, "AIFF-C channels %d rate %d bits %d", channels, rate, bits);
					_rate.reset(rate, mixRate);
				} else if (memcmp(buf, "SSND", 4) == 0) {
					_f.readUint32BE(); // block offset
					_f.readUint32BE(); // block size
					_ssndOffset = startOffset + offset + 8 + 8;
					_ssndSize = sz;
					debugC(kDebugSound, "AIFF-C ssnd size %d", _ssndSize);
					break;
				} else if (memcmp(buf, "FVER", 4) == 0) {
					const uint32 version = _f.readUint32BE();
					if (version != 0xA2805140) {
						warning("Unexpected AIFF-C version 0x%x (%s)", version, path);
					}
				} else if (memcmp(buf, "INST", 4) == 0) {
					// unused
				} else if (memcmp(buf, "MARK", 4) == 0) {
					const int count = _f.readUint16BE();
					for (int i = 0; i < count; ++i) {
						_f.readUint16BE(); // marker_id
						_f.readUint32BE(); // marker_position
						const int len = _f.readByte();
						if (len != 0) {
							char name[256];
							_f.read(name, len);
							name[len] = 0;
						}
						// pad ((len + 1) & 1)
					}
				} else {
					warning("Unhandled AIFF-C tag '%02x%02x%02x%02x' size %d offset 0x%x path %s", buf[0], buf[1], buf[2], buf[3], sz, startOffset + offset, path);
					break;
				}
				offset += sz + 8;
			}
		}
	}
	_pos = 0;
	_sampleL = _sampleR = 0;
	return _ssndSize != 0;
}

void AifcPlayer::stop() {
	_f.close();
}

static int16 decodeSDX2(int16 prev, int8 data) {
	const int sqr = data * ABS(data) * 2;
	return (data & 1) != 0 ? prev + sqr : sqr;
}

int8 AifcPlayer::readSampleData() {
	if (_pos >= _ssndSize) {
		_pos = 0;
		_f.seek(_ssndOffset);
	}
	const int8 data = _f.readByte();
	++_pos;
	return data;
}

void AifcPlayer::decodeSamples() {
	for (const uint32 pos = _rate.getInt(); pos == _rate.getInt(); _rate.offset += _rate.inc) {
		_sampleL = decodeSDX2(_sampleL, readSampleData());
		_sampleR = decodeSDX2(_sampleR, readSampleData());
	}
}

void AifcPlayer::readSamples(int16 *buf, int len) {
	for (int i = 0; i < len; i += 2) {
		decodeSamples();
		*buf++ = _sampleL;
		*buf++ = _sampleR;
	}
}

} // namespace Awe