DevKit7/libctru
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add decompressHeader

Browse Source
This commit is contained in:
Michael Theall 2017-12-02 01:48:47 -06:00 committed by fincs
parent 1165b4cb8b
commit cc22550296
2 changed files with 153 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
libctru/include/3ds/util/decompress.h
View File

@ -5,8 +5,28 @@
#pragma once #pragma once
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h>
#include <sys/types.h> #include <sys/types.h>
/** @brief Compression types */
typedef enum
{
DECOMPRESS_DUMMY = 0x00, ///< Dummy compression
DECOMPRESS_LZSS = 0x10, ///< LZSS/LZ10 compression
DECOMPRESS_LZ10 = 0x10, ///< LZSS/LZ10 compression
DECOMPRESS_LZ11 = 0x11, ///< LZ11 compression
DECOMPRESS_HUFF1 = 0x21, ///< Huffman compression with 1-bit data
DECOMPRESS_HUFF2 = 0x22, ///< Huffman compression with 2-bit data
DECOMPRESS_HUFF3 = 0x23, ///< Huffman compression with 3-bit data
DECOMPRESS_HUFF4 = 0x24, ///< Huffman compression with 4-bit data
DECOMPRESS_HUFF5 = 0x25, ///< Huffman compression with 5-bit data
DECOMPRESS_HUFF6 = 0x26, ///< Huffman compression with 6-bit data
DECOMPRESS_HUFF7 = 0x27, ///< Huffman compression with 7-bit data
DECOMPRESS_HUFF8 = 0x28, ///< Huffman compression with 8-bit data
DECOMPRESS_HUFF = 0x28, ///< Huffman compression with 8-bit data
DECOMPRESS_RLE = 0x30, ///< Run-length encoding compression
} decompressType;
/** @brief I/O vector */ /** @brief I/O vector */
typedef struct typedef struct
{ {
@ -39,6 +59,19 @@ ssize_t decompressCallback_FD(void *userdata, void *buffer, size_t size);
*/ */
ssize_t decompressCallback_Stdio(void *userdata, void *buffer, size_t size); ssize_t decompressCallback_Stdio(void *userdata, void *buffer, size_t size);
/** @brief Decode decompression header
* @param[out] type Decompression type
* @param[out] size Decompressed size
* @param[in] callback Data callback (see decompressV())
* @param[in] userdata User data passed to callback (see decompressV())
* @param[in] insize Size of userdata (see decompressV())
* @returns Bytes consumed
* @retval -1 error
*/
ssize_t decompressHeader(decompressType *type, size_t *size,
decompressCallback callback, void *userdata,
size_t insize);
/** @brief Decompress data /** @brief Decompress data
* @param[in] iov Output vector * @param[in] iov Output vector
* @param[in] iovcnt Number of buffers * @param[in] iovcnt Number of buffers
@ -137,6 +170,7 @@ decompress_LZ11(void *output, size_t size, decompressCallback callback,
} }
/** @brief Decompress Huffman /** @brief Decompress Huffman
* @param[in] bits Data size in bits (usually 4 or 8)
* @param[in] iov Output vector * @param[in] iov Output vector
* @param[in] iovcnt Number of buffers * @param[in] iovcnt Number of buffers
* @param[in] callback Data callback (see decompressV()) * @param[in] callback Data callback (see decompressV())
@ -144,11 +178,12 @@ decompress_LZ11(void *output, size_t size, decompressCallback callback,
* @param[in] insize Size of userdata (see decompressV()) * @param[in] insize Size of userdata (see decompressV())
* @returns Whether succeeded * @returns Whether succeeded
*/ */
bool decompressV_Huff(const decompressIOVec *iov, size_t iovcnt, bool decompressV_Huff(size_t bits, const decompressIOVec *iov, size_t iovcnt,
decompressCallback callback, void *userdata, decompressCallback callback, void *userdata,
size_t insize); size_t insize);
/** @brief Decompress Huffman /** @brief Decompress Huffman
* @param[in] bits Data size in bits (usually 4 or 8)
* @param[in] output Output buffer * @param[in] output Output buffer
* @param[in] size Output size limit * @param[in] size Output size limit
* @param[in] callback Data callback (see decompressV()) * @param[in] callback Data callback (see decompressV())
@ -157,14 +192,14 @@ bool decompressV_Huff(const decompressIOVec *iov, size_t iovcnt,
* @returns Whether succeeded * @returns Whether succeeded
*/ */
static inline bool static inline bool
decompress_Huff(void *output, size_t size, decompressCallback callback, decompress_Huff(size_t bits, void *output, size_t size,
void *userdata, size_t insize) decompressCallback callback, void *userdata, size_t insize)
{ {
decompressIOVec iov; decompressIOVec iov;
iov.data = output; iov.data = output;
iov.size = size; iov.size = size;
return decompressV_Huff(&iov, 1, callback, userdata, insize); return decompressV_Huff(bits, &iov, 1, callback, userdata, insize);
} }
/** @brief Decompress run-length encoding /** @brief Decompress run-length encoding

179
libctru/source/util/decompress/decompress.c
View File

@ -31,24 +31,39 @@ typedef struct
/** @brief Initialize buffer object from memory /** @brief Initialize buffer object from memory
* @param[in] buffer Decompression buffer object * @param[in] buffer Decompression buffer object
* @param[in] data Data to buffer * @param[in] data Data to emulate buffering
* @param[in] size Data size * @param[in] size Data size
*/ */
static inline void static inline void
buffer_memory(buffer_t *buffer, const void *data, size_t size) buffer_memory(buffer_t *buffer, const void *data, size_t size)
{ {
buffer->data = (void*)data; buffer->data = (void*)data;
buffer->size = size; buffer->limit = size;
buffer->pos = 0; buffer->size = size;
buffer->pos = 0;
} }
/** @brief Initialize buffer object /** @brief Initialize buffer object with static memory
* @param[in] buffer Decompression buffer object
* @param[in] data Data buffer
* @param[in] size Data size
*/
static inline void
buffer_static(buffer_t *buffer, const void *data, size_t size)
{
buffer->data = (void*)data;
buffer->limit = size;
buffer->size = 0;
buffer->pos = 0;
}
/** @brief Initialize buffer object with dynamic memory
* @param[in] buffer Decompression buffer object * @param[in] buffer Decompression buffer object
* @param[in] size Buffer size limit * @param[in] size Buffer size limit
* @returns Whether succeeded * @returns Whether succeeded
*/ */
static inline bool static inline bool
buffer_init(buffer_t *buffer, size_t size) buffer_dynamic(buffer_t *buffer, size_t size)
{ {
buffer->data = (uint8_t*)malloc(size); buffer->data = (uint8_t*)malloc(size);
if(!buffer->data) if(!buffer->data)
@ -498,6 +513,7 @@ decompress_lz11(buffer_t *buffer, const decompressIOVec *iov, size_t iovcnt,
} }
/** @brief Decompress Huffman /** @brief Decompress Huffman
* @param[in] bits Data size in bits (usually 4 or 8)
* @param[in] buffer Decompression buffer object * @param[in] buffer Decompression buffer object
* @param[in] iov Output vector * @param[in] iov Output vector
* @param[in] iovcnt Number of buffers * @param[in] iovcnt Number of buffers
@ -507,9 +523,13 @@ decompress_lz11(buffer_t *buffer, const decompressIOVec *iov, size_t iovcnt,
* @returns Whether succeeded * @returns Whether succeeded
*/ */
static bool static bool
decompress_huff(buffer_t *buffer, const decompressIOVec *iov, size_t iovcnt, decompress_huff(const size_t bits, buffer_t *buffer, const decompressIOVec *iov,
size_t size, decompressCallback callback, void *userdata) size_t iovcnt, size_t size, decompressCallback callback,
void *userdata)
{ {
if(bits < 1 || bits > 8)
return false;
uint8_t *tree = (uint8_t*)malloc(512); uint8_t *tree = (uint8_t*)malloc(512);
if(!tree) if(!tree)
return false; return false;
@ -528,14 +548,13 @@ decompress_huff(buffer_t *buffer, const decompressIOVec *iov, size_t iovcnt,
return false; return false;
} }
iov_iter out = iov_begin(iov, iovcnt); iov_iter out = iov_begin(iov, iovcnt);
const size_t bits = 8; uint32_t word = 0; // 32-bits of input bitstream
uint32_t word = 0; // 32-bits of input bitstream uint32_t mask = 0; // which bit we are reading
uint32_t mask = 0; // which bit we are reading uint8_t dataMask = (1<<bits)-1; // mask to apply to data
uint32_t dataMask = (1<<bits)-1; // mask to apply to data size_t node; // node in the huffman tree
size_t node; // node in the huffman tree size_t child; // child of a node
size_t child; // child of a node uint32_t offset; // offset from node to child
uint32_t offset; // offset from node to child
// point to the root of the huffman tree // point to the root of the huffman tree
node = 1; node = 1;
@ -686,45 +705,67 @@ decompressCallback_Stdio(void *userdata, void *buffer, size_t size)
return fread(buffer, 1, size, fp); return fread(buffer, 1, size, fp);
} }
ssize_t
decompressHeader(decompressType *type, size_t *size,
decompressCallback callback, void *userdata, size_t insize)
{
buffer_t buffer;
uint8_t bufferdata[4];
if(!callback)
buffer_memory(&buffer, userdata, insize);
else
buffer_static(&buffer, bufferdata, sizeof(bufferdata));
uint8_t header[4];
if(!buffer_read(&buffer, header, 4, callback, userdata))
return -1;
size_t bytes = 4;
decompressType outtype = header[0] & ~0x80;
size_t outsize = (header[1] << 0)
| (header[2] << 8)
| (header[3] << 16);
if(header[0] & 0x80)
{
if(!buffer_read(&buffer, header, 4, callback, userdata))
return -1;
bytes += 4;
outsize |= header[0] << 24;
}
if(type)
*type = outtype;
if(size)
*size = outsize;
return bytes;
}
bool bool
decompressV(const decompressIOVec *iov, size_t iovcnt, decompressV(const decompressIOVec *iov, size_t iovcnt,
decompressCallback callback, void *userdata, size_t usersize) decompressCallback callback, void *userdata, size_t insize)
{ {
if(iovcnt == 0) if(iovcnt == 0)
return false; return false;
decompressType type;
size_t size;
ssize_t bytes = decompressHeader(&type, &size, callback, userdata, insize);
if(bytes < 0)
return false;
buffer_t buffer; buffer_t buffer;
if(!callback) if(!callback)
buffer_memory(&buffer, userdata, usersize);
else if(!buffer_init(&buffer, BUFFERSIZE))
return false;
uint8_t header[8];
if(!buffer_read(&buffer, header, 4, callback, userdata))
{ {
if(callback) userdata = (uint8_t*)userdata + bytes;
buffer_destroy(&buffer); insize -= bytes;
buffer_memory(&buffer, userdata, insize);
}
else if(!buffer_dynamic(&buffer, BUFFERSIZE))
return false; return false;
}
uint8_t type = header[0];
size_t size = (header[1] << 0)
| (header[2] << 8)
| (header[3] << 16);
if(type & 0x80)
{
type &= ~0x80;
if(!buffer_read(&buffer, &header[4], 4, callback, userdata))
{
if(callback)
buffer_destroy(&buffer);
return false;
}
size |= header[4] << 24;
}
size_t iovsize = iov_size(iov, iovcnt); size_t iovsize = iov_size(iov, iovcnt);
if(iovsize < size) if(iovsize < size)
@ -733,26 +774,34 @@ decompressV(const decompressIOVec *iov, size_t iovcnt,
bool result = false; bool result = false;
switch(type) switch(type)
{ {
case 0x00: case DECOMPRESS_DUMMY:
{ {
iov_iter out = iov_begin(iov, iovcnt); iov_iter out = iov_begin(iov, iovcnt);
result = iov_read(&buffer, &out, size, callback, userdata); result = iov_read(&buffer, &out, size, callback, userdata);
break; break;
} }
case 0x10: case DECOMPRESS_LZSS:
result = decompress_lzss(&buffer, iov, iovcnt, size, callback, userdata); result = decompress_lzss(&buffer, iov, iovcnt, size, callback, userdata);
break; break;
case 0x11: case DECOMPRESS_LZ11:
result = decompress_lz11(&buffer, iov, iovcnt, size, callback, userdata); result = decompress_lz11(&buffer, iov, iovcnt, size, callback, userdata);
break; break;
case 0x28: case DECOMPRESS_HUFF1:
result = decompress_huff(&buffer, iov, iovcnt, size, callback, userdata); case DECOMPRESS_HUFF2:
case DECOMPRESS_HUFF3:
case DECOMPRESS_HUFF4:
case DECOMPRESS_HUFF5:
case DECOMPRESS_HUFF6:
case DECOMPRESS_HUFF7:
case DECOMPRESS_HUFF8:
result = decompress_huff(type & 0xF, &buffer, iov, iovcnt, size,
callback, userdata);
break; break;
case 0x30: case DECOMPRESS_RLE:
result = decompress_rle(&buffer, iov, iovcnt, size, callback, userdata); result = decompress_rle(&buffer, iov, iovcnt, size, callback, userdata);
break; break;
} }
@ -764,12 +813,12 @@ decompressV(const decompressIOVec *iov, size_t iovcnt,
bool bool
decompressV_LZSS(const decompressIOVec *iov, size_t iovcnt, decompressV_LZSS(const decompressIOVec *iov, size_t iovcnt,
decompressCallback callback, void *userdata, size_t usersize) decompressCallback callback, void *userdata, size_t insize)
{ {
buffer_t buffer; buffer_t buffer;
if(!callback) if(!callback)
buffer_memory(&buffer, userdata, usersize); buffer_memory(&buffer, userdata, insize);
else if(!buffer_init(&buffer, BUFFERSIZE)) else if(!buffer_dynamic(&buffer, BUFFERSIZE))
return false; return false;
size_t size = iov_size(iov, iovcnt); size_t size = iov_size(iov, iovcnt);
@ -782,12 +831,12 @@ decompressV_LZSS(const decompressIOVec *iov, size_t iovcnt,
bool bool
decompressV_LZ11(const decompressIOVec *iov, size_t iovcnt, decompressV_LZ11(const decompressIOVec *iov, size_t iovcnt,
decompressCallback callback, void *userdata, size_t usersize) decompressCallback callback, void *userdata, size_t insize)
{ {
buffer_t buffer; buffer_t buffer;
if(!callback) if(!callback)
buffer_memory(&buffer, userdata, usersize); buffer_memory(&buffer, userdata, insize);
else if(!buffer_init(&buffer, BUFFERSIZE)) else if(!buffer_dynamic(&buffer, BUFFERSIZE))
return false; return false;
size_t size = iov_size(iov, iovcnt); size_t size = iov_size(iov, iovcnt);
@ -799,17 +848,17 @@ decompressV_LZ11(const decompressIOVec *iov, size_t iovcnt,
} }
bool bool
decompressV_Huff(const decompressIOVec *iov, size_t iovcnt, decompressV_Huff(size_t bits, const decompressIOVec *iov, size_t iovcnt,
decompressCallback callback, void *userdata, size_t usersize) decompressCallback callback, void *userdata, size_t insize)
{ {
buffer_t buffer; buffer_t buffer;
if(!callback) if(!callback)
buffer_memory(&buffer, userdata, usersize); buffer_memory(&buffer, userdata, insize);
else if(!buffer_init(&buffer, BUFFERSIZE)) else if(!buffer_dynamic(&buffer, BUFFERSIZE))
return false; return false;
size_t size = iov_size(iov, iovcnt); size_t size = iov_size(iov, iovcnt);
bool result = decompress_huff(&buffer, iov, iovcnt, size, callback, userdata); bool result = decompress_huff(bits, &buffer, iov, iovcnt, size, callback, userdata);
if(callback) if(callback)
buffer_destroy(&buffer); buffer_destroy(&buffer);
@ -818,12 +867,12 @@ decompressV_Huff(const decompressIOVec *iov, size_t iovcnt,
bool bool
decompressV_RLE(const decompressIOVec *iov, size_t iovcnt, decompressV_RLE(const decompressIOVec *iov, size_t iovcnt,
decompressCallback callback, void *userdata, size_t usersize) decompressCallback callback, void *userdata, size_t insize)
{ {
buffer_t buffer; buffer_t buffer;
if(!callback) if(!callback)
buffer_memory(&buffer, userdata, usersize); buffer_memory(&buffer, userdata, insize);
else if(!buffer_init(&buffer, BUFFERSIZE)) else if(!buffer_dynamic(&buffer, BUFFERSIZE))
return false; return false;
size_t size = iov_size(iov, iovcnt); size_t size = iov_size(iov, iovcnt);