// The row of a layer that each display line shows.

//

// tests/test_vera_layer.c pins the layer registers and the base addresses they

// name. This pins the other half of the vertical path: given a display line

// and VSCROLL, which row of the tilemap is fetched and which line inside the

// tile is drawn.

//

// The emulator carries the answer as one number, the layer row, recorded per

// scanline for the debug views (video.c:1326-1328). The RTL carries it as two:

// a wrapped tile row and the line within the tile. This file derives the RTL's

// two from the emulator's one and compares them, over every display line

// rather than a chosen few, so an error that only shows up at a wrap boundary

// has nowhere to hide.

//

// Horizontal is still not covered. The RTL adds a pre-shifted HSCROLL to a

// per-line tile counter (layer_renderer.v:95) while video.c shifts after

// adding (video.c:574, 587); those differ on carry when HSCROLL is not tile

// aligned, and settling it needs rendered pixels, which means the framebuffer

// seam. Nothing here claims to reach it.

//

// ORACLE: B -- X16Community/vera-module Verilog, tag v47.0.2

// (45cc1f053376dae12173ea63612820e4d289c0da), modelled directly below from the

// quoted lines. layer_renderer.v is identical at v48.0.1 and at the tip.

#include "support/video_fixture.h"

#include "support/harness.h"

#include "video.h"

#include <stdio.h>

#include <stdint.h>

#define VERA_CTRL    0x05

#define VERA_DC_VIDEO 0x09

#define L0_CONFIG    0x0D

#define L0_VSCROLL_L 0x12

#define L0_VSCROLL_H 0x13

#define L0_TILEBASE  0x0F

#define DISPLAY_LINES 480

static void

step_frame(void)

{

	for (unsigned i = 0; i < 525; i++) {

		video_step(25.0f, 801.0f, false);

	}

}

// layer_renderer.v:81-82

//     wire [11:0] scrolled_line_idx = {3'b000, line_idx} + vscroll;

//     wire [7:0] vmap_idx = tile_height ? {scrolled_line_idx[11:4]} : scrolled_line_idx[10:3];

//

// layer_renderer.v:84-90

//     reg [7:0] wrapped_vmap_idx;

//     always @* case (map_height)

//         2'd0: wrapped_vmap_idx = {3'b0, vmap_idx[4:0]}; // 32

//         2'd1: wrapped_vmap_idx = {2'b0, vmap_idx[5:0]}; // 64

//         2'd2: wrapped_vmap_idx = {1'b0, vmap_idx[6:0]}; // 128

//         2'd3: wrapped_vmap_idx = {      vmap_idx[7:0]}; // 256

//     endcase

//

// The sum is twelve bits, so it wraps at 4096 pixel rows before anything else

// happens to it.

static unsigned

rtl_wrapped_vmap_idx(unsigned line_idx, unsigned vscroll, unsigned tile_height, unsigned map_height)

{

	const unsigned scrolled = (line_idx + vscroll) & 0xFFF;

	const unsigned vmap     = (tile_height ? (scrolled >> 4) : (scrolled >> 3)) & 0xFF;

	return vmap & ((1u << (5 + map_height)) - 1);

}

// The line within the tile is the low bits of the same twelve-bit sum: three

// for an 8-pixel tile, four for a 16-pixel one.

static unsigned

rtl_line_in_tile(unsigned line_idx, unsigned vscroll, unsigned tile_height)

{

	const unsigned scrolled = (line_idx + vscroll) & 0xFFF;

	return scrolled & (tile_height ? 0xFu : 0x7u);

}

// map_height and tile_height as the register fields, not as pixel counts.

static void

configure_layer0(unsigned map_height, unsigned tile_height, unsigned vscroll)

{

	video_write(VERA_CTRL, 0x00);

	video_write(VERA_DC_VIDEO, 0x31);  // VGA output, both layers on

	// 4bpp tile mode, so the layer is neither text nor bitmap and takes its

	// scroll from the registers below.

	video_write(L0_CONFIG, (uint8_t)((map_height << 6) | (2 << 4) | 0x02));

	video_write(L0_TILEBASE, (uint8_t)(0xFC | (tile_height << 1)));

	video_write(L0_VSCROLL_L, (uint8_t)(vscroll & 0xFF));

	video_write(L0_VSCROLL_H, (uint8_t)((vscroll >> 8) & 0x0F));

}

// The renderer takes the layer row from one register generation and the layout

// from another, so a change needs a couple of lines to settle. Two frames puts

// every line of the second one past that.

static void

settle(void)

{

	step_frame();

	step_frame();

}

static void

check_every_line_against_the_rtl(unsigned map_height, unsigned tile_height, unsigned vscroll)

{

	char what[128];

	char first[192];

	configure_layer0(map_height, tile_height, vscroll);

	settle();

	first[0] = '\0';

	unsigned mismatches = 0;

	unsigned examined   = 0;

	for (uint16_t line = 0; line < DISPLAY_LINES; line++) {

		uint16_t row    = 0;

		uint16_t eff_y  = 0;

		if (!video_get_layer_line_state(0, line, NULL, &eff_y, NULL, &row)) {

			continue;

		}

		examined++;

		const unsigned want_tile_row = rtl_wrapped_vmap_idx(eff_y, vscroll, tile_height, map_height);

		const unsigned want_in_tile  = rtl_line_in_tile(eff_y, vscroll, tile_height);

		// Deliberately not masked to the map height. video.c:587 shifts the row

		// down and puts it straight into the map index, so whatever wrapping

		// the map height calls for has to be in the row already. Masking here

		// would supply it and hide its absence.

		const unsigned got_tile_row = row >> (3 + tile_height);

		const unsigned got_in_tile  = row & ((1u << (3 + tile_height)) - 1);

		if (got_tile_row != want_tile_row || got_in_tile != want_in_tile) {

			mismatches++;

			if (first[0] == '\0') {

				snprintf(first, sizeof first,

				         "line %u (eff_y %u): tile row %u want %u, line in tile %u want %u",

				         line, eff_y, got_tile_row, want_tile_row, got_in_tile, want_in_tile);

			}

		}

	}

	if (first[0] != '\0') {

		printf("      %s\n", first);

	}

	// Without this the sweep would pass by examining nothing: an accessor that

	// reported every line as unrendered leaves no mismatches to count.

	snprintf(what, sizeof what,

	         "all %u display lines are recorded (map_height %u, tile_height %u, vscroll %u)",

	         DISPLAY_LINES, map_height, tile_height, vscroll);

	check_eq(examined, DISPLAY_LINES, what);

	snprintf(what, sizeof what,

	         "every row matches the RTL (map_height %u, tile_height %u, vscroll %u)",

	         map_height, tile_height, vscroll);

	check_eq(mismatches, 0, what);

}

// The composer's effective layer Y, which the sweep above feeds to the RTL

// model as line_idx. At unit vertical scale over a full-height window it is the

// display line itself; asserting it makes the sweep's input a known quantity

// rather than whatever the composer happened to produce.

static void

test_the_layer_y_is_the_display_line_at_unit_scale(void)

{

	video_reset();

	configure_layer0(0, 0, 0);

	settle();

	unsigned wrong = 0;

	for (uint16_t line = 0; line < DISPLAY_LINES; line++) {

		uint16_t eff_y = 0xFFFF;

		if (!video_get_layer_line_state(0, line, NULL, &eff_y, NULL, NULL)) {

			wrong++;

			continue;

		}

		if (eff_y != line) {

			wrong++;

		}

	}

	check_eq(wrong, 0, "the layer Y follows the display line one for one");

}

// Every map height against every tile height, with no scroll: the wrap point

// is then the map height alone.

static void

test_the_row_wraps_at_the_map_height(void)

{

	for (unsigned map_height = 0; map_height < 4; map_height++) {

		for (unsigned tile_height = 0; tile_height < 2; tile_height++) {

			video_reset();

			check_every_line_against_the_rtl(map_height, tile_height, 0);

		}

	}

}

// VSCROLL moves the start of the sweep. 4095 is the largest the twelve-bit

// register holds and puts the sum over the wrap for most of the frame; 300 and

// 7 land it mid-tile, where an off-by-one between the tile row and the line

// inside the tile shows up.

static void

test_vscroll_shifts_the_row(void)

{

	static const unsigned scrolls[] = { 1, 7, 300, 4095 };

	for (unsigned i = 0; i < sizeof scrolls / sizeof scrolls[0]; i++) {

		video_reset();

		check_every_line_against_the_rtl(0, 0, scrolls[i]);

		video_reset();

		check_every_line_against_the_rtl(3, 1, scrolls[i]);

	}

}

int

main(void)

{

	test_the_layer_y_is_the_display_line_at_unit_scale();

	test_the_row_wraps_at_the_map_height();

	test_vscroll_shifts_the_row();

	return x16_test_summary("vera_layer_rows");

}