hca.bt

//------------------------------------------------
//--- 010 Editor v8.0 Binary Template
//
//      File: hca.bt
//   Authors: Misaka Honoka
//    E-mail: 2361547758@qq.com
//       Url: 
//   Version: 1.0
//   Purpose: Parse CRIDWARE hca file. 
//  Category: Binary
// File Mask: *.hca
//  ID Bytes: C8 C3 C1 00
//   History: 
//
//   License: This file is released into the public domain. People may 
//          use it for any purpose, commercial or otherwise. 
//------------------------------------------------

local uint16 v[256] = {
	0x0000,0x8005,0x800F,0x000A,0x801B,0x001E,0x0014,0x8011,0x8033,0x0036,0x003C,0x8039,0x0028,0x802D,0x8027,0x0022,
	0x8063,0x0066,0x006C,0x8069,0x0078,0x807D,0x8077,0x0072,0x0050,0x8055,0x805F,0x005A,0x804B,0x004E,0x0044,0x8041,
	0x80C3,0x00C6,0x00CC,0x80C9,0x00D8,0x80DD,0x80D7,0x00D2,0x00F0,0x80F5,0x80FF,0x00FA,0x80EB,0x00EE,0x00E4,0x80E1,
	0x00A0,0x80A5,0x80AF,0x00AA,0x80BB,0x00BE,0x00B4,0x80B1,0x8093,0x0096,0x009C,0x8099,0x0088,0x808D,0x8087,0x0082,
	0x8183,0x0186,0x018C,0x8189,0x0198,0x819D,0x8197,0x0192,0x01B0,0x81B5,0x81BF,0x01BA,0x81AB,0x01AE,0x01A4,0x81A1,
	0x01E0,0x81E5,0x81EF,0x01EA,0x81FB,0x01FE,0x01F4,0x81F1,0x81D3,0x01D6,0x01DC,0x81D9,0x01C8,0x81CD,0x81C7,0x01C2,
	0x0140,0x8145,0x814F,0x014A,0x815B,0x015E,0x0154,0x8151,0x8173,0x0176,0x017C,0x8179,0x0168,0x816D,0x8167,0x0162,
	0x8123,0x0126,0x012C,0x8129,0x0138,0x813D,0x8137,0x0132,0x0110,0x8115,0x811F,0x011A,0x810B,0x010E,0x0104,0x8101,
	0x8303,0x0306,0x030C,0x8309,0x0318,0x831D,0x8317,0x0312,0x0330,0x8335,0x833F,0x033A,0x832B,0x032E,0x0324,0x8321,
	0x0360,0x8365,0x836F,0x036A,0x837B,0x037E,0x0374,0x8371,0x8353,0x0356,0x035C,0x8359,0x0348,0x834D,0x8347,0x0342,
	0x03C0,0x83C5,0x83CF,0x03CA,0x83DB,0x03DE,0x03D4,0x83D1,0x83F3,0x03F6,0x03FC,0x83F9,0x03E8,0x83ED,0x83E7,0x03E2,
	0x83A3,0x03A6,0x03AC,0x83A9,0x03B8,0x83BD,0x83B7,0x03B2,0x0390,0x8395,0x839F,0x039A,0x838B,0x038E,0x0384,0x8381,
	0x0280,0x8285,0x828F,0x028A,0x829B,0x029E,0x0294,0x8291,0x82B3,0x02B6,0x02BC,0x82B9,0x02A8,0x82AD,0x82A7,0x02A2,
	0x82E3,0x02E6,0x02EC,0x82E9,0x02F8,0x82FD,0x82F7,0x02F2,0x02D0,0x82D5,0x82DF,0x02DA,0x82CB,0x02CE,0x02C4,0x82C1,
	0x8243,0x0246,0x024C,0x8249,0x0258,0x825D,0x8257,0x0252,0x0270,0x8275,0x827F,0x027A,0x826B,0x026E,0x0264,0x8261,
	0x0220,0x8225,0x822F,0x022A,0x823B,0x023E,0x0234,0x8231,0x8213,0x0216,0x021C,0x8219,0x0208,0x820D,0x8207,0x0202
};

uint16 HCACheckSum(uchar data[], uint size) {
	local uint16 sum = 0;
	local uint i = 0;
	while (i < size)
		sum = (sum << 8) ^ v[(sum >> 8) ^ data[i++]];
	return sum;
}

typedef struct {
	ubyte main;
	ubyte sub;
} VERSION <read=versionRead>;
string versionRead(VERSION& o) {
	uchar dist[6];
	SPrintf(dist, "%d.%d", o.main, o.sub);
	return dist;
}

typedef struct {
	uchar sign[4];
} maskSign <read=maskRead>;
string maskRead(maskSign& o) {
	local uchar buff[4];
	buff[0] = o.sign[0] & 0x7f;
	buff[1] = o.sign[1] & 0x7f;
	buff[2] = o.sign[2] & 0x7f;
	buff[3] = o.sign[3] & 0x7f;
	return buff;
}

typedef struct {
	VERSION version;
	uint16 dataOffset;
} stHeader <read=headerRead>;
string headerRead(stHeader& o) { return versionRead(o.version); }

local uint32 _samplingRate, _blockCount;
typedef struct {
	uint32 channelCount:8;
	uint32 samplingRate:24;
	_samplingRate = samplingRate;
	uint32 blockCount;
	_blockCount = blockCount;
	uint16 droppedHeader;
	uint16 droppedFooter;
} stFormat <read=formatRead>;
string formatRead(stFormat& o) {
	uchar dist[32];
	SPrintf(dist, "%dch %dHz [%d, %d)", o.channelCount, o.samplingRate, o.droppedHeader, o.blockCount * 1024 - o.droppedFooter);
	return dist;
}

local uint16 _blockSize;
typedef struct {
	uint16 blockSize;
	_blockSize = blockSize;
    uchar MinResolution;
    uchar MaxResolution;
    uchar TrackCount;
    uchar ChannelConfig;
    uchar TotalBandCount;
    uchar BaseBandCount;
    uchar StereoBandCount;
    uchar BandsPerHfrGroup;
    uchar Reserved1;
    uchar Reserved2;
} stCompress <read=compressRead>;
string compressRead(stCompress& o) {
	uchar dist[24];
	SPrintf(dist, "bitrate: %.2f kbps", _samplingRate * o.blockSize / 128000.0f);
	return dist;
}

typedef struct {
	uint16 blockSize;
	_blockSize = blockSize;
	char r01;
	char r02;
	char count1;
	char count2;
	char r03;
	char r04;
	char enableCount2;
} stDecode <read=decodeRead>;
string decodeRead(stDecode& o) {
	uchar dist[24];
	SPrintf(dist, "bitrate: %.2f kbps", _samplingRate * o.blockSize / 128000.0f);
	return dist;
}

typedef struct {
	uint16 r01;
	uint16 r02;
} stVBR;

typedef struct {
	uint16 type;
} stATH;

typedef struct {
	uint32 start;
	uint32 end;
	uint16 droppedHeader;
	uint16 droppedFooter;
} stLoop <read=loopRead>;
wstring loopRead(stLoop& o) {
	uchar dist[32];
	SPrintf(dist, "at sample: [%d, %d)", o.start * 1024 + o.droppedHeader, (o.end + 1) * 1024 - o.droppedFooter);
	return StringToWString(dist, CHARSET_UTF8);
}

typedef struct {
	uint16 type;
} stCipher <read=cipherRead>;
wstring cipherRead(stCipher& o) {
	switch (o.type) {
		case 0: return StringToWString("unencrypted", CHARSET_UTF8);
		case 1: return StringToWString("encrypted with no key", CHARSET_UTF8);
		case 0x38: return StringToWString("encrypted with specific key", CHARSET_UTF8);
	}
	return StringToWString("unknown", CHARSET_UTF8);
}

typedef struct {
	float volume;
} stRVA;

typedef struct {
	ubyte len;
	if (len) uchar comment[len];
} stComment <optimize=false, read=commentRead>;
string commentRead(stComment& o) { return o.len ? o.comment : ""; }

typedef struct {
	uchar nop[head.header.dataOffset - FTell() - 2];
} stPadding <optimize=false, read=paddingRead>;
string paddingRead(stPadding& o) {
	uchar dist[10];
	SPrintf(dist, "len: %d", sizeof(o.nop));
	return dist;
}

typedef struct {
	maskSign sign;
	switch (maskRead(sign)) {
		case "HCA": stHeader header; break;
		case "fmt": stFormat format; break;
		case "comp": stCompress compress; break;
		case "dec": stDecode decode; break;
		case "vbr": stVBR vbr; break;
		case "ath": stATH ath; break;
		case "loop": stLoop loop; break;
		case "ciph": stCipher cipher; break;
		case "rva": stRVA rva; break;
		case "comm": stComment comment; break;
		case "pad": stPadding padding; break;
		default: break;
	}
} st <optimize=false, read=stRead>;
string stRead(st& o) { return maskRead(o.sign); }

typedef struct {
	uchar data[_blockSize - 2];
	uint16 checksum <format=hex>;
} BLOCK <optimize=true, read=blockRead>;
string blockRead(BLOCK& o) {
	uchar dist[1];
	local uint16 sum = HCACheckSum(o.data, _blockSize - 2);
	SPrintf(dist, "%02X %02X; ", sum >> 8, sum & 0xFF);
	if (o.checksum != sum) {
		Warning("Checksum diff on 0x%X", FTell());
		return dist +"Broken";
	} else return dist + "OK";
}

typedef struct {
	st head;
	local int i = sizeof(head);
	while (i < head.header.dataOffset - 2) {
		st trunks;
		i += sizeof(trunks);
	}
	uint16 checksum <format=hex>;
} HEADER <optimize=true>;

typedef struct {
	HEADER header;
	BLOCK block[_blockCount];
} HCA;

BigEndian();

HCA hca;