// Commander X16 Emulator

// Copyright (c) 2019 Michael Steil

// Copyright (c) 2020 Frank van den Hoef

// All rights reserved. License: 2-clause BSD

#ifndef __APPLE__

#ifndef _MSC_VER

#define _XOPEN_SOURCE   600

#define _POSIX_C_SOURCE 1

#endif

#endif

#include "video.h"

#include "memory.h"

#include "glue.h"

#include "debugger.h"

#ifdef HAS_IMGUI

#include "smc.h" // smc_requested_reset (Ctrl+Shift+F5 restart)

#include "dbg_load.h" // dbg_load_note_debugger, when the UI fails to open

#include "debug_ui/debug_ui.h"

#endif

#include "keyboard.h"

#include "gif.h"

#include "joystick.h"

#include "vera_spi.h"

#include "vera_psg.h"

#include "vera_pcm.h"

#include "sprite_trace.h"

#include "vera_bandwidth.h"

#include "icon.h"

#include "sdcard.h"

#include "i2c.h"

#include "audio.h"

#include <stdbool.h>

#include <limits.h>

#include <stdint.h>

#include <time.h>

#include "compat.h"

#ifdef __EMSCRIPTEN__

#include "emscripten.h"

#endif

#ifndef __EMSCRIPTEN__

#define STB_IMAGE_WRITE_IMPLEMENTATION

#include "stb_image_write.h"

#endif

#define APPROX_TITLEBAR_HEIGHT 30

#define VERA_VERSION_MAJOR  47

#define VERA_VERSION_MINOR  0

#define VERA_VERSION_PATCH  2

#define ADDR_VRAM_START     0x00000

#define ADDR_VRAM_END       0x20000

#define ADDR_PSG_START      0x1F9C0

#define ADDR_PSG_END        0x1FA00

#define ADDR_PALETTE_START  0x1FA00

#define ADDR_PALETTE_END    0x1FC00

#define ADDR_SPRDATA_START  0x1FC00

#define ADDR_SPRDATA_END    0x20000

#define NUM_SPRITES 128

// Clocks the sprite renderer gets per scanline before both of its state

// machines are forced to DONE.

//

//   sprite_renderer.v:44  wire render_time_done = (render_time_r == 'd798);

//

// render_time_r is cleared by line_render_start and counts every clock after,

// so this is elapsed time for the line rather than an amount of work. The

// comment above it in the RTL gives the reason for the number: "Limit render

// time so that VGA and composite mode get the same amount of render time".

#define SPRITE_RENDER_TIME 798

// both VGA and NTSC

#define SCAN_HEIGHT 525

#define PIXEL_FREQ 25.0

// VGA

#define VGA_SCAN_WIDTH 800

#define VGA_Y_OFFSET 0

// NTSC: 262.5 lines per frame, lower field first

#define NTSC_HALF_SCAN_WIDTH 794

#define NTSC_X_OFFSET 270

#define NTSC_Y_OFFSET_LOW 42

#define NTSC_Y_OFFSET_HIGH 568

#define TITLE_SAFE_X 0.067

#define TITLE_SAFE_Y 0.05

// visible area we're drawing

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480

#define SCREEN_RAM_OFFSET 0x00000

#ifdef __APPLE__

#define LSHORTCUT_KEY SDL_SCANCODE_LGUI

#define RSHORTCUT_KEY SDL_SCANCODE_RGUI

#else

#define LSHORTCUT_KEY SDL_SCANCODE_LCTRL

#define RSHORTCUT_KEY SDL_SCANCODE_RCTRL

#endif

// When rendering a layer line, we can amortize some of the cost by calculating multiple pixels at a time.

#define LAYER_PIXELS_PER_ITERATION 8

#define MAX(a,b) ((a) > (b) ? a : b)

static SDL_Window *window;

static SDL_Renderer *renderer;

static SDL_Texture *sdlTexture;

static bool is_fullscreen = false;

#ifdef HAS_IMGUI

// ImGui debugger window (separate; created only when -imgui is passed).

static SDL_Window *imgui_window = NULL;

static SDL_Renderer *imgui_renderer = NULL;

static Uint32 imgui_window_id = 0;

#endif

bool mouse_grabbed = false;

bool no_keyboard_capture = false;

bool kernal_mouse_enabled = false;

static uint8_t video_ram[0x20000];

static uint8_t palette[256 * 2];

static uint8_t sprite_data[128][8];

// I/O registers

static uint32_t io_addr[2];

static uint8_t io_rddata[2];

static uint8_t io_inc[2];

static uint8_t io_addrsel;

static uint8_t io_dcsel;

static uint8_t ien;

static uint8_t isr;

static uint16_t irq_line;

static uint8_t reg_layer[2][7];

// Per-scanline record of the layer registers that were actually used to render

// each line, so debug views can reproduce raster-split effects -- programs

// routinely rewrite MAPBASE/TILEBASE/scroll part-way down a frame from a line

// IRQ. Without this a debugger can only ever show one register snapshot for the

// whole frame, which describes just one band of the screen.

static uint8_t  line_reg_layer[SCREEN_HEIGHT][2][7];

static uint16_t line_eff_y[SCREEN_HEIGHT];

// The layer row each line actually displayed. Recorded rather than left for a

// consumer to recompute from the registers: the renderers take the layout from

// prev_layer_properties[1] but VSCROLL and the layer-height mask from [0]

// (video.c: render_layer_line_text/tile via calc_layer_eff_y(props0, ...)), so

// no single register generation describes the result. Storing the answer makes

// the contract true instead of approximately true.

static uint16_t line_layer_row[SCREEN_HEIGHT][2];

static uint8_t  line_layer_enabled[SCREEN_HEIGHT];

static bool     line_state_valid[SCREEN_HEIGHT];

// The raw registers on the same two-stage delay the layer properties use, so

// the history above can record the generation that actually rendered a line.

static uint8_t  prev_reg_layer[2][2][7];

#define COMPOSER_SLOTS 4*64

static uint8_t reg_composer[COMPOSER_SLOTS];

static uint8_t prev_reg_composer[2][COMPOSER_SLOTS];

static uint8_t layer_line[2][SCREEN_WIDTH];

static uint8_t sprite_line_col[SCREEN_WIDTH];

static uint8_t sprite_line_z[SCREEN_WIDTH];

static uint8_t sprite_line_mask[SCREEN_WIDTH];

static uint8_t sprite_line_collisions;

static bool layer_line_enable[2];

static bool old_layer_line_enable[2];

static bool old_sprite_line_enable;

static bool sprite_line_enable;

////////////////////////////////////////////////////////////

// FX registers

////////////////////////////////////////////////////////////

static uint8_t fx_addr1_mode;

// These are all 16.16 fixed point in the emulator

// even though the VERA uses smaller bit widths

// for the whole and fractional parts.

//

// Sign extension is done manually when assigning negative numbers

//

// Native VERA bit widths are shown below.

static uint32_t fx_x_pixel_increment;  // 11.9 fixed point (6.9 without 32x multiplier, 11.4 with 32x multiplier on)

static uint32_t fx_y_pixel_increment;  // 11.9 fixed point (6.9 without 32x multiplier, 11.4 with 32x multiplier on)

static uint32_t fx_x_pixel_position;   // 11.9 fixed point

static uint32_t fx_y_pixel_position;   // 11.9 fixed point

static uint16_t fx_poly_fill_length;      // 10 bits

static uint32_t fx_affine_tile_base;

static uint32_t fx_affine_map_base;

static uint8_t fx_affine_map_size;

static bool fx_4bit_mode;

static bool fx_16bit_hop;

static bool fx_cache_byte_cycling;

static bool fx_cache_fill;

static bool fx_cache_write;

static bool fx_trans_writes;

static bool fx_2bit_poly;

static bool fx_2bit_poking;

static bool fx_cache_increment_mode;

static bool fx_cache_nibble_index;

static uint8_t fx_cache_byte_index;

static bool fx_multiplier;

static bool fx_subtract;

static bool fx_affine_clip;

static uint8_t fx_16bit_hop_align;

static bool fx_nibble_bit[2];

static bool fx_nibble_incr[2];

static uint8_t fx_cache[4];

static int32_t fx_mult_accumulator;

static const uint8_t vera_version_string[] = {'V',

	VERA_VERSION_MAJOR,

	VERA_VERSION_MINOR,

	VERA_VERSION_PATCH

};

float vga_scan_pos_x;

uint16_t vga_scan_pos_y;

float ntsc_half_cnt;

uint16_t ntsc_scan_pos_y;

int frame_count = 0;

// CPU cycles elapsed, accumulated from the counts video_step() is handed. Kept

// here rather than read from clockticks6502 so that video.c does not pull the

// CPU in: the eight test targets that link this file supply a host fixture, not

// a processor. The sum is exact -- main.c passes each instruction's cycle count

// once, and the mid-line raster calls pass zero.

static uint32_t sprite_trace_cpu_cycles = 0;

// The display line the beam is on right now, for stamping attribute writes.

// SPRITE_TRACE_NO_LINE outside the active display, where a write is an ordinary

// full-frame update rather than a raster-timed one.

static uint16_t

sprite_trace_current_line(void)

{

	int y;

	if (reg_composer[0] & 2) {

		y = (ntsc_scan_pos_y < SCAN_HEIGHT) ? (int)ntsc_scan_pos_y - NTSC_Y_OFFSET_LOW

		                                    : (int)ntsc_scan_pos_y - NTSC_Y_OFFSET_HIGH;

	} else {

		y = (int)vga_scan_pos_y - VGA_Y_OFFSET;

	}

	if (y < 0 || y >= SPRITE_TRACE_LINES) {

		return SPRITE_TRACE_NO_LINE;

	}

	return (uint16_t)y;

}

static uint8_t framebuffer[SCREEN_WIDTH * SCREEN_HEIGHT * 4];

#ifndef __EMSCRIPTEN__

static uint8_t png_buffer[SCREEN_WIDTH * SCREEN_HEIGHT * 3];

#endif

static GifWriter gif_writer;

static const uint16_t default_palette[] = {

0x000,0xfff,0x800,0xafe,0xc4c,0x0c5,0x00a,0xee7,0xd85,0x640,0xf77,0x333,0x777,0xaf6,0x08f,0xbbb,0x000,0x111,0x222,0x333,0x444,0x555,0x666,0x777,0x888,0x999,0xaaa,0xbbb,0xccc,0xddd,0xeee,0xfff,0x211,0x433,0x644,0x866,0xa88,0xc99,0xfbb,0x211,0x422,0x633,0x844,0xa55,0xc66,0xf77,0x200,0x411,0x611,0x822,0xa22,0xc33,0xf33,0x200,0x400,0x600,0x800,0xa00,0xc00,0xf00,0x221,0x443,0x664,0x886,0xaa8,0xcc9,0xfeb,0x211,0x432,0x653,0x874,0xa95,0xcb6,0xfd7,0x210,0x431,0x651,0x862,0xa82,0xca3,0xfc3,0x210,0x430,0x640,0x860,0xa80,0xc90,0xfb0,0x121,0x343,0x564,0x786,0x9a8,0xbc9,0xdfb,0x121,0x342,0x463,0x684,0x8a5,0x9c6,0xbf7,0x120,0x241,0x461,0x582,0x6a2,0x8c3,0x9f3,0x120,0x240,0x360,0x480,0x5a0,0x6c0,0x7f0,0x121,0x343,0x465,0x686,0x8a8,0x9ca,0xbfc,0x121,0x242,0x364,0x485,0x5a6,0x6c8,0x7f9,0x020,0x141,0x162,0x283,0x2a4,0x3c5,0x3f6,0x020,0x041,0x061,0x082,0x0a2,0x0c3,0x0f3,0x122,0x344,0x466,0x688,0x8aa,0x9cc,0xbff,0x122,0x244,0x366,0x488,0x5aa,0x6cc,0x7ff,0x022,0x144,0x166,0x288,0x2aa,0x3cc,0x3ff,0x022,0x044,0x066,0x088,0x0aa,0x0cc,0x0ff,0x112,0x334,0x456,0x668,0x88a,0x9ac,0xbcf,0x112,0x224,0x346,0x458,0x56a,0x68c,0x79f,0x002,0x114,0x126,0x238,0x24a,0x35c,0x36f,0x002,0x014,0x016,0x028,0x02a,0x03c,0x03f,0x112,0x334,0x546,0x768,0x98a,0xb9c,0xdbf,0x112,0x324,0x436,0x648,0x85a,0x96c,0xb7f,0x102,0x214,0x416,0x528,0x62a,0x83c,0x93f,0x102,0x204,0x306,0x408,0x50a,0x60c,0x70f,0x212,0x434,0x646,0x868,0xa8a,0xc9c,0xfbe,0x211,0x423,0x635,0x847,0xa59,0xc6b,0xf7d,0x201,0x413,0x615,0x826,0xa28,0xc3a,0xf3c,0x201,0x403,0x604,0x806,0xa08,0xc09,0xf0b

};

uint8_t video_space_read(uint32_t address);

static void video_space_read_range(uint8_t* dest, uint32_t address, uint32_t size);

static void refresh_palette();

void

mousegrab_toggle() {

	mouse_grabbed = !mouse_grabbed;

	SDL_SetWindowGrab(window, mouse_grabbed && !no_keyboard_capture);

	SDL_SetRelativeMouseMode(mouse_grabbed);

	SDL_ShowCursor((mouse_grabbed || kernal_mouse_enabled) ? SDL_DISABLE : SDL_ENABLE);

	sprintf(window_title, WINDOW_TITLE "%s", mouse_grabbed ? MOUSE_GRAB_MSG : "");

	video_update_title(window_title);

}

// Re-derive the layer properties from the raw layer registers and seed both

// generations of the render pipeline from them. Called on reset: the derived

// properties are otherwise refreshed only when the guest writes a layer

// register, so clearing reg_layer alone left the derived state describing the

// pre-reset machine while the registers read zero -- and a debug view

// correlating the two would pair zeroed registers with stale geometry.

static void video_reset_layer_pipeline(void);

void

video_reset()

{

	// Drop the per-scanline debug history: it describes a machine that no

	// longer exists. Both pipeline generations are re-seeded from the cleared

	// registers below, so raw and derived state stay matched rather than one

	// side reading zero while the other still holds pre-reset geometry.

	memset(line_state_valid, 0, sizeof(line_state_valid));

	// init I/O registers

	memset(io_addr, 0, sizeof(io_addr));

	memset(io_inc, 0, sizeof(io_inc));

	io_addrsel = 0;

	io_dcsel = 0;

	io_rddata[0] = 0;

	io_rddata[1] = 0;

	ien = 0;

	isr = 0;

	irq_line = 0;

	// init Layer registers

	memset(reg_layer, 0, sizeof(reg_layer));

	video_reset_layer_pipeline();

	// init composer registers

	memset(reg_composer, 0, sizeof(reg_composer));

	reg_composer[1] = 128; // hscale = 1.0

	reg_composer[2] = 128; // vscale = 1.0

	reg_composer[5] = 640 >> 2;

	reg_composer[7] = 480 >> 1;

	// Initialize FX registers

	fx_addr1_mode = 0;

	fx_x_pixel_position = 0x8000;

	fx_y_pixel_position = 0x8000;

	fx_x_pixel_increment = 0;

	fx_y_pixel_increment = 0;

	fx_cache_write = false;

	fx_cache_fill = false;

	fx_4bit_mode = false;

	fx_16bit_hop = false;

	fx_subtract = false;

	fx_cache_byte_cycling = false;

	fx_trans_writes = false;

	fx_multiplier = false;

	fx_mult_accumulator = 0;

	fx_2bit_poly = false;

	fx_2bit_poking = false;

	fx_cache_nibble_index = 0;

	fx_cache_byte_index = 0;

	fx_cache_increment_mode = 0;

	fx_cache[0] = 0;

	fx_cache[1] = 0;

	fx_cache[2] = 0;

	fx_cache[3] = 0;

	fx_16bit_hop_align = 0;

	fx_nibble_bit[0] = false;

	fx_nibble_bit[1] = false;

	fx_nibble_incr[0] = false;

	fx_nibble_incr[1] = false;

	fx_poly_fill_length = 0;

	fx_affine_tile_base = 0;

	fx_affine_map_base = 0;

	fx_affine_map_size = 2;

	fx_affine_clip = false;

	// init sprite data

	memset(sprite_data, 0, sizeof(sprite_data));

	// copy palette

	memcpy(palette, default_palette, sizeof(palette));

	for (int i = 0; i < 256; i++) {

		palette[i * 2 + 0] = default_palette[i] & 0xff;

		palette[i * 2 + 1] = default_palette[i] >> 8;

	}

	refresh_palette();

	// fill video RAM with random data

	for (int i = 0; i < 128 * 1024; i++) {

		video_ram[i] = rand();

	}

	sprite_line_collisions = 0;

	vga_scan_pos_x = 0;

	vga_scan_pos_y = 0;

	ntsc_half_cnt = 0;

	ntsc_scan_pos_y = 0;

	psg_reset();

	pcm_reset();

}

// Repaint the emulator window straight from the last rendered frame. On

// Windows a window drag/resize spins the OS in a modal message loop that

// blocks our main loop, so no new frames are produced; without this the

// window freezes or tears while being moved. Registered as an SDL event

// watch, this fires synchronously from inside that modal loop and keeps the

// last good frame on screen. (The matching timing re-base in timing.c stops

// the post-drag fast-forward.)

static int SDLCALL

video_move_resize_watch(void *userdata, SDL_Event *event)

{

	(void)userdata;

	static bool in_watch = false; // guard against present -> pump -> watch recursion

	if (in_watch) {

		return 1;

	}

	if (event->type == SDL_WINDOWEVENT && window && renderer && sdlTexture &&

	    event->window.windowID == SDL_GetWindowID(window)) {

		switch (event->window.event) {

			case SDL_WINDOWEVENT_MOVED:

			case SDL_WINDOWEVENT_RESIZED:

			case SDL_WINDOWEVENT_SIZE_CHANGED:

			case SDL_WINDOWEVENT_EXPOSED:

				in_watch = true;

				SDL_RenderClear(renderer);

				SDL_RenderCopy(renderer, sdlTexture, NULL, NULL);

				SDL_RenderPresent(renderer);

				in_watch = false;

				break;

		}

	}

	return 1; // leave the event in the queue for normal handling

}

bool

video_init(int window_scale, float screen_x_scale, char *quality, bool fullscreen, float opacity)

{

	uint32_t window_flags = SDL_WINDOW_ALLOW_HIGHDPI;

#ifdef __EMSCRIPTEN__

	// Setting this flag would render the web canvas outside of its bounds on high dpi screens

	window_flags &= ~SDL_WINDOW_ALLOW_HIGHDPI;

#endif

	video_reset();

	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, quality);

	SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, "1"); // Grabs keyboard shortcuts from the system during window grab

	SDL_CreateWindowAndRenderer(SCREEN_WIDTH * window_scale * screen_x_scale, SCREEN_HEIGHT * window_scale, window_flags, &window, &renderer);

#ifndef __MORPHOS__

	SDL_SetWindowResizable(window, true);

#endif

	SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH * screen_x_scale, SCREEN_HEIGHT);

	sdlTexture = SDL_CreateTexture(renderer,

									SDL_PIXELFORMAT_RGB888,

									SDL_TEXTUREACCESS_STREAMING,

									SCREEN_WIDTH, SCREEN_HEIGHT);

	// Keep the window painted while the OS holds us in a modal move/resize loop.

	SDL_AddEventWatch(video_move_resize_watch, NULL);

	SDL_SetWindowTitle(window, WINDOW_TITLE);

	SDL_SetWindowIcon(window, CommanderX16Icon());

	if (fullscreen) {

		is_fullscreen = true;

		SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);

	} else {

		int winX, winY;

		SDL_GetWindowPosition(window, &winX, &winY);

		if (winX < 0 || winY < APPROX_TITLEBAR_HEIGHT) {

			winX = winX < 0 ? 0 : winX;

			winY = winY < APPROX_TITLEBAR_HEIGHT ? APPROX_TITLEBAR_HEIGHT : winY;

			SDL_SetWindowPosition(window, winX, winY);

		}

	}

	SDL_SetWindowOpacity(window, opacity);

#ifdef _WIN32

	extern void video_win32_set_rounded_corners(SDL_Window *window);

	video_win32_set_rounded_corners(window);

	// Subclass the window proc so emulation keeps running during a drag; see

	// video_win32.c for why the SDL message hook is not enough.

	extern void video_win32_install_move_hook(SDL_Window *window);

	video_win32_install_move_hook(window);

#endif

	if (record_gif != RECORD_GIF_DISABLED) {

		if (!strcmp(gif_path+strlen(gif_path)-5, ",wait")) {

			// wait for POKE

			record_gif = RECORD_GIF_PAUSED;

			// move the string terminator to remove the ",wait"

			gif_path[strlen(gif_path)-5] = 0;

		} else {

			// start now

			record_gif = RECORD_GIF_ACTIVE;

		}

		if (!GifBegin(&gif_writer, gif_path, SCREEN_WIDTH, SCREEN_HEIGHT, 1, 8, false)) {

			record_gif = RECORD_GIF_DISABLED;

		}

	}

	if (debugger_enabled) {

		DEBUGInitUI(renderer);

	}

#ifdef HAS_IMGUI

	// ImGui debugger window -- additive, independent of the -debug SDL debugger.

	if (imgui_debugger_enabled) {

		int mainX, mainY, mainW;

		SDL_GetWindowPosition(window, &mainX, &mainY);

		SDL_GetWindowSize(window, &mainW, NULL);

		imgui_window = SDL_CreateWindow("Commander X16 - ImGui Debugger",

			mainX + mainW + 4, mainY,

			960, 720,

			SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);

		if (imgui_window) {

			// Deliberately NOT SDL_RENDERER_PRESENTVSYNC. This renderer is

			// presented from the emulator thread, so a vsync'd present would

			// block it for up to a refresh interval every frame -- capping the

			// machine at the monitor's rate and defeating warp mode entirely.

			// The main window does not vsync either; timing.c does the

			// throttling. debug_ui_render() is rate-limited instead (see

			// video_render_all_ex).

			imgui_renderer = SDL_CreateRenderer(imgui_window, -1, SDL_RENDERER_ACCELERATED);

		}

		if (imgui_window && imgui_renderer) {

			imgui_window_id = SDL_GetWindowID(imgui_window);

			debug_ui_init(imgui_window, imgui_renderer);

#ifdef _WIN32

			// Keep both windows painted while the OS holds us in a modal

			// move/resize loop dragging the debugger window. Emulation does

			// *not* continue through a drag once a debugger is up --

			// emulator_step_during_move() returns early for exactly that

			// reason, so breakpoints cannot be stepped past behind the UI's

			// back -- but without this the windows would freeze mid-drag.

			video_win32_install_move_hook(imgui_window);

#endif

		} else {

			printf("Warning: Failed to create debugger window: %s\n", SDL_GetError());

			if (imgui_renderer) { SDL_DestroyRenderer(imgui_renderer); imgui_renderer = NULL; }

			if (imgui_window) { SDL_DestroyWindow(imgui_window); imgui_window = NULL; }

			// Stop claiming the UI exists. Left set, -imgui alone would still

			// route the emulator loop through DEBUGGetCurrentStatus() and stop

			// at breakpoints, with no window to resume from and no text

			// debugger either -- the machine would simply hang.

			imgui_debugger_enabled = false;

			printf("The graphical debugger is disabled for this session.\n");

			// Same reasoning as the headless path in main.c: the .dbg policy

			// was noted from a flag that has just been cleared.

			dbg_load_note_debugger(debugger_enabled);

		}

	}

#endif

	if (grab_mouse && !mouse_grabbed)

		mousegrab_toggle();

	return true;

}

struct video_layer_properties

{

	uint8_t color_depth;

	uint32_t map_base;

	uint32_t tile_base;

	bool text_mode;

	bool text_mode_256c;

	bool tile_mode;

	bool bitmap_mode;

	uint16_t hscroll;

	uint16_t vscroll;

	uint8_t  mapw_log2;

	uint8_t  maph_log2;

	uint16_t tilew;

	uint16_t tileh;

	uint8_t  tilew_log2;

	uint8_t  tileh_log2;

	uint16_t mapw_max;

	uint16_t maph_max;

	uint16_t tilew_max;

	uint16_t tileh_max;

	uint16_t layerw_max;

	uint16_t layerh_max;

	uint8_t tile_size_log2;

	int min_eff_x;

	int max_eff_x;

	uint8_t bits_per_pixel;

	uint8_t first_color_pos;

	uint8_t color_mask;

	uint8_t color_fields_max;

};

#define NUM_LAYERS 2

struct video_layer_properties layer_properties[NUM_LAYERS];

struct video_layer_properties prev_layer_properties[2][NUM_LAYERS];

static int

calc_layer_eff_x(const struct video_layer_properties *props, const int x)

{

	return (x + props->hscroll) & (props->layerw_max);

}

static int

calc_layer_eff_y(const struct video_layer_properties *props, const int y)

{

	return (y + props->vscroll) & (props->layerh_max);

}

static uint32_t

calc_layer_map_addr_base2(const struct video_layer_properties *props, const int eff_x, const int eff_y)

{

	// Slightly faster on some platforms because we know that tilew and tileh are powers of 2.

	return props->map_base + ((((eff_y >> props->tileh_log2) << props->mapw_log2) + (eff_x >> props->tilew_log2)) << 1);

}

//TODO: Unused in all current cases. Delete? Or leave commented as a reminder?

//static uint32_t

//calc_layer_map_addr(struct video_layer_properties *props, int eff_x, int eff_y)

//{

//	return props->map_base + ((eff_y / props->tileh) * props->mapw + (eff_x / props->tilew)) * 2;

//}

static void

refresh_layer_properties(const uint8_t layer)

{

	struct video_layer_properties* props = &layer_properties[layer];

	uint16_t prev_layerw_max = props->layerw_max;

	uint16_t prev_hscroll = props->hscroll;

	props->color_depth    = reg_layer[layer][0] & 0x3;

	props->map_base       = reg_layer[layer][1] << 9;

	props->tile_base      = (reg_layer[layer][2] & 0xFC) << 9;

	props->bitmap_mode    = (reg_layer[layer][0] & 0x4) != 0;

	props->text_mode      = (props->color_depth == 0) && !props->bitmap_mode;

	props->text_mode_256c = (reg_layer[layer][0] & 8) != 0;

	props->tile_mode      = !props->bitmap_mode && !props->text_mode;

	if (!props->bitmap_mode) {

		props->hscroll = reg_layer[layer][3] | (reg_layer[layer][4] & 0xf) << 8;

		props->vscroll = reg_layer[layer][5] | (reg_layer[layer][6] & 0xf) << 8;

	} else {

		props->hscroll = 0;

		props->vscroll = 0;

	}

	uint16_t mapw = 0;

	uint16_t maph = 0;

	props->tilew = 0;

	props->tileh = 0;

	if (props->tile_mode || props->text_mode) {

		props->mapw_log2 = 5 + ((reg_layer[layer][0] >> 4) & 3);

		props->maph_log2 = 5 + ((reg_layer[layer][0] >> 6) & 3);

		mapw      = 1 << props->mapw_log2;

		maph      = 1 << props->maph_log2;

		// Scale the tiles or text characters according to TILEW and TILEH.

		props->tilew_log2 = 3 + (reg_layer[layer][2] & 1);