// Commander X16 Emulator

// Copyright (c) 2019 Michael Steil

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

#ifndef _VIDEO_H_

#define _VIDEO_H_

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <SDL.h>

#include "glue.h"

#ifdef __cplusplus

extern "C" {

#endif

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

void video_reset(void);

bool video_step(float mhz, float steps, bool midline);

bool video_update(void);

void video_present_no_input(void);

void video_repaint_only(void);

// The ImGui debugger window, in builds configured with -DENABLE_IMGUI.

// Both are always defined: without the UI, available() is false and the pump

// reports "stay paused", so call sites need no #ifdef.

bool video_debug_ui_available(void);

int  video_debug_ui_pump_paused(void);

bool video_is_debug_ui_window(Uint32 window_id);

bool video_event_targets_debug_ui(const SDL_Event *ev);

void video_debug_ui_shortcut_key(const SDL_Event *ev);

void video_debug_ui_feed_event(const SDL_Event *ev);

// ─── Debug view accessors ──────────────────────────────────────────────────

// Per-scanline history of the layer registers each display line was actually

// rendered with. Programs rewrite MAPBASE/TILEBASE/scroll part-way down a frame

// from a line IRQ ("raster split"), so one register snapshot describes only one

// band of the screen.

//

// out_regs receives the 7 layer registers L?_CONFIG..L?_VSCROLL_H; out_eff_y is

// the composer's effective layer Y for that line, before the layer's own

// VSCROLL; out_layer_row is the row of the layer image the line displayed,

// recorded rather than derivable because the renderer mixes two register

// generations; out_enabled is false for a line the layer did not reach the

// screen on, including border lines outside the active display window. Returns

// false if the line is out of range or has not been rendered yet. Every

// out-parameter is optional.

//

// Accurate for the common shape of a raster split -- a program rewriting

// MAPBASE/TILEBASE/scroll from a line IRQ so that horizontal bands differ --

// and approximate in narrower ones. Known limits: out_regs is the layout

// generation, one behind the generation the row was computed from, so a scroll

// change at the split misleads anything derived from out_regs alone; bitmap

// mode takes its palette offset from the live registers, so a palette change at

// a split reports up to two lines late; there is one snapshot per scanline and

// the last render_line() call wins, so a mid-line change is not represented;

// settlement is tracked per line rather than per layer; and a split that

// changes tile geometry falls back to the live registers for those rows.

// Getting these exact means having each render_layer_line_* publish the state

// it actually used, rather than reconstructing it from outside as this does.

bool video_get_layer_line_state(uint8_t layer, uint16_t line, uint8_t out_regs[7],

                                uint16_t *out_eff_y, bool *out_enabled,

                                uint16_t *out_layer_row);

uint16_t video_get_scanline_count(void);

// The frame period video_step() actually raises a new frame on, expressed in

// VERA's 25 MHz dot clock and in scanlines. Together with the CPU clock these

// give the cycles a program has between vsyncs, which is what a performance

// budget is measured against.

//

// NTSC reports a FIELD, not a full interlaced frame, because a field is what

// video_step() signals a new frame at -- and it is also what a program syncing

// to VSYNC actually gets.

uint32_t video_frame_dot_clocks(void);

uint16_t video_frame_scanlines(void);

// Size in layer pixels of the image the composer is actually displaying: the

// active window (DC_HSTART/HSTOP, DC_VSTART/VSTOP) scaled by DC_HSCALE/VSCALE.

// Viewers use this to size themselves to the current video mode.

void video_get_active_layer_size(int *out_w, int *out_h);

// Cycles until the next enabled VERA interrupt and the ISR bit that will cause

// it (1 = VSYNC, 2 = LINE); false when neither is enabled.

bool video_next_irq(float mhz, uint32_t *out_cycles, uint8_t *out_source);

void video_get_irq_state(uint8_t *out_ien, uint8_t *out_isr, uint16_t *out_irq_line);

void video_end(void);

bool video_get_irq_out(void);

// For the control port (control_backend.c): the last whole frame, BGRA8888,

// and the count of frames completed.

const uint8_t *video_get_framebuffer(int *width, int *height);

uint32_t video_get_frame_count(void);

void video_save(SDL_RWops *f);

uint8_t video_read(uint8_t reg, bool debugOn);

void video_write(uint8_t reg, uint8_t value);

// Announce that the next video_write() is the DEBUGGER's, not the guest's, so

// its data-port traffic is not charged to VERA's bandwidth accounting.

// video_read() is told the same thing directly, as its debugOn argument.

void video_set_debug_write(bool on);

void video_update_title(const char* window_title);

uint8_t via1_read(uint8_t reg, bool debug);

void via1_write(uint8_t reg, uint8_t value);

// For debugging purposes only:

uint8_t video_space_read(uint32_t address);

void video_space_write(uint32_t address, uint8_t value);

bool video_is_tilemap_address(int addr);

bool video_is_tiledata_address(int addr);

bool video_is_special_address(int addr);

uint32_t video_get_address(uint8_t sel);

uint32_t video_get_fx_accum(void);

uint8_t video_get_dc_value(uint8_t reg);

#ifdef __cplusplus

}

#endif

#endif