src/cassette/TsxParser.cc at main · doomsdayone/openmsx

◆ main openmsx / src / cassette / TsxParser.cc

10.8 KiB · C++ · last changed chore(): initial commit 1 month ago source blame history raw

// Based on code written by:
//   (2017) NataliaPC aka @ishwin74
//   Under GPL License

#include "TsxParser.hh"

#include "strCat.hh"
#include "xrange.hh"

#include <array>
#include <cstring>

// Current version supports these TZX 1.20 blocks plus the #4B TSX block:
static constexpr uint8_t B10_STD_BLOCK      = 0x10; // Standard Speed Block (Turbo normal)
static constexpr uint8_t B11_TURBO_BLOCK    = 0x11; // Turbo Speed Block (Turbo speed)
static constexpr uint8_t B12_PURE_TONE      = 0x12; // Pure Tone Block
static constexpr uint8_t B13_PULSE_SEQUENCE = 0x13; // Pulse sequence Block
static constexpr uint8_t B15_DIRECT_REC     = 0x15; // Direct recording Block
static constexpr uint8_t B20_SILENCE_BLOCK  = 0x20; // Silence Block
static constexpr uint8_t B30_TEXT_DESCRIP   = 0x30; // Text description Block
static constexpr uint8_t B32_ARCHIVE_INFO   = 0x32; // Archive info Block
static constexpr uint8_t B35_CUSTOM_INFO    = 0x35; // Custom info Block
static constexpr uint8_t B4B_KCS_BLOCK      = 0x4B; // KCS (Kansas City Standard) Block

// These blocks are detected, but ignored
static constexpr uint8_t B21_GRP_START      = 0x21; // Group start Block
static constexpr uint8_t B22_GRP_END        = 0x22; // Group end Block
static constexpr uint8_t B5A_GLUE_BLOCK     = 0x5A; // Glue Block

// These blocks are not supported at all (trigger an error when encountered)
static constexpr uint8_t B14_PURE_DATA      = 0x14; // Pure data Block
static constexpr uint8_t B18_CSW_RECORDING  = 0x18; // CSW recording block
static constexpr uint8_t B19_GEN_DATA       = 0x19; // Generalized data block
static constexpr uint8_t B23_JUMP_BLOCK     = 0x23; // Jump Block
static constexpr uint8_t B24_LOOP_START     = 0x24; // Loop start Block
static constexpr uint8_t B25_LOOP_END       = 0x25; // Loop end Block
static constexpr uint8_t B26_CALL_SEQ       = 0x26; // Call sequence Block
static constexpr uint8_t B27_RET_SEQ        = 0x27; // Return sequence Block
static constexpr uint8_t B28_SELECT_BLOCK   = 0x28; // Select block
static constexpr uint8_t B2A_STOP_TAPE      = 0x2A; // Stop the tape if in 48K mode
static constexpr uint8_t B2B_SIGNAL_LEVEL   = 0x2B; // Set signal level
static constexpr uint8_t B31_MSG_BLOCK      = 0x31; // Message Block
static constexpr uint8_t B33_HARDWARE_TYPE  = 0x33; // Hardware type


TsxParser::TsxParser(std::span<const uint8_t> file)
	: buf(file)
{
	// Check for a TZX header
	static constexpr std::array<uint8_t, 8> TSX_HEADER = { 'Z','X','T','a','p','e','!', 0x1A };
	if (memcmp(get<uint8_t>(TSX_HEADER.size()).data(), TSX_HEADER.data(), TSX_HEADER.size()) != 0) {
		error("Invalid TSX header");
	}

	// Check version >= 1.21
	if (auto version = Endian::read_UA_B16(get<uint8_t>(2).data());
	    version < 0x0115) {
		error("TSX version below 1.21");
	}

	while (!buf.empty()) {
		accumBytes = 0.f;
		auto blockId = get<uint8_t>();
		switch (blockId) {
		case B10_STD_BLOCK:
			processBlock10(get<Block10>());
			break;
		case B11_TURBO_BLOCK:
			processBlock11(get<Block11>());
			break;
		case B12_PURE_TONE:
			processBlock12(get<Block12>());
			break;
		case B13_PULSE_SEQUENCE:
			processBlock13(get<Block13>());
			break;
		case B15_DIRECT_REC:
			processBlock15(get<Block15>());
			break;
		case B20_SILENCE_BLOCK:
			processBlock20(get<Block20>());
			break;
		case B21_GRP_START:
			processBlock21(get<Block21>());
			break;
		case B22_GRP_END:
			// ignore (block has no data)
			break;
		case B30_TEXT_DESCRIP:
			processBlock30(get<Block30>());
			break;
		case B32_ARCHIVE_INFO:
			processBlock32(get<Block32>());
			break;
		case B35_CUSTOM_INFO:
			processBlock35(get<Block35>());
			break;
		case B4B_KCS_BLOCK:
			processBlock4B(get<Block4B>());
			break;
		case B5A_GLUE_BLOCK:
			get<uint8_t>(10); // skip (ignore) this block
			break;
		case B14_PURE_DATA:
		case B18_CSW_RECORDING:
		case B19_GEN_DATA:
		case B23_JUMP_BLOCK:
		case B24_LOOP_START:
		case B25_LOOP_END:
		case B26_CALL_SEQ:
		case B27_RET_SEQ:
		case B28_SELECT_BLOCK:
		case B2A_STOP_TAPE:
		case B2B_SIGNAL_LEVEL:
		case B31_MSG_BLOCK:
		case B33_HARDWARE_TYPE:
			// TODO not yet implemented, useful?
			[[fallthrough]];
		default:
			error(strCat("Unsupported block: #", hex_string<2>(blockId)));
		}
	}
}

[[nodiscard]] static float tStates2samples(float tStates)
{
	return tStates * TsxParser::OUTPUT_FREQUENCY / TsxParser::TZX_Z80_FREQ;
}

void TsxParser::writeSample(uint32_t tStates, int8_t value)
{
	accumBytes += tStates2samples(float(tStates));
	output.insert(end(output), int(accumBytes), value);
	accumBytes -= float(int(accumBytes));
}

void TsxParser::writePulse(uint32_t tStates)
{
	writeSample(tStates, currentValue);
	currentValue = int8_t(-currentValue);
}

void TsxParser::writePulses(uint32_t count, uint32_t tStates)
{
	repeat(count, [&] { writePulse(tStates); });
}

void TsxParser::writeSilence(int ms)
{
	if (!ms) return;
	output.insert(end(output), OUTPUT_FREQUENCY * ms / 1000, 0);
	currentValue = 127;
}

// Standard Speed Block
void TsxParser::processBlock10(const Block10& b)
{
	// delegate to 'block 11' but with some hardcoded values
	Block11 b11 = {};
	b11.pilot = 2168;
	b11.sync1 = 667;
	b11.sync2 = 735;
	b11.zero = 855;
	b11.one = 1710;
	b11.pilotLen = 3223;
	b11.lastBits = 8;
	b11.pauseMs = b.pauseMs;
	b11.len = b.len;
	processBlock11(b11);
}

// Turbo Speed Block
void TsxParser::processBlock11(const Block11& b)
{
	if ((b.len < 1) || (b.lastBits < 1) || (b.lastBits > 8)) {
		error("Invalid block #11");
	}

	currentValue = -127;
	writePulses(b.pilotLen, b.pilot);
	writePulse(b.sync1);
	writePulse(b.sync2);

	auto writeByte = [&](uint8_t d, int nBits) {
		for (auto bit : xrange(nBits)) {
			if (d & (128 >> bit)) {
				writePulses(2, b.one);
			} else {
				writePulses(2, b.zero);
			}
		}
	};
	uint32_t len = b.len;
	auto data = get<uint8_t>(len);
	for (auto i : xrange(len - 1)) {
		writeByte(data[i], 8);
	}
	writeByte(data[len - 1], b.lastBits);

	if (b.pauseMs != 0) writePulse(2000);
	writeSilence(b.pauseMs);
}

// Pure Tone Block
void TsxParser::processBlock12(const Block12& b)
{
	auto n = b.pulses & ~1; // round down to even
	writePulses(n, b.len);
}

// Pulse sequence Block
void TsxParser::processBlock13(const Block13& b)
{
	auto pulses = get<Endian::UA_L16>(b.num);
	for (auto i : xrange(b.num)) {
		writePulse(pulses[i]);
	}
}

// Direct Recording
void TsxParser::processBlock15(const Block15& b)
{
	if ((b.len < 1) || (b.lastBits < 1) || (b.lastBits > 8)) {
		error("Invalid block #15");
	}
	auto samples = get<uint8_t>(b.len);

	auto writeBit = [&](uint8_t& sample) {
		writeSample(b.bitTstates, (sample & 128) ? 127 : -127);
		sample <<= 1;
	};
	auto writeByte = [&](uint8_t sample, int nBits) {
		repeat(nBits, [&]{ writeBit(sample); });
	};
	for (auto i : xrange(b.len - 1)) {
		writeByte(samples[i], 8);
	}
	writeByte(samples[b.len - 1], b.lastBits);

	writeSilence(b.pauseMs);
}

// Silence Block
void TsxParser::processBlock20(const Block20& b)
{
	writeSilence(b.pauseMs);
}

// Group start Block
void TsxParser::processBlock21(const Block21& b)
{
	get<uint8_t>(b.len); // ignore group name
}

// Text description Block
void TsxParser::processBlock30(const Block30& b)
{
	auto text = get<char>(b.len);
	messages.emplace_back(text.data(), text.size());
}

// Archive info Block
void TsxParser::processBlock32(const Block32& b)
{
	uint16_t len = b.blockLen;
	auto extra = sizeof(Block32) - sizeof(uint16_t);
	if (len < extra) error("Invalid block #32");
	len -= extra; // number of available bytes in the data block

	auto data = get<char>(len);
	repeat(uint32_t(b.num), [&] {
		if (data.size() < 2) error("Invalid block #32");
		uint8_t textId  = data[0];
		uint8_t textLen = data[1];
		data = data.subspan(2);

		if (data.size() < textLen) error("Invalid block #32");
		if (textId == 0) {
			messages.emplace_back(data.data(), textLen);
		}
		data = data.subspan(textLen);
	});
	if (!data.empty()) error("Invalid block #32");
}

// Custom info Block
void TsxParser::processBlock35(const Block35& b)
{
	get<uint8_t>(b.len); // just skip (ignore) the data
}

// MSX KCS Block
void TsxParser::processBlock4B(const Block4B& b)
{
	static constexpr std::array<uint8_t, 10> ASCII_HEADER  = { 0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA };
	static constexpr std::array<uint8_t, 10> BINARY_HEADER = { 0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0 };
	static constexpr std::array<uint8_t, 10> BASIC_HEADER  = { 0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3 };

	// get data block
	uint32_t len = b.blockLen;
	auto extra = sizeof(Block4B) - sizeof(uint32_t);
	if (len < extra) error("Invalid block #4B: invalid length");
	len -= extra; // number of available bytes in the data block
	auto data = get<uint8_t>(len);

	// determine file type
	if (!firstFileType && (len == 16)) {
		using enum FileType;
		if (memcmp(data.data(), ASCII_HEADER.data(), ASCII_HEADER.size()) == 0) {
			firstFileType = ASCII;
		} else if (memcmp(data.data(), BINARY_HEADER.data(), BINARY_HEADER.size()) == 0) {
			firstFileType = BINARY;
		} else if (memcmp(data.data(), BASIC_HEADER.data(), BASIC_HEADER.size()) == 0) {
			firstFileType = BASIC;
		} else {
			firstFileType = UNKNOWN;
		}
	}

	// read the block
	uint32_t pulsePilot = b.pilot;
	uint32_t pulseOne   = b.bit1len;
	uint32_t pulseZero  = b.bit0len;

	auto decodeBitCfg = [](uint8_t x) { return x ? x : 16; };
	auto numZeroPulses = decodeBitCfg(b.bitCfg >> 4); // 2 for MSX
	auto numOnePulses  = decodeBitCfg(b.bitCfg & 15); // 4 for MSX

	auto numStartBits = (b.byteCfg & 0b11000000) >> 6; // 1 for MSX
	bool startBitVal  = (b.byteCfg & 0b00100000) >> 5; // 0 for MSX
	auto numStopBits  = (b.byteCfg & 0b00011000) >> 3; // 2 for MSX
	bool stopBitVal   = (b.byteCfg & 0b00000100) >> 2; // 1 for MSX
	bool msb          = (b.byteCfg & 0b00000001) >> 0; // 0 (LSB first) for MSX
	if (b.byteCfg & 0b00000010) {
		error(strCat("Invalid block #4B: unsupported byte-cfg: ", hex_string<2>(b.byteCfg)));
	}

	// write a header signal
	writePulses(b.pulses, pulsePilot);

	// write KCS bytes
	auto write_01 = [&](bool bit) {
		if (bit) {
			writePulses(numOnePulses, pulseOne);
		} else {
			writePulses(numZeroPulses, pulseZero);
		}
	};
	auto write_N_01 = [&](unsigned n, bool bit) {
		repeat(n, [&] { write_01(bit); });
	};
	for (auto i : xrange(len)) {
		// start bit(s)
		write_N_01(numStartBits, startBitVal);
		// 8 data bits
		uint8_t d = data[i];
		for (auto bit : xrange(8)) {
			auto mask = uint8_t(1) << (msb ? (7 - bit) : bit);
			write_01(d & mask);
		}
		// stop bit(s)
		write_N_01(numStopBits, stopBitVal);
	}
	writeSilence(b.pauseMs);
}

template<typename T>
std::span<const T> TsxParser::get(size_t count)
{
	static_assert(alignof(T) == 1, "T must be unaligned");

	auto bytes = count * sizeof(T);
	if (buf.size() < bytes) error("Invalid TSX file, read beyond end of file");

	const T* result = std::bit_cast<const T*>(buf.data());
	buf = buf.subspan(bytes);
	return {result, count};
}

template<typename T>
const T& TsxParser::get()
{
	const T* t = get<T>(1).data();
	return *t;
}

void TsxParser::error(std::string msg) const
{
	throw msg;
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1	// Based on code written by:
2	// (2017) NataliaPC aka @ishwin74
3	// Under GPL License
4
5	#include "TsxParser.hh"
6
7	#include "strCat.hh"
8	#include "xrange.hh"
9
10	#include <array>
11	#include <cstring>
12
13	// Current version supports these TZX 1.20 blocks plus the #4B TSX block:
14	static constexpr uint8_t B10_STD_BLOCK = 0x10; // Standard Speed Block (Turbo normal)
15	static constexpr uint8_t B11_TURBO_BLOCK = 0x11; // Turbo Speed Block (Turbo speed)
16	static constexpr uint8_t B12_PURE_TONE = 0x12; // Pure Tone Block
17	static constexpr uint8_t B13_PULSE_SEQUENCE = 0x13; // Pulse sequence Block
18	static constexpr uint8_t B15_DIRECT_REC = 0x15; // Direct recording Block
19	static constexpr uint8_t B20_SILENCE_BLOCK = 0x20; // Silence Block
20	static constexpr uint8_t B30_TEXT_DESCRIP = 0x30; // Text description Block
21	static constexpr uint8_t B32_ARCHIVE_INFO = 0x32; // Archive info Block
22	static constexpr uint8_t B35_CUSTOM_INFO = 0x35; // Custom info Block
23	static constexpr uint8_t B4B_KCS_BLOCK = 0x4B; // KCS (Kansas City Standard) Block
24
25	// These blocks are detected, but ignored
26	static constexpr uint8_t B21_GRP_START = 0x21; // Group start Block
27	static constexpr uint8_t B22_GRP_END = 0x22; // Group end Block
28	static constexpr uint8_t B5A_GLUE_BLOCK = 0x5A; // Glue Block
29
30	// These blocks are not supported at all (trigger an error when encountered)
31	static constexpr uint8_t B14_PURE_DATA = 0x14; // Pure data Block
32	static constexpr uint8_t B18_CSW_RECORDING = 0x18; // CSW recording block
33	static constexpr uint8_t B19_GEN_DATA = 0x19; // Generalized data block
34	static constexpr uint8_t B23_JUMP_BLOCK = 0x23; // Jump Block
35	static constexpr uint8_t B24_LOOP_START = 0x24; // Loop start Block
36	static constexpr uint8_t B25_LOOP_END = 0x25; // Loop end Block
37	static constexpr uint8_t B26_CALL_SEQ = 0x26; // Call sequence Block
38	static constexpr uint8_t B27_RET_SEQ = 0x27; // Return sequence Block
39	static constexpr uint8_t B28_SELECT_BLOCK = 0x28; // Select block
40	static constexpr uint8_t B2A_STOP_TAPE = 0x2A; // Stop the tape if in 48K mode
41	static constexpr uint8_t B2B_SIGNAL_LEVEL = 0x2B; // Set signal level
42	static constexpr uint8_t B31_MSG_BLOCK = 0x31; // Message Block
43	static constexpr uint8_t B33_HARDWARE_TYPE = 0x33; // Hardware type
44
45
46	TsxParser::TsxParser(std::span<const uint8_t> file)
47	: buf(file)
48	{
49	// Check for a TZX header
50	static constexpr std::array<uint8_t, 8> TSX_HEADER = { 'Z','X','T','a','p','e','!', 0x1A };
51	if (memcmp(get<uint8_t>(TSX_HEADER.size()).data(), TSX_HEADER.data(), TSX_HEADER.size()) != 0) {
52	error("Invalid TSX header");
53	}
54
55	// Check version >= 1.21
56	if (auto version = Endian::read_UA_B16(get<uint8_t>(2).data());
57	version < 0x0115) {
58	error("TSX version below 1.21");
59	}
60
61	while (!buf.empty()) {
62	accumBytes = 0.f;
63	auto blockId = get<uint8_t>();
64	switch (blockId) {
65	case B10_STD_BLOCK:
66	processBlock10(get<Block10>());
67	break;
68	case B11_TURBO_BLOCK:
69	processBlock11(get<Block11>());
70	break;
71	case B12_PURE_TONE:
72	processBlock12(get<Block12>());
73	break;
74	case B13_PULSE_SEQUENCE:
75	processBlock13(get<Block13>());
76	break;
77	case B15_DIRECT_REC:
78	processBlock15(get<Block15>());
79	break;
80	case B20_SILENCE_BLOCK:
81	processBlock20(get<Block20>());
82	break;
83	case B21_GRP_START:
84	processBlock21(get<Block21>());
85	break;
86	case B22_GRP_END:
87	// ignore (block has no data)
88	break;
89	case B30_TEXT_DESCRIP:
90	processBlock30(get<Block30>());
91	break;
92	case B32_ARCHIVE_INFO:
93	processBlock32(get<Block32>());
94	break;
95	case B35_CUSTOM_INFO:
96	processBlock35(get<Block35>());
97	break;
98	case B4B_KCS_BLOCK:
99	processBlock4B(get<Block4B>());
100	break;
101	case B5A_GLUE_BLOCK:
102	get<uint8_t>(10); // skip (ignore) this block
103	break;
104	case B14_PURE_DATA:
105	case B18_CSW_RECORDING:
106	case B19_GEN_DATA:
107	case B23_JUMP_BLOCK:
108	case B24_LOOP_START:
109	case B25_LOOP_END:
110	case B26_CALL_SEQ:
111	case B27_RET_SEQ:
112	case B28_SELECT_BLOCK:
113	case B2A_STOP_TAPE:
114	case B2B_SIGNAL_LEVEL:
115	case B31_MSG_BLOCK:
116	case B33_HARDWARE_TYPE:
117	// TODO not yet implemented, useful?
118	[[fallthrough]];
119	default:
120	error(strCat("Unsupported block: #", hex_string<2>(blockId)));
121	}
122	}
123	}
124
125	[[nodiscard]] static float tStates2samples(float tStates)
126	{
127	return tStates * TsxParser::OUTPUT_FREQUENCY / TsxParser::TZX_Z80_FREQ;
128	}
129
130	void TsxParser::writeSample(uint32_t tStates, int8_t value)
131	{
132	accumBytes += tStates2samples(float(tStates));
133	output.insert(end(output), int(accumBytes), value);
134	accumBytes -= float(int(accumBytes));
135	}
136
137	void TsxParser::writePulse(uint32_t tStates)
138	{
139	writeSample(tStates, currentValue);
140	currentValue = int8_t(-currentValue);
141	}
142
143	void TsxParser::writePulses(uint32_t count, uint32_t tStates)
144	{
145	repeat(count, [&] { writePulse(tStates); });
146	}
147
148	void TsxParser::writeSilence(int ms)
149	{
150	if (!ms) return;
151	output.insert(end(output), OUTPUT_FREQUENCY * ms / 1000, 0);
152	currentValue = 127;
153	}
154
155	// Standard Speed Block
156	void TsxParser::processBlock10(const Block10& b)
157	{
158	// delegate to 'block 11' but with some hardcoded values
159	Block11 b11 = {};
160	b11.pilot = 2168;
161	b11.sync1 = 667;
162	b11.sync2 = 735;
163	b11.zero = 855;
164	b11.one = 1710;
165	b11.pilotLen = 3223;
166	b11.lastBits = 8;
167	b11.pauseMs = b.pauseMs;
168	b11.len = b.len;
169	processBlock11(b11);
170	}
171
172	// Turbo Speed Block
173	void TsxParser::processBlock11(const Block11& b)
174	{
175	if ((b.len < 1) \|\| (b.lastBits < 1) \|\| (b.lastBits > 8)) {
176	error("Invalid block #11");
177	}
178
179	currentValue = -127;
180	writePulses(b.pilotLen, b.pilot);
181	writePulse(b.sync1);
182	writePulse(b.sync2);
183
184	auto writeByte = [&](uint8_t d, int nBits) {
185	for (auto bit : xrange(nBits)) {
186	if (d & (128 >> bit)) {
187	writePulses(2, b.one);
188	} else {
189	writePulses(2, b.zero);
190	}
191	}
192	};
193	uint32_t len = b.len;
194	auto data = get<uint8_t>(len);
195	for (auto i : xrange(len - 1)) {
196	writeByte(data[i], 8);
197	}
198	writeByte(data[len - 1], b.lastBits);
199
200	if (b.pauseMs != 0) writePulse(2000);
201	writeSilence(b.pauseMs);
202	}
203
204	// Pure Tone Block
205	void TsxParser::processBlock12(const Block12& b)
206	{
207	auto n = b.pulses & ~1; // round down to even
208	writePulses(n, b.len);
209	}
210
211	// Pulse sequence Block
212	void TsxParser::processBlock13(const Block13& b)
213	{
214	auto pulses = get<Endian::UA_L16>(b.num);
215	for (auto i : xrange(b.num)) {
216	writePulse(pulses[i]);
217	}
218	}
219
220	// Direct Recording
221	void TsxParser::processBlock15(const Block15& b)
222	{
223	if ((b.len < 1) \|\| (b.lastBits < 1) \|\| (b.lastBits > 8)) {
224	error("Invalid block #15");
225	}
226	auto samples = get<uint8_t>(b.len);
227
228	auto writeBit = [&](uint8_t& sample) {
229	writeSample(b.bitTstates, (sample & 128) ? 127 : -127);
230	sample <<= 1;
231	};
232	auto writeByte = [&](uint8_t sample, int nBits) {
233	repeat(nBits, [&]{ writeBit(sample); });
234	};
235	for (auto i : xrange(b.len - 1)) {
236	writeByte(samples[i], 8);
237	}
238	writeByte(samples[b.len - 1], b.lastBits);
239
240	writeSilence(b.pauseMs);
241	}
242
243	// Silence Block
244	void TsxParser::processBlock20(const Block20& b)
245	{
246	writeSilence(b.pauseMs);
247	}
248
249	// Group start Block
250	void TsxParser::processBlock21(const Block21& b)
251	{
252	get<uint8_t>(b.len); // ignore group name
253	}
254
255	// Text description Block
256	void TsxParser::processBlock30(const Block30& b)
257	{
258	auto text = get<char>(b.len);
259	messages.emplace_back(text.data(), text.size());
260	}
261
262	// Archive info Block
263	void TsxParser::processBlock32(const Block32& b)
264	{
265	uint16_t len = b.blockLen;
266	auto extra = sizeof(Block32) - sizeof(uint16_t);
267	if (len < extra) error("Invalid block #32");
268	len -= extra; // number of available bytes in the data block
269
270	auto data = get<char>(len);
271	repeat(uint32_t(b.num), [&] {
272	if (data.size() < 2) error("Invalid block #32");
273	uint8_t textId = data[0];
274	uint8_t textLen = data[1];
275	data = data.subspan(2);
276
277	if (data.size() < textLen) error("Invalid block #32");
278	if (textId == 0) {
279	messages.emplace_back(data.data(), textLen);
280	}
281	data = data.subspan(textLen);
282	});
283	if (!data.empty()) error("Invalid block #32");
284	}
285
286	// Custom info Block
287	void TsxParser::processBlock35(const Block35& b)
288	{
289	get<uint8_t>(b.len); // just skip (ignore) the data
290	}
291
292	// MSX KCS Block
293	void TsxParser::processBlock4B(const Block4B& b)
294	{
295	static constexpr std::array<uint8_t, 10> ASCII_HEADER = { 0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA,0xEA };
296	static constexpr std::array<uint8_t, 10> BINARY_HEADER = { 0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0,0xD0 };
297	static constexpr std::array<uint8_t, 10> BASIC_HEADER = { 0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3,0xD3 };
298
299	// get data block
300	uint32_t len = b.blockLen;
301	auto extra = sizeof(Block4B) - sizeof(uint32_t);
302	if (len < extra) error("Invalid block #4B: invalid length");
303	len -= extra; // number of available bytes in the data block
304	auto data = get<uint8_t>(len);
305
306	// determine file type
307	if (!firstFileType && (len == 16)) {
308	using enum FileType;
309	if (memcmp(data.data(), ASCII_HEADER.data(), ASCII_HEADER.size()) == 0) {
310	firstFileType = ASCII;
311	} else if (memcmp(data.data(), BINARY_HEADER.data(), BINARY_HEADER.size()) == 0) {
312	firstFileType = BINARY;
313	} else if (memcmp(data.data(), BASIC_HEADER.data(), BASIC_HEADER.size()) == 0) {
314	firstFileType = BASIC;
315	} else {
316	firstFileType = UNKNOWN;
317	}
318	}
319
320	// read the block
321	uint32_t pulsePilot = b.pilot;
322	uint32_t pulseOne = b.bit1len;
323	uint32_t pulseZero = b.bit0len;
324
325	auto decodeBitCfg = [](uint8_t x) { return x ? x : 16; };
326	auto numZeroPulses = decodeBitCfg(b.bitCfg >> 4); // 2 for MSX
327	auto numOnePulses = decodeBitCfg(b.bitCfg & 15); // 4 for MSX
328
329	auto numStartBits = (b.byteCfg & 0b11000000) >> 6; // 1 for MSX
330	bool startBitVal = (b.byteCfg & 0b00100000) >> 5; // 0 for MSX
331	auto numStopBits = (b.byteCfg & 0b00011000) >> 3; // 2 for MSX
332	bool stopBitVal = (b.byteCfg & 0b00000100) >> 2; // 1 for MSX
333	bool msb = (b.byteCfg & 0b00000001) >> 0; // 0 (LSB first) for MSX
334	if (b.byteCfg & 0b00000010) {
335	error(strCat("Invalid block #4B: unsupported byte-cfg: ", hex_string<2>(b.byteCfg)));
336	}
337
338	// write a header signal
339	writePulses(b.pulses, pulsePilot);
340
341	// write KCS bytes
342	auto write_01 = [&](bool bit) {
343	if (bit) {
344	writePulses(numOnePulses, pulseOne);
345	} else {
346	writePulses(numZeroPulses, pulseZero);
347	}
348	};
349	auto write_N_01 = [&](unsigned n, bool bit) {
350	repeat(n, [&] { write_01(bit); });
351	};
352	for (auto i : xrange(len)) {
353	// start bit(s)
354	write_N_01(numStartBits, startBitVal);
355	// 8 data bits
356	uint8_t d = data[i];
357	for (auto bit : xrange(8)) {
358	auto mask = uint8_t(1) << (msb ? (7 - bit) : bit);
359	write_01(d & mask);
360	}
361	// stop bit(s)
362	write_N_01(numStopBits, stopBitVal);
363	}
364	writeSilence(b.pauseMs);
365	}
366
367	template<typename T>
368	std::span<const T> TsxParser::get(size_t count)
369	{
370	static_assert(alignof(T) == 1, "T must be unaligned");
371
372	auto bytes = count * sizeof(T);
373	if (buf.size() < bytes) error("Invalid TSX file, read beyond end of file");
374
375	const T* result = std::bit_cast<const T*>(buf.data());
376	buf = buf.subspan(bytes);
377	return {result, count};
378	}
379
380	template<typename T>
381	const T& TsxParser::get()
382	{
383	const T* t = get<T>(1).data();
384	return *t;
385	}
386
387	void TsxParser::error(std::string msg) const
388	{
389	throw msg;
390	}

Keyboard