/* 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

/*
 * This code is based on original Soltys source code
 * Copyright (c) 1994-1995 Janus B. Wisniewski and L.K. Avalon
 */

#ifndef __WAV__
#define __WAV__

#include "cge/general.h"
#include <string.h>

namespace CGE {

#define WAVE_FORMAT_PCM     0x0001
#define IBM_FORMAT_MULAW    0x0101
#define IBM_FORMAT_ALAW     0x0102
#define IBM_FORMAT_ADPCM    0x0103


typedef char FOURCC[4];             // Four-character code
typedef uint32 CKSIZE;              // 32-bit unsigned size


class CKID { // Chunk type identifier
	union {
		FOURCC Tx;
		uint32 Id;
	};
protected:
	static XFILE *ckFile;
public:
	CKID(FOURCC t) {
		memcpy(Tx, t, sizeof(Tx));
	}
	CKID(uint32 d) {
		Id = d;
	}
	CKID(XFILE *xf) {
		(ckFile = xf)->Read(Tx, sizeof(Tx));
	}
	bool operator !=(CKID &X) {
		return Id != X.Id;
	}
	bool operator ==(CKID &X) {
		return Id == X.Id;
	}
	const char *Name(void);
};


class CKHEA : public CKID {
protected:
	CKSIZE ckSize;        // Chunk size field (size of ckData)
public:
	CKHEA(XFILE *xf) : CKID(xf) {
		XRead(xf, &ckSize);
	}
	CKHEA(char id[]) : CKID(id), ckSize(0) { }
	void Skip(void);
	CKSIZE Size(void) {
		return ckSize;
	}
};


class FMTCK : public CKHEA {
	struct WAV {
		uint16 wFormatTag;         // Format category
		uint16 wChannels;          // Number of channels
		uint32 dwSamplesPerSec;    // Sampling rate
		uint32 dwAvgBytesPerSec;   // For buffer estimation
		uint16 wBlockAlign;        // Data block size
	} Wav;

	union {
		struct PCM {
			uint16 wBitsPerSample;      // Sample size
		} Pcm;
	};
public:
	FMTCK(CKHEA &hea);
	inline  uint16 Channels(void) {
		return Wav.wChannels;
	}
	inline uint32 SmplRate(void) {
		return Wav.dwSamplesPerSec;
	}
	inline uint32 ByteRate(void) {
		return Wav.dwAvgBytesPerSec;
	}
	inline  uint16 BlckSize(void) {
		return Wav.wBlockAlign;
	}
	inline  uint16 SmplSize(void) {
		return Pcm.wBitsPerSample;
	}
};


class DATACK : public CKHEA {
	bool e;
	union {
		uint8 *Buf;
		EMS *EBuf;
	};
public:
	DATACK(CKHEA &hea);
	DATACK(CKHEA &hea, EMM *emm);
	DATACK(int first, int last);
	~DATACK(void);
	inline uint8 *Addr(void) {
		return Buf;
	}
	inline EMS *EAddr(void) {
		return EBuf;
	}
};


extern  CKID    RIFF;
extern  CKID    WAVE;
extern  CKID    FMT;
extern  CKID    DATA;


DATACK     *LoadWave(XFILE *file, EMM *emm = NULL);

} // End of namespace CGE

#endif