AI_Slop/joeylib2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
joeylib2/tests/gate/amigaCheck.c
Scott Duensing b28916f930 More bug squashing.
2026-10-19 15:46:47 -05:00

559 lines
20 KiB
C
Raw Permalink Blame History

// Part of JoeyLib, Copyright (c) 2026 Scott Duensing, under the MIT License.
// See LICENSE.md for license information.
// SPDX-License-Identifier: MIT
//
// amigaCheck.c - the Amiga gates' checks of a screenshot and the probes'
// logs (scripts/verify-amiga-icon.sh and verify-amiga-palette.sh).
//
// amigaCheck icon WORK STACK WBTOOL LABEL
// amigaCheck palette PNG LOG MINRATE LABEL
//
// icon: WORK holds WBLAUNCH's log (wblaunch.txt), Prog/Palprobe.info, and
// the screenshot (screen.png). Every line of the log with FAIL in it fails;
// the log must say icon.library read the icon as a tool's (type WBTOOL) of
// STACK bytes of stack and the file's image size and depth; and the
// screenshot must show the icon. The screen is Workbench's gray and the
// icon's colored pixels lie inside it: the file's colored pixels (index
// not 0) and the screenshot's (not gray) must have the same bounds, scaled,
// and each of the file's pixels is looked at in the middle of its cell.
// Only the gray's upper half is searched: FS-UAE prints its notices over
// the bottom. Then Palprobe's log must be in Prog/ with its last line, and
// no log in WORK: it ran in its own folder.
//
// palette: LOG must have PALPROBE's two rates (palette and SCB changes
// presented a second; the last of each the log has), each at least
// MINRATE, and the color bands down the screenshot's middle column, top to
// bottom, black (the border) dropped, must be red, green, yellow, and red.
//
// Prints LABEL: PASS or LABEL: FAIL - the reasons, as the gate's verdict;
// exits 0 or 1, or 2 on a bad command line.
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gateArg.h"
#include "gateImage.h"
#include "gateText.h"
#include "toolBuf.h"
#include "toolFile.h"
#define TOOL_NAME "amigaCheck"
#define FAIL_EXIT 1
#define PATH_BYTES 4096u
#define NAME_BYTES 32u
#define SEPARATOR "; "
#define LIST_SEPARATOR ", "
// A pattern: its text, '#' standing for a run of digits (a number that
// fits a long, so of NUMBER_DIGITS_MAX digits at most).
#define PATTERN_NUMBER '#'
#define PATTERN_VALUES_MAX 8u
#define NUMBER_DIGITS_MAX 19u
// The icon file: a 78-byte DiskObject and the struct Image's first 4
// bytes, then its width, height, and depth (big-endian words); its planes
// follow the 20-byte struct Image, rows of whole 16-bit words.
#define INFO_SIZE_AT 82u
#define INFO_PLANES_AT 98u
#define INFO_DEPTH_MAX 8
#define WORD_PIXELS 16
#define WORD_BYTES 2
#define BYTE_BITS 8
#define TOP_BIT 0x80u
#define AMIGA_COLORS 4u
#define GRAY_STEP 2
#define HALF 0.5
#define ICON_PATTERN "icon type=# stack=# gadget=#x# image=#x#x#"
#define ICON_TYPE 0u
#define ICON_STACK 1u
#define ICON_IMAGE_W 4u
#define ICON_IMAGE_H 5u
#define ICON_IMAGE_DEPTH 6u
#define PALPROBE_DONE "PALPROBE: done"
#define FAIL_TEXT "FAIL"
// The palette probe: its two rates (the third number of its line), and
// the bands it draws.
#define RATE_KINDS 2u
#define RATE_VALUE 2u
#define BAND_COUNT 4u
#define BAND_NAMES 3u
#define BAND_OTHER BAND_NAMES
// The reasons a gate fails, "; " between them.
typedef struct FailsT {
ToolBufT text;
uint32_t count;
} FailsT;
// A box round some pixels, and whether there are any.
typedef struct BoundsT {
long x0;
long x1;
long y0;
long y1;
bool any;
} BoundsT;
// A Workbench icon's image: its size and depth as the file gives them, and
// each pixel's color index (no pixels when the size is not positive).
typedef struct IconT {
long width;
long height;
long depth;
long cols;
long rows;
uint8_t *indices;
} IconT;
static long be16(const uint8_t *p);
static void boundsAdd(BoundsT *bounds, long x, long y);
static int checkIcon(char **args);
static int checkPalette(char **args);
static void failAdd(FailsT *fails, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
static void failLine(FailsT *fails, const uint8_t *line, size_t len);
static void failSeparate(FailsT *fails);
static bool fileExists(const char *path);
static bool findPattern(const uint8_t *text, size_t len, size_t *at, const char *pattern, long *values);
static void iconRead(const char *path, IconT *icon);
static void iconShown(const char *path, const IconT *icon, const char *label, FailsT *fails);
static bool matchAt(const uint8_t *text, size_t len, size_t at, const char *pattern, long *values);
static int printVerdict(const FailsT *fails, const char *label);
static uint8_t *readText(const char *path, size_t *len);
static const GateModeT kModes[] = {
{ "icon", 4, checkIcon },
{ "palette", 4, checkPalette }
};
// Workbench's gray, black, white, and blue.
static const uint8_t kWorkbench[AMIGA_COLORS][GATE_RGB_BYTES] = { { 170, 170, 170 }, { 0, 0, 0 }, { 255, 255, 255 }, { 102, 136, 187 } };
static const char *const kRateKinds[RATE_KINDS] = { "palette", "scb" };
static const char *const kRatePatterns[RATE_KINDS] = { "PALPROBE: palette+present: # in # ms = #/s", "PALPROBE: scb+present: # in # ms = #/s" };
static const uint8_t kBandColors[BAND_NAMES][GATE_RGB_BYTES] = { { 255, 0, 0 }, { 0, 255, 0 }, { 255, 255, 0 } };
static const char *const kBandNames[BAND_NAMES] = { "red", "green", "yellow" };
static const uint32_t kWantBands[BAND_COUNT] = { 0u, 1u, 2u, 0u };
static const uint8_t kBlack[GATE_RGB_BYTES] = { 0, 0, 0 };
static const char *const kUsage[] = {
"usage:",
" amigaCheck icon WORK STACK WBTOOL LABEL WBLAUNCH read and drew the",
" icon; Palprobe ran in Prog/",
" amigaCheck palette PNG LOG MINRATE LABEL PALPROBE's rates and bands"
};
// A signed big-endian 16-bit number.
static long be16(const uint8_t *p) {
return (int16_t)(((uint32_t)p[0] << BYTE_BITS) | p[1]);
}
static void boundsAdd(BoundsT *bounds, long x, long y) {
bounds->x0 = (!bounds->any || x < bounds->x0) ? x : bounds->x0;
bounds->x1 = (!bounds->any || x > bounds->x1) ? x : bounds->x1;
bounds->y0 = (!bounds->any || y < bounds->y0) ? y : bounds->y0;
bounds->y1 = (!bounds->any || y > bounds->y1) ? y : bounds->y1;
bounds->any = true;
}
static int checkIcon(char **args) {
FailsT fails;
IconT icon;
char path[PATH_BYTES];
uint8_t *log;
uint8_t *palLog;
long got[PATTERN_VALUES_MAX];
size_t logLen;
size_t palLogLen;
size_t at;
size_t end;
size_t lineLen;
long wantStack;
long wbTool;
memset(&fails, 0, sizeof(fails));
wantStack = gateArgLong("stack", args[1]);
wbTool = gateArgLong("tool type", args[2]);
snprintf(path, sizeof(path), "%s/wblaunch.txt", args[0]);
log = readText(path, &logLen);
// Each line (a \r before its \n dropped) with FAIL in it.
for (at = 0; at < logLen; at = end + 1u) {
end = gateTextFind(log, logLen, at, "\n", 1u);
end = (end == GATE_TEXT_NOT_FOUND) ? logLen : end;
lineLen = (end > at && log[end - 1u] == '\r') ? end - at - 1u : end - at;
if (gateTextFind(log + at, lineLen, 0u, FAIL_TEXT, strlen(FAIL_TEXT)) != GATE_TEXT_NOT_FOUND) {
failLine(&fails, log + at, lineLen);
}
}
snprintf(path, sizeof(path), "%s/Prog/Palprobe.info", args[0]);
iconRead(path, &icon);
at = 0u;
if (!findPattern(log, logLen, &at, ICON_PATTERN, got)) {
failAdd(&fails, "icon.library never read the icon");
} else {
if (got[ICON_TYPE] != wbTool) {
failAdd(&fails, "icon type %ld, want WBTOOL (%ld)", got[ICON_TYPE], wbTool);
}
if (got[ICON_STACK] != wantStack) {
failAdd(&fails, "icon stack %ld, want %ld", got[ICON_STACK], wantStack);
}
if (got[ICON_IMAGE_W] != icon.width || got[ICON_IMAGE_H] != icon.height || got[ICON_IMAGE_DEPTH] != icon.depth) {
failAdd(&fails, "icon.library's image %ldx%ldx%ld, the file's %ldx%ldx%ld", got[ICON_IMAGE_W], got[ICON_IMAGE_H], got[ICON_IMAGE_DEPTH], icon.width, icon.height, icon.depth);
}
}
snprintf(path, sizeof(path), "%s/screen.png", args[0]);
iconShown(path, &icon, args[3], &fails);
snprintf(path, sizeof(path), "%s/Prog/joeylog.txt", args[0]);
palLog = fileExists(path) ? readText(path, &palLogLen) : NULL;
if (palLog == NULL || gateTextFind(palLog, palLogLen, 0u, PALPROBE_DONE, strlen(PALPROBE_DONE)) == GATE_TEXT_NOT_FOUND) {
failAdd(&fails, "Palprobe's log is not in Prog/ with its last line: it did not run in its own folder");
}
snprintf(path, sizeof(path), "%s/joeylog.txt", args[0]);
if (fileExists(path)) {
failAdd(&fails, "a joeylog.txt is in the drive's root: Palprobe ran outside its folder");
}
if (fails.count != 0u) {
return printVerdict(&fails, args[3]);
}
printf("%s: PASS (icon.library reads a tool's icon, %ld bytes of stack, %ldx%ldx%ld, and draws every pixel of it; started from it as Workbench does, Palprobe ran in its own folder and its message came back)\n", args[3], wantStack, icon.width, icon.height, icon.depth);
return 0;
}
static int checkPalette(char **args) {
GateImageT img;
FailsT fails;
ToolBufT bands;
uint8_t *log;
const uint8_t *rgb;
long values[PATTERN_VALUES_MAX];
long rates[RATE_KINDS];
bool seen[RATE_KINDS];
uint32_t bandIds[BAND_COUNT];
uint32_t bandCount;
uint32_t band;
uint32_t k;
uint32_t y;
size_t logLen;
size_t at;
long minRate;
bool matched;
char name[NAME_BYTES];
char last[NAME_BYTES];
memset(&fails, 0, sizeof(fails));
memset(&bands, 0, sizeof(bands));
minRate = gateArgLong("minimum rate", args[2]);
log = readText(args[1], &logLen);
// Each kind's rate: the last the log has.
for (k = 0; k < RATE_KINDS; k++) {
seen[k] = false;
rates[k] = 0;
for (at = 0u; findPattern(log, logLen, &at, kRatePatterns[k], values); at++) {
seen[k] = true;
rates[k] = values[RATE_VALUE];
}
}
if (!seen[0] || !seen[1]) {
printf("%s: FAIL - the log does not have both rates (", args[3]);
for (k = 0; k < RATE_KINDS; k++) {
printf("%s%s ", (k == 0u) ? "" : LIST_SEPARATOR, kRateKinds[k]);
if (seen[k]) {
printf("%ld/s", rates[k]);
} else {
printf("missing");
}
}
printf(")\n");
return FAIL_EXIT;
}
// The bands down the middle column, top to bottom, black (the border)
// dropped: each run of one color is a band.
gateImageLoad(args[0], &img);
bandCount = 0u;
for (y = 0; y < img.height; y++) {
rgb = gateImagePixel(&img, img.width / 2u, y);
if (memcmp(rgb, kBlack, GATE_RGB_BYTES) == 0) {
continue;
}
band = BAND_OTHER;
for (k = 0; k < BAND_NAMES && band == BAND_OTHER; k++) {
band = (memcmp(rgb, kBandColors[k], GATE_RGB_BYTES) == 0) ? k : BAND_OTHER;
}
if (band != BAND_OTHER) {
snprintf(name, sizeof(name), "%s", kBandNames[band]);
} else {
snprintf(name, sizeof(name), "other (%u, %u, %u)", (unsigned)rgb[0], (unsigned)rgb[1], (unsigned)rgb[2]);
}
if (bandCount > 0u && strcmp(name, last) == 0) {
continue;
}
gateTextAdd(&bands, "%s%s", (bandCount == 0u) ? "" : LIST_SEPARATOR, name);
if (bandCount < BAND_COUNT) {
bandIds[bandCount] = band;
}
bandCount++;
memcpy(last, name, sizeof(last));
}
for (k = 0; k < RATE_KINDS; k++) {
if (rates[k] < minRate) {
failAdd(&fails, "%s changes presented %ld/s, want at least %ld", kRateKinds[k], rates[k], minRate);
}
}
matched = bandCount == BAND_COUNT;
for (k = 0; k < BAND_COUNT && matched; k++) {
matched = bandIds[k] == kWantBands[k];
}
if (!matched) {
failAdd(&fails, "bands %s, want red, green, yellow, red", (bandCount == 0u) ? "none" : gateTextString(&bands));
}
if (fails.count != 0u) {
return printVerdict(&fails, args[3]);
}
printf("%s: PASS (palette changes %ld/s, SCB changes %ld/s; bands red, green, yellow, red after a palette change and a same-layout SCB change)\n", args[3], rates[0], rates[1]);
return 0;
}
static void failAdd(FailsT *fails, const char *fmt, ...) {
va_list args;
failSeparate(fails);
va_start(args, fmt);
gateTextAddV(&fails->text, fmt, args);
va_end(args);
}
// A line of a log as a reason, its bytes as they are.
static void failLine(FailsT *fails, const uint8_t *line, size_t len) {
failSeparate(fails);
toolBufAdd(&fails->text, line, len);
}
// "; " before every reason but the first.
static void failSeparate(FailsT *fails) {
if (fails->count > 0u) {
toolBufAdd(&fails->text, SEPARATOR, strlen(SEPARATOR));
}
fails->count++;
}
static bool fileExists(const char *path) {
FILE *f;
f = fopen(path, "rb");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
// The first place at or after *at that the pattern matches: there, in *at,
// and its numbers in values.
static bool findPattern(const uint8_t *text, size_t len, size_t *at, const char *pattern, long *values) {
for (; *at < len; (*at)++) {
if (matchAt(text, len, *at, pattern, values)) {
return true;
}
}
return false;
}
// The image of the icon file at path: its size and depth, and its pixels'
// color indices, a bit of each from each plane.
static void iconRead(const char *path, IconT *icon) {
uint8_t *info;
size_t infoLen;
size_t byteAt;
long rowBytes;
long plane;
long x;
long y;
info = readText(path, &infoLen);
if (infoLen < INFO_PLANES_AT) {
toolFail("%s is too short for an icon", path);
}
icon->width = be16(info + INFO_SIZE_AT);
icon->height = be16(info + INFO_SIZE_AT + WORD_BYTES);
icon->depth = be16(info + INFO_SIZE_AT + 2u * WORD_BYTES);
if (icon->depth > INFO_DEPTH_MAX) {
toolFail("%s has %ld planes", path, icon->depth);
}
icon->cols = (icon->width > 0 && icon->height > 0) ? icon->width : 0;
icon->rows = (icon->cols > 0) ? icon->height : 0;
icon->indices = (uint8_t *)calloc((size_t)(icon->cols * icon->rows) + 1u, 1u);
if (icon->indices == NULL) {
toolFail("out of memory");
}
rowBytes = (icon->width + WORD_PIXELS - 1) / WORD_PIXELS * WORD_BYTES;
for (plane = 0; plane < icon->depth; plane++) {
for (y = 0; y < icon->rows; y++) {
for (x = 0; x < icon->cols; x++) {
byteAt = INFO_PLANES_AT + (size_t)(plane * rowBytes * icon->rows + y * rowBytes + x / BYTE_BITS);
if (byteAt >= infoLen) {
toolFail("%s's planes are truncated", path);
}
if (info[byteAt] & (TOP_BIT >> (x % BYTE_BITS))) {
icon->indices[y * icon->cols + x] |= (uint8_t)(1u << plane);
}
}
}
}
free(info);
}
// Whether the screenshot at path shows the icon: the bounds of the gray
// (looked for at every other pixel), the non-gray inside its upper half,
// and each of the icon's pixels in the middle of its cell there. Prints
// where the icon is and how many of its pixels are right; adds what is
// wrong to fails.
static void iconShown(const char *path, const IconT *icon, const char *label, FailsT *fails) {
GateImageT shot;
BoundsT gray;
BoundsT shown;
BoundsT held;
const uint8_t *pixel;
long x;
long y;
long cells;
long wrong;
uint8_t index;
double scaleX;
double scaleY;
gateImageLoad(path, &shot);
memset(&gray, 0, sizeof(gray));
for (y = 0; y < (long)shot.height; y += GRAY_STEP) {
for (x = 0; x < (long)shot.width; x += GRAY_STEP) {
if (memcmp(gateImagePixel(&shot, (uint32_t)x, (uint32_t)y), kWorkbench[0], GATE_RGB_BYTES) == 0) {
boundsAdd(&gray, x, y);
}
}
}
if (!gray.any) {
failAdd(fails, "no Workbench gray on the screenshot");
return;
}
memset(&shown, 0, sizeof(shown));
for (y = gray.y0; y <= (gray.y0 + gray.y1) / 2; y++) {
for (x = gray.x0; x <= gray.x1; x++) {
if (memcmp(gateImagePixel(&shot, (uint32_t)x, (uint32_t)y), kWorkbench[0], GATE_RGB_BYTES) != 0) {
boundsAdd(&shown, x, y);
}
}
}
memset(&held, 0, sizeof(held));
for (y = 0; y < icon->rows; y++) {
for (x = 0; x < icon->cols; x++) {
if (icon->indices[y * icon->cols + x] != 0u) {
boundsAdd(&held, x, y);
}
}
}
if (!shown.any || !held.any) {
failAdd(fails, held.any ? "no icon on the screenshot" : "the icon file is empty");
return;
}
scaleX = (double)(shown.x1 + 1 - shown.x0) / (double)(held.x1 + 1 - held.x0);
scaleY = (double)(shown.y1 + 1 - shown.y0) / (double)(held.y1 + 1 - held.y0);
wrong = 0;
for (y = held.y0; y <= held.y1; y++) {
for (x = held.x0; x <= held.x1; x++) {
index = icon->indices[y * icon->cols + x];
if (index >= AMIGA_COLORS) {
toolFail("the icon's pixel %ld,%ld is color %u, past Workbench's four", x, y, (unsigned)index);
}
pixel = gateImagePixel(&shot, (uint32_t)(shown.x0 + (x - held.x0 + HALF) * scaleX), (uint32_t)(shown.y0 + (y - held.y0 + HALF) * scaleY));
if (memcmp(pixel, kWorkbench[index], GATE_RGB_BYTES) != 0) {
wrong++;
}
}
}
cells = (held.x1 + 1 - held.x0) * (held.y1 + 1 - held.y0);
printf("%s: icon shown at %ld,%ld scaled %.2fx%.2f: %ld/%ld pixels right\n", label, shown.x0, shown.y0, scaleX, scaleY, cells - wrong, cells);
if (wrong != 0) {
failAdd(fails, "%ld of the icon's %ld pixels wrong on the screen", wrong, cells);
}
gateImageFree(&shot);
}
// Whether the pattern matches text at at: its characters as they are, a
// PATTERN_NUMBER a run of digits that fits a long, each number in values.
static bool matchAt(const uint8_t *text, size_t len, size_t at, const char *pattern, long *values) {
char digits[NUMBER_DIGITS_MAX + 1u];
uint32_t count;
size_t n;
count = 0u;
for (; *pattern != '\0'; pattern++) {
if (*pattern != PATTERN_NUMBER) {
if (at >= len || text[at] != (uint8_t)*pattern) {
return false;
}
at++;
continue;
}
n = 0u;
while (at + n < len && text[at + n] >= '0' && text[at + n] <= '9') {
n++;
}
if (n == 0u || n > NUMBER_DIGITS_MAX) {
return false;
}
memcpy(digits, text + at, n);
digits[n] = '\0';
if (!gateArgParseLong(digits, &values[count])) {
return false;
}
count++;
at += n;
}
return true;
}
static int printVerdict(const FailsT *fails, const char *label) {
printf("%s: FAIL - ", label);
fwrite(fails->text.data, 1u, fails->text.len, stdout);
printf("\n");
return FAIL_EXIT;
}
// A whole file; one that cannot be read is fatal.
static uint8_t *readText(const char *path, size_t *len) {
uint8_t *data;
if (!toolReadFile(path, &data, len)) {
toolFail("cannot read %s", path);
}
return data;
}
int main(int argc, char **argv) {
int exitCode;
toolFileName(TOOL_NAME);
if (!gateModeRun(kModes, GATE_COUNT_OF(kModes), argc, argv, &exitCode)) {
return gateUsage(kUsage, GATE_COUNT_OF(kUsage));
}
return exitCode;
}
Reference in a new issue View git blame Copy permalink