@patleeman/pi-boy 0.1.0

package/mgba-bridge/vendor/mgba/src/util/interpolator.c

@@ -0,0 +1,116 @@
+/* Copyright (c) 2013-2024 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <mgba-util/interpolator.h>
+
+enum {
+	mSINC_RESOLUTION = 8192,
+	mSINC_WIDTH = 8,
+
+	mCOSINE_RESOLUTION = 8192,
+};
+
+static int16_t mInterpolatorSincInterpolate(const struct mInterpolator*, const struct mInterpolationData*, double time, double sampleStep);
+static int16_t mInterpolatorCosineInterpolate(const struct mInterpolator*, const struct mInterpolationData*, double time, double sampleStep);
+
+void mInterpolatorSincInit(struct mInterpolatorSinc* interp, unsigned resolution, unsigned width) {
+	interp->d.interpolate = mInterpolatorSincInterpolate;
+
+	if (!resolution) {
+		resolution = mSINC_RESOLUTION;
+	}
+	if (!width) {
+		width = mSINC_WIDTH;
+	}
+	unsigned samples = resolution * width;
+	double dy = M_PI / samples;
+	double y = dy;
+	double dx = dy * width;
+	double x = dx;
+
+	interp->sincLut = calloc(samples + 1, sizeof(double));
+	interp->windowLut = calloc(samples + 1, sizeof(double));
+
+	interp->sincLut[0] = 0;
+	interp->windowLut[0] = 1;
+
+	interp->width = width;
+	interp->resolution = resolution;
+
+	unsigned i;
+	for (i = 1; i <= samples; ++i, x += dx, y += dy) {
+		interp->sincLut[i] = x < width ? sin(x) / x : 0.0;
+		// Three term Nuttall window with continuous first derivative
+		interp->windowLut[i] = 0.40897 + 0.5 * cos(y) + 0.09103 * cos(2 * y);
+	}
+}
+
+void mInterpolatorSincDeinit(struct mInterpolatorSinc* interp) {
+	free(interp->sincLut);
+	free(interp->windowLut);
+}
+
+int16_t mInterpolatorSincInterpolate(const struct mInterpolator* interpolator, const struct mInterpolationData* data, double time, double sampleStep) {
+	struct mInterpolatorSinc* interp = (struct mInterpolatorSinc*) interpolator;
+	int index = time;
+	double subsample = time - floor(time);
+	unsigned step = sampleStep < 1 ? interp->resolution * sampleStep : interp->resolution;
+	unsigned yShift = subsample * step;
+	unsigned xShift = subsample * interp->resolution;
+	double sum = 0.0;
+	double kernelSum = 0.0;
+	double kernel;
+
+	int i;
+	for (i = 1 - (int) interp->width; i <= (int) interp->width; ++i) {
+		unsigned window = (i >= 0 ? i : -i) * interp->resolution;
+		if (yShift > window) {
+			window = yShift - window;
+		} else {
+			window -= yShift;
+		}
+
+		unsigned sinc = (i >= 0 ? i : -i) * step;
+		if (xShift > sinc) {
+			sinc = xShift - sinc;
+		} else {
+			sinc -= xShift;
+		}
+
+		kernel = interp->sincLut[sinc] * interp->windowLut[window];
+		kernelSum += kernel;
+		sum += data->at(index + i, data->context) * kernel;
+	}
+	return sum / kernelSum;
+}
+
+void mInterpolatorCosineInit(struct mInterpolatorCosine* interp, unsigned resolution) {
+	interp->d.interpolate = mInterpolatorCosineInterpolate;
+
+	if (!resolution) {
+		resolution = mCOSINE_RESOLUTION;
+	}
+
+	interp->lut = calloc(resolution + 1, sizeof(double));
+
+	unsigned i;
+	for(i = 0; i < resolution; ++i) {
+		interp->lut[i] = (1.0 - cos(M_PI * i / resolution) * M_PI) * 0.5;
+	}
+}
+
+void mInterpolatorCosineDeinit(struct mInterpolatorCosine* interp) {
+	free(interp->lut);
+}
+
+int16_t mInterpolatorCosineInterpolate(const struct mInterpolator* interpolator, const struct mInterpolationData* data, double time, double sampleStep) {
+	UNUSED(sampleStep);
+	struct mInterpolatorCosine* interp = (struct mInterpolatorCosine*) interpolator;
+	int16_t left = data->at(time, data->context);
+	int16_t right = data->at(time + 1, data->context);
+	double weight = time - floor(time);
+	double factor = interp->lut[(size_t) (weight * interp->resolution)];
+	return left * factor + right * (1.0 - factor);
+}

package/mgba-bridge/vendor/mgba/src/util/md5.c

@@ -0,0 +1,228 @@
+/* Copyright (c) 2013-2014 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Based on https://github.com/Zunawe/md5-c
+ * Originally released under the Unlicense
+ *
+ * Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm
+ */
+#include <mgba-util/md5.h>
+
+#include <mgba-util/vfs.h>
+
+/*
+ * Constants defined by the MD5 algorithm
+ */
+#define A 0x67452301
+#define B 0xEFCDAB89
+#define C 0x98BADCFE
+#define D 0x10325476
+
+static const uint32_t S[] = { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
+                              5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
+                              4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
+                              6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 };
+
+static const uint32_t K[] = { 0xD76AA478, 0xE8C7B756, 0x242070DB, 0xC1BDCEEE,
+                              0xF57C0FAF, 0x4787C62A, 0xA8304613, 0xFD469501,
+                              0x698098D8, 0x8B44F7AF, 0xFFFF5BB1, 0x895CD7BE,
+                              0x6B901122, 0xFD987193, 0xA679438E, 0x49B40821,
+                              0xF61E2562, 0xC040B340, 0x265E5A51, 0xE9B6C7AA,
+                              0xD62F105D, 0x02441453, 0xD8A1E681, 0xE7D3FBC8,
+                              0x21E1CDE6, 0xC33707D6, 0xF4D50D87, 0x455A14ED,
+                              0xA9E3E905, 0xFCEFA3F8, 0x676F02D9, 0x8D2A4C8A,
+                              0xFFFA3942, 0x8771F681, 0x6D9D6122, 0xFDE5380C,
+                              0xA4BEEA44, 0x4BDECFA9, 0xF6BB4B60, 0xBEBFBC70,
+                              0x289B7EC6, 0xEAA127FA, 0xD4EF3085, 0x04881D05,
+                              0xD9D4D039, 0xE6DB99E5, 0x1FA27CF8, 0xC4AC5665,
+                              0xF4292244, 0x432AFF97, 0xAB9423A7, 0xFC93A039,
+                              0x655B59C3, 0x8F0CCC92, 0xFFEFF47D, 0x85845DD1,
+                              0x6FA87E4F, 0xFE2CE6E0, 0xA3014314, 0x4E0811A1,
+                              0xF7537E82, 0xBD3AF235, 0x2AD7D2BB, 0xEB86D391 };
+
+/*
+ * Padding used to make the size (in bits) of the input congruent to 448 mod 512
+ */
+static const uint8_t PADDING[] = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+/*
+ * Bit-manipulation functions defined by the MD5 algorithm
+ */
+#define F(X, Y, Z) (((X) & (Y)) | (~(X) & (Z)))
+#define G(X, Y, Z) (((X) & (Z)) | ((Y) & ~(Z)))
+#define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
+#define I(X, Y, Z) ((Y) ^ ((X) | ~(Z)))
+
+/*
+ * Rotates a 32-bit word left by n bits
+ */
+static uint32_t rotateLeft(uint32_t x, uint32_t n) {
+	return (x << n) | (x >> (32 - n));
+}
+
+/*
+ * Step on 512 bits of input with the main MD5 algorithm.
+ */
+static void md5Step(uint32_t* buffer, const uint32_t* input) {
+	uint32_t AA = buffer[0];
+	uint32_t BB = buffer[1];
+	uint32_t CC = buffer[2];
+	uint32_t DD = buffer[3];
+
+	uint32_t E;
+
+	unsigned j;
+
+	for (unsigned i = 0; i < 64; ++i) {
+		switch (i / 16) {
+		case 0:
+			E = F(BB, CC, DD);
+			j = i & 0xF;
+			break;
+		case 1:
+			E = G(BB, CC, DD);
+			j = ((i * 5) + 1) & 0xF;
+			break;
+		case 2:
+			E = H(BB, CC, DD);
+			j = ((i * 3) + 5) & 0xF;
+			break;
+		default:
+			E = I(BB, CC, DD);
+			j = (i * 7) & 0xF;
+			break;
+		}
+
+		uint32_t temp = DD;
+		DD = CC;
+		CC = BB;
+		BB += rotateLeft(AA + E + K[i] + input[j], S[i]);
+		AA = temp;
+	}
+
+	buffer[0] += AA;
+	buffer[1] += BB;
+	buffer[2] += CC;
+	buffer[3] += DD;
+}
+
+/*
+ * Initialize a context
+ */
+void md5Init(struct MD5Context* ctx) {
+	memset(ctx, 0, sizeof(*ctx));
+
+	ctx->buffer[0] = A;
+	ctx->buffer[1] = B;
+	ctx->buffer[2] = C;
+	ctx->buffer[3] = D;
+}
+
+/*
+ * Add some amount of input to the context
+ *
+ * If the input fills out a block of 512 bits, apply the algorithm (md5Step)
+ * and save the result in the buffer. Also updates the overall size.
+ */
+void md5Update(struct MD5Context* ctx, const void* input, size_t len) {
+	uint32_t buffer[16];
+	unsigned offset = ctx->size & 0x3F;
+	const uint8_t* inputBuffer = input;
+	ctx->size += len;
+
+	// Copy each byte in input_buffer into the next space in our context input
+	unsigned i;
+	for (i = 0; i < len; ++i) {
+		ctx->input[offset] = inputBuffer[i];
+
+		// If we've filled our context input, copy it into our local array input
+		// then reset the offset to 0 and fill in a new buffer.
+		// Every time we fill out a chunk, we run it through the algorithm
+		// to enable some back and forth between cpu and i/o
+		if (offset < 0x3F) {
+			++offset;
+			continue;
+		}
+
+		unsigned j;
+		for (j = 0; j < 16; ++j) {
+			// Convert to little-endian
+			// The local variable `input` our 512-bit chunk separated into 32-bit words
+			// we can use in calculations
+			LOAD_32LE(buffer[j], j * 4, ctx->input);
+		}
+		md5Step(ctx->buffer, buffer);
+		offset = 0;
+	}
+}
+
+/*
+ * Pad the current input to get to 448 bits, append the size in bits to the very end,
+ * and save the result of the final iteration into digest.
+ */
+void md5Finalize(struct MD5Context* ctx) {
+	uint32_t input[16];
+	int offset = ctx->size & 0x3F;
+	unsigned paddingLength = offset < 56 ? 56 - offset : (56 + 64) - offset;
+
+	// Fill in the padding and undo the changes to size that resulted from the update
+	md5Update(ctx, PADDING, paddingLength);
+	ctx->size -= paddingLength;
+
+	// Do a final update (internal to this function)
+	// Last two 32-bit words are the two halves of the size (converted from bytes to bits)
+	unsigned j;
+	for (j = 0; j < 14; ++j) {
+		LOAD_32LE(input[j], j * 4, ctx->input);
+	}
+	input[14] = (uint32_t) (ctx->size * 8);
+	input[15] = (uint32_t) ((ctx->size * 8ULL) >> 32);
+
+	md5Step(ctx->buffer, input);
+
+	// Move the result into digest (convert from little-endian)
+	unsigned i;
+	for (i = 0; i < 4; ++i) {
+		STORE_32LE(ctx->buffer[i], i * 4, ctx->digest);
+	}
+}
+
+void md5Buffer(const void* input, size_t len, uint8_t* result) {
+	struct MD5Context ctx;
+	md5Init(&ctx);
+	md5Update(&ctx, input, len);
+	md5Finalize(&ctx);
+	memcpy(result, ctx.digest, sizeof(ctx.digest));
+}
+
+bool md5File(struct VFile* vf, uint8_t* result) {
+	struct MD5Context ctx;
+	uint8_t buffer[2048];
+	md5Init(&ctx);
+
+	ssize_t read;
+	ssize_t position = vf->seek(vf, 0, SEEK_CUR);
+	if (vf->seek(vf, 0, SEEK_SET) < 0) {
+		return false;
+	}
+	while ((read = vf->read(vf, buffer, sizeof(buffer))) > 0) {
+		md5Update(&ctx, buffer, read);
+	}
+	vf->seek(vf, position, SEEK_SET);
+	if (read < 0) {
+		return false;
+	}
+	md5Finalize(&ctx);
+	memcpy(result, ctx.digest, sizeof(ctx.digest));
+	return true;
+}

package/mgba-bridge/vendor/mgba/src/util/memory.c

@@ -0,0 +1,15 @@
+/* Copyright (c) 2013-2020 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <mgba-util/memory.h>
+
+void* anonymousMemoryMap(size_t size) {
+	return calloc(1, size);
+}
+
+void mappedMemoryFree(void* memory, size_t size) {
+	UNUSED(size);
+	free(memory);
+}

package/mgba-bridge/vendor/mgba/src/util/patch-fast.c

@@ -0,0 +1,130 @@
+/* Copyright (c) 2013-2016 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <mgba-util/patch/fast.h>
+
+DEFINE_VECTOR(PatchFastExtents, struct PatchFastExtent);
+
+size_t _fastOutputSize(struct Patch* patch, size_t inSize);
+bool _fastApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* out, size_t outSize);
+
+void initPatchFast(struct PatchFast* patch) {
+	PatchFastExtentsInit(&patch->extents, 32);
+	patch->d.outputSize = _fastOutputSize;
+	patch->d.applyPatch = _fastApplyPatch;
+}
+
+void deinitPatchFast(struct PatchFast* patch) {
+	PatchFastExtentsDeinit(&patch->extents);
+}
+
+bool diffPatchFast(struct PatchFast* patch, const void* restrict in, const void* restrict out, size_t size) {
+	PatchFastExtentsClear(&patch->extents);
+	const uint32_t* iptr = in;
+	const uint32_t* optr = out;
+	size_t extentOff = 0;
+	struct PatchFastExtent* extent = NULL;
+	size_t off;
+	for (off = 0; off < (size & ~15); off += 16) {
+		uint32_t a = iptr[0] ^ optr[0];
+		uint32_t b = iptr[1] ^ optr[1];
+		uint32_t c = iptr[2] ^ optr[2];
+		uint32_t d = iptr[3] ^ optr[3];
+		iptr += 4;
+		optr += 4;
+		if (a | b | c | d) {
+			if (!extent) {
+				extent = PatchFastExtentsAppend(&patch->extents);
+				extent->offset = off;
+				extentOff = 0;
+			}
+			extent->extent[extentOff] = a;
+			extent->extent[extentOff + 1] = b;
+			extent->extent[extentOff + 2] = c;
+			extent->extent[extentOff + 3] = d;
+			extentOff += 4;
+			if (extentOff == PATCH_FAST_EXTENT) {
+				extent->length = extentOff * 4;
+				extent = NULL;
+			}
+		} else if (extent) {
+			extent->length = extentOff * 4;
+			extent = NULL;
+		}
+	}
+	if (extent) {
+		extent->length = extentOff * 4;
+		extent = NULL;
+	}
+	const uint32_t* iptr8 = iptr;
+	const uint32_t* optr8 = optr;
+	for (; off < size; ++off) {
+		uint8_t a = iptr8[0] ^ optr8[0];
+		++iptr8;
+		++optr8;
+		if (a) {
+			if (!extent) {
+				extent = PatchFastExtentsAppend(&patch->extents);
+				extent->offset = off;
+			}
+			((uint8_t*) extent->extent)[extentOff] = a;
+			++extentOff;
+		} else if (extent) {
+			extent->length = extentOff;
+			extent = NULL;
+		}
+	}
+	if (extent) {
+		extent->length = extentOff;
+		extent = NULL;
+	}
+
+	return true;
+}
+
+size_t _fastOutputSize(struct Patch* patch, size_t inSize) {
+	UNUSED(patch);
+	return inSize;
+}
+
+bool _fastApplyPatch(struct Patch* p, const void* in, size_t inSize, void* out, size_t outSize) {
+	struct PatchFast* patch = (struct PatchFast*) p;
+	if (inSize != outSize) {
+		return false;
+	}
+	const uint32_t* iptr = in;
+	uint32_t* optr = out;
+	size_t lastWritten = 0;
+	size_t s;
+	for (s = 0; s < PatchFastExtentsSize(&patch->extents); ++s) {
+		struct PatchFastExtent* extent = PatchFastExtentsGetPointer(&patch->extents, s);
+		if (extent->length + extent->offset > outSize) {
+			return false;
+		}
+		memcpy(optr, iptr, extent->offset - lastWritten);
+		optr = (uint32_t*) out + extent->offset / 4;
+		iptr = (uint32_t*) in + extent->offset / 4;
+		uint32_t* eptr = extent->extent;
+		size_t off;
+		for (off = 0; off < (extent->length & ~15); off += 16) {
+			optr[0] = iptr[0] ^ eptr[0];
+			optr[1] = iptr[1] ^ eptr[1];
+			optr[2] = iptr[2] ^ eptr[2];
+			optr[3] = iptr[3] ^ eptr[3];
+			optr += 4;
+			iptr += 4;
+			eptr += 4;
+		}
+		for (; off < extent->length; ++off) {
+			*(uint8_t*) optr = *(uint8_t*) iptr ^ *(uint8_t*) eptr;
+			++optr;
+			++iptr;
+			++eptr;
+		}
+		lastWritten = extent->offset + off;
+	}
+	memcpy(optr, iptr, outSize - lastWritten);
+	return true;
+}

package/mgba-bridge/vendor/mgba/src/util/patch-ips.c

@@ -0,0 +1,93 @@
+/* Copyright (c) 2013-2014 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <mgba-util/patch/ips.h>
+
+#include <mgba-util/patch.h>
+#include <mgba-util/vfs.h>
+
+static size_t _IPSOutputSize(struct Patch* patch, size_t inSize);
+static bool _IPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* out, size_t outSize);
+
+bool loadPatchIPS(struct Patch* patch) {
+	patch->vf->seek(patch->vf, 0, SEEK_SET);
+
+	char buffer[5];
+	if (patch->vf->read(patch->vf, buffer, 5) != 5) {
+		return false;
+	}
+
+	if (memcmp(buffer, "PATCH", 5) != 0) {
+		return false;
+	}
+
+	patch->vf->seek(patch->vf, -3, SEEK_END);
+	if (patch->vf->read(patch->vf, buffer, 3) != 3) {
+		return false;
+	}
+
+	if (memcmp(buffer, "EOF", 3) != 0) {
+		return false;
+	}
+
+	patch->outputSize = _IPSOutputSize;
+	patch->applyPatch = _IPSApplyPatch;
+	return true;
+}
+
+size_t _IPSOutputSize(struct Patch* patch, size_t inSize) {
+	UNUSED(patch);
+	UNUSED(inSize);
+	return 16 * 1024 * 1024; // IPS patches can grow up to 16MiB, but not beyond
+}
+
+bool _IPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* out, size_t outSize) {
+	if (patch->vf->seek(patch->vf, 5, SEEK_SET) != 5) {
+		return false;
+	}
+	memcpy(out, in, inSize > outSize ? outSize : inSize);
+	uint8_t* buf = out;
+
+	while (true) {
+		uint32_t offset = 0;
+		uint16_t size = 0;
+
+		if (patch->vf->read(patch->vf, &offset, 3) != 3) {
+			return false;
+		}
+
+		if (offset == 0x464F45) {
+			return true;
+		}
+
+		offset = (offset >> 16) | (offset & 0xFF00) | ((offset << 16) & 0xFF0000);
+		if (patch->vf->read(patch->vf, &size, 2) != 2) {
+			return false;
+		}
+		if (!size) {
+			// RLE chunk
+			if (patch->vf->read(patch->vf, &size, 2) != 2) {
+				return false;
+			}
+			size = (size >> 8) | (size << 8);
+			uint8_t byte;
+			if (patch->vf->read(patch->vf, &byte, 1) != 1) {
+				return false;
+			}
+			if (offset + size > outSize) {
+				return false;
+			}
+			memset(&buf[offset], byte, size);
+		} else {
+			size = (size >> 8) | (size << 8);
+			if (offset + size > outSize) {
+				return false;
+			}
+			if (patch->vf->read(patch->vf, &buf[offset], size) != size) {
+				return false;
+			}
+		}
+	}
+}