mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2026-01-19 13:03:11 +01:00
Code Issues Releases Wiki Activity

clang-format ui/util/windows

Browse Source
This commit is contained in:
clang-format
2018-06-22 23:16:39 +02:00
committed by Hielke Morsink
parent abb097124c
commit adb69a2fe8
11 changed files with 906 additions and 587 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -7,20 +7,21 @@
* OpenRCT2 is licensed under the GNU General Public License version 3.
*****************************************************************************/
#include <cstring>
#include "SawyerCoding.h"
#include "../core/Math.hpp"
#include "../platform/platform.h"
#include "../scenario/Scenario.h"
#include "SawyerCoding.h"
#include "Util.h"
#include <cstring>
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_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);
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;
@@ -35,70 +36,74 @@ uint32_t sawyercoding_calculate_checksum(const uint8_t* buffer, size_t length)
}
/**
*
* rct2: 0x006762E1
*
*/
size_t sawyercoding_write_chunk_buffer(uint8_t *dst_file, const uint8_t* buffer, sawyercoding_chunk_header chunkHeader) {
*
* rct2: 0x006762E1
*
*/
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) {
if (gUseRLE == false)
{
if (chunkHeader.encoding == CHUNK_ENCODING_RLE || chunkHeader.encoding == CHUNK_ENCODING_RLECOMPRESSED)
{
chunkHeader.encoding = CHUNK_ENCODING_NONE;
}
}
switch (chunkHeader.encoding){
case CHUNK_ENCODING_NONE:
memcpy(dst_file, &chunkHeader, sizeof(sawyercoding_chunk_header));
dst_file += sizeof(sawyercoding_chunk_header);
memcpy(dst_file, buffer, chunkHeader.length);
//fwrite(&chunkHeader, sizeof(sawyercoding_chunk_header), 1, file);
//fwrite(buffer, 1, chunkHeader.length, file);
break;
case CHUNK_ENCODING_RLE:
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);
switch (chunkHeader.encoding)
{
case CHUNK_ENCODING_NONE:
memcpy(dst_file, &chunkHeader, sizeof(sawyercoding_chunk_header));
dst_file += sizeof(sawyercoding_chunk_header);
memcpy(dst_file, buffer, chunkHeader.length);
// fwrite(&chunkHeader, sizeof(sawyercoding_chunk_header), 1, file);
// fwrite(buffer, 1, chunkHeader.length, file);
break;
case CHUNK_ENCODING_RLE:
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);
free(encode_buffer);
break;
case CHUNK_ENCODING_RLECOMPRESSED:
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);
free(encode_buffer);
break;
case CHUNK_ENCODING_RLECOMPRESSED:
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);
free(encode_buffer2);
free(encode_buffer);
break;
case CHUNK_ENCODING_ROTATE:
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));
dst_file += sizeof(sawyercoding_chunk_header);
memcpy(dst_file, encode_buffer, chunkHeader.length);
free(encode_buffer2);
free(encode_buffer);
break;
case CHUNK_ENCODING_ROTATE:
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));
dst_file += sizeof(sawyercoding_chunk_header);
memcpy(dst_file, encode_buffer, chunkHeader.length);
free(encode_buffer);
break;
free(encode_buffer);
break;
}
return chunkHeader.length + sizeof(sawyercoding_chunk_header);
}
size_t sawyercoding_decode_sv4(const uint8_t *src, uint8_t *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_t *src, uint8_t *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);
@@ -107,17 +112,18 @@ size_t sawyercoding_decode_sc4(const uint8_t *src, uint8_t *dst, size_t length,
for (size_t i = 0x60018; i <= std::min(decodedLength - 1, (size_t)0x1F8353); i++)
dst[i] = dst[i] ^ 0x9C;
for (size_t i = 0x60018; i <= std::min(decodedLength - 1, (size_t)0x1F8350); i += 4) {
for (size_t i = 0x60018; i <= std::min(decodedLength - 1, (size_t)0x1F8350); i += 4)
{
dst[i + 1] = ror8(dst[i + 1], 3);
uint32_t *code = (uint32_t*)&dst[i];
uint32_t* code = (uint32_t*)&dst[i];
*code = rol32(*code, 9);
}
return decodedLength;
}
size_t sawyercoding_encode_sv4(const uint8_t *src, uint8_t *dst, size_t length)
size_t sawyercoding_encode_sv4(const uint8_t* src, uint8_t* dst, size_t length)
{
size_t encodedLength;
uint32_t checksum;
@@ -132,16 +138,18 @@ size_t sawyercoding_encode_sv4(const uint8_t *src, uint8_t *dst, size_t length)
return encodedLength + 4;
}
size_t sawyercoding_decode_td6(const uint8_t *src, uint8_t *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_t* src, uint8_t* 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_t checksum = 0;
for (size_t i = 0; i < output_length; i++){
for (size_t i = 0; i < output_length; i++)
{
uint8_t new_byte = ((checksum & 0xFF) + dst[i]) & 0xFF;
checksum = (checksum & 0xFFFFFF00) + new_byte;
checksum = rol32(checksum, 3);
@@ -154,22 +162,24 @@ size_t sawyercoding_encode_td6(const uint8_t* src, uint8_t* dst, size_t length){
}
/* Based off of rct2: 0x006770C1 */
int32_t sawyercoding_validate_track_checksum(const uint8_t* src, size_t length){
int32_t sawyercoding_validate_track_checksum(const uint8_t* src, size_t length)
{
uint32_t file_checksum = *((uint32_t*)&src[length - 4]);
uint32_t checksum = 0;
for (size_t i = 0; i < length - 4; i++){
for (size_t i = 0; i < length - 4; i++)
{
uint8_t new_byte = ((checksum & 0xFF) + src[i]) & 0xFF;
checksum = (checksum & 0xFFFFFF00) + new_byte;
checksum = rol32(checksum, 3);
}
if (checksum - 0x1D4C1 == file_checksum)
return 1; // .TD6
return 1; // .TD6
else if (checksum - 0x1A67C == file_checksum)
return 1; // .TD4
return 1; // .TD4
else if (checksum - 0x1A650 == file_checksum)
return 1; // .TD4
return 1; // .TD4
else
return 0;
}
@@ -187,14 +197,18 @@ static size_t decode_chunk_rle(const uint8_t* src_buffer, uint8_t* dst_buffer, s
dst = dst_buffer;
for (size_t i = 0; i < length; i++) {
for (size_t i = 0; i < length; i++)
{
rleCodeByte = src_buffer[i];
if (rleCodeByte & 128) {
if (rleCodeByte & 128)
{
i++;
count = 257 - rleCodeByte;
memset(dst, src_buffer[i], count);
dst = (uint8_t*)((uintptr_t)dst + count);
} else {
}
else
{
memcpy(dst, src_buffer + i + 1, rleCodeByte + 1);
dst = (uint8_t*)((uintptr_t)dst + rleCodeByte + 1);
i += rleCodeByte + 1;
@@ -218,16 +232,20 @@ static size_t decode_chunk_rle_with_size(const uint8_t* src_buffer, uint8_t* dst
assert(length > 0);
assert(dstSize > 0);
for (size_t i = 0; i < length; i++) {
for (size_t i = 0; i < length; i++)
{
rleCodeByte = src_buffer[i];
if (rleCodeByte & 128) {
if (rleCodeByte & 128)
{
i++;
count = 257 - rleCodeByte;
assert(dst + count <= dst_buffer + dstSize);
assert(i < length);
memset(dst, src_buffer[i], count);
dst = (uint8_t*)((uintptr_t)dst + count);
} else {
}
else
{
assert(dst + rleCodeByte + 1 <= dst_buffer + dstSize);
assert(i + 1 < length);
memcpy(dst, src_buffer + i + 1, rleCodeByte + 1);
@@ -248,7 +266,7 @@ static size_t decode_chunk_rle_with_size(const uint8_t* src_buffer, uint8_t* dst
* Ensure dst_buffer is bigger than src_buffer then resize afterwards
* returns length of dst_buffer
*/
static size_t encode_chunk_rle(const uint8_t *src_buffer, uint8_t *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_t* src = src_buffer;
uint8_t* dst = dst_buffer;
@@ -256,18 +274,22 @@ static size_t encode_chunk_rle(const uint8_t *src_buffer, uint8_t *dst_buffer, s
uint8_t count = 0;
const uint8_t* src_norm_start = src;
while (src < end_src - 1){
if ((count && *src == src[1]) || count > 125){
while (src < end_src - 1)
{
if ((count && *src == src[1]) || count > 125)
{
*dst++ = count - 1;
memcpy(dst, src_norm_start, count);
dst += count;
src_norm_start += count;
count = 0;
}
if (*src == src[1]){
for (; (count < 125) && ((src + count) < end_src); count++){
if (*src != src[count]) break;
if (*src == src[1])
{
for (; (count < 125) && ((src + count) < end_src); count++)
{
if (*src != src[count])
break;
}
*dst++ = 257 - count;
*dst++ = *src;
@@ -275,13 +297,16 @@ static size_t encode_chunk_rle(const uint8_t *src_buffer, uint8_t *dst_buffer, s
src_norm_start = src;
count = 0;
}
else{
else
{
count++;
src++;
}
}
if (src == end_src - 1)count++;
if (count){
if (src == end_src - 1)
count++;
if (count)
{
*dst++ = count - 1;
memcpy(dst, src_norm_start, count);
dst += count;
@@ -289,7 +314,7 @@ static size_t encode_chunk_rle(const uint8_t *src_buffer, uint8_t *dst_buffer, s
return dst - dst_buffer;
}
static size_t encode_chunk_repeat(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)
{
if (length == 0)
return 0;
@@ -302,26 +327,33 @@ static size_t encode_chunk_repeat(const uint8_t *src_buffer, uint8_t *dst_buffer
outLength += 2;
// Iterate through remainder of the source buffer
for (size_t i = 1; i < length; ) {
for (size_t i = 1; i < length;)
{
size_t searchIndex = (i < 32) ? 0 : (i - 32);
size_t searchEnd = i - 1;
size_t bestRepeatIndex = 0;
size_t bestRepeatCount = 0;
for (size_t repeatIndex = searchIndex; repeatIndex <= searchEnd; repeatIndex++) {
for (size_t repeatIndex = searchIndex; repeatIndex <= searchEnd; repeatIndex++)
{
size_t repeatCount = 0;
size_t maxRepeatCount = std::min(std::min((size_t)7, searchEnd - repeatIndex), length - i - 1);
// maxRepeatCount should not exceed length
assert(repeatIndex + maxRepeatCount < length);
assert(i + maxRepeatCount < length);
for (size_t j = 0; j <= maxRepeatCount; j++) {
if (src_buffer[repeatIndex + j] == src_buffer[i + j]) {
for (size_t j = 0; j <= maxRepeatCount; j++)
{
if (src_buffer[repeatIndex + j] == src_buffer[i + j])
{
repeatCount++;
} else {
}
else
{
break;
}
}
if (repeatCount > bestRepeatCount) {
if (repeatCount > bestRepeatCount)
{
bestRepeatIndex = repeatIndex;
bestRepeatCount = repeatCount;
@@ -331,12 +363,15 @@ static size_t encode_chunk_repeat(const uint8_t *src_buffer, uint8_t *dst_buffer
}
}
if (bestRepeatCount == 0) {
if (bestRepeatCount == 0)
{
*dst_buffer++ = 255;
*dst_buffer++ = src_buffer[i];
outLength += 2;
i++;
} else {
}
else
{
*dst_buffer++ = (uint8_t)((bestRepeatCount - 1) | ((32 - (i - bestRepeatIndex)) << 3));
outLength++;
i += bestRepeatCount;
@@ -346,11 +381,12 @@ static size_t encode_chunk_repeat(const uint8_t *src_buffer, uint8_t *dst_buffer
return outLength;
}
static void encode_chunk_rotate(uint8_t *buffer, size_t length)
static void encode_chunk_rotate(uint8_t* buffer, size_t length)
{
size_t i;
uint8_t code = 1;
for (i = 0; i < length; i++) {
for (i = 0; i < length; i++)
{
buffer[i] = rol8(buffer[i], code);
code = (code + 2) % 8;
}
@@ -358,7 +394,7 @@ static void encode_chunk_rotate(uint8_t *buffer, size_t length)
#pragma endregion
int32_t sawyercoding_detect_file_type(const uint8_t *src, size_t length)
int32_t sawyercoding_detect_file_type(const uint8_t* src, size_t length)
{
size_t i;
@@ -366,7 +402,8 @@ int32_t sawyercoding_detect_file_type(const uint8_t *src, size_t length)
uint32_t checksum = *((uint32_t*)&src[length - 4]);
uint32_t actualChecksum = 0;
for (i = 0; i < length - 4; i++) {
for (i = 0; i < length - 4; i++)
{
actualChecksum = (actualChecksum & 0xFFFFFF00) | (((actualChecksum & 0xFF) + (uint8_t)src[i]) & 0xFF);
actualChecksum = rol32(actualChecksum, 3);
}