[pcsx_rearmed.git] / deps / libretro-common / formats / libchdr / libchdr_lzma.c

/***************************************************************************

    libchdr_lzma_codec.c

    MAME Compressed Hunks of Data file format

****************************************************************************

    Copyright Aaron Giles
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are
    met:

        * Redistributions of source code must retain the above copyright
          notice, this list of conditions and the following disclaimer.
        * Redistributions in binary form must reproduce the above copyright
          notice, this list of conditions and the following disclaimer in
          the documentation and/or other materials provided with the
          distribution.
        * Neither the name 'MAME' nor the names of its contributors may be
          used to endorse or promote products derived from this software
          without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.

***************************************************************************/

#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zlib.h>
#include <libchdr/chd.h>
#include <libchdr/minmax.h>
#include <libchdr/cdrom.h>
#include <libchdr/lzma.h>
#include <libchdr/huffman.h>

#include <retro_inline.h>
#include <streams/file_stream.h>

#define TRUE 1
#define FALSE 0

/***************************************************************************
 *  LZMA ALLOCATOR HELPER
 ***************************************************************************
 */

/*-------------------------------------------------
 *  lzma_fast_alloc - fast malloc for lzma, which
 *  allocates and frees memory frequently
 *-------------------------------------------------
 */

/* Huge alignment values for possible SIMD optimization by compiler (NEON, SSE, AVX) */
#define LZMA_MIN_ALIGNMENT_BITS 512
#define LZMA_MIN_ALIGNMENT_BYTES (LZMA_MIN_ALIGNMENT_BITS / 8)

static void *lzma_fast_alloc(void *p, size_t size)
{
	int scan;
	uint32_t *addr        = NULL;
	lzma_allocator *codec = (lzma_allocator *)(p);
	uintptr_t vaddr = 0;

	/* compute the size, rounding to the nearest 1k */
	size = (size + 0x3ff) & ~0x3ff;

	/* reuse a hunk if we can */
	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
	{
		uint32_t *ptr = codec->allocptr[scan];
		if (ptr != NULL && size == *ptr)
		{
			/* set the low bit of the size so we don't match next time */
			*ptr |= 1;

			/* return aligned address of the block */
			return codec->allocptr2[scan];
		}
	}

	/* alloc a new one and put it into the list */
	addr = (uint32_t *)malloc(size + sizeof(uint32_t) + LZMA_MIN_ALIGNMENT_BYTES);
	if (addr==NULL)
		return NULL;
	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
	{
		if (codec->allocptr[scan] == NULL)
		{
			/* store block address */
			codec->allocptr[scan] = addr;

			/* compute aligned address, store it */
			vaddr = (uintptr_t)addr;
			vaddr = (vaddr + sizeof(uint32_t) + (LZMA_MIN_ALIGNMENT_BYTES-1)) & (~(LZMA_MIN_ALIGNMENT_BYTES-1));
			codec->allocptr2[scan] = (uint32_t*)vaddr;
			break;
		}
	}

	/* set the low bit of the size so we don't match next time */
	*addr = size | 1;

	/* return aligned address */
	return (void*)vaddr;
}

/*-------------------------------------------------
 *  lzma_fast_free - fast free for lzma, which
 *  allocates and frees memory frequently
 *-------------------------------------------------
 */
static void lzma_fast_free(void *p, void *address)
{
	int scan;
	uint32_t *ptr = NULL;
	lzma_allocator *codec = NULL;

	if (address == NULL)
		return;

	codec = (lzma_allocator *)(p);

	/* find the hunk */
	ptr = (uint32_t *)address;
	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
	{
		if (ptr == codec->allocptr2[scan])
		{
			/* clear the low bit of the size to allow matches */
			*codec->allocptr[scan] &= ~1;
			return;
		}
	}
}

/*-------------------------------------------------
 *  lzma_allocator_init
 *-------------------------------------------------
 */

void lzma_allocator_init(void* p)
{
	lzma_allocator *codec = (lzma_allocator *)(p);

	/* reset pointer list */
	memset(codec->allocptr, 0, sizeof(codec->allocptr));
	codec->Alloc = lzma_fast_alloc;
	codec->Free = lzma_fast_free;
}

/*-------------------------------------------------
 *  lzma_allocator_free
 *-------------------------------------------------
 */

void lzma_allocator_free(void* p )
{
	lzma_allocator *codec = (lzma_allocator *)(p);

	/* free our memory */
	int i;
	for (i = 0 ; i < MAX_LZMA_ALLOCS ; i++)
	{
		if (codec->allocptr[i] != NULL)
			free(codec->allocptr[i]);
	}
}

/***************************************************************************
 *  LZMA DECOMPRESSOR
 ***************************************************************************
 */

/*-------------------------------------------------
 *  lzma_codec_init - constructor
 *-------------------------------------------------
 */

chd_error lzma_codec_init(void* codec, uint32_t hunkbytes)
{
	CLzmaEncProps encoder_props;
   CLzmaEncHandle enc;
	uint8_t decoder_props[LZMA_PROPS_SIZE];
   lzma_allocator* alloc;
   size_t props_size;
	lzma_codec_data* lzma_codec = (lzma_codec_data*) codec;

	/* construct the decoder */
	LzmaDec_Construct(&lzma_codec->decoder);

	/* FIXME: this code is written in a way that makes it impossible to safely upgrade the LZMA SDK
	 * This code assumes that the current version of the encoder imposes the same requirements on the
	 * decoder as the encoder used to produce the file.  This is not necessarily true.  The format
	 * needs to be changed so the encoder properties are written to the file.

	 * configure the properties like the compressor did */
	LzmaEncProps_Init(&encoder_props);
	encoder_props.level = 9;
	encoder_props.reduceSize = hunkbytes;
	LzmaEncProps_Normalize(&encoder_props);

	/* convert to decoder properties */
	alloc = &lzma_codec->allocator;
	lzma_allocator_init(alloc);
	enc = LzmaEnc_Create((ISzAlloc*)alloc);
	if (!enc)
		return CHDERR_DECOMPRESSION_ERROR;
	if (LzmaEnc_SetProps(enc, &encoder_props) != SZ_OK)
	{
		LzmaEnc_Destroy(enc, (ISzAlloc*)&alloc, (ISzAlloc*)&alloc);
		return CHDERR_DECOMPRESSION_ERROR;
	}
	props_size = sizeof(decoder_props);
	if (LzmaEnc_WriteProperties(enc, decoder_props, &props_size) != SZ_OK)
	{
		LzmaEnc_Destroy(enc, (ISzAlloc*)alloc, (ISzAlloc*)alloc);
		return CHDERR_DECOMPRESSION_ERROR;
	}
	LzmaEnc_Destroy(enc, (ISzAlloc*)alloc, (ISzAlloc*)alloc);

	/* do memory allocations */
	if (LzmaDec_Allocate(&lzma_codec->decoder, decoder_props, LZMA_PROPS_SIZE, (ISzAlloc*)alloc) != SZ_OK)
		return CHDERR_DECOMPRESSION_ERROR;

	/* Okay */
	return CHDERR_NONE;
}

/*-------------------------------------------------
 *  lzma_codec_free
 *-------------------------------------------------
 */

void lzma_codec_free(void* codec)
{
	lzma_codec_data* lzma_codec = (lzma_codec_data*) codec;
	lzma_allocator* alloc = &lzma_codec->allocator;

	/* free memory */
	LzmaDec_Free(&lzma_codec->decoder, (ISzAlloc*)&lzma_codec->allocator);
	lzma_allocator_free(alloc);
}

/*-------------------------------------------------
 *  decompress - decompress data using the LZMA
 *  codec
 *-------------------------------------------------
 */

chd_error lzma_codec_decompress(void* codec, const uint8_t *src, uint32_t complen, uint8_t *dest, uint32_t destlen)
{
	ELzmaStatus status;
   SRes res;
   size_t consumedlen, decodedlen;
	/* initialize */
	lzma_codec_data* lzma_codec = (lzma_codec_data*) codec;
	LzmaDec_Init(&lzma_codec->decoder);

	/* decode */
	consumedlen = complen;
	decodedlen = destlen;
	res = LzmaDec_DecodeToBuf(&lzma_codec->decoder, dest, &decodedlen, src, &consumedlen, LZMA_FINISH_END, &status);
	if ((res != SZ_OK && res != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK) || consumedlen != complen || decodedlen != destlen)
		return CHDERR_DECOMPRESSION_ERROR;
	return CHDERR_NONE;
}

/* cdlz */
chd_error cdlz_codec_init(void* codec, uint32_t hunkbytes)
{
	chd_error ret;
	cdlz_codec_data* cdlz = (cdlz_codec_data*) codec;

	/* allocate buffer */
	cdlz->buffer = (uint8_t*)malloc(sizeof(uint8_t) * hunkbytes);
	if (cdlz->buffer == NULL)
		return CHDERR_OUT_OF_MEMORY;

	ret = lzma_codec_init(&cdlz->base_decompressor, (hunkbytes / CD_FRAME_SIZE) * CD_MAX_SECTOR_DATA);
	if (ret != CHDERR_NONE)
		return ret;

#ifdef WANT_SUBCODE
	ret = zlib_codec_init(&cdlz->subcode_decompressor, (hunkbytes / CD_FRAME_SIZE) * CD_MAX_SECTOR_DATA);
	if (ret != CHDERR_NONE)
		return ret;
#endif

	return CHDERR_NONE;
}

void cdlz_codec_free(void* codec)
{
	cdlz_codec_data* cdlz = (cdlz_codec_data*) codec;

	lzma_codec_free(&cdlz->base_decompressor);
#ifdef WANT_SUBCODE
	zlib_codec_free(&cdlz->subcode_decompressor);
#endif
	if (cdlz->buffer)
		free(cdlz->buffer);
}

chd_error cdlz_codec_decompress(void *codec, const uint8_t *src, uint32_t complen, uint8_t *dest, uint32_t destlen)
{
#ifdef WANT_RAW_DATA_SECTOR
	uint8_t *sector;
#endif
	uint32_t framenum;
	cdlz_codec_data* cdlz = (cdlz_codec_data*)codec;

	/* determine header bytes */
	uint32_t frames = destlen / CD_FRAME_SIZE;
	uint32_t complen_bytes = (destlen < 65536) ? 2 : 3;
	uint32_t ecc_bytes = (frames + 7) / 8;
	uint32_t header_bytes = ecc_bytes + complen_bytes;

	/* extract compressed length of base */
	uint32_t complen_base = (src[ecc_bytes + 0] << 8) | src[ecc_bytes + 1];
	if (complen_bytes > 2)
		complen_base = (complen_base << 8) | src[ecc_bytes + 2];

	/* reset and decode */
	lzma_codec_decompress(&cdlz->base_decompressor, &src[header_bytes], complen_base, &cdlz->buffer[0], frames * CD_MAX_SECTOR_DATA);
#ifdef WANT_SUBCODE
	if (header_bytes + complen_base >= complen)
		return CHDERR_DECOMPRESSION_ERROR;
	zlib_codec_decompress(&cdlz->subcode_decompressor, &src[header_bytes + complen_base], complen - complen_base - header_bytes, &cdlz->buffer[frames * CD_MAX_SECTOR_DATA], frames * CD_MAX_SUBCODE_DATA);
#endif

	/* reassemble the data */
	for (framenum = 0; framenum < frames; framenum++)
	{
		memcpy(&dest[framenum * CD_FRAME_SIZE], &cdlz->buffer[framenum * CD_MAX_SECTOR_DATA], CD_MAX_SECTOR_DATA);
#ifdef WANT_SUBCODE
		memcpy(&dest[framenum * CD_FRAME_SIZE + CD_MAX_SECTOR_DATA], &cdlz->buffer[frames * CD_MAX_SECTOR_DATA + framenum * CD_MAX_SUBCODE_DATA], CD_MAX_SUBCODE_DATA);
#endif

#ifdef WANT_RAW_DATA_SECTOR
		/* reconstitute the ECC data and sync header */
		sector = (uint8_t *)&dest[framenum * CD_FRAME_SIZE];
		if ((src[framenum / 8] & (1 << (framenum % 8))) != 0)
		{
			memcpy(sector, s_cd_sync_header, sizeof(s_cd_sync_header));
			ecc_generate(sector);
		}
#endif
	}
	return CHDERR_NONE;
}
Commit	Line	Data
3719602c PC	1	/***************************************************************************
	2
	3	libchdr_lzma_codec.c
	4
	5	MAME Compressed Hunks of Data file format
	6
	7	****************************************************************************
	8
	9	Copyright Aaron Giles
	10	All rights reserved.
	11
	12	Redistribution and use in source and binary forms, with or without
	13	modification, are permitted provided that the following conditions are
	14	met:
	15
	16	* Redistributions of source code must retain the above copyright
	17	notice, this list of conditions and the following disclaimer.
	18	* Redistributions in binary form must reproduce the above copyright
	19	notice, this list of conditions and the following disclaimer in
	20	the documentation and/or other materials provided with the
	21	distribution.
	22	* Neither the name 'MAME' nor the names of its contributors may be
	23	used to endorse or promote products derived from this software
	24	without specific prior written permission.
	25
	26	THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
	27	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	28	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	29	DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
	30	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	31	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	32	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	33	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	34	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	35	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	36	POSSIBILITY OF SUCH DAMAGE.
	37
	38	***************************************************************************/
	39
	40	#include <stddef.h>
	41	#include <stdint.h>
	42	#include <stdio.h>
	43	#include <stdlib.h>
	44	#include <string.h>
	45	#include <zlib.h>
	46	#include <libchdr/chd.h>
	47	#include <libchdr/minmax.h>
	48	#include <libchdr/cdrom.h>
	49	#include <libchdr/lzma.h>
	50	#include <libchdr/huffman.h>
	51
	52	#include <retro_inline.h>
	53	#include <streams/file_stream.h>
	54
	55	#define TRUE 1
	56	#define FALSE 0
	57
	58	/***************************************************************************
	59	* LZMA ALLOCATOR HELPER
	60	***************************************************************************
	61	*/
	62
	63	/*-------------------------------------------------
	64	* lzma_fast_alloc - fast malloc for lzma, which
65	* allocates and frees memory frequently
66	*-------------------------------------------------
67	*/
68
69	/* Huge alignment values for possible SIMD optimization by compiler (NEON, SSE, AVX) */
70	#define LZMA_MIN_ALIGNMENT_BITS 512
71	#define LZMA_MIN_ALIGNMENT_BYTES (LZMA_MIN_ALIGNMENT_BITS / 8)
72
73	static void lzma_fast_alloc(void p, size_t size)
74	{
75	int scan;
76	uint32_t *addr = NULL;
77	lzma_allocator codec = (lzma_allocator )(p);
78	uintptr_t vaddr = 0;
79
80	/* compute the size, rounding to the nearest 1k */
81	size = (size + 0x3ff) & ~0x3ff;
82
83	/* reuse a hunk if we can */
84	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
85	{
86	uint32_t *ptr = codec->allocptr[scan];
87	if (ptr != NULL && size == *ptr)
88	{
89	/* set the low bit of the size so we don't match next time */
90	*ptr \|= 1;
91
92	/* return aligned address of the block */
93	return codec->allocptr2[scan];
94	}
95	}
96
97	/* alloc a new one and put it into the list */
98	addr = (uint32_t *)malloc(size + sizeof(uint32_t) + LZMA_MIN_ALIGNMENT_BYTES);
99	if (addr==NULL)
100	return NULL;
101	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
102	{
103	if (codec->allocptr[scan] == NULL)
104	{
105	/* store block address */
106	codec->allocptr[scan] = addr;
107
108	/* compute aligned address, store it */
109	vaddr = (uintptr_t)addr;
110	vaddr = (vaddr + sizeof(uint32_t) + (LZMA_MIN_ALIGNMENT_BYTES-1)) & (~(LZMA_MIN_ALIGNMENT_BYTES-1));
111	codec->allocptr2[scan] = (uint32_t*)vaddr;
112	break;
113	}
114	}
115
116	/* set the low bit of the size so we don't match next time */
117	*addr = size \| 1;
118
119	/* return aligned address */
120	return (void*)vaddr;
121	}
122
123	/*-------------------------------------------------
124	* lzma_fast_free - fast free for lzma, which
125	* allocates and frees memory frequently
126	*-------------------------------------------------
127	*/
128	static void lzma_fast_free(void p, void address)
129	{
130	int scan;
131	uint32_t *ptr = NULL;
132	lzma_allocator *codec = NULL;
133
134	if (address == NULL)
135	return;
136
137	codec = (lzma_allocator *)(p);
138
139	/* find the hunk */
140	ptr = (uint32_t *)address;
141	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
142	{
143	if (ptr == codec->allocptr2[scan])
144	{
145	/* clear the low bit of the size to allow matches */
146	*codec->allocptr[scan] &= ~1;
147	return;
148	}
149	}
150	}
151
152	/*-------------------------------------------------
153	* lzma_allocator_init
154	*-------------------------------------------------
155	*/
156
157	void lzma_allocator_init(void* p)
158	{
159	lzma_allocator codec = (lzma_allocator )(p);
160
161	/* reset pointer list */
162	memset(codec->allocptr, 0, sizeof(codec->allocptr));
163	codec->Alloc = lzma_fast_alloc;
164	codec->Free = lzma_fast_free;
165	}
166
167	/*-------------------------------------------------
168	* lzma_allocator_free
169	*-------------------------------------------------
170	*/
171
172	void lzma_allocator_free(void* p )
173	{
174	lzma_allocator codec = (lzma_allocator )(p);
175
176	/* free our memory */
177	int i;
178	for (i = 0 ; i < MAX_LZMA_ALLOCS ; i++)
179	{
180	if (codec->allocptr[i] != NULL)
181	free(codec->allocptr[i]);
182	}
183	}
184
185	/***************************************************************************
186	* LZMA DECOMPRESSOR
187	***************************************************************************
188	*/
189
190	/*-------------------------------------------------
191	* lzma_codec_init - constructor
192	*-------------------------------------------------
193	*/
194
195	chd_error lzma_codec_init(void* codec, uint32_t hunkbytes)
196	{
197	CLzmaEncProps encoder_props;
198	CLzmaEncHandle enc;
199	uint8_t decoder_props[LZMA_PROPS_SIZE];
200	lzma_allocator* alloc;
201	size_t props_size;
202	lzma_codec_data* lzma_codec = (lzma_codec_data*) codec;
203
204	/* construct the decoder */
205	LzmaDec_Construct(&lzma_codec->decoder);
206
207	/* FIXME: this code is written in a way that makes it impossible to safely upgrade the LZMA SDK
208	* This code assumes that the current version of the encoder imposes the same requirements on the
209	* decoder as the encoder used to produce the file. This is not necessarily true. The format
210	* needs to be changed so the encoder properties are written to the file.
211
212	* configure the properties like the compressor did */
213	LzmaEncProps_Init(&encoder_props);
214	encoder_props.level = 9;
215	encoder_props.reduceSize = hunkbytes;
216	LzmaEncProps_Normalize(&encoder_props);
217
218	/* convert to decoder properties */
219	alloc = &lzma_codec->allocator;
220	lzma_allocator_init(alloc);
221	enc = LzmaEnc_Create((ISzAlloc*)alloc);
222	if (!enc)
223	return CHDERR_DECOMPRESSION_ERROR;
224	if (LzmaEnc_SetProps(enc, &encoder_props) != SZ_OK)
225	{
226	LzmaEnc_Destroy(enc, (ISzAlloc)&alloc, (ISzAlloc)&alloc);
227	return CHDERR_DECOMPRESSION_ERROR;
228	}
229	props_size = sizeof(decoder_props);
230	if (LzmaEnc_WriteProperties(enc, decoder_props, &props_size) != SZ_OK)
231	{
232	LzmaEnc_Destroy(enc, (ISzAlloc)alloc, (ISzAlloc)alloc);
233	return CHDERR_DECOMPRESSION_ERROR;
234	}
235	LzmaEnc_Destroy(enc, (ISzAlloc)alloc, (ISzAlloc)alloc);
236
237	/* do memory allocations */
238	if (LzmaDec_Allocate(&lzma_codec->decoder, decoder_props, LZMA_PROPS_SIZE, (ISzAlloc*)alloc) != SZ_OK)
239	return CHDERR_DECOMPRESSION_ERROR;
240
241	/* Okay */
242	return CHDERR_NONE;
243	}
244
245	/*-------------------------------------------------
246	* lzma_codec_free
247	*-------------------------------------------------
248	*/
249
250	void lzma_codec_free(void* codec)
251	{
252	lzma_codec_data* lzma_codec = (lzma_codec_data*) codec;
253	lzma_allocator* alloc = &lzma_codec->allocator;
254
255	/* free memory */
256	LzmaDec_Free(&lzma_codec->decoder, (ISzAlloc*)&lzma_codec->allocator);
257	lzma_allocator_free(alloc);
258	}
259
260	/*-------------------------------------------------
261	* decompress - decompress data using the LZMA
262	* codec
263	*-------------------------------------------------
264	*/
265
266	chd_error lzma_codec_decompress(void* codec, const uint8_t src, uint32_t complen, uint8_t dest, uint32_t destlen)
267	{
268	ELzmaStatus status;
269	SRes res;
270	size_t consumedlen, decodedlen;
271	/* initialize */
272	lzma_codec_data* lzma_codec = (lzma_codec_data*) codec;
273	LzmaDec_Init(&lzma_codec->decoder);
274
275	/* decode */
276	consumedlen = complen;
277	decodedlen = destlen;
278	res = LzmaDec_DecodeToBuf(&lzma_codec->decoder, dest, &decodedlen, src, &consumedlen, LZMA_FINISH_END, &status);
279	if ((res != SZ_OK && res != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK) \|\| consumedlen != complen \|\| decodedlen != destlen)
280	return CHDERR_DECOMPRESSION_ERROR;
281	return CHDERR_NONE;
282	}
283
284	/* cdlz */
285	chd_error cdlz_codec_init(void* codec, uint32_t hunkbytes)
286	{
287	chd_error ret;
288	cdlz_codec_data* cdlz = (cdlz_codec_data*) codec;
289
290	/* allocate buffer */
291	cdlz->buffer = (uint8_t)malloc(sizeof(uint8_t) hunkbytes);
292	if (cdlz->buffer == NULL)
293	return CHDERR_OUT_OF_MEMORY;
294
295	ret = lzma_codec_init(&cdlz->base_decompressor, (hunkbytes / CD_FRAME_SIZE) * CD_MAX_SECTOR_DATA);
296	if (ret != CHDERR_NONE)
297	return ret;
298
299	#ifdef WANT_SUBCODE
300	ret = zlib_codec_init(&cdlz->subcode_decompressor, (hunkbytes / CD_FRAME_SIZE) * CD_MAX_SECTOR_DATA);
301	if (ret != CHDERR_NONE)
302	return ret;
303	#endif
304
305	return CHDERR_NONE;
306	}
307
308	void cdlz_codec_free(void* codec)
309	{
310	cdlz_codec_data* cdlz = (cdlz_codec_data*) codec;
311
312	lzma_codec_free(&cdlz->base_decompressor);
313	#ifdef WANT_SUBCODE
314	zlib_codec_free(&cdlz->subcode_decompressor);
315	#endif
316	if (cdlz->buffer)
317	free(cdlz->buffer);
318	}
319
320	chd_error cdlz_codec_decompress(void codec, const uint8_t src, uint32_t complen, uint8_t *dest, uint32_t destlen)
321	{
322	#ifdef WANT_RAW_DATA_SECTOR
323	uint8_t *sector;
324	#endif
325	uint32_t framenum;
326	cdlz_codec_data* cdlz = (cdlz_codec_data*)codec;
327
328	/* determine header bytes */
329	uint32_t frames = destlen / CD_FRAME_SIZE;
330	uint32_t complen_bytes = (destlen < 65536) ? 2 : 3;
331	uint32_t ecc_bytes = (frames + 7) / 8;
332	uint32_t header_bytes = ecc_bytes + complen_bytes;
333
334	/* extract compressed length of base */
335	uint32_t complen_base = (src[ecc_bytes + 0] << 8) \| src[ecc_bytes + 1];
336	if (complen_bytes > 2)
337	complen_base = (complen_base << 8) \| src[ecc_bytes + 2];
338
339	/* reset and decode */
340	lzma_codec_decompress(&cdlz->base_decompressor, &src[header_bytes], complen_base, &cdlz->buffer[0], frames * CD_MAX_SECTOR_DATA);
341	#ifdef WANT_SUBCODE
342	if (header_bytes + complen_base >= complen)
343	return CHDERR_DECOMPRESSION_ERROR;
344	zlib_codec_decompress(&cdlz->subcode_decompressor, &src[header_bytes + complen_base], complen - complen_base - header_bytes, &cdlz->buffer[frames * CD_MAX_SECTOR_DATA], frames * CD_MAX_SUBCODE_DATA);
345	#endif
346
347	/* reassemble the data */
348	for (framenum = 0; framenum < frames; framenum++)
349	{
350	memcpy(&dest[framenum * CD_FRAME_SIZE], &cdlz->buffer[framenum * CD_MAX_SECTOR_DATA], CD_MAX_SECTOR_DATA);
351	#ifdef WANT_SUBCODE
352	memcpy(&dest[framenum * CD_FRAME_SIZE + CD_MAX_SECTOR_DATA], &cdlz->buffer[frames * CD_MAX_SECTOR_DATA + framenum * CD_MAX_SUBCODE_DATA], CD_MAX_SUBCODE_DATA);
353	#endif
354
355	#ifdef WANT_RAW_DATA_SECTOR
356	/* reconstitute the ECC data and sync header */
357	sector = (uint8_t )&dest[framenum CD_FRAME_SIZE];
358	if ((src[framenum / 8] & (1 << (framenum % 8))) != 0)
359	{
360	memcpy(sector, s_cd_sync_header, sizeof(s_cd_sync_header));
361	ecc_generate(sector);
362	}
363	#endif
364	}
365	return CHDERR_NONE;
366	}