Files
VCCPlusOSS/platforms/macos/Tools/Playtest/main.mm
T

831 lines
51 KiB
Plaintext

// SPDX-License-Identifier: GPL-3.0-or-later
// App-owned disposable machine. STDIO is private to the parent app; no sockets,
// credentials, user settings, host paths, or externally mounted media are read.
#import <AppKit/AppKit.h>
#import <CommonCrypto/CommonDigest.h>
#include "../../../../src/core/MachineSession.h"
#include "../../../../src/devices/FD502/Fd502Device.h"
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <cstdint>
// The class is implemented in Swift and shares CoCoVideoEncoder with the app.
@interface VCCPlaytestVideoWriter : NSObject
- (instancetype)initWithDirectory:(NSURL *)directory includeAudio:(BOOL)includeAudio error:(NSError **)error;
- (BOOL)appendPixels:(NSData *)pixels area:(CGRect)area samples:(NSData *)samples error:(NSError **)error;
- (NSURL *)finishAndReturnError:(NSError **)error;
@end
using namespace VCC::Mac;
namespace {
constexpr size_t wireLimit = 1024 * 1024;
constexpr uint64_t fieldBudget = 216000;
constexpr size_t maximumDiskBytes = 512 * 1024;
constexpr unsigned audioFieldLimit = 120;
constexpr size_t audioSampleFrameLimit = 131072;
constexpr uint64_t videoByteLimit = 64 * 1024 * 1024;
void little16(std::vector<uint8_t>& bytes, uint16_t value) {
bytes.push_back(value & 255); bytes.push_back(value >> 8);
}
void little32(std::vector<uint8_t>& bytes, uint32_t value) {
little16(bytes, value & 65535); little16(bytes, value >> 16);
}
NSString *sha256(const std::vector<uint8_t>& bytes) {
unsigned char digest[CC_SHA256_DIGEST_LENGTH];
CC_SHA256(bytes.data(), static_cast<CC_LONG>(bytes.size()), digest);
NSMutableString *text = [NSMutableString string];
for (auto byte : digest) [text appendFormat:@"%02x",byte];
return text;
}
std::vector<uint8_t> wave(const std::vector<StereoSample>& samples) {
// No host gain or device/microphone path is involved. Preserve both guest
// channels, quantized to standard signed 16-bit little-endian PCM.
if (samples.size() > audioSampleFrameLimit) throw std::runtime_error("playtest_audio_limit");
const uint32_t dataBytes = uint32_t(samples.size() * 4);
std::vector<uint8_t> bytes; bytes.reserve(44 + dataBytes);
bytes.insert(bytes.end(), {'R','I','F','F'}); little32(bytes, 36 + dataBytes);
bytes.insert(bytes.end(), {'W','A','V','E','f','m','t',' '}); little32(bytes, 16);
little16(bytes, 1); little16(bytes, 2); little32(bytes, CassetteDeck::rate);
little32(bytes, CassetteDeck::rate * 4); little16(bytes, 4); little16(bytes, 16);
bytes.insert(bytes.end(), {'d','a','t','a'}); little32(bytes, dataBytes);
for (const auto& sample : samples) {
for (float value : {sample.left, sample.right}) {
if (!std::isfinite(value)) throw std::runtime_error("playtest_audio_invalid_sample");
const long quantized = std::lround(std::clamp(value, -1.0f, 1.0f) * 32768.0f);
little16(bytes, uint16_t(int16_t(std::clamp(quantized, -32768L, 32767L))));
}
}
return bytes;
}
int number(id value, int low, int high) {
if (![value isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID())
throw std::invalid_argument("invalid_arguments");
double n = [value doubleValue];
if (!std::isfinite(n) || n < low || n > high || std::floor(n) != n) throw std::invalid_argument("invalid_arguments");
return int(n);
}
NSString *mediaIdentifier(id value) {
if (![value isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_media_id");
const auto count = [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
if (!count || count > 64 || count != [value length]) throw std::invalid_argument("invalid_media_id");
const char *text = [value UTF8String];
for (NSUInteger i = 0; i < count; ++i) {
const auto c = static_cast<unsigned char>(text[i]);
if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
(c >= '0' && c <= '9') || c == '-' || c == '_')) throw std::invalid_argument("invalid_media_id");
}
return value;
}
struct InputStep {
uint64_t keys = 0;
unsigned fields = 0;
std::array<JoystickInputSnapshot, 2> joysticks{};
};
std::vector<InputStep> inputPlan(id value, unsigned& total) {
if (![value isKindOfClass:NSArray.class] || [value count] == 0 || [value count] > 64)
throw std::invalid_argument("invalid_arguments");
std::vector<InputStep> plan;
total = 0;
for (id raw in (NSArray *)value) {
if (![raw isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_arguments");
NSDictionary *step = raw;
for (NSString *key in step)
if (![@[@"mask", @"fields", @"joysticks"] containsObject:key]) throw std::invalid_argument("invalid_arguments");
NSNumber *mask = step[@"mask"];
if (![mask isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)mask) == CFBooleanGetTypeID() ||
!std::isfinite(mask.doubleValue) || mask.doubleValue < 0 || std::floor(mask.doubleValue) != mask.doubleValue ||
mask.unsignedLongLongValue >> 56) throw std::invalid_argument("invalid_arguments");
InputStep item;
item.keys = mask.unsignedLongLongValue;
item.fields = number(step[@"fields"], 1, 600);
total += item.fields;
if (total > 3600) throw std::invalid_argument("invalid_arguments");
if (step[@"joysticks"]) {
id ports = step[@"joysticks"];
if (![ports isKindOfClass:NSArray.class] || [ports count] > 2) throw std::invalid_argument("invalid_arguments");
bool seen[2] = {};
for (id rawPort in (NSArray *)ports) {
if (![rawPort isKindOfClass:NSDictionary.class] || [rawPort count] != 4)
throw std::invalid_argument("invalid_arguments");
NSDictionary *port = rawPort;
for (NSString *key in port)
if (![@[@"port", @"x", @"y", @"buttons"] containsObject:key]) throw std::invalid_argument("invalid_arguments");
unsigned index;
if ([port[@"port"] isEqual:@"right"]) index = 0;
else if ([port[@"port"] isEqual:@"left"]) index = 1;
else throw std::invalid_argument("invalid_arguments");
if (seen[index]) throw std::invalid_argument("invalid_arguments");
seen[index] = true;
auto& input = item.joysticks[index];
input.x = number(port[@"x"], 0, 16383);
input.y = number(port[@"y"], 0, 16383);
id buttons = port[@"buttons"];
if (![buttons isKindOfClass:NSArray.class] || [buttons count] > 2) throw std::invalid_argument("invalid_arguments");
for (id button in (NSArray *)buttons) {
unsigned bit;
if ([button isEqual:@"fire1"]) bit = 1;
else if ([button isEqual:@"fire2"]) bit = 2;
else throw std::invalid_argument("invalid_arguments");
if (input.buttons & bit) throw std::invalid_argument("invalid_arguments");
input.buttons |= bit;
}
}
}
plan.push_back(item);
}
return plan;
}
struct ReleaseInput {
MachineSession *machine;
~ReleaseInput() { machine->releaseInputs(); }
};
NSDictionary *inputMetadata(const Snapshot& snapshot) {
NSMutableArray *ports = [NSMutableArray arrayWithCapacity:2];
bool neutral = !snapshot.keyboardHeld;
for (unsigned index = 0; index < snapshot.joysticks.size(); ++index) {
const auto& port = snapshot.joysticks[index];
NSMutableArray *buttons = [NSMutableArray array];
if (port.buttons & 1) [buttons addObject:@"fire1"];
if (port.buttons & 2) [buttons addObject:@"fire2"];
neutral = neutral && port.x == 8191 && port.y == 8191 && port.buttons == 0;
[ports addObject:@{@"port":index == 0 ? @"right" : @"left", @"x":@(port.x), @"y":@(port.y),
@"buttons":buttons, @"interface":@[@"standard",@"software",@"tandy",@"coco_max"][std::min(port.mode, 3u)]}];
}
return @{@"source":@"owned_playtest", @"interface":@"standard", @"axis_min":@0, @"axis_max":@16383,
@"axis_center":@8191, @"x_direction":@"increases_right", @"y_direction":@"increases_down",
@"ports":ports, @"keyboard_held":@(snapshot.keyboardHeld), @"neutral":@(neutral)};
}
std::vector<uint8_t> bytes(id value, size_t maximum, size_t exact = 0) {
if (![value isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_arguments");
NSData *data = [[NSData alloc] initWithBase64EncodedString:value options:0];
if (!data || !data.length || data.length > maximum || (exact && data.length != exact))
throw std::invalid_argument("invalid_bytes");
auto p = static_cast<const uint8_t *>(data.bytes);
return {p, p + data.length};
}
NSArray *array(const std::vector<uint8_t>& data) {
NSMutableArray *out = [NSMutableArray arrayWithCapacity:data.size()];
for (auto b : data) [out addObject:@(b)];
return out;
}
DebugGraphicsMode graphicsMode(NSString *name) {
if (![name isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_graphics_buffer_mode");
const std::pair<const char*, DebugGraphicsMode> modes[] = {
{"sg4", DebugGraphicsMode::SG4}, {"pmode0", DebugGraphicsMode::PMODE0},
{"pmode1", DebugGraphicsMode::PMODE1}, {"pmode2", DebugGraphicsMode::PMODE2},
{"pmode3", DebugGraphicsMode::PMODE3}, {"pmode4", DebugGraphicsMode::PMODE4},
{"hscreen1", DebugGraphicsMode::HSCREEN1}, {"hscreen2", DebugGraphicsMode::HSCREEN2},
{"hscreen3", DebugGraphicsMode::HSCREEN3}, {"hscreen4", DebugGraphicsMode::HSCREEN4},
{"current_gime", DebugGraphicsMode::CurrentGime}};
for (const auto& [text, mode] : modes)
if ([name isEqualToString:[NSString stringWithUTF8String:text]]) return mode;
throw std::invalid_argument("invalid_graphics_buffer_mode");
}
NSString *png(const std::vector<uint32_t>& pixels, unsigned width, unsigned height, size_t maximum) {
if (!width || !height || width > Frame::width || height > Frame::height || pixels.size() != size_t(width) * height)
throw std::runtime_error("playtest_capture_failed");
NSBitmapImageRep *image = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:nullptr
pixelsWide:width pixelsHigh:height bitsPerSample:8 samplesPerPixel:4 hasAlpha:YES
isPlanar:NO colorSpaceName:NSDeviceRGBColorSpace bytesPerRow:width * 4 bitsPerPixel:32];
if (!image) throw std::runtime_error("playtest_capture_failed");
auto p = image.bitmapData;
for (size_t i = 0; i < pixels.size(); ++i) {
const auto rgb = pixels[i];
p[i*4] = rgb >> 16; p[i*4+1] = rgb >> 8; p[i*4+2] = rgb; p[i*4+3] = 255;
}
NSData *data = [image representationUsingType:NSBitmapImageFileTypePNG properties:@{}];
if (!data || data.length > maximum) throw std::runtime_error("playtest_capture_limit");
return [data base64EncodedStringWithOptions:0];
}
NSMutableDictionary *graphicsMetadata(const DebugGraphicsPreview& preview, NSString *identity) {
NSMutableArray *ranges = [NSMutableArray array], *palette = [NSMutableArray array];
for (auto color : preview.palette) [palette addObject:@(color)];
bool contiguous = !preview.byteAddresses.empty();
for (size_t i = 0; i < preview.byteAddresses.size();) {
const auto begin = preview.byteAddresses[i];
size_t count = 1;
while (i + count < preview.byteAddresses.size() && preview.byteAddresses[i + count] == begin + count) ++count;
[ranges addObject:@{@"address":@(begin),@"count":@(count)}];
if (ranges.count > 1024) throw std::runtime_error("playtest_capture_limit");
i += count;
}
contiguous = contiguous && ranges.count == 1;
NSMutableDictionary *metadata = [@{@"id":identity, @"selection":@"current_video_registers", @"physical_address":@(preview.address),
@"byte_count":@(preview.bytes.size()), @"contiguous":@(contiguous), @"physical_ranges":ranges,
@"mode":[NSString stringWithUTF8String:preview.modeName.c_str()], @"width":@(preview.width), @"height":@(preview.height),
@"bytes_per_row":@(preview.bytesPerRow), @"pixels_per_byte":@(preview.pixelsPerByte),
@"lines_per_row":@(preview.linesPerRow), @"palette":palette,
@"video_origin":@(preview.videoOrigin), @"row_stride_bytes":@(preview.rowStrideBytes),
@"horizontal_offset_bytes":@(preview.horizontalOffsetBytes), @"vertical_scroll_lines":@(preview.verticalScrollLines),
@"generation":@(preview.generation), @"cycles":@(preview.cycles)} mutableCopy];
if (!preview.canvasIdentifier.empty()) {
metadata[@"canvas_id"] = [NSString stringWithUTF8String:preview.canvasIdentifier.c_str()];
metadata[@"canvas_address"] = @(preview.canvasAddress); metadata[@"canvas_bytes"] = @(preview.canvasBytes);
metadata[@"viewport_offset"] = @(preview.viewportOffset);
}
return metadata;
}
class Playtest {
std::unique_ptr<MachineSession> machine;
std::shared_ptr<VCC::Devices::Fd502Device> floppy;
std::vector<uint8_t> rom;
std::vector<uint64_t> bootKeys;
std::vector<DebugBankedModule> modules;
std::vector<DebugCodeGuard> flatGuards;
std::vector<DebugGraphicsBuffer> graphicsBuffers;
std::vector<uint16_t> stops;
std::string stopModule;
void armEvidence(const std::vector<uint16_t>& points, const std::string& selectedModule) {
if (!flatGuards.empty()) {
if (!selectedModule.empty()) throw std::invalid_argument("unverified_stop_module");
auto guards = flatGuards;
// The native flat guard API expects each stop at the beginning of
// a verified range. Split retained byte ranges without inventing
// instruction boundaries; stop addresses are verified by the host.
for (auto point : points) {
const auto found = std::find_if(guards.begin(), guards.end(), [&](const auto& guard) {
return point >= guard.address && size_t(point - guard.address) < guard.bytes.size();
});
if (found == guards.end()) throw std::invalid_argument("unverified_stop");
const auto offset = size_t(point - found->address);
if (offset) {
DebugCodeGuard tail{point, std::vector<uint8_t>(found->bytes.begin() + offset, found->bytes.end())};
found->bytes.resize(offset); guards.push_back(std::move(tail));
}
}
std::sort(guards.begin(), guards.end(), [](const auto& lhs, const auto& rhs) { return lhs.address < rhs.address; });
machine->debuggerArmDevelopmentBreakpoints(points, guards);
return;
}
if (modules.empty()) {
if (!points.empty()) throw std::invalid_argument("unverified_stop_module");
machine->debuggerClearDevelopmentBreakpoints();
return;
}
auto registered = modules;
bool selected = points.empty();
for (auto& module : registered) {
if (!points.empty() && module.identifier == selectedModule) {
module.breakpointAddresses = points; selected = true;
} else module.breakpointAddresses = std::vector<uint16_t>{};
}
if (!selected) throw std::invalid_argument("unverified_stop_module");
// Keep every verified module available for pauses and steps after a
// bank switch; only the selected module owns the requested stop points.
machine->debuggerArmBankedDevelopmentBreakpoints(points, registered);
}
void armStop() { armEvidence(stops, stopModule); }
void armInspection() { armEvidence({}, {}); }
uint64_t consumed = 0, fieldClock = 0, bootNumber = 0, mediaGeneration = 0;
VCCPlaytestVideoWriter *videoWriter = nil;
NSMutableDictionary *videoInfo = nil;
NSURL *videoDirectory = nil;
unsigned videoMaximumFields = 0;
uint64_t videoFirstField = 0, videoSamples = 0;
void finishVideo(NSString *reason) {
if (!videoWriter) return;
NSError *error = nil;
NSURL *output = nil;
if (videoSamples) output = [videoWriter finishAndReturnError:&error];
videoWriter = nil;
videoInfo[@"field_end"] = @(fieldClock);
videoInfo[@"fields_recorded"] = @(fieldClock - videoFirstField);
videoInfo[@"sample_frames"] = @(videoSamples);
videoInfo[@"truncated"] = @(![reason isEqual:@"stopped"] && ![reason isEqual:@"run_stopped"]);
videoInfo[@"reason"] = reason;
videoInfo[@"status"] = @"failed"; videoInfo[@"completed"] = @NO;
if (!output) { videoInfo[@"error"] = error.localizedDescription ?: @"No emulated audio/video interval was recorded."; return; }
NSData *data = [NSData dataWithContentsOfURL:output options:NSDataReadingMappedIfSafe error:&error];
if (!data || data.length == 0 || data.length > videoByteLimit) {
videoInfo[@"error"] = error.localizedDescription ?: @"playtest_video_byte_limit"; return;
}
std::vector<uint8_t> bytes(static_cast<const uint8_t *>(data.bytes), static_cast<const uint8_t *>(data.bytes) + data.length);
videoInfo[@"status"] = @"complete"; videoInfo[@"completed"] = @YES;
videoInfo[@"byte_count"] = @(data.length); videoInfo[@"sha256"] = sha256(bytes);
videoInfo[@"mime_type"] = @"video/mp4"; videoInfo[@"filename"] = @"Clip.mp4";
}
void recordVideo(const std::vector<StereoSample>& samples) {
if (!videoWriter || samples.empty()) return;
const auto snapshot = machine->snapshot();
const auto frame = snapshot.frame;
if (!frame || frame->pixels.size() != Frame::width * Frame::height) {
finishVideo(@"picture_unavailable"); return;
}
const auto area = frame->activeArea;
NSError *error = nil;
const BOOL ok = [videoWriter appendPixels:[NSData dataWithBytes:frame->pixels.data() length:frame->pixels.size() * sizeof(uint32_t)]
area:CGRectMake(area.x, area.y, area.width, area.height)
samples:[NSData dataWithBytes:samples.data() length:samples.size() * sizeof(StereoSample)] error:&error];
if (!ok) {
videoWriter = nil; videoInfo[@"status"] = @"failed"; videoInfo[@"completed"] = @NO;
videoInfo[@"error"] = error.localizedDescription ?: @"playtest_video_writer_failed"; return;
}
videoSamples += samples.size();
videoInfo[@"field_end"] = @(fieldClock); videoInfo[@"fields_recorded"] = @(fieldClock - videoFirstField);
NSDictionary *attributes = [NSFileManager.defaultManager attributesOfItemAtPath:[videoDirectory URLByAppendingPathComponent:@"Working.mov"].path error:nil];
if ([attributes fileSize] >= videoByteLimit - 1024 * 1024) finishVideo(@"byte_limit");
else if (fieldClock - videoFirstField >= videoMaximumFields) finishVideo(@"field_limit");
}
Processor processor = Processor::MC6809;
NSString *originalDiskHash = nil, *currentMediaID = nil;
NSString *diskHash() const {
const auto *image = floppy ? floppy->image(0) : nullptr;
return image ? sha256(image->bytes()) : @"";
}
void requireMediaExchangeState() const {
if (machine->snapshot().state != RunState::Paused) throw std::runtime_error("playtest_not_stopped");
// Motor activity or previously written bytes do not mean a transfer is
// pending. Only the actual FDC busy state prevents a disk exchange.
if (floppy->snapshot().busy) throw std::runtime_error("playtest_media_busy");
}
NSDictionary *exportMedia() const {
requireMediaExchangeState();
NSMutableDictionary *out = [status() mutableCopy];
if (const auto *image = floppy->image(0)) {
const auto& data = image->bytes();
out[@"disk_base64"] = [[NSData dataWithBytes:data.data() length:data.size()] base64EncodedStringWithOptions:0];
}
return out;
}
NSDictionary *exchangeMedia(NSDictionary *request) {
for (NSString *key in request)
if (![@[@"op", @"expected_media_generation", @"expected_disk_sha256", @"media_id", @"disk_base64"] containsObject:key])
throw std::invalid_argument("invalid_arguments");
const bool inserting = request[@"media_id"] != nil;
if ((request[@"disk_base64"] != nil) != inserting || request.count != (inserting ? 5u : 3u))
throw std::invalid_argument("invalid_arguments");
const auto expected = number(request[@"expected_media_generation"], 0, INT32_MAX);
if (![request[@"expected_disk_sha256"] isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_arguments");
NSString *nextID = nil;
std::optional<VCC::Devices::DiskImage> replacement;
// Complete container validation and allocation precede any change to
// mounted media. Invalid images cannot eject or replace the old disk.
if (inserting) {
nextID = mediaIdentifier(request[@"media_id"]);
replacement.emplace(VCC::Devices::DiskImage::load(bytes(request[@"disk_base64"], maximumDiskBytes)));
}
requireMediaExchangeState();
NSString *oldHash = diskHash(), *oldID = currentMediaID;
if (uint64_t(expected) != mediaGeneration || ![request[@"expected_disk_sha256"] isEqual:oldHash])
throw std::runtime_error("stale_media_exchange");
if (mediaGeneration == INT32_MAX) throw std::runtime_error("playtest_media_limit");
// The parent exports and durably retains the old image first. Explicit
// discard only releases this worker's already-retained mounted copy.
if (replacement) floppy->mount(0, std::move(*replacement), true);
else floppy->eject(0, true);
currentMediaID = nextID; originalDiskHash = diskHash(); ++mediaGeneration;
NSMutableDictionary *out = [status() mutableCopy];
out[@"previous_media_id"] = oldID ?: (id)NSNull.null;
out[@"previous_disk_sha256"] = oldHash;
out[@"advances_execution"] = @NO;
return out;
}
void fields(unsigned n) {
if (consumed + n > fieldBudget) throw std::runtime_error("playtest_field_limit");
for (unsigned i = 0; i < n && machine->snapshot().state == RunState::Running; ++i) {
const auto before = machine->snapshot().frames;
machine->advance(); ++consumed;
fieldClock += machine->snapshot().frames - before;
auto samples = machine->takeAudio(); recordVideo(samples);
}
}
void boot() {
if (++bootNumber > 16) throw std::runtime_error("playtest_restart_limit");
machine->releaseInputs(); machine->cancelPaste(); machine->reset(); machine->resume();
fields(300);
if (!machine->basicAtDirectPrompt()) throw std::runtime_error("playtest_basic_unavailable");
if (!modules.empty() || !flatGuards.empty()) { armStop(); machine->resume(); }
machine->paste(bootKeys);
for (unsigned n = 0; machine->pasteRemaining() && n < 3600; ++n) {
if (machine->snapshot().state == RunState::Paused) { machine->cancelPaste(); break; }
fields(1);
}
if (machine->pasteRemaining()) throw std::runtime_error("playtest_boot_timeout");
fields(600);
}
NSDictionary *status() const {
auto s = machine->snapshot();
const bool hd6309 = s.configuration.processor == Processor::HD6309;
const auto *image = floppy->image(0);
NSMutableDictionary *out = [@{ @"cpu": hd6309 ? @"6309" : @"6809", @"processor": hd6309 ? @"HD6309" : @"MC6809",
@"execution_mode": hd6309 ? (s.cpu.IsNative6309 ? @"native" : @"emulation") : @"not_applicable",
@"md_register": hd6309 ? (id)@(s.cpu.MD) : NSNull.null, @"ram_kb": @512,
@"fields": @(fieldClock), @"field_clock": @(fieldClock), @"boot": @(bootNumber), @"machine_frame": @(s.frames),
@"remaining_field_budget": @(fieldBudget - std::min(fieldBudget, consumed)),
@"remaining_boots": @(bootNumber < 16 ? 16 - bootNumber : 0),
@"cycles": @(s.cycles), @"generation": @(s.generation), @"pc": @(s.cpu.PC),
@"state": s.state == RunState::Paused ? @"paused" : @"running",
@"disk_original_sha256": originalDiskHash ?: @"", @"disk_sha256": diskHash(),
@"disk_present": @(image != nullptr), @"media_id": currentMediaID ?: (id)NSNull.null,
@"media_generation": @(mediaGeneration), @"floppy_busy": @(floppy->snapshot().busy),
@"disk_dirty": @(image && image->dirty()), @"disk_reads": @(floppy->readEvents(0)),
@"disk_writes": @(floppy->writeEvents(0)), @"isolated": @YES, @"input":inputMetadata(s) } mutableCopy];
if (videoInfo) out[@"video_recording"] = [videoInfo copy];
return out;
}
NSDictionary *capture() const {
NSMutableDictionary *out = [status() mutableCopy];
out[@"frame_snapshot_kind"] = @"last_published_frame";
try {
out[@"display_buffer"] = graphicsMetadata(machine->debuggerGraphicsPreview(true, true, 0, DebugGraphicsMode::HSCREEN2, false, graphicsBuffers), @"displayed");
} catch (const std::exception& error) {
out[@"display_buffer"] = @{@"selection":@"current_video_registers", @"unavailable":[NSString stringWithUTF8String:error.what()]};
}
try { out[@"screen_text"] = [NSString stringWithUTF8String:machine->copyScreenText().c_str()]; }
catch (const std::exception&) { out[@"screen_text_unavailable"] = @"Guest display is in graphics mode."; }
auto frame = machine->snapshot().frame;
if (frame && frame->pixels.size() == Frame::width * Frame::height) {
out[@"png_base64"] = png(frame->pixels, Frame::width, Frame::height, 650000);
out[@"width"] = @(Frame::width); out[@"height"] = @(Frame::height);
out[@"frame_number"] = @(frame->number);
}
return out;
}
NSDictionary *captureAudio(unsigned requested) {
if (consumed + requested > fieldBudget) throw std::runtime_error("playtest_field_limit");
const auto before = machine->snapshot();
const auto firstField = fieldClock;
std::vector<StereoSample> samples;
samples.reserve(std::min(size_t(requested) * 1024, audioSampleFrameLimit));
auto collect = [&] {
auto next = machine->takeAudio();
if (next.size() > audioSampleFrameLimit - samples.size()) throw std::runtime_error("playtest_audio_limit");
samples.insert(samples.end(), next.begin(), next.end());
recordVideo(next);
};
// Discard audio from earlier input/steps. A capture owns only this
// explicit interval, including any normal leave-breakpoint CPU slice.
machine->takeAudio(); machine->releaseInputs();
try {
if (before.state == RunState::Paused) {
machine->resume();
const auto resumedFields = machine->snapshot().frames - before.frames;
fieldClock += resumedFields; consumed += resumedFields;
collect();
}
for (unsigned attempt = 0; attempt < requested && fieldClock - firstField < requested &&
machine->snapshot().state == RunState::Running; ++attempt) {
const auto previous = machine->snapshot().frames;
machine->advance(); ++consumed;
fieldClock += machine->snapshot().frames - previous;
collect();
}
} catch (...) { machine->releaseInputs(); machine->pause(); throw; }
machine->releaseInputs(); machine->pause();
const auto after = machine->snapshot();
const auto data = wave(samples);
NSMutableDictionary *out = [status() mutableCopy];
out[@"audio_wav_base64"] = [[NSData dataWithBytes:data.data() length:data.size()] base64EncodedStringWithOptions:0];
out[@"audio"] = @{@"mime_type":@"audio/wav", @"sample_rate":@(CassetteDeck::rate), @"channels":@2,
@"encoding":@"pcm_s16le", @"bits_per_sample":@16, @"sample_frames":@(samples.size()),
@"sample_count":@(samples.size() * 2), @"byte_count":@(data.size()), @"sha256":sha256(data),
@"field_start":@(firstField), @"field_end":@(fieldClock), @"fields_requested":@(requested),
@"fields_advanced":@(fieldClock - firstField), @"cycles_start":@(before.cycles), @"cycles_end":@(after.cycles),
@"advances_execution":@YES, @"completed":@(fieldClock - firstField == requested), @"truncated":@NO};
return out;
}
public:
bool stopped = false;
NSDictionary *reply(NSDictionary *r) {
NSString *op = r[@"op"];
if (![op isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_arguments");
if ([op isEqual:@"init"]) {
if (machine) throw std::runtime_error("already_started");
rom = bytes(r[@"system_rom"], 32768, 32768);
auto diskROM = bytes(r[@"disk_rom"], 8192, 8192), disk = bytes(r[@"disk"], maximumDiskBytes);
NSString *initialMediaID = mediaIdentifier(r[@"media_id"] ?: @"primary");
NSArray *keys = r[@"boot_keys"];
if (![keys isKindOfClass:NSArray.class] || keys.count == 0 || keys.count > 256) throw std::invalid_argument("invalid_boot_keys");
for (NSNumber *n in keys) {
if (![n isKindOfClass:NSNumber.class] || n.unsignedLongLongValue >> 56) throw std::invalid_argument("invalid_boot_keys");
bootKeys.push_back(n.unsignedLongLongValue);
}
if ([r[@"cpu"] isEqual:@"6309"]) processor = Processor::HD6309;
else if (r[@"cpu"] && ![r[@"cpu"] isEqual:@"6809"]) throw std::invalid_argument("invalid_cpu");
NSArray *declared = r[@"modules"] ?: @[];
if (![declared isKindOfClass:NSArray.class] || declared.count > 256) throw std::invalid_argument("invalid_modules");
size_t guardTotal = 0;
for (NSDictionary *item in declared) {
if (![item isKindOfClass:NSDictionary.class] || ![item[@"id"] isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_modules");
DebugBankedModule module; module.identifier = [item[@"id"] UTF8String];
id overlayGroup = item[@"overlay_group"], overlayOwner = item[@"overlay_owner"];
if (overlayGroup || overlayOwner) {
if (![overlayGroup isKindOfClass:NSString.class] || ![overlayOwner isKindOfClass:NSString.class] ||
![overlayGroup length] || ![overlayOwner length] ||
[overlayGroup lengthOfBytesUsingEncoding:NSUTF8StringEncoding] > 128 ||
[overlayOwner lengthOfBytesUsingEncoding:NSUTF8StringEncoding] > 128)
throw std::invalid_argument("invalid_overlay_identity");
const char *groupText = [overlayGroup UTF8String], *ownerText = [overlayOwner UTF8String];
if (!groupText || !ownerText || std::strlen(groupText) != [overlayGroup lengthOfBytesUsingEncoding:NSUTF8StringEncoding] ||
std::strlen(ownerText) != [overlayOwner lengthOfBytesUsingEncoding:NSUTF8StringEncoding])
throw std::invalid_argument("invalid_overlay_identity");
module.overlayGroup = groupText; module.overlayOwner = ownerText;
}
NSArray *pages = item[@"pages"], *guards = item[@"guards"];
if (![pages isKindOfClass:NSArray.class] || pages.count == 0 || pages.count > 8 ||
![guards isKindOfClass:NSArray.class] || guards.count == 0 || guards.count > 8192) throw std::invalid_argument("invalid_modules");
for (NSDictionary *page in pages) {
if (![page isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_modules");
module.pages.push_back({uint8_t(number(page[@"logical_page"],0,7)),uint32_t(number(page[@"physical_page"],0,63))});
}
for (NSDictionary *guard in guards) {
if (![guard isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_modules");
int address = number(guard[@"address"],0,65535);
auto value = bytes(guard[@"bytes_base64"], 65536);
guardTotal += value.size();
if (value.size() > 65536 - address || guardTotal > 512*1024) throw std::invalid_argument("invalid_modules");
module.guards.push_back({uint16_t(address),std::move(value)});
}
modules.push_back(std::move(module));
}
NSArray *declaredFlat = r[@"flat_guards"] ?: @[];
if (![declaredFlat isKindOfClass:NSArray.class] || declaredFlat.count > 8192 ||
(declaredFlat.count && !modules.empty())) throw std::invalid_argument("invalid_flat_guards");
std::vector<bool> occupied(65536, false);
size_t flatTotal = 0;
for (NSDictionary *guard in declaredFlat) {
if (![guard isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_flat_guards");
const auto address = number(guard[@"address"], 0, 0xfdff);
auto value = bytes(guard[@"bytes_base64"], 65536);
flatTotal += value.size();
if (value.size() > 0xfe00 - address || flatTotal > 65536) throw std::invalid_argument("invalid_flat_guards");
for (size_t i = 0; i < value.size(); ++i) {
if (occupied[address + i]) throw std::invalid_argument("invalid_flat_guards");
occupied[address + i] = true;
}
flatGuards.push_back({uint16_t(address), std::move(value)});
}
NSArray *buffers = r[@"graphics_buffers"] ?: @[];
if (![buffers isKindOfClass:NSArray.class] || buffers.count > 4) throw std::invalid_argument("invalid_graphics_buffers");
for (NSDictionary *item in buffers) {
if (![item isKindOfClass:NSDictionary.class] || ![item[@"id"] isKindOfClass:NSString.class])
throw std::invalid_argument("invalid_graphics_buffers");
const std::string identifier = [item[@"id"] UTF8String];
if (identifier.empty() || identifier.size() > 64 || identifier.size() != [item[@"id"] lengthOfBytesUsingEncoding:NSUTF8StringEncoding] || identifier == "displayed" ||
!std::all_of(identifier.begin(), identifier.end(), [](unsigned char c) {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '-';
}) || std::any_of(graphicsBuffers.begin(), graphicsBuffers.end(), [&](const auto& buffer) { return buffer.identifier == identifier; }))
throw std::invalid_argument("invalid_graphics_buffer_id");
const auto mode = graphicsMode(item[@"mode"]);
const auto origin = uint32_t(number(item[@"physical_address"],0,512*1024-1));
uint32_t span = 0;
if (mode == DebugGraphicsMode::CurrentGime) {
span = uint32_t(number(item[@"canvas_bytes"],8192,512*1024));
if ((span & (span - 1)) || origin % span || span > 512*1024 - origin)
throw std::invalid_argument("invalid_graphics_canvas_span");
for (const auto& other : graphicsBuffers)
if (other.mode == DebugGraphicsMode::CurrentGime && origin < other.physicalAddress + other.canvasBytes && other.physicalAddress < origin + span)
throw std::invalid_argument("ambiguous_graphics_canvases");
} else if (item[@"canvas_bytes"]) throw std::invalid_argument("unexpected_graphics_canvas_span");
graphicsBuffers.push_back({identifier, origin, mode, false, span});
}
if (r[@"stop_at"]) {
if (modules.empty() && flatGuards.empty()) throw std::invalid_argument("unverified_stop");
stops.push_back(uint16_t(number(r[@"stop_at"],0,65535)));
if (!flatGuards.empty()) {
if (r[@"stop_module"]) throw std::invalid_argument("unverified_stop_module");
} else {
if (![r[@"stop_module"] isKindOfClass:NSString.class]) throw std::invalid_argument("unverified_stop_module");
stopModule = [r[@"stop_module"] UTF8String];
}
}
machine = std::make_unique<MachineSession>();
MachineConfiguration config; config.processor = processor; config.ram = 1; config.frameInterval = 1;
machine->configure(config);
floppy = std::make_shared<VCC::Devices::Fd502Device>(diskROM);
floppy->mount(0,VCC::Devices::DiskImage::load(disk));
originalDiskHash = diskHash(); currentMediaID = initialMediaID;
machine->cartridges().configure({nullptr,nullptr,nullptr,nullptr,floppy},true,4);
machine->load(rom,processor);
for (const auto& buffer : graphicsBuffers)
if (buffer.mode != DebugGraphicsMode::CurrentGime)
(void)machine->debuggerGraphicsPreview(false, true, buffer.physicalAddress, buffer.mode);
boot(); return status();
}
if (!machine || stopped) throw std::runtime_error("stale_run");
if ([op isEqual:@"media_status"]) {
if (r.count != 1) throw std::invalid_argument("invalid_arguments");
return status();
}
if ([op isEqual:@"export_media"]) {
if (r.count != 1) throw std::invalid_argument("invalid_arguments");
return exportMedia();
}
if ([op isEqual:@"exchange_media"]) return exchangeMedia(r);
if ([op isEqual:@"video_start"]) {
if (r.count != 5 || ![r[@"clip_id"] isKindOfClass:NSString.class] ||
![r[@"directory"] isKindOfClass:NSString.class] || !r[@"include_audio"] ||
CFGetTypeID((__bridge CFTypeRef)r[@"include_audio"]) != CFBooleanGetTypeID()) throw std::invalid_argument("invalid_arguments");
if (videoWriter) throw std::runtime_error("playtest_video_active");
NSUUID *identifier = [[NSUUID alloc] initWithUUIDString:r[@"clip_id"]];
NSURL *directory = [NSURL fileURLWithPath:r[@"directory"] isDirectory:YES];
if (!identifier || ![directory.lastPathComponent isEqual:identifier.UUIDString] ||
![NSFileManager.defaultManager fileExistsAtPath:directory.path]) throw std::invalid_argument("invalid_arguments");
videoMaximumFields = number(r[@"max_fields"], 1, 3600);
NSError *error = nil;
videoWriter = [[VCCPlaytestVideoWriter alloc] initWithDirectory:directory includeAudio:[r[@"include_audio"] boolValue] error:&error];
if (!videoWriter) throw std::runtime_error((error.localizedDescription ?: @"playtest_video_start_failed").UTF8String);
videoDirectory = directory; videoFirstField = fieldClock; videoSamples = 0;
machine->takeAudio();
videoInfo = [@{@"clip_id":identifier.UUIDString, @"status":@"recording", @"include_audio":r[@"include_audio"],
@"max_fields":@(videoMaximumFields), @"field_start":@(fieldClock), @"field_end":@(fieldClock),
@"fields_recorded":@0, @"completed":@NO, @"truncated":@NO, @"boot":@(bootNumber),
@"ui_cues_included":@NO, @"microphone_included":@NO, @"host_audio_included":@NO} mutableCopy];
return status();
}
if ([op isEqual:@"video_stop"]) {
if (r.count != 1 || !videoInfo) throw std::runtime_error("playtest_video_unavailable");
finishVideo(@"stopped");
NSMutableDictionary *out = [status() mutableCopy]; out[@"video"] = [videoInfo copy]; return out;
}
if ([op isEqual:@"input"]) {
if (r.count != 2) throw std::invalid_argument("invalid_arguments");
unsigned total = 0;
const auto plan = inputPlan(r[@"steps"], total);
if (consumed + total > fieldBudget) throw std::runtime_error("playtest_field_limit");
ReleaseInput cleanup{machine.get()};
NSMutableArray *trace = [NSMutableArray arrayWithCapacity:plan.size()];
for (unsigned index = 0; index < plan.size(); ++index) {
const auto& step = plan[index];
const auto before = machine->snapshot();
if (before.state != RunState::Running && index != 0) break;
const auto first = fieldClock;
Snapshot applied;
if (before.state == RunState::Paused) {
armInspection();
// Input is staged through the same setters before the
// normal leave-breakpoint slice can sample the PIA.
applied = machine->resumeWithInput(step.keys, step.joysticks);
const auto advanced = machine->snapshot().frames - before.frames;
fieldClock += advanced; consumed += advanced;
auto samples = machine->takeAudio(); recordVideo(samples);
if (advanced > step.fields) throw std::runtime_error("playtest_input_timing");
} else {
machine->setKeyboard(step.keys);
for (unsigned port = 0; port < step.joysticks.size(); ++port) {
const auto& input = step.joysticks[port];
machine->setJoystick(port, input.x, input.y, input.buttons, 0);
}
applied = machine->snapshot();
}
fields(step.fields - unsigned(fieldClock - first));
[trace addObject:@{@"step_index":@(index), @"fields_requested":@(step.fields),
@"fields_advanced":@(fieldClock - first), @"field_start":@(first), @"field_end":@(fieldClock), @"input":inputMetadata(applied)}];
}
machine->releaseInputs();
NSMutableDictionary *result = [status() mutableCopy]; result[@"input_trace"] = trace;
return result;
}
if ([op isEqual:@"input_status"]) {
if (r.count != 1) throw std::invalid_argument("invalid_arguments");
return status();
}
if ([op isEqual:@"capture"]) return capture();
if ([op isEqual:@"audio_capture"]) {
if (r.count != 2 || !r[@"fields"]) throw std::invalid_argument("invalid_arguments");
return captureAudio(number(r[@"fields"], 1, audioFieldLimit));
}
if ([op isEqual:@"graphics_capture"]) {
if (r.count > 2) throw std::invalid_argument("invalid_arguments");
for (NSString *key in r)
if (![key isEqualToString:@"op"] && ![key isEqualToString:@"buffer_id"])
throw std::invalid_argument("invalid_arguments");
std::optional<DebugGraphicsBuffer> selected;
if (r[@"buffer_id"]) {
if (![r[@"buffer_id"] isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_graphics_buffer_id");
const std::string id = [r[@"buffer_id"] UTF8String];
if (id.size() != [r[@"buffer_id"] lengthOfBytesUsingEncoding:NSUTF8StringEncoding]) throw std::invalid_argument("invalid_graphics_buffer_id");
const auto found = std::find_if(graphicsBuffers.begin(), graphicsBuffers.end(), [&](const auto& buffer) { return buffer.identifier == id; });
if (found == graphicsBuffers.end()) throw std::invalid_argument("unknown_graphics_buffer");
selected = *found;
}
const auto captured = machine->debuggerGraphicsCapture(selected, graphicsBuffers);
NSMutableDictionary *out = [status() mutableCopy];
out[@"paused"] = @YES; out[@"snapshot_kind"] = @"paused_register_preview";
auto displayed = graphicsMetadata(captured.displayed, @"displayed");
out[@"display_buffer"] = [displayed copy];
displayed[@"kind"] = @"current_register_preview";
displayed[@"png_base64"] = png(captured.displayed.pixels,captured.displayed.width,captured.displayed.height,350000);
NSMutableArray *images = [NSMutableArray arrayWithObject:displayed];
if (captured.declared) {
auto other = graphicsMetadata(*captured.declared,[NSString stringWithUTF8String:captured.declaredIdentifier.c_str()]);
other[@"selection"] = @"project_declaration"; other[@"kind"] = @"declared_buffer_preview";
other[@"png_base64"] = png(captured.declared->pixels,captured.declared->width,captured.declared->height,350000);
[images addObject:other];
}
out[@"buffers"] = images;
return out;
}
if ([op isEqual:@"restart"]) {
if (videoWriter) throw std::runtime_error("playtest_video_active: stop the recording before restarting");
if (floppy->snapshot().busy) throw std::runtime_error("disk_busy");
boot(); return status();
}
if ([op isEqual:@"continue"]) { armInspection(); const auto before = machine->snapshot().frames; machine->resume(); fieldClock += machine->snapshot().frames - before; auto samples = machine->takeAudio(); recordVideo(samples); return status(); }
if ([op isEqual:@"pause"]) { machine->releaseInputs(); machine->pause(); return status(); }
if ([op isEqual:@"step"]) {
if (machine->snapshot().state != RunState::Paused) throw std::runtime_error("playtest_not_stopped");
const auto before = machine->snapshot().frames;
machine->debuggerStep(); fieldClock += machine->snapshot().frames - before; auto samples = machine->takeAudio(); recordVideo(samples); return status();
}
if ([op isEqual:@"stop_at"]) {
if (modules.empty() && flatGuards.empty()) throw std::runtime_error("unverified_stop");
const auto nextPoint = uint16_t(number(r[@"address"],0,65535));
std::string nextModule;
if (!flatGuards.empty()) {
if (r[@"module_id"]) throw std::invalid_argument("unverified_stop_module");
} else {
if (![r[@"module_id"] isKindOfClass:NSString.class]) throw std::invalid_argument("unverified_stop_module");
nextModule = [r[@"module_id"] UTF8String];
}
armEvidence({nextPoint}, nextModule);
stops = {nextPoint}; stopModule = nextModule;
const auto before = machine->snapshot().frames; machine->resume(); fieldClock += machine->snapshot().frames - before;
auto samples = machine->takeAudio(); recordVideo(samples); return status();
}
if ([op isEqual:@"debug"]) {
if (machine->snapshot().state != RunState::Paused) throw std::runtime_error("playtest_not_stopped");
auto d = machine->debuggerSnapshot(0,65536); auto c = d.cpu;
NSMutableDictionary *out = [status() mutableCopy];
NSMutableDictionary *registers = [@{ @"A":@(c.A), @"B":@(c.B), @"X":@(c.X), @"Y":@(c.Y), @"U":@(c.U), @"S":@(c.S), @"PC":@(c.PC), @"DP":@(c.DP), @"CC":@(c.CC) } mutableCopy];
if (machine->snapshot().configuration.processor == Processor::HD6309) {
registers[@"E"] = @(c.E); registers[@"F"] = @(c.F);
registers[@"W"] = @((unsigned(c.E) << 8) | unsigned(c.F));
registers[@"V"] = @(c.V); registers[@"MD"] = @(c.MD);
}
out[@"registers"] = registers;
out[@"mapping_fingerprint"] = [NSString stringWithFormat:@"%llu",(unsigned long long)machine->snapshot().debuggerMappingFingerprint];
out[@"program_revision"] = @(machine->snapshot().debuggerProgramRevision);
out[@"residency_fingerprint"] = [NSString stringWithFormat:@"%llu",(unsigned long long)machine->snapshot().debuggerResidencyFingerprint];
out[@"attached"] = @(machine->snapshot().debuggerDevelopmentAttached);
out[@"paused"] = @YES;
out[@"logical_memory"] = [[NSData dataWithBytes:d.memory.data() length:d.memory.size()] base64EncodedStringWithOptions:0];
out[@"available"] = [[NSData dataWithBytes:d.memoryAvailable.data() length:d.memoryAvailable.size()] base64EncodedStringWithOptions:0];
NSMutableDictionary *pages = [NSMutableDictionary dictionary];
NSMutableArray *sources = [NSMutableArray array];
for (size_t i = 0; i < d.mmu.Effective.size(); ++i) {
const auto& page = d.mmu.Effective[i];
if (page.Source == VCC::MMUSource::RAM) pages[[NSString stringWithFormat:@"%zu",i]] = @(page.SourceStart / 8192);
[sources addObject:@(int(page.Source))];
}
out[@"physical_pages"] = pages; out[@"page_sources"] = sources;
out[@"mmu_enabled"] = @(d.mmu.Enabled); out[@"active_task"] = @(d.mmu.ActiveTask);
out[@"verified_banked_program"] = @(machine->snapshot().debuggerBankedDevelopment);
return out;
}
if ([op isEqual:@"read_memory"]) {
auto d = machine->debuggerMemoryRange(number(r[@"address"],0,65535),number(r[@"count"],1,256),false);
for (auto b : d.available) if (!b) throw std::runtime_error("memory_unavailable");
NSMutableDictionary *out = [status() mutableCopy];
out[@"address"] = @(d.address); out[@"bytes"] = array(d.bytes);
out[@"cycles"] = @(d.cycles); out[@"generation"] = @(d.generation);
return out;
}
if ([op isEqual:@"stop"]) {
machine->releaseInputs(); machine->pause();
finishVideo(@"run_stopped");
NSMutableDictionary *out = [status() mutableCopy];
if (videoInfo) out[@"video"] = [videoInfo copy];
if (const auto *image = floppy->image(0)) {
const auto& disk = image->bytes();
out[@"disk_base64"] = [[NSData dataWithBytes:disk.data() length:disk.size()] base64EncodedStringWithOptions:0];
}
stopped = true; return out;
}
throw std::invalid_argument("unknown_operation");
}
};
}
int main() {
@autoreleasepool {
Playtest test;
for (;;) {
std::string line; char c;
while (std::cin.get(c) && c != '\n') {
if (line.size() >= wireLimit) return 2;
line.push_back(c);
}
if (line.empty() && !std::cin) break;
@autoreleasepool {
NSDictionary *result;
try {
NSData *data = [NSData dataWithBytes:line.data() length:line.size()];
id request = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
if (![request isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_request");
result = @{ @"result": test.reply(request) };
} catch (const std::exception& error) { result = @{ @"error": [NSString stringWithUTF8String:error.what()] ?: @"playtest_failed" }; }
NSData *data = [NSJSONSerialization dataWithJSONObject:result options:NSJSONWritingSortedKeys error:nil];
if (!data || data.length > wireLimit) return 3;
std::cout.write(static_cast<const char *>(data.bytes),data.length); std::cout << '\n' << std::flush;
}
if (test.stopped) break;
}
}
return 0;
}