mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2026-01-27 00:34:46 +01:00
Code Issues Releases Wiki Activity

Replace our own integer types with standard ones

Browse Source
This commit is contained in:
Michael Steenbeek
2018-06-20 17:28:51 +02:00
parent ec3a1e575e
commit 1b08fb4e69
618 changed files with 33440 additions and 33449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
src/openrct2/util/SawyerCoding.cpp
View File

@@ -15,19 +15,19 @@
#include "SawyerCoding.h"
#include "Util.h"
static size_t decode_chunk_rle(const uint8* src_buffer, uint8* dst_buffer, size_t length);
static size_t decode_chunk_rle_with_size(const uint8* src_buffer, uint8* dst_buffer, size_t length, size_t dstSize);
static size_t decode_chunk_rle(const uint8_t* src_buffer, uint8_t* dst_buffer, size_t length);
static size_t decode_chunk_rle_with_size(const uint8_t* src_buffer, uint8_t* dst_buffer, size_t length, size_t dstSize);
static size_t encode_chunk_rle(const uint8 *src_buffer, uint8 *dst_buffer, size_t length);
static size_t encode_chunk_repeat(const uint8 *src_buffer, uint8 *dst_buffer, size_t length);
static void encode_chunk_rotate(uint8 *buffer, size_t length);
static size_t encode_chunk_rle(const uint8_t *src_buffer, uint8_t *dst_buffer, size_t length);
static size_t encode_chunk_repeat(const uint8_t *src_buffer, uint8_t *dst_buffer, size_t length);
static void encode_chunk_rotate(uint8_t *buffer, size_t length);
bool gUseRLE = true;
uint32 sawyercoding_calculate_checksum(const uint8* buffer, size_t length)
uint32_t sawyercoding_calculate_checksum(const uint8_t* buffer, size_t length)
{
size_t i;
uint32 checksum = 0;
uint32_t checksum = 0;
for (i = 0; i < length; i++)
checksum += buffer[i];
@@ -39,8 +39,8 @@ uint32 sawyercoding_calculate_checksum(const uint8* buffer, size_t length)
* rct2: 0x006762E1
*
*/
size_t sawyercoding_write_chunk_buffer(uint8 *dst_file, const uint8* buffer, sawyercoding_chunk_header chunkHeader) {
uint8 *encode_buffer, *encode_buffer2;
size_t sawyercoding_write_chunk_buffer(uint8_t *dst_file, const uint8_t* buffer, sawyercoding_chunk_header chunkHeader) {
uint8_t *encode_buffer, *encode_buffer2;
if (gUseRLE == false) {
if (chunkHeader.encoding == CHUNK_ENCODING_RLE || chunkHeader.encoding == CHUNK_ENCODING_RLECOMPRESSED) {
@@ -56,8 +56,8 @@ size_t sawyercoding_write_chunk_buffer(uint8 *dst_file, const uint8* buffer, saw
//fwrite(buffer, 1, chunkHeader.length, file);
break;
case CHUNK_ENCODING_RLE:
encode_buffer = (uint8 *)malloc(0x600000);
chunkHeader.length = (uint32)encode_chunk_rle(buffer, encode_buffer, chunkHeader.length);
encode_buffer = (uint8_t *)malloc(0x600000);
chunkHeader.length = (uint32_t)encode_chunk_rle(buffer, encode_buffer, chunkHeader.length);
memcpy(dst_file, &chunkHeader, sizeof(sawyercoding_chunk_header));
dst_file += sizeof(sawyercoding_chunk_header);
memcpy(dst_file, encode_buffer, chunkHeader.length);
@@ -65,10 +65,10 @@ size_t sawyercoding_write_chunk_buffer(uint8 *dst_file, const uint8* buffer, saw
free(encode_buffer);
break;
case CHUNK_ENCODING_RLECOMPRESSED:
encode_buffer = (uint8 *)malloc(chunkHeader.length * 2);
encode_buffer2 = (uint8 *)malloc(0x600000);
chunkHeader.length = (uint32)encode_chunk_repeat(buffer, encode_buffer, chunkHeader.length);
chunkHeader.length = (uint32)encode_chunk_rle(encode_buffer, encode_buffer2, chunkHeader.length);
encode_buffer = (uint8_t *)malloc(chunkHeader.length * 2);
encode_buffer2 = (uint8_t *)malloc(0x600000);
chunkHeader.length = (uint32_t)encode_chunk_repeat(buffer, encode_buffer, chunkHeader.length);
chunkHeader.length = (uint32_t)encode_chunk_rle(encode_buffer, encode_buffer2, chunkHeader.length);
memcpy(dst_file, &chunkHeader, sizeof(sawyercoding_chunk_header));
dst_file += sizeof(sawyercoding_chunk_header);
memcpy(dst_file, encode_buffer2, chunkHeader.length);
@@ -77,7 +77,7 @@ size_t sawyercoding_write_chunk_buffer(uint8 *dst_file, const uint8* buffer, saw
free(encode_buffer);
break;
case CHUNK_ENCODING_ROTATE:
encode_buffer = (uint8 *)malloc(chunkHeader.length);
encode_buffer = (uint8_t *)malloc(chunkHeader.length);
memcpy(encode_buffer, buffer, chunkHeader.length);
encode_chunk_rotate(encode_buffer, chunkHeader.length);
memcpy(dst_file, &chunkHeader, sizeof(sawyercoding_chunk_header));
@@ -91,14 +91,14 @@ size_t sawyercoding_write_chunk_buffer(uint8 *dst_file, const uint8* buffer, saw
return chunkHeader.length + sizeof(sawyercoding_chunk_header);
}
size_t sawyercoding_decode_sv4(const uint8 *src, uint8 *dst, size_t length, size_t bufferLength)
size_t sawyercoding_decode_sv4(const uint8_t *src, uint8_t *dst, size_t length, size_t bufferLength)
{
// (0 to length - 4): RLE chunk
// (length - 4 to length): checksum
return decode_chunk_rle_with_size(src, dst, length - 4, bufferLength);
}
size_t sawyercoding_decode_sc4(const uint8 *src, uint8 *dst, size_t length, size_t bufferLength)
size_t sawyercoding_decode_sc4(const uint8_t *src, uint8_t *dst, size_t length, size_t bufferLength)
{
// Uncompress
size_t decodedLength = decode_chunk_rle_with_size(src, dst, length - 4, bufferLength);
@@ -110,56 +110,56 @@ size_t sawyercoding_decode_sc4(const uint8 *src, uint8 *dst, size_t length, size
for (size_t i = 0x60018; i <= std::min(decodedLength - 1, (size_t)0x1F8350); i += 4) {
dst[i + 1] = ror8(dst[i + 1], 3);
uint32 *code = (uint32*)&dst[i];
uint32_t *code = (uint32_t*)&dst[i];
*code = rol32(*code, 9);
}
return decodedLength;
}
size_t sawyercoding_encode_sv4(const uint8 *src, uint8 *dst, size_t length)
size_t sawyercoding_encode_sv4(const uint8_t *src, uint8_t *dst, size_t length)
{
size_t encodedLength;
uint32 checksum;
uint32_t checksum;
// Encode
encodedLength = encode_chunk_rle(src, dst, length);
// Append checksum
checksum = sawyercoding_calculate_checksum(dst, encodedLength);
*((uint32*)&dst[encodedLength]) = checksum;
*((uint32_t*)&dst[encodedLength]) = checksum;
return encodedLength + 4;
}
size_t sawyercoding_decode_td6(const uint8 *src, uint8 *dst, size_t length)
size_t sawyercoding_decode_td6(const uint8_t *src, uint8_t *dst, size_t length)
{
return decode_chunk_rle(src, dst, length - 4);
}
size_t sawyercoding_encode_td6(const uint8* src, uint8* dst, size_t length){
size_t sawyercoding_encode_td6(const uint8_t* src, uint8_t* dst, size_t length){
size_t output_length = encode_chunk_rle(src, dst, length);
uint32 checksum = 0;
uint32_t checksum = 0;
for (size_t i = 0; i < output_length; i++){
uint8 new_byte = ((checksum & 0xFF) + dst[i]) & 0xFF;
uint8_t new_byte = ((checksum & 0xFF) + dst[i]) & 0xFF;
checksum = (checksum & 0xFFFFFF00) + new_byte;
checksum = rol32(checksum, 3);
}
checksum -= 0x1D4C1;
*((uint32*)&dst[output_length]) = checksum;
*((uint32_t*)&dst[output_length]) = checksum;
output_length += 4;
return output_length;
}
/* Based off of rct2: 0x006770C1 */
sint32 sawyercoding_validate_track_checksum(const uint8* src, size_t length){
uint32 file_checksum = *((uint32*)&src[length - 4]);
int32_t sawyercoding_validate_track_checksum(const uint8_t* src, size_t length){
uint32_t file_checksum = *((uint32_t*)&src[length - 4]);
uint32 checksum = 0;
uint32_t checksum = 0;
for (size_t i = 0; i < length - 4; i++){
uint8 new_byte = ((checksum & 0xFF) + src[i]) & 0xFF;
uint8_t new_byte = ((checksum & 0xFF) + src[i]) & 0xFF;
checksum = (checksum & 0xFFFFFF00) + new_byte;
checksum = rol32(checksum, 3);
}
@@ -180,10 +180,10 @@ sint32 sawyercoding_validate_track_checksum(const uint8* src, size_t length){
*
* rct2: 0x0067693A
*/
static size_t decode_chunk_rle(const uint8* src_buffer, uint8* dst_buffer, size_t length)
static size_t decode_chunk_rle(const uint8_t* src_buffer, uint8_t* dst_buffer, size_t length)
{
size_t count;
uint8 *dst, rleCodeByte;
uint8_t *dst, rleCodeByte;
dst = dst_buffer;
@@ -193,10 +193,10 @@ static size_t decode_chunk_rle(const uint8* src_buffer, uint8* dst_buffer, size_
i++;
count = 257 - rleCodeByte;
memset(dst, src_buffer[i], count);
dst = (uint8*)((uintptr_t)dst + count);
dst = (uint8_t*)((uintptr_t)dst + count);
} else {
memcpy(dst, src_buffer + i + 1, rleCodeByte + 1);
dst = (uint8*)((uintptr_t)dst + rleCodeByte + 1);
dst = (uint8_t*)((uintptr_t)dst + rleCodeByte + 1);
i += rleCodeByte + 1;
}
}
@@ -209,10 +209,10 @@ static size_t decode_chunk_rle(const uint8* src_buffer, uint8* dst_buffer, size_
*
* rct2: 0x0067693A
*/
static size_t decode_chunk_rle_with_size(const uint8* src_buffer, uint8* dst_buffer, size_t length, size_t dstSize)
static size_t decode_chunk_rle_with_size(const uint8_t* src_buffer, uint8_t* dst_buffer, size_t length, size_t dstSize)
{
size_t count;
uint8 *dst, rleCodeByte;
uint8_t *dst, rleCodeByte;
dst = dst_buffer;
@@ -226,12 +226,12 @@ static size_t decode_chunk_rle_with_size(const uint8* src_buffer, uint8* dst_buf
assert(dst + count <= dst_buffer + dstSize);
assert(i < length);
memset(dst, src_buffer[i], count);
dst = (uint8*)((uintptr_t)dst + count);
dst = (uint8_t*)((uintptr_t)dst + count);
} else {
assert(dst + rleCodeByte + 1 <= dst_buffer + dstSize);
assert(i + 1 < length);
memcpy(dst, src_buffer + i + 1, rleCodeByte + 1);
dst = (uint8*)((uintptr_t)dst + rleCodeByte + 1);
dst = (uint8_t*)((uintptr_t)dst + rleCodeByte + 1);
i += rleCodeByte + 1;
}
}
@@ -248,13 +248,13 @@ static size_t decode_chunk_rle_with_size(const uint8* src_buffer, uint8* dst_buf
* Ensure dst_buffer is bigger than src_buffer then resize afterwards
* returns length of dst_buffer
*/
static size_t encode_chunk_rle(const uint8 *src_buffer, uint8 *dst_buffer, size_t length)
static size_t encode_chunk_rle(const uint8_t *src_buffer, uint8_t *dst_buffer, size_t length)
{
const uint8* src = src_buffer;
uint8* dst = dst_buffer;
const uint8* end_src = src + length;
uint8 count = 0;
const uint8* src_norm_start = src;
const uint8_t* src = src_buffer;
uint8_t* dst = dst_buffer;
const uint8_t* end_src = src + length;
uint8_t count = 0;
const uint8_t* src_norm_start = src;
while (src < end_src - 1){
@@ -289,7 +289,7 @@ static size_t encode_chunk_rle(const uint8 *src_buffer, uint8 *dst_buffer, size_
return dst - dst_buffer;
}
static size_t encode_chunk_repeat(const uint8 *src_buffer, uint8 *dst_buffer, size_t length)
static size_t encode_chunk_repeat(const uint8_t *src_buffer, uint8_t *dst_buffer, size_t length)
{
if (length == 0)
return 0;
@@ -337,7 +337,7 @@ static size_t encode_chunk_repeat(const uint8 *src_buffer, uint8 *dst_buffer, si
outLength += 2;
i++;
} else {
*dst_buffer++ = (uint8)((bestRepeatCount - 1) | ((32 - (i - bestRepeatIndex)) << 3));
*dst_buffer++ = (uint8_t)((bestRepeatCount - 1) | ((32 - (i - bestRepeatIndex)) << 3));
outLength++;
i += bestRepeatCount;
}
@@ -346,10 +346,10 @@ static size_t encode_chunk_repeat(const uint8 *src_buffer, uint8 *dst_buffer, si
return outLength;
}
static void encode_chunk_rotate(uint8 *buffer, size_t length)
static void encode_chunk_rotate(uint8_t *buffer, size_t length)
{
size_t i;
uint8 code = 1;
uint8_t code = 1;
for (i = 0; i < length; i++) {
buffer[i] = rol8(buffer[i], code);
code = (code + 2) % 8;
@@ -358,25 +358,25 @@ static void encode_chunk_rotate(uint8 *buffer, size_t length)
#pragma endregion
sint32 sawyercoding_detect_file_type(const uint8 *src, size_t length)
int32_t sawyercoding_detect_file_type(const uint8_t *src, size_t length)
{
size_t i;
// Currently can't detect TD4, as the checksum is the same as SC4 (need alternative method)
uint32 checksum = *((uint32*)&src[length - 4]);
uint32 actualChecksum = 0;
uint32_t checksum = *((uint32_t*)&src[length - 4]);
uint32_t actualChecksum = 0;
for (i = 0; i < length - 4; i++) {
actualChecksum = (actualChecksum & 0xFFFFFF00) | (((actualChecksum & 0xFF) + (uint8)src[i]) & 0xFF);
actualChecksum = (actualChecksum & 0xFFFFFF00) | (((actualChecksum & 0xFF) + (uint8_t)src[i]) & 0xFF);
actualChecksum = rol32(actualChecksum, 3);
}
return sawyercoding_detect_rct1_version(checksum - actualChecksum);
}
sint32 sawyercoding_detect_rct1_version(sint32 gameVersion)
int32_t sawyercoding_detect_rct1_version(int32_t gameVersion)
{
sint32 fileType = (gameVersion) > 0 ? FILE_TYPE_SV4 : FILE_TYPE_SC4;
int32_t fileType = (gameVersion) > 0 ? FILE_TYPE_SV4 : FILE_TYPE_SC4;
gameVersion = abs(gameVersion);
if (gameVersion >= 108000 && gameVersion < 110000)