mirror of
https://github.com/afska/gba-link-connection.git
synced 2026-03-21 17:44:21 -05:00
424 lines
14 KiB
C++
424 lines
14 KiB
C++
#ifndef LINK_WIRELESS_OPEN_SDK_H
|
|
#define LINK_WIRELESS_OPEN_SDK_H
|
|
|
|
// --------------------------------------------------------------------------
|
|
// An open-source implementation of the "official" Wireless Adapter protocol.
|
|
// --------------------------------------------------------------------------
|
|
// - Advanced usage only!
|
|
// - You only need this if you want to interact with N software.
|
|
// --------------------------------------------------------------------------
|
|
|
|
#ifndef LINK_DEVELOPMENT
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
#include "_link_common.hpp"
|
|
|
|
#include "LinkRawWireless.hpp"
|
|
|
|
static volatile char VERSION[] = "LinkWirelessOpenSDK/v7.1.0";
|
|
|
|
/**
|
|
* @brief An open-source implementation of the "official" Wireless Adapter
|
|
* protocol.
|
|
* \warning Advanced usage only!
|
|
* \warning You only need this if you want to interact with N software.
|
|
*/
|
|
class LinkWirelessOpenSDK {
|
|
private:
|
|
using u32 = unsigned int;
|
|
using u16 = unsigned short;
|
|
using u8 = unsigned char;
|
|
|
|
public:
|
|
static constexpr int MAX_TRANSFER_WORDS = 23;
|
|
static constexpr int MAX_TRANSFER_BYTES_SERVER = 87;
|
|
static constexpr int MAX_TRANSFER_BYTES_CLIENT = 16;
|
|
static constexpr int HEADER_SIZE_SERVER = 3;
|
|
static constexpr int HEADER_SIZE_CLIENT = 2;
|
|
static constexpr int HEADER_MASK_SERVER = (1 << (HEADER_SIZE_SERVER * 8)) - 1;
|
|
static constexpr int HEADER_MASK_CLIENT = (1 << (HEADER_SIZE_CLIENT * 8)) - 1;
|
|
static constexpr int MAX_PAYLOAD_SERVER =
|
|
MAX_TRANSFER_BYTES_SERVER - HEADER_SIZE_SERVER;
|
|
static constexpr int MAX_PAYLOAD_CLIENT =
|
|
MAX_TRANSFER_BYTES_CLIENT - HEADER_SIZE_CLIENT;
|
|
static constexpr int MAX_PACKETS_SERVER =
|
|
MAX_TRANSFER_BYTES_SERVER / HEADER_SIZE_SERVER;
|
|
static constexpr int MAX_PACKETS_CLIENT =
|
|
MAX_TRANSFER_BYTES_CLIENT / HEADER_SIZE_CLIENT;
|
|
|
|
public:
|
|
template <class T>
|
|
struct SendBuffer {
|
|
T header;
|
|
std::array<u32, MAX_TRANSFER_WORDS> data;
|
|
u32 dataSize = 0;
|
|
u32 totalByteCount = 0;
|
|
};
|
|
|
|
enum CommState : unsigned int {
|
|
OFF = 0,
|
|
STARTING = 1,
|
|
COMMUNICATING = 2,
|
|
ENDING = 3,
|
|
DIRECT = 4
|
|
};
|
|
|
|
struct SequenceNumber {
|
|
u32 n = 0;
|
|
u32 phase = 0;
|
|
CommState commState = OFF;
|
|
|
|
static SequenceNumber fromPacketId(u32 packetId) {
|
|
return SequenceNumber{.n = ((packetId + 4) / 4) % 4,
|
|
packetId % 4,
|
|
.commState = COMMUNICATING};
|
|
}
|
|
|
|
bool operator==(const SequenceNumber& other) {
|
|
return n == other.n && phase == other.phase &&
|
|
commState == other.commState;
|
|
}
|
|
};
|
|
|
|
struct ServerSDKHeader {
|
|
unsigned int payloadSize : 7;
|
|
unsigned int _unused_ : 2;
|
|
unsigned int phase : 2;
|
|
unsigned int n : 2;
|
|
unsigned int isACK : 1;
|
|
CommState commState : 4;
|
|
unsigned int targetSlots : 4;
|
|
|
|
SequenceNumber sequence() {
|
|
return SequenceNumber{.n = n, .phase = phase, .commState = commState};
|
|
}
|
|
};
|
|
union ServerSDKHeaderSerializer {
|
|
ServerSDKHeader asStruct;
|
|
u32 asInt;
|
|
};
|
|
struct ServerPacket {
|
|
ServerSDKHeader header;
|
|
u8 payload[MAX_PAYLOAD_SERVER];
|
|
};
|
|
struct ServerResponse {
|
|
ServerPacket packets[MAX_PACKETS_SERVER];
|
|
u32 packetsSize = 0;
|
|
};
|
|
struct ParentData {
|
|
ServerResponse response;
|
|
};
|
|
|
|
struct ClientSDKHeader {
|
|
unsigned int payloadSize : 5;
|
|
unsigned int phase : 2;
|
|
unsigned int n : 2;
|
|
unsigned int isACK : 1;
|
|
CommState commState : 4;
|
|
|
|
SequenceNumber sequence() {
|
|
return SequenceNumber{.n = n, .phase = phase, .commState = commState};
|
|
}
|
|
};
|
|
union ClientSDKHeaderSerializer {
|
|
ClientSDKHeader asStruct;
|
|
u16 asInt;
|
|
};
|
|
struct ClientPacket {
|
|
ClientSDKHeader header;
|
|
u8 payload[MAX_PAYLOAD_CLIENT];
|
|
};
|
|
struct ClientResponse {
|
|
ClientPacket packets[MAX_PACKETS_CLIENT];
|
|
u32 packetsSize = 0;
|
|
};
|
|
struct ChildrenData {
|
|
ClientResponse responses[4];
|
|
};
|
|
|
|
/**
|
|
* @brief Parses the `response` and returns a struct containing all the
|
|
* received packets from the connected clients.
|
|
* @param response The response to be parsed.
|
|
*/
|
|
[[nodiscard]]
|
|
ChildrenData getChildrenData(LinkRawWireless::ReceiveDataResponse response) {
|
|
u8* buffer = (u8*)response.data;
|
|
u32 cursor = 0;
|
|
ChildrenData childrenData;
|
|
|
|
if (response.sentBytes[1] + response.sentBytes[2] + response.sentBytes[3] +
|
|
response.sentBytes[4] >
|
|
response.dataSize * 4)
|
|
return childrenData;
|
|
|
|
for (u32 i = 1; i < LINK_RAW_WIRELESS_MAX_PLAYERS; i++) {
|
|
ClientResponse* clientResponse = &childrenData.responses[i - 1];
|
|
u32 remainingBytes = response.sentBytes[i];
|
|
|
|
while (remainingBytes >= HEADER_SIZE_CLIENT) {
|
|
ClientPacket* packet =
|
|
&clientResponse->packets[clientResponse->packetsSize];
|
|
|
|
u32 headerInt = *((u16*)(buffer + cursor));
|
|
packet->header = parseClientHeader(headerInt);
|
|
cursor += HEADER_SIZE_CLIENT;
|
|
remainingBytes -= HEADER_SIZE_CLIENT;
|
|
|
|
if (packet->header.payloadSize > 0 &&
|
|
packet->header.payloadSize <= MAX_PAYLOAD_CLIENT &&
|
|
remainingBytes >= packet->header.payloadSize) {
|
|
for (u32 j = 0; j < packet->header.payloadSize; j++)
|
|
packet->payload[j] = buffer[cursor++];
|
|
remainingBytes -= packet->header.payloadSize;
|
|
}
|
|
|
|
clientResponse->packetsSize++;
|
|
}
|
|
}
|
|
|
|
return childrenData;
|
|
}
|
|
|
|
/**
|
|
* @brief Parses the `response` and returns a struct containing all the
|
|
* received packets from the host.
|
|
* @param response The response to be parsed.
|
|
*/
|
|
[[nodiscard]]
|
|
ParentData getParentData(LinkRawWireless::ReceiveDataResponse response) {
|
|
u8* buffer = (u8*)response.data;
|
|
u32 cursor = 0;
|
|
ParentData parentData;
|
|
|
|
if (response.sentBytes[0] > response.dataSize * 4)
|
|
return parentData;
|
|
|
|
ServerResponse* serverResponse = &parentData.response;
|
|
u32 remainingBytes = response.sentBytes[0];
|
|
|
|
while (remainingBytes >= HEADER_SIZE_SERVER) {
|
|
ServerPacket* packet =
|
|
&serverResponse->packets[serverResponse->packetsSize];
|
|
|
|
u32 headerInt = (*((u16*)(buffer + cursor))) |
|
|
(((*((u8*)(buffer + cursor + 2)))) << 16);
|
|
packet->header = parseServerHeader(headerInt);
|
|
cursor += HEADER_SIZE_SERVER;
|
|
remainingBytes -= HEADER_SIZE_SERVER;
|
|
|
|
if (packet->header.payloadSize > 0 &&
|
|
packet->header.payloadSize <= MAX_PAYLOAD_SERVER &&
|
|
remainingBytes >= packet->header.payloadSize) {
|
|
for (u32 j = 0; j < packet->header.payloadSize; j++)
|
|
packet->payload[j] = buffer[cursor++];
|
|
remainingBytes -= packet->header.payloadSize;
|
|
}
|
|
|
|
serverResponse->packetsSize++;
|
|
}
|
|
|
|
return parentData;
|
|
}
|
|
|
|
/**
|
|
* @brief Creates a buffer for the host to send a `fullPayload` with a valid
|
|
* header. If `fullPayloadSize` is higher than `84` (the maximum payload
|
|
* size), the buffer will only contain the **first** `84` bytes (unless an
|
|
* `offset` > 0 is used). A `sequence` number must be created by using
|
|
* `LinkWirelessOpenSDK::SequenceNumber::fromPacketId(...)`. Optionally, a
|
|
* `targetSlots` bit array can be used to exclude some clients from the
|
|
* transmissions (the default is `0b1111`).
|
|
* @param fullPayload A pointer to the payload buffer.
|
|
* @param fullPayloadSize Total size of the payload.
|
|
* @param sequence A sequence number created using
|
|
* `LinkWirelessOpenSDK::SequenceNumber::fromPacketId(...)`.
|
|
* @param targetSlots A bit array that can be used to exclude some clients
|
|
* (the default is `0b1111`).
|
|
* @param offset The offset within the `fullPayload` pointer. Defaults to `0`.
|
|
*/
|
|
[[nodiscard]]
|
|
SendBuffer<ServerSDKHeader> createServerBuffer(const u8* fullPayload,
|
|
u32 fullPayloadSize,
|
|
SequenceNumber sequence,
|
|
u8 targetSlots = 0b1111,
|
|
u32 offset = 0) {
|
|
SendBuffer<ServerSDKHeader> buffer;
|
|
u32 payloadSize = Link::_min(fullPayloadSize, MAX_PAYLOAD_SERVER);
|
|
|
|
buffer.header.isACK = 0;
|
|
buffer.header.targetSlots = targetSlots;
|
|
buffer.header.payloadSize = payloadSize;
|
|
buffer.header.n = sequence.n;
|
|
buffer.header.phase = sequence.phase;
|
|
buffer.header.commState = sequence.commState;
|
|
u32 headerInt = serializeServerHeader(buffer.header);
|
|
|
|
buffer.data[buffer.dataSize++] = headerInt;
|
|
if (offset < fullPayloadSize)
|
|
buffer.data[0] |= fullPayload[offset] << 24;
|
|
|
|
for (u32 i = 1; i < payloadSize; i += 4) {
|
|
u32 word = 0;
|
|
for (u32 j = 0; j < 4; j++) {
|
|
if (offset + i + j < fullPayloadSize && i + j < MAX_PAYLOAD_SERVER) {
|
|
u8 byte = fullPayload[offset + i + j];
|
|
word |= byte << (j * 8);
|
|
}
|
|
}
|
|
buffer.data[buffer.dataSize++] = word;
|
|
}
|
|
|
|
buffer.totalByteCount = HEADER_SIZE_SERVER + payloadSize;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* @brief Creates a buffer for the host to acknowledge a header received from
|
|
* a certain `clientNumber`.
|
|
* @param clientHeader The header of the received packet.
|
|
* @param clientNumber `(0~3)` The client number that sent the packet.
|
|
*/
|
|
[[nodiscard]]
|
|
SendBuffer<ServerSDKHeader> createServerACKBuffer(
|
|
ClientSDKHeader clientHeader,
|
|
u8 clientNumber) {
|
|
SendBuffer<ServerSDKHeader> buffer;
|
|
|
|
buffer.header = createACKHeaderFor(clientHeader, clientNumber);
|
|
u32 headerInt = serializeServerHeader(buffer.header);
|
|
|
|
buffer.data[buffer.dataSize++] = headerInt;
|
|
buffer.totalByteCount = HEADER_SIZE_SERVER;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* @brief Creates a buffer for the client to send a `fullPayload` with a valid
|
|
* header. If `fullPayloadSize` is higher than `14` (the maximum payload
|
|
* size), the buffer will only contain the **first** `14` bytes (unless an
|
|
* `offset` > 0 is used). A `sequence` number must be created by using
|
|
* `LinkWirelessOpenSDK::SequenceNumber::fromPacketId(...)`.
|
|
* @param fullPayload A pointer to the payload buffer.
|
|
* @param fullPayloadSize Total size of the payload.
|
|
* @param sequence A sequence number created using
|
|
* `LinkWirelessOpenSDK::SequenceNumber::fromPacketId(...)`.
|
|
* @param offset The offset within the `fullPayload` pointer. Defaults to `0`.
|
|
*/
|
|
[[nodiscard]]
|
|
SendBuffer<ClientSDKHeader> createClientBuffer(const u8* fullPayload,
|
|
u32 fullPayloadSize,
|
|
SequenceNumber sequence,
|
|
u32 offset = 0) {
|
|
SendBuffer<ClientSDKHeader> buffer;
|
|
u32 payloadSize = Link::_min(fullPayloadSize, MAX_PAYLOAD_CLIENT);
|
|
|
|
buffer.header.isACK = 0;
|
|
buffer.header.payloadSize = payloadSize;
|
|
buffer.header.n = sequence.n;
|
|
buffer.header.phase = sequence.phase;
|
|
buffer.header.commState = sequence.commState;
|
|
u16 headerInt = serializeClientHeader(buffer.header);
|
|
|
|
buffer.data[buffer.dataSize++] = headerInt;
|
|
if (offset < fullPayloadSize)
|
|
buffer.data[0] |= fullPayload[offset] << 16;
|
|
if (offset + 1 < fullPayloadSize)
|
|
buffer.data[0] |= fullPayload[offset + 1] << 24;
|
|
|
|
for (u32 i = 2; i < payloadSize; i += 4) {
|
|
u32 word = 0;
|
|
for (u32 j = 0; j < 4; j++) {
|
|
if (offset + i + j < fullPayloadSize && i + j < MAX_PAYLOAD_CLIENT) {
|
|
u8 byte = fullPayload[offset + i + j];
|
|
word |= byte << (j * 8);
|
|
}
|
|
}
|
|
buffer.data[buffer.dataSize++] = word;
|
|
}
|
|
|
|
buffer.totalByteCount = HEADER_SIZE_CLIENT + payloadSize;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* @brief Creates a buffer for the client to acknowledge a header received
|
|
* from the host.
|
|
* @param serverHeader The header of the received packet.
|
|
*/
|
|
[[nodiscard]]
|
|
SendBuffer<ClientSDKHeader> createClientACKBuffer(
|
|
ServerSDKHeader serverHeader) {
|
|
SendBuffer<ClientSDKHeader> buffer;
|
|
|
|
buffer.header = createACKHeaderFor(serverHeader);
|
|
u16 headerInt = serializeClientHeader(buffer.header);
|
|
|
|
buffer.data[buffer.dataSize++] = headerInt;
|
|
buffer.totalByteCount = HEADER_SIZE_CLIENT;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
private:
|
|
[[nodiscard]]
|
|
ServerSDKHeader createACKHeaderFor(ClientSDKHeader clientHeader,
|
|
u8 clientNumber) {
|
|
ServerSDKHeader serverHeader;
|
|
serverHeader.isACK = 1;
|
|
serverHeader.targetSlots = (1 << clientNumber);
|
|
serverHeader.payloadSize = 0;
|
|
serverHeader.n = clientHeader.n;
|
|
serverHeader.phase = clientHeader.phase;
|
|
serverHeader.commState = clientHeader.commState;
|
|
|
|
return serverHeader;
|
|
}
|
|
|
|
[[nodiscard]]
|
|
ClientSDKHeader createACKHeaderFor(ServerSDKHeader serverHeader) {
|
|
ClientSDKHeader clientHeader;
|
|
clientHeader.isACK = 1;
|
|
clientHeader.payloadSize = 0;
|
|
clientHeader.n = serverHeader.n;
|
|
clientHeader.phase = serverHeader.phase;
|
|
clientHeader.commState = serverHeader.commState;
|
|
|
|
return clientHeader;
|
|
}
|
|
|
|
[[nodiscard]]
|
|
ClientSDKHeader parseClientHeader(u32 clientHeaderInt) {
|
|
ClientSDKHeaderSerializer clientSerializer;
|
|
clientSerializer.asInt = clientHeaderInt & HEADER_MASK_CLIENT;
|
|
return clientSerializer.asStruct;
|
|
}
|
|
|
|
[[nodiscard]]
|
|
u16 serializeClientHeader(ClientSDKHeader clientHeader) {
|
|
ClientSDKHeaderSerializer clientSerializer;
|
|
clientSerializer.asStruct = clientHeader;
|
|
return clientSerializer.asInt & HEADER_MASK_CLIENT;
|
|
}
|
|
|
|
[[nodiscard]]
|
|
ServerSDKHeader parseServerHeader(u32 serverHeaderInt) {
|
|
ServerSDKHeaderSerializer serverSerializer;
|
|
serverSerializer.asInt = serverHeaderInt & HEADER_MASK_SERVER;
|
|
return serverSerializer.asStruct;
|
|
}
|
|
|
|
[[nodiscard]]
|
|
u32 serializeServerHeader(ServerSDKHeader serverHeader) {
|
|
ServerSDKHeaderSerializer serverSerializer;
|
|
serverSerializer.asStruct = serverHeader;
|
|
return serverSerializer.asInt & HEADER_MASK_SERVER;
|
|
}
|
|
};
|
|
|
|
#endif // LINK_WIRELESS_OPEN_SDK_H
|