Helper function to encode a PNG

Can be disabled by defining MUXY_GATEWAY_WITHOUT_PNG_ENCODER

Author: albert-wang

include/gateway.h

@@ -13,11 +13,25 @@ namespace gateway
 	struct GameMetadata
 	{
 		string GameName;
-		// Base64 encoded image
+
+		// Base64 encoded image, PNG, JPG or SVG
 		string GameLogo;
 		string Theme;
 	};
 
+#ifndef MUXY_GATEWAY_WITHOUT_PNG_ENCODER
+	/// Encodes an image as packed RGB(A) data into a base64 data url.
+	/// @param image - Pointer to array of bytes in RGB or RGBA format, 8 bits per pixel.
+	/// @param width - How many pixels wide the image is.
+	/// @param height - How many pixels high the image is.
+	/// @param components - 3 for RGB, 4 for RGBA. Other values are not supported.
+	/// @param strideBytes - How many bytes a row of pixels are. May be larger than width * component.
+	/// @param flipVertically - Set to true to flip the Y axis of the image efore encoding.
+	/// @return Returns a data url in the form "data:image/png;base64,<base64encoded image>"
+	/// @note This function is pretty slow, avoid calling this function on the main thread.
+	string EncodeImageToBase64PNG(const void* image, uint32_t width, uint32_t height, uint32_t components, uint32_t strideBytes, bool flipVertically);
+#endif
+
 	class Payload
 	{
 		friend class SDK;

src/gateway.cpp

@@ -1,7 +1,132 @@
 #include "gateway.h"
 
+#ifndef MUXY_GATEWAY_WITHOUT_PNG_ENCODER
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define STBI_WRITE_NO_STDIO
+#define STB_IMAGE_WRITE_STATIC
+#include "third_party/stb/stb_image_write.h"
+#endif
+
 namespace gateway
 {
+	
+#ifndef MUXY_GATEWAY_WITHOUT_PNG_ENCODER
+	string base64EncodeWithImageURLPrefix(const void* voidIn, uint32_t length)
+	{
+		uint32_t outputLength = length / 3 * 4;
+		if (outputLength > 1024 * 1024) 
+		{
+			return string("");
+		}
+
+		const uint8_t* in = static_cast<const uint8_t*>(voidIn);
+		static const char* codes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+		uint32_t o = 0;
+
+		const char* prefix = "data:image/png;base64,";
+		uint32_t prefixSize = strlen(prefix);
+
+		char* out = new char[length / 3 * 4 + 4 + prefixSize];
+		memcpy(out, prefix, prefixSize);
+
+		o += prefixSize;
+
+		for (uint32_t i = 0; i < length; i += 3)
+		{
+			// Read 6 bits.
+			uint32_t bits = (in[i] & 0xFC) >> 2;
+			out[o++] = codes[bits];
+
+			// Read in 2 bits
+			bits = (in[i] & 0x3) << 4;
+			if (i + 1 < length)
+			{
+				// Read in 4 bits
+				bits |= (in[i + 1] & 0xF0) >> 4;
+				out[o++] = codes[bits];
+
+				// Read in 4 bits
+				bits = (in[i + 1] & 0xF) << 2;
+				if (i + 2 < length)
+				{
+					// Read in 2 bits
+					bits |= (in[i + 2] & 0xC0) >> 6;
+					out[o++] = codes[bits];
+
+					// Read in 6 bits
+					bits = in[i + 2] & 0x3F;
+					out[o++] = codes[bits];
+				}
+				else
+				{
+					out[o++] = codes[bits];
+					out[o++] = '=';
+				}
+			}
+			else
+			{
+				out[o++] = codes[bits];
+				out[o++] = '=';
+				out[o++] = '=';
+			}
+		}
+
+		out[o] = '\0';
+		string result = string(out, o - 1);
+
+		delete [] out;
+		return result;
+	}
+
+	string EncodeImageToBase64PNG(const void* untypedData, uint32_t w, uint32_t h, uint32_t components, uint32_t strideBytes, bool flipVertically)
+	{
+		const uint8_t* data = static_cast<const uint8_t*>(untypedData);
+		if (components != 3 && components != 4)
+		{
+			return string("");
+		}
+
+		if (flipVertically)
+		{
+			// Copy out the rows into a big buffer, flipping vertically.
+			uint8_t* buffer = new uint8_t[w * h * components]; 
+			for (uint32_t y = 0; y < h; ++y)
+			{
+				memcpy(&buffer[components * w * (h - y - 1)], &data[strideBytes * y], w * components);
+			}
+
+			int outputLength = 0;
+			unsigned char* png = stbi_write_png_to_mem(reinterpret_cast<const unsigned char*>(buffer), 
+				static_cast<int>(strideBytes), 
+				static_cast<int>(w),
+				static_cast<int>(h), 
+				components,
+				&outputLength);
+
+			string result = base64EncodeWithImageURLPrefix(png, outputLength);
+			delete[] buffer;
+			STBIW_FREE(png);
+			return result;
+		}
+		else
+		{
+			int outputLength = 0;
+			unsigned char* png = stbi_write_png_to_mem(reinterpret_cast<const unsigned char*>(data), 
+				static_cast<int>(strideBytes), 
+				static_cast<int>(w),
+				static_cast<int>(h), 
+				components,
+				&outputLength);
+
+			string result = base64EncodeWithImageURLPrefix(png, outputLength);
+			STBIW_FREE(png);
+			
+			return result;
+		}
+	}
+
+#endif
+
 	Payload::Payload(const char* data, uint32_t length)
 		: _Data(data)
 		, _Length(length)

test/constrained_types.h

@@ -55,7 +55,6 @@ class ConstrainedString
 	{
 		return _data.c_str();
 	}
-
 private:
 	std::string _data;
 };

test/gateway_gamemetadata.cpp

@@ -0,0 +1,72 @@
+#include "catch2/catch.hpp"
+#include "util.h"
+
+#include "gateway.h"
+#include "gateway_c.h"
+
+
+// Generate an image 512x512 pixels, alternating between almost-black and debug pink.
+// Generates an RGB image.
+std::vector<uint8_t> generateImage()
+{
+	static uint32_t width = 512;
+	static uint32_t height = 512;
+
+	std::vector<uint8_t> result;
+	result.resize(width * height * 3);
+
+	for (uint32_t y = 0; y < height / 8; ++y)
+	{
+		for (uint32_t x = 0; x < width / 8; ++x)
+		{
+			// Compute parity for black or pink.
+			uint32_t parity = (x + y) % 2;
+			
+			// Draw a 8x8 square.
+			uint32_t upperLeftPixelIndex = 
+				(y * 8) * width + 
+				(x * 8);
+
+			if (parity == 0)
+			{
+				for (uint32_t innerY = 0; innerY < 8; ++innerY)
+				{
+					for (uint32_t innerX = 0; innerX < 8; ++innerX)
+					{
+						uint32_t pixelIndex = upperLeftPixelIndex + innerY * width + innerX;
+						result[pixelIndex * 3 + 0] = 0x05;
+						result[pixelIndex * 3 + 1] = 0x05;
+						result[pixelIndex * 3 + 2] = 0x05;
+					}
+				}
+			}
+			else if (parity == 1)
+			{
+				for (uint32_t innerY = 0; innerY < 8; ++innerY)
+				{
+					for (uint32_t innerX = 0; innerX < 8; ++innerX)
+					{
+						uint32_t pixelIndex = upperLeftPixelIndex + innerY * width + innerX;
+						result[pixelIndex * 3 + 0] = 0x7F;
+						result[pixelIndex * 3 + 1] = 0;
+						result[pixelIndex * 3 + 2] = 0x7F;
+					}
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+
+TEST_CASE("Set basic image", "[gateawy][metadata]")
+{
+	gateway::SDK sdk("This is a game");
+	std::vector<uint8_t> image = generateImage();
+	
+	gateway::GameMetadata metadata;
+	metadata.GameLogo = gateway::EncodeImageToBase64PNG(image.data(), 512, 512, 3, 512 * 3, true);
+
+	REQUIRE(metadata.GameLogo.size() > 0);
+}

test/integration.cpp

@@ -392,7 +392,7 @@ TEST_CASE_METHOD(IntegrationTestFixture, "Transactions Support through gateway",
 	gateway.OnActionUsed([&](const gateway::ActionUsed& used)
 	{
 		// This should get 5 calls, which are all coins 
-		REQUIRE(used.SKU == "costs-ten");
+		REQUIRE(used.ActionID == "costs-ten");
 		REQUIRE(used.Cost == 10);
 
 		coinCalls++;