source: buchla-emu/emu/vid.c@ ac4e192

/*
 *  Copyright (C) 2017 The Contributors
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 *  General Public License for more details.
 *
 *  A copy of the GNU General Public License can be found in the file
 *  "gpl.txt" in the top directory of this repository.
 */

#include <all.h>

#define ver(...) _ver(vid_verbose, 0, __VA_ARGS__)
#define ver2(...) _ver(vid_verbose, 1, __VA_ARGS__)
#define ver3(...) _ver(vid_verbose, 2, __VA_ARGS__)

int32_t vid_verbose = 0;

#define SCR_W 512
#define SCR_H 350
#define VBL_H 50

#define REG_VCR0 0
#define REG_VCR1 1
#define REG_RWBA 2
#define REG_DSBA 5
#define REG_ODTBA 7
#define REG_ATBA 8
#define REG_ATBAC 11

#define VCR0_UCF 0x0001
#define VCR0_DEN 0x0008

#define DSBA_BS1 0x0080
#define DSBA_BS0 0x0100

#define REG_OFF 0x200
#define PAL_OFF 0x40000

#define OD0_BLA 0x0010

#define WIN_SZ_W 0x10000
#define MEM_SZ_W 0x20000

#define N_BANKS 2

static int32_t reg_off = REG_OFF;

static uint16_t mem[MEM_SZ_W];
static int32_t bank = 0;

static int32_t pal[16];
static int32_t i_pal = 0;

void vid_init(void)
{
        ver("vid init");
}

void vid_quit(void)
{
        ver("vid quit");
}

bool vid_exec(void)
{
        ver3("vid exec");

        static int32_t skip = 99999;
        static int32_t line = 99999;

        if (++skip < 10) {
                ver3("vid skip %d", skip);
                return false;
        }

        skip = 0;
        int32_t vcr0 = mem[REG_VCR0];

        if ((vcr0 & VCR0_DEN) == 0) {
                ver3("vid dis");
                return false;
        }

        if (++line < SCR_H + VBL_H) {
                ver3("vid line %d", line);

                if (line < SCR_H) {
                        ++mem[REG_ATBAC];
                }

                return line == SCR_H;
        }

        // We get here every 4,000 invocations -> 25 fps.

        ver2("vid frame");
        line = 0;

        int32_t dsba = mem[REG_DSBA];
        bank = ((dsba & DSBA_BS0) != 0 ? 1 : 0) + ((dsba & DSBA_BS1) != 0 ? 2 : 0);

        int32_t rwba = mem[REG_RWBA];
        reg_off = (rwba & 0xfff0) << 1;

        int32_t atba = mem[REG_ATBA];
        mem[REG_ATBAC] = (uint16_t)atba;

        int32_t odtba = mem[REG_ODTBA] & 0xffc0;
        int32_t y_beg[16], y_end[16];

        for (int32_t i = 0; i < 16; ++i) {
                y_beg[i] = -1;
                y_end[i] = -1;

                uint16_t *od = mem + odtba + 4 * i;

                if ((od[0] & OD0_BLA) != 0) {
                        ver3("obj %d blanked", i);
                        continue;
                }

                int32_t w = (od[1] & 0xfc00) >> 6;

                if (w == 0) {
                        ver3("obj %d empty", i);
                        continue;
                }

                int32_t mask = 1 << i;

                for (int32_t k = 0; k < SCR_H; ++k) {
                        if ((mem[atba + k] & mask) == 0) {
                                if (y_beg[i] < 0) {
                                        y_beg[i] = k;
                                }
                                else if (y_end[i] < 0) {
                                        y_end[i] = k;
                                }
                        }
                }

                if (y_beg[i] < 0) {
                        ver3("obj %d unused", i);
                        continue;
                }

                int32_t x = od[1] & 0x03ff;
                ver2("obj %d %d:%d %d+%d", i, y_beg[i], y_end[i], x, w);
        }

        int32_t vcr1 = mem[REG_VCR1];
        int32_t fon_h = (vcr1 & 0xf000) >> 12;

        return false;
}

uint32_t vid_read(uint32_t off, int32_t sz)
{
        ver2("vid rd %d 0x%05x:%d", bank, off, sz * 8);

        int32_t off16 = (int32_t)(off / 2);

        if (sz != 2 || bank >= N_BANKS || off % 2 != 0 || off16 >= WIN_SZ_W) {
                fail("invalid vid rd %d %u:%d", bank, off, sz * 8);
        }

        if (off16 >= reg_off && off16 < reg_off + 16) {
                return mem[off16 - reg_off];
        }

        return mem[bank * WIN_SZ_W + off16];
}

void vid_write(uint32_t off, int32_t sz, uint32_t val)
{
        ver2("vid wr %d 0x%05x:%d 0x%0*x", bank, off, sz * 8, sz * 2, val);

        int32_t off16 = (int32_t)(off / 2);

        if (sz != 2 || bank >= N_BANKS || off % 2 != 0 || (off16 >= WIN_SZ_W && off16 != PAL_OFF)) {
                fail("invalid vid wr %d %u:%d", bank, off, sz * 8);
        }

        if (off16 == PAL_OFF) {
                pal[i_pal] = (int32_t)val;
                i_pal = (i_pal + 1) % 16;
                return;
        }

        if (off16 >= reg_off && off16 < reg_off + 16) {
                mem[off16 - reg_off] = (uint16_t)val;
                return;
        }

        mem[bank * WIN_SZ_W + off16] = (uint16_t)val;
}