Skip to content

Commit

Permalink
Consistently use RGB32 pixel format
Browse files Browse the repository at this point in the history
  • Loading branch information
@calc84maniac
calc84maniac committed Jul 4, 2024
1 parent c745fda commit 485ba4e
Show file tree
Hide file tree
Showing 8 changed files with 110 additions and 90 deletions.
32 changes: 16 additions & 16 deletions core/lcd.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -42,16 +42,16 @@ static inline uint32_t lcd_bgr888swap(uint32_t bgr888, uint32_t mask) {
return bgr888 ^ diff ^ (diff << 16);
}

static inline uint32_t lcd_abgr8888out(uint32_t abgr8888) {
return abgr8888 | (abgr8888 >> 5 & 0x040004) | (abgr8888 >> 6 & 0x030303);
static inline uint32_t lcd_argb8888out(uint32_t argb8888) {
return argb8888 | (argb8888 >> 5 & 0x040004) | (argb8888 >> 6 & 0x030303);
}

static inline uint32_t lcd_bgr565out(uint32_t bgr565) {
return lcd_abgr8888out(UINT32_C(0xFF000000) | (bgr565 << 8 & 0xF80000) | (bgr565 << 5 & 0xFC00) | (bgr565 << 3 & 0xF8));
static inline uint32_t lcd_rgb565out(uint32_t rgb565) {
return lcd_argb8888out(UINT32_C(0xFF000000) | (rgb565 << 8 & 0xF80000) | (rgb565 << 5 & 0xFC00) | (rgb565 << 3 & 0xF8));
}

static inline uint32_t lcd_bgr888out(uint32_t bgr888) {
return lcd_abgr8888out(UINT32_C(0xFF000000) | (bgr888 & 0xF8FCF8));
static inline uint32_t lcd_rgb888out(uint32_t rgb888) {
return lcd_argb8888out(UINT32_C(0xFF000000) | (rgb888 & 0xF8FCF8));
}

void emu_set_lcd_callback(bool (*callback)(void*), void *data) {
Expand Down Expand Up @@ -86,7 +86,7 @@ void emu_lcd_drawmem(void *output, void *data, void *data_end, uint32_t lcd_cont
uint32_t *dat;
uint32_t *dat_end;

bgr = lcd_control & (1 << 8) ? 0x001F001F : 0;
bgr = lcd_control & (1 << 8) ? 0 : 0x001F001F;
bebo = lcd_control & (1 << 9);
mode = lcd_control >> 1 & 7;
out = output;
Expand All @@ -110,9 +110,9 @@ void emu_lcd_drawmem(void *output, void *data, void *data_end, uint32_t lcd_cont
color = lcd.palette[word >> ((bitpos -= bpp) ^ bi) & mask];
color |= (uint32_t)lcd.palette[word >> ((bitpos -= bpp) ^ bi) & mask] << 16;
color = lcd_bgr565swap(color, bgr);
*out++ = lcd_bgr565out(color);
*out++ = lcd_rgb565out(color);
if (out == out_end) break;
*out++ = lcd_bgr565out(color >> 16);
*out++ = lcd_rgb565out(color >> 16);
} while (bitpos && out != out_end);
} while (dat < dat_end);

Expand All @@ -121,37 +121,37 @@ void emu_lcd_drawmem(void *output, void *data, void *data_end, uint32_t lcd_cont
do {
word = rotr32(lcd_next_word(&dat), bi);
word = lcd_bgr565swap(c1555(word), bgr);
*out++ = lcd_bgr565out(word);
*out++ = lcd_rgb565out(word);
if (out == out_end) break;
*out++ = lcd_bgr565out(word >> 16);
*out++ = lcd_rgb565out(word >> 16);
} while (dat < dat_end);

} else if (mode == 5) {
bgr = bgr ? 0xFF : 0;
do {
word = lcd_next_word(&dat);
word = lcd_bgr888swap(word, bgr);
*out++ = lcd_bgr888out(word);
*out++ = lcd_rgb888out(word);
} while (dat < dat_end);

} else if (mode == 6) {
uint_fast8_t bi = bebo ? 16 : 0;
do {
word = rotr32(lcd_next_word(&dat), bi);
word = lcd_bgr565swap(word, bgr);
*out++ = lcd_bgr565out(word);
*out++ = lcd_rgb565out(word);
if (out == out_end) break;
*out++ = lcd_bgr565out(word >> 16);
*out++ = lcd_rgb565out(word >> 16);
} while (dat < dat_end);

} else { /* mode == 7 */
uint_fast8_t bi = bebo ? 16 : 0;
do {
word = rotr32(lcd_next_word(&dat), bi);
word = lcd_bgr565swap(c444(word), bgr);
*out++ = lcd_bgr565out(word);
*out++ = lcd_rgb565out(word);
if (out == out_end) break;
*out++ = lcd_bgr565out(word >> 16);
*out++ = lcd_rgb565out(word >> 16);
} while (dat < dat_end);
}

Expand Down
4 changes: 2 additions & 2 deletions core/os/os-emscripten.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -86,8 +86,8 @@ void EMSCRIPTEN_KEEPALIVE set_file_to_send(const char* path) {
strcpy(file_buf, path);
}

uint8_t* EMSCRIPTEN_KEEPALIVE lcd_get_frame() {
return &(panel.display[0][0][0]);
uint32_t* EMSCRIPTEN_KEEPALIVE lcd_get_frame() {
return &(panel.display[0][0]);
}

int EMSCRIPTEN_KEEPALIVE emsc_set_main_loop_timing(int mode, int value) {
Expand Down
123 changes: 68 additions & 55 deletions core/panel.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -206,16 +206,20 @@ static inline uint32_t panel_reverse_addr(uint32_t addr, uint32_t upperBound, ui
return (addr ^ dirMask) + (upperBound & dirMask);
}

static inline void panel_buffer_pixel_chunk(uint8_t (* restrict srcPixel)[3], uint8_t (* restrict dstPixel)[3], size_t redIndex) {
size_t blueIndex = PANEL_RED + PANEL_BLUE - redIndex;
(*dstPixel)[redIndex] = panel.gammaLut[PANEL_RED][(*srcPixel)[PANEL_RED]];
(*dstPixel)[PANEL_GREEN] = panel.gammaLut[PANEL_GREEN][(*srcPixel)[PANEL_GREEN]];
(*dstPixel)[blueIndex] = panel.gammaLut[PANEL_BLUE][(*srcPixel)[PANEL_BLUE]];
static inline void panel_buffer_pixel_chunk(uint8_t (* restrict srcPixel)[3], uint32_t * restrict dstPixel, uint8_t redShift) {
uint8_t blueShift = redShift ^ (PANEL_DISP_RED ^ PANEL_DISP_BLUE);
uint32_t pixel = UINT32_C(0xFF000000);
pixel |= panel.gammaLut[PANEL_RAM_RED ][(*srcPixel)[PANEL_RAM_RED ]] << redShift;
pixel |= panel.gammaLut[PANEL_RAM_GREEN][(*srcPixel)[PANEL_RAM_GREEN]] << PANEL_DISP_GREEN;
pixel |= panel.gammaLut[PANEL_RAM_BLUE ][(*srcPixel)[PANEL_RAM_BLUE ]] << blueShift;
*dstPixel = pixel;
dstPixel += PANEL_NUM_COLS / 2;
srcPixel += PANEL_NUM_COLS / 2;
(*dstPixel)[redIndex] = panel.gammaLut[PANEL_RED][(*srcPixel)[PANEL_RED]];
(*dstPixel)[PANEL_GREEN] = panel.gammaLut[PANEL_GREEN][(*srcPixel)[PANEL_GREEN]];
(*dstPixel)[blueIndex] = panel.gammaLut[PANEL_BLUE][(*srcPixel)[PANEL_BLUE]];
pixel = UINT32_C(0xFF000000);
pixel |= panel.gammaLut[PANEL_RAM_RED ][(*srcPixel)[PANEL_RAM_RED ]] << redShift;
pixel |= panel.gammaLut[PANEL_RAM_GREEN][(*srcPixel)[PANEL_RAM_GREEN]] << PANEL_DISP_GREEN;
pixel |= panel.gammaLut[PANEL_RAM_BLUE ][(*srcPixel)[PANEL_RAM_BLUE ]] << blueShift;
*dstPixel = pixel;
}

static void panel_buffer_pixels(void) {
Expand All @@ -228,40 +232,40 @@ static void panel_buffer_pixels(void) {
if (nextRamCol >= ramCol) {
return;
}
size_t redIndex = panel_bgr_enabled() ? PANEL_BLUE : PANEL_RED;
uint8_t redShift = panel_bgr_enabled() ? PANEL_DISP_BLUE : PANEL_DISP_RED;
uint8_t (*srcPixel)[3] = &panel.frame[panel.srcRow][nextRamCol >> 1];
uint8_t (*dstPixel)[3] = &panel.lineBuffers[panel.currLineBuffer][nextRamCol >> 1];
uint32_t *dstPixel = &panel.lineBuffers[panel.currLineBuffer][nextRamCol >> 1];
if (panel.srcRow < 300) {
/* If the next read column is odd, read offsets 1, 3, 5 in the group of 6 */
if (nextRamCol & 2) {
panel_buffer_pixel_chunk(srcPixel, dstPixel, redIndex);
panel_buffer_pixel_chunk(srcPixel + 2, dstPixel + 2, redIndex);
panel_buffer_pixel_chunk(srcPixel + 4, dstPixel + 4, redIndex);
panel_buffer_pixel_chunk(srcPixel, dstPixel, redShift);
panel_buffer_pixel_chunk(srcPixel + 2, dstPixel + 2, redShift);
panel_buffer_pixel_chunk(srcPixel + 4, dstPixel + 4, redShift);
srcPixel += 5;
dstPixel += 5;
nextRamCol += 10;
}
/* Read as many full groups of 6 as possible */
while (nextRamCol + 2 < ramCol) {
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redIndex);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redIndex);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redIndex);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redIndex);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redIndex);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redIndex);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redShift);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redShift);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redShift);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redShift);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redShift);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redShift);
nextRamCol += 12;
}
/* The next read column is even, if we reached it then read offsets 0, 2, 4 */
if (nextRamCol < ramCol) {
panel_buffer_pixel_chunk(srcPixel, dstPixel, redIndex);
panel_buffer_pixel_chunk(srcPixel + 2, dstPixel + 2, redIndex);
panel_buffer_pixel_chunk(srcPixel + 4, dstPixel + 4, redIndex);
panel_buffer_pixel_chunk(srcPixel, dstPixel, redShift);
panel_buffer_pixel_chunk(srcPixel + 2, dstPixel + 2, redShift);
panel_buffer_pixel_chunk(srcPixel + 4, dstPixel + 4, redShift);
nextRamCol += 2;
}
} else {
/* Read every other clock */
do {
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redIndex);
panel_buffer_pixel_chunk(srcPixel++, dstPixel++, redShift);
nextRamCol += 2;
} while (nextRamCol < ramCol);
}
Expand All @@ -278,12 +282,12 @@ static bool panel_start_line(uint16_t row) {
panel.currLineBuffer = !panel.currLineBuffer;
}
uint32_t scanReverse = panel_source_scan_reverse_mask();
uint8_t (*dstPixel)[4] = &panel.display[scanReverse & PANEL_LAST_COL][panel.dstRow];
uint8_t (*srcPixel)[3] = &panel.lineBuffers[!panel.currLineBuffer][0];
uint32_t *dstPixel = &panel.display[scanReverse & PANEL_LAST_COL][panel.dstRow];
uint32_t *srcPixel = &panel.lineBuffers[!panel.currLineBuffer][0];
int32_t dstDelta = (scanReverse * 2 + 1) * PANEL_NUM_ROWS;
uint8_t count = PANEL_NUM_COLS;
do {
memcpy(dstPixel, srcPixel++, 3);
*dstPixel = *srcPixel++;
dstPixel += dstDelta;
} while (--count);
}
Expand Down Expand Up @@ -341,18 +345,24 @@ static bool panel_start_line(uint16_t row) {
if (unlikely(panel.clock_pixel == panel_clock_pixel_ram_bypass)) {
panel.nextRamCol = PANEL_NUM_COLS;
} else if (unlikely(panel.mode & (PANEL_MODE_SLEEP | PANEL_MODE_OFF | PANEL_MODE_BLANK))) {
memset(&panel.lineBuffers[panel.currLineBuffer], panel.blankLevel, sizeof(panel.lineBuffers[0]));
uint32_t *dstPixel = &panel.lineBuffers[panel.currLineBuffer][0];
uint32_t blankPixel = panel.blankPixel;
uint8_t count = PANEL_NUM_COLS;
do {
*dstPixel++ = blankPixel;
} while (--count);
panel.nextRamCol = PANEL_NUM_COLS;
} else if (unlikely(panel.srcRow > PANEL_LAST_ROW)) {
uint8_t (*dstPixel)[3] = &panel.lineBuffers[panel.currLineBuffer][0];
size_t redIndex = panel_bgr_enabled() ? PANEL_BLUE : PANEL_RED;
size_t blueIndex = PANEL_RED + PANEL_BLUE - redIndex;
uint32_t *dstPixel = &panel.lineBuffers[panel.currLineBuffer][0];
uint8_t redShift = panel_bgr_enabled() ? PANEL_DISP_BLUE : PANEL_DISP_RED;
uint8_t blueShift = redShift ^ (PANEL_DISP_RED ^ PANEL_DISP_BLUE);
uint8_t count = PANEL_NUM_COLS;
do {
(*dstPixel)[redIndex] = panel.gammaLut[PANEL_RED][bus_rand() % 64];
(*dstPixel)[PANEL_GREEN] = panel.gammaLut[PANEL_GREEN][bus_rand() % 64];
(*dstPixel)[blueIndex] = panel.gammaLut[PANEL_BLUE][bus_rand() % 64];
dstPixel++;
uint32_t pixel = UINT32_C(0xFF000000);
pixel |= panel.gammaLut[PANEL_RAM_RED ][bus_rand() % 64] << redShift;
pixel |= panel.gammaLut[PANEL_RAM_GREEN][bus_rand() % 64] << PANEL_DISP_GREEN;
pixel |= panel.gammaLut[PANEL_RAM_BLUE ][bus_rand() % 64] << blueShift;
*dstPixel++ = pixel;
} while (--count);
panel.nextRamCol = PANEL_NUM_COLS;
} else {
Expand All @@ -365,7 +375,7 @@ static bool panel_start_line(uint16_t row) {
static void panel_invert_luts(void) {
for (uint8_t c = 0; c < 32; c++) {
uint8_t rc = 63 - c;
for (uint8_t i = PANEL_RED; i <= PANEL_BLUE; i++) {
for (uint8_t i = PANEL_RAM_RED; i <= PANEL_RAM_BLUE; i++) {
uint8_t temp = panel.gammaLut[i][c];
panel.gammaLut[i][c] = panel.gammaLut[i][rc];
panel.gammaLut[i][rc] = temp;
Expand Down Expand Up @@ -491,29 +501,29 @@ static void panel_generate_luts(void) {
float diff = gamma - piece->gamma;
float grayscale = ((piece->a * diff + piece->b) * diff + piece->c) * diff + piece->d;
assert(grayscale >= 0.0f && grayscale < 256.0f / 255.0f);
panel.gammaLut[PANEL_GREEN][c] = (uint8_t)(grayscale * backlightFactor);
panel.gammaLut[PANEL_RAM_GREEN][c] = (uint8_t)(grayscale * backlightFactor);
}
} else {
backlightFactor *= 4.0625f;
for (uint8_t c = 0; c < 64; c++) {
panel.gammaLut[PANEL_GREEN][c] = (uint8_t)(c * backlightFactor);
panel.gammaLut[PANEL_RAM_GREEN][c] = (uint8_t)(c * backlightFactor);
}
}

if (unlikely(panel.mode & PANEL_MODE_IDLE)) {
memset(&panel.gammaLut[PANEL_GREEN][1], panel.gammaLut[PANEL_GREEN][0], 31);
memset(&panel.gammaLut[PANEL_GREEN][32], panel.gammaLut[PANEL_GREEN][63], 31);
memset(&panel.gammaLut[PANEL_RAM_GREEN][1], panel.gammaLut[PANEL_RAM_GREEN][0], 31);
memset(&panel.gammaLut[PANEL_RAM_GREEN][32], panel.gammaLut[PANEL_RAM_GREEN][63], 31);
}

if (unlikely(panel.params.DGMEN.DGMEN) && !(panel.mode & PANEL_MODE_IDLE)) {
for (uint8_t c = 0; c < 64; c += 2) {
/* Yes, the opposite DGMLUTs are used on purpose, the datasheet seemingly reversed them because of default BGR */
panel.gammaLut[PANEL_RED][c] = panel.gammaLut[PANEL_RED][c + 1] = panel.gammaLut[PANEL_GREEN][panel.params.DGMLUTB[c] >> 2];
panel.gammaLut[PANEL_BLUE][c] = panel.gammaLut[PANEL_BLUE][c + 1] = panel.gammaLut[PANEL_GREEN][panel.params.DGMLUTR[c] >> 2];
panel.gammaLut[PANEL_RAM_RED][c] = panel.gammaLut[PANEL_RAM_RED][c + 1] = panel.gammaLut[PANEL_RAM_GREEN][panel.params.DGMLUTB[c] >> 2];
panel.gammaLut[PANEL_RAM_BLUE][c] = panel.gammaLut[PANEL_RAM_BLUE][c + 1] = panel.gammaLut[PANEL_RAM_GREEN][panel.params.DGMLUTR[c] >> 2];
}
} else {
memcpy(panel.gammaLut[PANEL_RED], panel.gammaLut[PANEL_GREEN], 64);
memcpy(panel.gammaLut[PANEL_BLUE], panel.gammaLut[PANEL_GREEN], 64);
memcpy(panel.gammaLut[PANEL_RAM_RED], panel.gammaLut[PANEL_RAM_GREEN], 64);
memcpy(panel.gammaLut[PANEL_RAM_BLUE], panel.gammaLut[PANEL_RAM_GREEN], 64);
}

if (unlikely(panel_inv_enabled())) {
Expand All @@ -522,7 +532,7 @@ static void panel_generate_luts(void) {
}

bool blankLevel = panel_inv_enabled() ^ (!(panel.mode & (PANEL_MODE_SLEEP | PANEL_MODE_OFF)) && panel.params.PARCTRL.NDL);
panel.blankLevel = panel.gammaLut[PANEL_GREEN][blankLevel ? 0 : 63];
panel.blankPixel = UINT32_C(0xFF000000) | (panel.gammaLut[PANEL_RAM_GREEN][blankLevel ? 0 : 63] * 0x010101);
}

static uint32_t panel_start_frame() {
Expand Down Expand Up @@ -675,9 +685,9 @@ static void panel_buffer_catchup(uint8_t col) {

static inline void panel_write_pixel(uint8_t (*pixel)[3], uint32_t bgr666) {
assert(bgr666 <= 0x3FFFF);
(*pixel)[PANEL_RED] = bgr666 & 0x3F;
(*pixel)[PANEL_GREEN] = bgr666 >> 6 & 0x3F;
(*pixel)[PANEL_BLUE] = bgr666 >> 12;
(*pixel)[PANEL_RAM_RED] = bgr666 & 0x3F;
(*pixel)[PANEL_RAM_GREEN] = bgr666 >> 6 & 0x3F;
(*pixel)[PANEL_RAM_BLUE] = bgr666 >> 12;
}

static void panel_write_pixel_row_oob(panel_mem_ptr_t* memPtr, uint32_t bgr666);
Expand Down Expand Up @@ -841,21 +851,23 @@ static void panel_clock_pixel_ram_bypass(uint16_t bgr565) {
panel.col += (panel.displayMode == PANEL_DM_RGB);
if (likely(col < PANEL_NUM_COLS)) {
col = panel_reverse_addr(col, PANEL_NUM_COLS, panel_col_scan_reverse_mask());
uint8_t (*dstPixel)[3] = &panel.lineBuffers[panel.currLineBuffer][col];
uint32_t *dstPixel = &panel.lineBuffers[panel.currLineBuffer][col];
if (unlikely(panel.mode & PANEL_MODE_BLANK)) {
if (panel.row != 0) {
memset(dstPixel, panel.blankLevel, sizeof(*dstPixel));
*dstPixel = panel.blankPixel;
return;
}
} else {
panel.ifPixel = panel_bgr565_epf_funcs[panel_rgb_epf()](bgr565);
}
size_t redIndex = panel_bgr_enabled() ? PANEL_BLUE : PANEL_RED;
size_t blueIndex = PANEL_RED + PANEL_BLUE - redIndex;
uint8_t redShift = panel_bgr_enabled() ? PANEL_DISP_BLUE : PANEL_DISP_RED;
uint8_t blueShift = redShift ^ (PANEL_DISP_RED ^ PANEL_DISP_BLUE);
assert(panel.ifPixel <= 0x3FFFF);
(*dstPixel)[redIndex] = panel.gammaLut[PANEL_RED][panel.ifPixel & 0x3F];
(*dstPixel)[PANEL_GREEN] = panel.gammaLut[PANEL_GREEN][panel.ifPixel >> 6 & 0x3F];
(*dstPixel)[blueIndex] = panel.gammaLut[PANEL_BLUE][panel.ifPixel >> 12];
uint32_t pixel = UINT32_C(0xFF000000);
pixel |= panel.gammaLut[PANEL_RAM_RED ][panel.ifPixel & 0x3F] << redShift;
pixel |= panel.gammaLut[PANEL_RAM_GREEN][panel.ifPixel >> 6 & 0x3F] << PANEL_DISP_GREEN;
pixel |= panel.gammaLut[PANEL_RAM_BLUE ][panel.ifPixel >> 12 ] << blueShift;
*dstPixel = pixel;
}
}

Expand Down Expand Up @@ -1325,7 +1337,8 @@ void init_panel(void) {
}

void panel_reset(void) {
memset(&panel, 0, offsetof(panel_state_t, display));
memset(&panel, 0, offsetof(panel_state_t, lineBuffers));
memset(&panel.lineBuffers, 0xFF, sizeof(panel.lineBuffers));
memset(&panel.display, 0xFF, sizeof(panel.display));

sched_init_event(SCHED_PANEL, CLOCK_PANEL, panel_event);
Expand Down
16 changes: 9 additions & 7 deletions core/panel.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,10 +11,12 @@ extern "C" {
#include <stdbool.h>
#include <stdio.h>

#define PANEL_RED 0
#define PANEL_GREEN 1
#define PANEL_BLUE 2
#define PANEL_ALPHA 3
#define PANEL_RAM_RED 0
#define PANEL_RAM_GREEN 1
#define PANEL_RAM_BLUE 2
#define PANEL_DISP_RED 16
#define PANEL_DISP_GREEN 8
#define PANEL_DISP_BLUE 0
#define PANEL_NUM_ROWS 320
#define PANEL_LAST_ROW 319
#define PANEL_NUM_COLS 240
Expand Down Expand Up @@ -576,8 +578,8 @@ typedef struct panel_state {
uint32_t ifPixel;

panel_params_t params;
uint8_t lineBuffers[2][240][3];
uint8_t frame[320][240][3], display[240][320][4];
uint8_t frame[PANEL_NUM_ROWS][PANEL_NUM_COLS][3];
uint32_t lineBuffers[2][PANEL_NUM_COLS], display[PANEL_NUM_COLS][PANEL_NUM_ROWS];

/* Below state is not affected by reset */
uint32_t clockRate;
Expand All @@ -588,8 +590,8 @@ typedef struct panel_state {
void (*write_pixel)(panel_mem_ptr_t *memPtr, uint32_t bgr666);
panel_mem_ptr_t windowStart, windowEnd;
uint8_t (*windowBasePtr)[3];
uint32_t blankPixel;
int8_t xDir, yDir;
uint8_t blankLevel;
bool accurateGamma;
bool gammaDirty;
bool skipFrame;
Expand Down
Loading

0 comments on commit 485ba4e

Please sign in to comment.