/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * * Copyright (C) 2014 Franklin Wei, Benjamin Brown * Copyright (C) 2004 Gregory Montoir * * 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 2 * of the License, or (at your option) any later version. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ***************************************************************************/ #include "video.h" #include "video_data.h" #include "resource.h" #include "serializer.h" #include "sys.h" #include "file.h" void polygon_readVertices(struct Polygon* g, const uint8_t *p, uint16_t zoom) { g->bbw = (*p++) * zoom / 64; g->bbh = (*p++) * zoom / 64; g->numPoints = *p++; assert((g->numPoints & 1) == 0 && g->numPoints < MAX_POINTS); //Read all points, directly from bytecode segment for (int i = 0; i < g->numPoints; ++i) { struct Point *pt = &g->points[i]; pt->x = (*p++) * zoom / 64; pt->y = (*p++) * zoom / 64; } } void video_create(struct Video* v, struct Resource* res, struct System* sys) { v->res = res; v->sys = sys; } void video_init(struct Video* v) { v->paletteIdRequested = NO_PALETTE_CHANGE_REQUESTED; v->page_data = v->res->_memPtrStart + MEM_BLOCK_SIZE; rb->memset(v->page_data, 0, 4 * VID_PAGE_SIZE); for (int i = 0; i < 4; ++i) { v->_pagePtrs[i] = v->page_data + i * VID_PAGE_SIZE; } v->_curPagePtr3 = video_getPagePtr(v, 1); v->_curPagePtr2 = video_getPagePtr(v, 2); video_changePagePtr1(v, 0xFE); v->_interpTable[0] = 0x4000; for (int i = 1; i < 0x400; ++i) { v->_interpTable[i] = 0x4000 / i; } } void video_setDataBuffer(struct Video* v, uint8_t *dataBuf, uint16_t offset) { v->_dataBuf = dataBuf; v->_pData.pc = dataBuf + offset; } /* A shape can be given in two different ways: - A list of screenspace vertices. - A list of objectspace vertices, based on a delta from the first vertex. This is a recursive function. */ void video_readAndDrawPolygon(struct Video* v, uint8_t color, uint16_t zoom, const struct Point *pt) { uint8_t i = scriptPtr_fetchByte(&v->_pData); //This is if (i >= 0xC0) { // 0xc0 = 192 // WTF ? if (color & 0x80) { //0x80 = 128 (1000 0000) color = i & 0x3F; //0x3F = 63 (0011 1111) } // pc is misleading here since we are not reading bytecode but only // vertices informations. polygon_readVertices(&v->polygon, v->_pData.pc, zoom); video_fillPolygon(v, color, zoom, pt); } else { i &= 0x3F; //0x3F = 63 if (i == 1) { warning("video_readAndDrawPolygon() ec=0x%X (i != 2)", 0xF80); } else if (i == 2) { video_readAndDrawPolygonHierarchy(v, zoom, pt); } else { warning("video_readAndDrawPolygon() ec=0x%X (i != 2)", 0xFBB); } } } void video_fillPolygon(struct Video* v, uint16_t color, uint16_t zoom, const struct Point *pt) { (void) zoom; if (v->polygon.bbw == 0 && v->polygon.bbh == 1 && v->polygon.numPoints == 4) { video_drawPoint(v, color, pt->x, pt->y); return; } int16_t x1 = pt->x - v->polygon.bbw / 2; int16_t x2 = pt->x + v->polygon.bbw / 2; int16_t y1 = pt->y - v->polygon.bbh / 2; int16_t y2 = pt->y + v->polygon.bbh / 2; if (x1 > 319 || x2 < 0 || y1 > 199 || y2 < 0) return; v->_hliney = y1; uint16_t i, j; i = 0; j = v->polygon.numPoints - 1; x2 = v->polygon.points[i].x + x1; x1 = v->polygon.points[j].x + x1; ++i; --j; drawLine drawFct; if (color < 0x10) { drawFct = &video_drawLineN; } else if (color > 0x10) { drawFct = &video_drawLineP; } else { drawFct = &video_drawLineBlend; } uint32_t cpt1 = x1 << 16; uint32_t cpt2 = x2 << 16; while (1) { v->polygon.numPoints -= 2; if (v->polygon.numPoints == 0) { #if TRACE_FRAMEBUFFER video_dumpFrameBuffers(v, "fillPolygonEnd"); #endif #if TRACE_BG_BUFFER video_dumpBackGroundBuffer(v); #endif break; } uint16_t h; int32_t step1 = video_calcStep(v, &v->polygon.points[j + 1], &v->polygon.points[j], &h); int32_t step2 = video_calcStep(v, &v->polygon.points[i - 1], &v->polygon.points[i], &h); ++i; --j; cpt1 = (cpt1 & 0xFFFF0000) | 0x7FFF; cpt2 = (cpt2 & 0xFFFF0000) | 0x8000; if (h == 0) { cpt1 += step1; cpt2 += step2; } else { for (; h != 0; --h) { if (v->_hliney >= 0) { x1 = cpt1 >> 16; x2 = cpt2 >> 16; if (x1 <= 319 && x2 >= 0) { if (x1 < 0) x1 = 0; if (x2 > 319) x2 = 319; (*drawFct)(v, x1, x2, color); } } cpt1 += step1; cpt2 += step2; ++v->_hliney; if (v->_hliney > 199) return; } } #if TRACE_FRAMEBUFFER video_dumpFrameBuffers(v, "fillPolygonChild"); #endif #if TRACE_BG_BUFFER video_dumpBackGroundBuffer(v); #endif } } /* What is read from the bytecode is not a pure screnspace polygon but a polygonspace polygon. */ void video_readAndDrawPolygonHierarchy(struct Video* v, uint16_t zoom, const struct Point *pgc) { struct Point pt = *pgc; pt.x -= scriptPtr_fetchByte(&v->_pData) * zoom / 64; pt.y -= scriptPtr_fetchByte(&v->_pData) * zoom / 64; int16_t childs = scriptPtr_fetchByte(&v->_pData); debug(DBG_VIDEO, "video_readAndDrawPolygonHierarchy childs=%d", childs); for ( ; childs >= 0; --childs) { uint16_t off = scriptPtr_fetchWord(&v->_pData); struct Point po; po = pt; po.x += scriptPtr_fetchByte(&v->_pData) * zoom / 64; po.y += scriptPtr_fetchByte(&v->_pData) * zoom / 64; uint16_t color = 0xFF; uint16_t _bp = off; off &= 0x7FFF; if (_bp & 0x8000) { color = *v->_pData.pc & 0x7F; v->_pData.pc += 2; } uint8_t *bak = v->_pData.pc; v->_pData.pc = v->_dataBuf + off * 2; video_readAndDrawPolygon(v, color, zoom, &po); v->_pData.pc = bak; } } int32_t video_calcStep(struct Video* v, const struct Point *p1, const struct Point *p2, uint16_t *dy) { (void) v; *dy = p2->y - p1->y; return (p2->x - p1->x) * v->_interpTable[*dy] * 4; } void video_drawString(struct Video* v, uint8_t color, uint16_t x, uint16_t y, uint16_t stringId) { const struct StrEntry *se = video_stringsTableEng; //Search for the location where the string is located. while (se->id != END_OF_STRING_DICTIONARY && se->id != stringId) ++se; debug(DBG_VIDEO, "video_drawString(%d, %d, %d, '%s')", color, x, y, se->str); //Not found if (se->id == END_OF_STRING_DICTIONARY) return; //Used if the string contains a return carriage. uint16_t xOrigin = x; int len = rb->strlen(se->str); for (int i = 0; i < len; ++i) { if (se->str[i] == '\n') { y += 8; x = xOrigin; continue; } video_drawChar(v, se->str[i], x, y, color, v->_curPagePtr1); x++; } } void video_drawChar(struct Video* v, uint8_t character, uint16_t x, uint16_t y, uint8_t color, uint8_t *buf) { (void) v; if (x <= 39 && y <= 192) { /* each character is 8x8 */ const uint8_t *ft = video_font + (character - ' ') * 8; /* x is multiplied by 4 and not 8 because there are two pixels per byte */ uint8_t *p = buf + x * 4 + y * 160; for (int j = 0; j < 8; ++j) { uint8_t ch = *(ft + j); for (int i = 0; i < 4; ++i) { uint8_t b = *(p + i); uint8_t cmask = 0xFF; uint8_t colb = 0; if (ch & 0x80) { colb |= color << 4; cmask &= 0x0F; } ch <<= 1; if (ch & 0x80) { colb |= color; cmask &= 0xF0; } ch <<= 1; *(p + i) = (b & cmask) | colb; } /* skip to the next line (320 pixels = 160 bytes) */ p += 160; } } } void video_drawPoint(struct Video* v, uint8_t color, int16_t x, int16_t y) { debug(DBG_VIDEO, "drawPoint(%d, %d, %d)", color, x, y); if (x >= 0 && x <= 319 && y >= 0 && y <= 199) { uint16_t off = y * 160 + x / 2; uint8_t cmasko, cmaskn; if (x & 1) { cmaskn = 0x0F; cmasko = 0xF0; } else { cmaskn = 0xF0; cmasko = 0x0F; } uint8_t colb = (color << 4) | color; if (color == 0x10) { cmaskn &= 0x88; cmasko = ~cmaskn; colb = 0x88; } else if (color == 0x11) { colb = *(v->_pagePtrs[0] + off); } uint8_t b = *(v->_curPagePtr1 + off); *(v->_curPagePtr1 + off) = (b & cmasko) | (colb & cmaskn); } } /* Blend a line in the current framebuffer (v->_curPagePtr1) */ void video_drawLineBlend(struct Video* v, int16_t x1, int16_t x2, uint8_t color) { /* silence warnings without XWORLD_DEBUG */ (void) color; debug(DBG_VIDEO, "drawLineBlend(%d, %d, %d)", x1, x2, color); int16_t xmax = MAX(x1, x2); int16_t xmin = MIN(x1, x2); uint8_t *p = v->_curPagePtr1 + v->_hliney * 160 + xmin / 2; uint16_t w = xmax / 2 - xmin / 2 + 1; uint8_t cmaske = 0; uint8_t cmasks = 0; if (xmin & 1) { --w; cmasks = 0xF7; } if (!(xmax & 1)) { --w; cmaske = 0x7F; } if (cmasks != 0) { *p = (*p & cmasks) | 0x08; ++p; } while (w--) { *p = (*p & 0x77) | 0x88; ++p; } if (cmaske != 0) { *p = (*p & cmaske) | 0x80; ++p; } } void video_drawLineN(struct Video* v, int16_t x1, int16_t x2, uint8_t color) { debug(DBG_VIDEO, "drawLineN(%d, %d, %d)", x1, x2, color); int16_t xmax = MAX(x1, x2); int16_t xmin = MIN(x1, x2); uint8_t *p = v->_curPagePtr1 + v->_hliney * 160 + xmin / 2; uint16_t w = xmax / 2 - xmin / 2 + 1; uint8_t cmaske = 0; uint8_t cmasks = 0; if (xmin & 1) { --w; cmasks = 0xF0; } if (!(xmax & 1)) { --w; cmaske = 0x0F; } uint8_t colb = ((color & 0xF) << 4) | (color & 0xF); if (cmasks != 0) { *p = (*p & cmasks) | (colb & 0x0F); ++p; } while (w--) { *p++ = colb; } if (cmaske != 0) { *p = (*p & cmaske) | (colb & 0xF0); ++p; } } void video_drawLineP(struct Video* v, int16_t x1, int16_t x2, uint8_t color) { /* silence warnings without XWORLD_DEBUG */ (void) color; debug(DBG_VIDEO, "drawLineP(%d, %d, %d)", x1, x2, color); int16_t xmax = MAX(x1, x2); int16_t xmin = MIN(x1, x2); uint16_t off = v->_hliney * 160 + xmin / 2; uint8_t *p = v->_curPagePtr1 + off; uint8_t *q = v->_pagePtrs[0] + off; uint8_t w = xmax / 2 - xmin / 2 + 1; uint8_t cmaske = 0; uint8_t cmasks = 0; if (xmin & 1) { --w; cmasks = 0xF0; } if (!(xmax & 1)) { --w; cmaske = 0x0F; } if (cmasks != 0) { *p = (*p & cmasks) | (*q & 0x0F); ++p; ++q; } while (w--) { *p++ = *q++; } if (cmaske != 0) { *p = (*p & cmaske) | (*q & 0xF0); ++p; ++q; } } uint8_t *video_getPagePtr(struct Video* v, uint8_t page) { uint8_t *p; if (page <= 3) { p = v->_pagePtrs[page]; } else { switch (page) { case 0xFF: p = v->_curPagePtr3; break; case 0xFE: p = v->_curPagePtr2; break; default: p = v->_pagePtrs[0]; // XXX check warning("video_getPagePtr() p != [0,1,2,3,0xFF,0xFE] == 0x%X", page); break; } } return p; } void video_changePagePtr1(struct Video* v, uint8_t page) { debug(DBG_VIDEO, "video_changePagePtr1(%d)", page); v->_curPagePtr1 = video_getPagePtr(v, page); } void video_fillPage(struct Video* v, uint8_t pageId, uint8_t color) { debug(DBG_VIDEO, "video_fillPage(%d, %d)", pageId, color); uint8_t *p = video_getPagePtr(v, pageId); // Since a palette indice is coded on 4 bits, we need to duplicate the // clearing color to the upper part of the byte. uint8_t c = (color << 4) | color; rb->memset(p, c, VID_PAGE_SIZE); #if TRACE_FRAMEBUFFER video_dumpFrameBuffers(v, "-fillPage"); #endif #if TRACE_BG_BUFFER video_dumpBackGroundBuffer(v); #endif } #if TRACE_FRAMEBUFFER #define SCREENSHOT_BPP 3 int traceFrameBufferCounter = 0; uint8_t allFrameBuffers[640 * 400 * SCREENSHOT_BPP]; #endif /* This opcode is used once the background of a scene has been drawn in one of the framebuffer: it is copied in the current framebuffer at the start of a new frame in order to improve performances. */ void video_copyPage(struct Video* v, uint8_t srcPageId, uint8_t dstPageId, int16_t vscroll) { debug(DBG_VIDEO, "video_copyPage(%d, %d)", srcPageId, dstPageId); if (srcPageId == dstPageId) return; uint8_t *p; uint8_t *q; if (srcPageId >= 0xFE || !((srcPageId &= 0xBF) & 0x80)) { p = video_getPagePtr(v, srcPageId); q = video_getPagePtr(v, dstPageId); memcpy(q, p, VID_PAGE_SIZE); } else { p = video_getPagePtr(v, srcPageId & 3); q = video_getPagePtr(v, dstPageId); if (vscroll >= -199 && vscroll <= 199) { uint16_t h = 200; if (vscroll < 0) { h += vscroll; p += -vscroll * 160; } else { h -= vscroll; q += vscroll * 160; } memcpy(q, p, h * 160); } } #if TRACE_FRAMEBUFFER char name[256]; rb->memset(name, 0, sizeof(name)); sprintf(name, "copyPage_0x%X_to_0x%X", (p - v->_pagePtrs[0]) / VID_PAGE_SIZE, (q - v->_pagePtrs[0]) / VID_PAGE_SIZE); dumpFrameBuffers(name); #endif } void video_copyPagePtr(struct Video* v, const uint8_t *src) { debug(DBG_VIDEO, "video_copyPagePtr()"); uint8_t *dst = v->_pagePtrs[0]; int h = 200; while (h--) { int w = 40; while (w--) { uint8_t p[] = { *(src + 8000 * 3), *(src + 8000 * 2), *(src + 8000 * 1), *(src + 8000 * 0) }; for(int j = 0; j < 4; ++j) { uint8_t acc = 0; for (int i = 0; i < 8; ++i) { acc <<= 1; acc |= (p[i & 3] & 0x80) ? 1 : 0; p[i & 3] <<= 1; } *dst++ = acc; } ++src; } } } /* uint8_t *video_allocPage() { uint8_t *buf = (uint8_t *)malloc(VID_PAGE_SIZE); rb->memset(buf, 0, VID_PAGE_SIZE); return buf; } */ #if TRACE_FRAMEBUFFER int dumpPaletteCursor = 0; #endif /* Note: The palettes set used to be allocated on the stack but I moved it to the heap so I could dump the four framebuffer and follow how frames are generated. */ uint8_t pal[NUM_COLORS * 3]; //3 = BYTES_PER_PIXEL void video_changePal(struct Video* v, uint8_t palNum) { debug(DBG_VIDEO, "video_changePal(v=0x%08x, palNum=%d", v, palNum); if (palNum >= 32) return; uint8_t *p = v->res->segPalettes + palNum * 32; //colors are coded on 2bytes (565) for 16 colors = 32 debug(DBG_VIDEO, "segPalettes: 0x%08x", v->res->segPalettes); // Moved to the heap, legacy code used to allocate the palette // on the stack. //uint8_t pal[NUM_COLORS * 3]; //3 = BYTES_PER_PIXEL for (int i = 0; i < NUM_COLORS; ++i) { debug(DBG_VIDEO, "i: %d", i); debug(DBG_VIDEO, "p: 0x%08x", p); uint8_t c1 = *(p + 0); uint8_t c2 = *(p + 1); p += 2; pal[i * 3 + 0] = ((c1 & 0x0F) << 2) | ((c1 & 0x0F) >> 2); // r pal[i * 3 + 1] = ((c2 & 0xF0) >> 2) | ((c2 & 0xF0) >> 6); // g pal[i * 3 + 2] = ((c2 & 0x0F) >> 2) | ((c2 & 0x0F) << 2); // b } sys_setPalette(v->sys, 0, NUM_COLORS, pal); v->currentPaletteId = palNum; #if TRACE_PALETTE printf("\nuint8_t dumpPalette[48] = {\n"); for (int i = 0; i < NUM_COLORS; ++i) { printf("0x%X,0x%X,0x%X,", pal[i * 3 + 0], pal[i * 3 + 1], pal[i * 3 + 2]); } printf("\n};\n"); #endif #if TRACE_FRAMEBUFFER dumpPaletteCursor++; #endif } void video_updateDisplay(struct Video* v, uint8_t pageId) { debug(DBG_VIDEO, "video_updateDisplay(%d)", pageId); if (pageId != 0xFE) { if (pageId == 0xFF) { /* swap ptrs 2 and 3 */ uint8_t* temp = v->_curPagePtr3; v->_curPagePtr3 = v->_curPagePtr2; v->_curPagePtr2 = temp; } else { v->_curPagePtr2 = video_getPagePtr(v, pageId); } } //Check if we need to change the palette if (v->paletteIdRequested != NO_PALETTE_CHANGE_REQUESTED) { video_changePal(v, v->paletteIdRequested); v->paletteIdRequested = NO_PALETTE_CHANGE_REQUESTED; } //Q: Why 160 ? //A: Because one byte gives two palette indices so // we only need to move 320/2 per line. sys_copyRect(v->sys, 0, 0, 320, 200, v->_curPagePtr2, 160); #if TRACE_FRAMEBUFFER dumpFrameBuffer(v->_curPagePtr2, allFrameBuffers, 320, 200); #endif } void video_saveOrLoad(struct Video* v, struct Serializer *ser) { uint8_t mask = 0; if (ser->_mode == SM_SAVE) { for (int i = 0; i < 4; ++i) { if (v->_pagePtrs[i] == v->_curPagePtr1) mask |= i << 4; if (v->_pagePtrs[i] == v->_curPagePtr2) mask |= i << 2; if (v->_pagePtrs[i] == v->_curPagePtr3) mask |= i << 0; } } struct Entry entries[] = { SE_INT(&v->currentPaletteId, SES_INT8, VER(1)), SE_INT(&v->paletteIdRequested, SES_INT8, VER(1)), SE_INT(&mask, SES_INT8, VER(1)), SE_ARRAY(v->_pagePtrs[0], VID_PAGE_SIZE, SES_INT8, VER(1)), SE_ARRAY(v->_pagePtrs[1], VID_PAGE_SIZE, SES_INT8, VER(1)), SE_ARRAY(v->_pagePtrs[2], VID_PAGE_SIZE, SES_INT8, VER(1)), SE_ARRAY(v->_pagePtrs[3], VID_PAGE_SIZE, SES_INT8, VER(1)), SE_END() }; ser_saveOrLoadEntries(ser, entries); if (ser->_mode == SM_LOAD) { v->_curPagePtr1 = v->_pagePtrs[(mask >> 4) & 0x3]; v->_curPagePtr2 = v->_pagePtrs[(mask >> 2) & 0x3]; v->_curPagePtr3 = v->_pagePtrs[(mask >> 0) & 0x3]; video_changePal(v, v->currentPaletteId); } } #if TRACE_FRAMEBUFFER uint8_t allPalettesDump[][48] = { { 0x4, 0x4, 0x4, 0x22, 0x0, 0x0, 0x4, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x2E, 0x22, 0x0, 0x3F, 0x0, 0x0, 0x33, 0x26, 0x0, 0x37, 0x2A, 0x0, 0x3B, 0x33, 0x0, 0x3F, 0x3B, 0x0, 0x3F, 0x3F, 0x1D, 0x3F, 0x3F, 0x2A, }, { 0x4, 0x4, 0x4, 0xC, 0xC, 0x11, 0x4, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x2E, 0x22, 0x0, 0x15, 0x11, 0x11, 0x33, 0x26, 0x0, 0x37, 0x2A, 0x0, 0x3B, 0x33, 0x0, 0x3F, 0x3B, 0x0, 0x3F, 0x3F, 0x1D, 0x3F, 0x3F, 0x2A, } , { 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x4, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x1D, 0x1D, 0x1D, 0x15, 0x15, 0x15, 0xC, 0x8, 0xC, 0x11, 0x11, 0x15, 0x1D, 0x15, 0x15, 0x15, 0x0, 0x0, 0x0, 0x4, 0xC, 0x3F, 0x3F, 0x2A, } , { 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x4, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x1D, 0x1D, 0x1D, 0x15, 0x15, 0x15, 0xC, 0x8, 0xC, 0x11, 0x11, 0x15, 0x1D, 0x15, 0x15, 0x15, 0x0, 0x0, 0x0, 0x4, 0xC, 0x3F, 0x3F, 0x2A, } , { 0x0, 0x0, 0x0, 0x1D, 0x0, 0x0, 0x4, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x1D, 0x1D, 0x1D, 0x15, 0x15, 0x15, 0xC, 0x8, 0xC, 0x15, 0x11, 0x19, 0x1D, 0x15, 0x15, 0x15, 0x0, 0x0, 0x0, 0x4, 0xC, 0x3F, 0x3F, 0x2A, } , { 0x0, 0x4, 0x8, 0x15, 0x1D, 0x1D, 0x0, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0xC, 0x19, 0x22, 0x11, 0x1D, 0x26, 0x8, 0x8, 0x8, 0x0, 0x0, 0x0, 0x2E, 0x2E, 0x2E, 0xC, 0xC, 0xC, 0x15, 0xC, 0x15, 0xC, 0x15, 0x15, 0x11, 0x19, 0x19, 0x1D, 0x26, 0x26, } , { 0x0, 0x0, 0x0, 0x0, 0x4, 0xC, 0x4, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x15, 0x0, 0x0, 0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0x11, 0x11, 0x11, 0x11, 0x15, 0x26, 0x0, 0x0, 0x33, 0x26, 0x0, 0x3B, 0x33, 0x11, } , { 0x0, 0x0, 0x0, 0x0, 0x4, 0xC, 0x0, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x15, 0x0, 0x0, 0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0x11, 0x11, 0x11, 0x11, 0x15, 0x26, 0x0, 0x0, 0x26, 0x15, 0x0, 0x26, 0x1D, 0x0, } , { 0x0, 0x0, 0x0, 0x0, 0x4, 0xC, 0x0, 0x8, 0x11, 0x4, 0xC, 0x15, 0x8, 0x11, 0x19, 0xC, 0x15, 0x1D, 0x15, 0x1D, 0x26, 0x1D, 0x2A, 0x2E, 0x15, 0x0, 0x0, 0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0x11, 0x11, 0x11, 0x11, 0x15, 0x26, 0x0, 0x0, 0x3F, 0x0, 0x0, 0x26, 0x1D, 0x0, } , { 0x0, 0x0, 0x0, 0x8, 0x4, 0xC, 0x15, 0xC, 0x11, 0x1D, 0x11, 0x0, 0xC, 0x8, 0x11, 0x2E, 0x1D, 0x0, 0x37, 0x26, 0x8, 0x3F, 0x2E, 0x0, 0x0, 0x0, 0x0, 0x11, 0xC, 0x15, 0x26, 0x15, 0x0, 0x15, 0x11, 0x19, 0x1D, 0x15, 0x1D, 0x26, 0x19, 0x19, 0x0, 0x0, 0x0, 0x3F, 0x3F, 0x3F, } , { 0x0, 0x0, 0x0, 0x8, 0x4, 0xC, 0x37, 0x1D, 0x1D, 0x3B, 0x2A, 0x22, 0x11, 0xC, 0x15, 0x2A, 0x0, 0x0, 0x33, 0x11, 0x0, 0x3F, 0x33, 0x1D, 0x3B, 0x19, 0x0, 0x11, 0x11, 0x19, 0x19, 0x15, 0x1D, 0x22, 0x19, 0x22, 0x2A, 0x1D, 0x26, 0x33, 0x22, 0x26, 0x37, 0x26, 0x22, 0x1D, 0x37, 0x3F, } , { 0x0, 0x0, 0x0, 0x0, 0x0, 0x1D, 0x4, 0x8, 0xC, 0x2A, 0x1D, 0xC, 0x3F, 0x3B, 0x26, 0x3B, 0x2A, 0x11, 0x2A, 0x0, 0x0, 0x0, 0x11, 0x15, 0x2A, 0x1D, 0x26, 0xC, 0x8, 0xC, 0x8, 0x15, 0x1D, 0x37, 0x26, 0x22, 0x33, 0x11, 0x0, 0x2E, 0x1D, 0x19, 0x22, 0x0, 0x0, 0x3F, 0x33, 0x1D, } , { 0x0, 0x0, 0x0, 0x0, 0x15, 0x0, 0x4, 0x8, 0xC, 0x0, 0xC, 0x11, 0x8, 0x11, 0x19, 0x0, 0x19, 0x22, 0x2A, 0x0, 0x0, 0x19, 0x15, 0x22, 0x2E, 0x26, 0x2E, 0xC, 0x8, 0xC, 0x0, 0x2E, 0x0, 0x37, 0x26, 0x22, 0x33, 0x11, 0x0, 0x2E, 0x1D, 0x19, 0x1D, 0x0, 0x0, 0x3F, 0x3F, 0x19, } , { 0x0, 0x0, 0x0, 0x8, 0xC, 0x11, 0x11, 0x11, 0x15, 0x19, 0x15, 0x22, 0x26, 0x19, 0x2A, 0x2E, 0x26, 0x2E, 0x4, 0x4, 0xC, 0x0, 0xC, 0x15, 0x2A, 0x1D, 0x26, 0x0, 0x19, 0x0, 0x0, 0x2A, 0x0, 0x37, 0x26, 0x22, 0x0, 0x15, 0x1D, 0x37, 0x2E, 0x1D, 0x3F, 0x3F, 0x2E, 0x37, 0x37, 0x26, } , { 0x0, 0x0, 0x0, 0x0, 0x15, 0x0, 0x4, 0x8, 0xC, 0x0, 0xC, 0x11, 0x8, 0x11, 0x19, 0x0, 0x19, 0x22, 0x2A, 0x0, 0x0, 0x19, 0x15, 0x22, 0x2E, 0x26, 0x2E, 0xC, 0x8, 0xC, 0x0, 0x2E, 0x0, 0x37, 0x26, 0x22, 0x33, 0x11, 0x0, 0x2E, 0x1D, 0x19, 0x1D, 0x0, 0x0, 0x3F, 0x3F, 0x19, } , { 0x0, 0x0, 0x0, 0x0, 0xC, 0x0, 0x8, 0x0, 0x4, 0xC, 0x8, 0xC, 0x19, 0x11, 0x11, 0x3F, 0x3F, 0x19, 0x0, 0x1D, 0x0, 0x0, 0x3F, 0x0, 0x0, 0x4, 0x8, 0x11, 0x19, 0x11, 0x19, 0x0, 0x0, 0x2E, 0x0, 0x0, 0x3F, 0x0, 0x0, 0x37, 0x1D, 0x15, 0x0, 0x11, 0x11, 0x0, 0x3F, 0x2A, } , { 0x0, 0x0, 0x0, 0x0, 0xC, 0x0, 0x0, 0x11, 0x0, 0x0, 0x19, 0x0, 0xC, 0x26, 0x0, 0x15, 0x2E, 0x0, 0x4, 0x8, 0x0, 0x26, 0x11, 0x0, 0x2E, 0x3F, 0x0, 0x0, 0x15, 0x0, 0xC, 0x1D, 0x0, 0x15, 0x2E, 0x0, 0x15, 0x37, 0x0, 0x1D, 0x3F, 0x0, 0xC, 0x1D, 0xC, 0x\ 1D, 0x26, 0x15, } }; #include "png.h" int GL_FCS_SaveAsSpecifiedPNG(char* path, uint8_t* pixels, int depth = 8, int format = PNG_COLOR_TYPE_RGB) { png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_byte ** row_pointers = NULL; int status = -1; int bytePerPixel = 0; int y; int fd = open (path, "wb"); if (fd < 0) { goto fopen_failed; } png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) { goto png_create_write_struct_failed; } info_ptr = png_create_info_struct (png_ptr); if (info_ptr == NULL) { goto png_create_info_struct_failed; } if (setjmp (png_jmpbuf (png_ptr))) { goto png_failure; } /* Set image attributes. */ png_set_IHDR (png_ptr, info_ptr, 640, 400, depth, format, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); if (format == PNG_COLOR_TYPE_GRAY ) bytePerPixel = depth / 8 * 1; else bytePerPixel = depth / 8 * 3; row_pointers = (png_byte **)png_malloc (png_ptr, 400 * sizeof (png_byte *)); //for (y = vid.height-1; y >=0; --y) for (y = 0; y < 400; y++) { row_pointers[y] = (png_byte*)&pixels[640 * (400 - y) * bytePerPixel]; } png_init_io (png_ptr, fp); png_set_rows (png_ptr, info_ptr, row_pointers); png_write_png (png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL); //png_read_image (png_ptr, info_ptr);// status = 0; png_free (png_ptr, row_pointers); png_failure: png_create_info_struct_failed: png_destroy_write_struct (&png_ptr, &info_ptr); png_create_write_struct_failed: fclose (fp); fopen_failed: return status; } void writeLine(uint8_t *dst, uint8_t *src, int size) { uint8_t* dumpPalette; if (!dumpPaletteCursor) dumpPalette = allPalettesDump[dumpPaletteCursor]; else dumpPalette = pal; for( uint8_t twoPixels = 0 ; twoPixels < size ; twoPixels++) { int pixelIndex0 = (*src & 0xF0) >> 4; pixelIndex0 &= 0x10 - 1; int pixelIndex1 = (*src & 0xF); pixelIndex1 &= 0x10 - 1; //We need to write those two pixels dst[0] = dumpPalette[pixelIndex0 * 3] << 2 | dumpPalette[pixelIndex0 * 3]; dst[1] = dumpPalette[pixelIndex0 * 3 + 1] << 2 | dumpPalette[pixelIndex0 * 3 + 1]; dst[2] = dumpPalette[pixelIndex0 * 3 + 2] << 2 | dumpPalette[pixelIndex0 * 3 + 2]; //dst[3] = 0xFF; dst += SCREENSHOT_BPP; dst[0] = dumpPalette[pixelIndex1 * 3] << 2 | dumpPalette[pixelIndex1 * 3]; dst[1] = dumpPalette[pixelIndex1 * 3 + 1] << 2 | dumpPalette[pixelIndex1 * 3 + 1]; dst[2] = dumpPalette[pixelIndex1 * 3 + 2] << 2 | dumpPalette[pixelIndex1 * 3 + 2]; //dst[3] = 0xFF; dst += SCREENSHOT_BPP; src++; } } void video_dumpFrameBuffer(uint8_t *src, uint8_t *dst, int x, int y) { for (int line = 199 ; line >= 0 ; line--) { writeLine(dst + x * SCREENSHOT_BPP + y * 640 * SCREENSHOT_BPP , src + line * 160, 160); dst += 640 * SCREENSHOT_BPP; } } void video_dumpFrameBuffers(char* comment) { if (!traceFrameBufferCounter) { rb->memset(allFrameBuffers, 0, sizeof(allFrameBuffers)); } dumpFrameBuffer(v->_pagePtrs[1], allFrameBuffers, 0, 0); dumpFrameBuffer(v->_pagePtrs[0], allFrameBuffers, 0, 200); dumpFrameBuffer(v->_pagePtrs[2], allFrameBuffers, 320, 0); //dumpFrameBuffer(v->_pagePtrs[3],allFrameBuffers,320,200); //if (v->_curPagePtr1 == v->_pagePtrs[3]) // /* uint8_t* offScreen = sys->getOffScreenFramebuffer(); for(int i=0 ; i < 200 ; i++) writeLine(allFrameBuffers+320*3+640*i*3 + 200*640*3, offScreen+320*i/2 , 160); */ int frameId = traceFrameBufferCounter++; //Write bitmap to disk. // Filling TGA header information /* char path[256]; sprintf(path,"test%d.tga",traceFrameBufferCounter); #define IMAGE_WIDTH 640 #define IMAGE_HEIGHT 400 uint8_t tga_header[18]; rb->memset(tga_header, 0, 18); tga_header[2] = 2; tga_header[12] = (IMAGE_WIDTH & 0x00FF); tga_header[13] = (IMAGE_WIDTH & 0xFF00) / 256; tga_header[14] = (IMAGE_HEIGHT & 0x00FF) ; tga_header[15] =(IMAGE_HEIGHT & 0xFF00) / 256; tga_header[16] = 32 ; // Open the file, write both header and payload, close, done. char path[256]; sprintf(path,"test%d.tga",traceFrameBufferCounter); FILE* pScreenshot = fopen(path, "wb"); fwrite(&tga_header, 18, sizeof(uint8_t), pScreenshot); fwrite(allFrameBuffers, IMAGE_WIDTH * IMAGE_HEIGHT,SCREENSHOT_BPP * sizeof(uint8_t),pScreenshot); fclose(pScreenshot); */ char path[256]; //sprintf(path,"%4d%s.png",traceFrameBufferCounter,comment); sprintf(path, "%4d.png", traceFrameBufferCounter); GL_FCS_SaveAsSpecifiedPNG(path, allFrameBuffers); } #endif #if TRACE_BG_BUFFER uint8_t bgPalette[48] = { 0x8, 0x8, 0xC, 0xC, 0xC, 0x15, 0xC, 0x11, 0x1D, 0x15, 0x2A, 0x3F, 0x1D, 0x19, 0x19, 0x37, 0x2E, 0x2A, 0x26, 0x1D, 0x1D, 0x37, 0x26, 0x22, 0x22, 0xC, 0x0, 0x26, 0x33, 0x3F, 0x11, 0x11, 0x15, 0x11, 0x15, 0x1D, 0x15, 0x19, 0x26, 0x15, 0x1D, 0x37, 0x0, 0x26, 0x3F, 0x2E, 0x15, 0x0, }; void bgWriteLine(uint8_t *dst, uint8_t *src, int size) { uint8_t* dumpPalette; // if (!dumpPaletteCursor) // dumpPalette = allPalettesDump[dumpPaletteCursor]; // else dumpPalette = bgPalette; for( uint8_t twoPixels = 0 ; twoPixels < size ; twoPixels++) { int pixelIndex0 = (*src & 0xF0) >> 4; pixelIndex0 &= 0x10 - 1; int pixelIndex1 = (*src & 0xF); pixelIndex1 &= 0x10 - 1; //We need to write those two pixels dst[0] = dumpPalette[pixelIndex0 * 3] << 2 | dumpPalette[pixelIndex0 * 3]; dst[1] = dumpPalette[pixelIndex0 * 3 + 1] << 2 | dumpPalette[pixelIndex0 * 3 + 1]; dst[2] = dumpPalette[pixelIndex0 * 3 + 2] << 2 | dumpPalette[pixelIndex0 * 3 + 2]; //dst[3] = 0xFF; dst += 3; dst[0] = dumpPalette[pixelIndex1 * 3] << 2 | dumpPalette[pixelIndex1 * 3]; dst[1] = dumpPalette[pixelIndex1 * 3 + 1] << 2 | dumpPalette[pixelIndex1 * 3 + 1]; dst[2] = dumpPalette[pixelIndex1 * 3 + 2] << 2 | dumpPalette[pixelIndex1 * 3 + 2]; //dst[3] = 0xFF; dst += 3; src++; } } void bgDumpFrameBuffer(uint8_t *src, uint8_t *dst, int x, int y) { for (int line = 199 ; line >= 0 ; line--) { bgWriteLine(dst + x * 3 + y * 320 * 3 , src + line * 160, 160); dst += 320 * 3; } } #include "png.h" int bgSaveAsSpecifiedPNG(char* path, uint8_t* pixels, int depth = 8, int format = PNG_COLOR_TYPE_RGB) { #if 0 FILE * fp; png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_byte ** row_pointers = NULL; int status = -1; int bytePerPixel = 0; int y; fp = fopen (path, "wb"); if (! fp) { goto fopen_failed; } png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) { goto png_create_write_struct_failed; } info_ptr = png_create_info_struct (png_ptr); if (info_ptr == NULL) { goto png_create_info_struct_failed; } if (setjmp (png_jmpbuf (png_ptr))) { goto png_failure; } /* Set image attributes. */ png_set_IHDR (png_ptr, info_ptr, 320, 200, depth, format, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); if (format == PNG_COLOR_TYPE_GRAY ) bytePerPixel = depth / 8 * 1; else bytePerPixel = depth / 8 * 3; row_pointers = (png_byte **)png_malloc (png_ptr, 200 * sizeof (png_byte *)); //for (y = vid.height-1; y >=0; --y) for (y = 0; y < 200; y++) { row_pointers[y] = (png_byte*)&pixels[320 * (200 - y) * bytePerPixel]; } png_init_io (png_ptr, fp); png_set_rows (png_ptr, info_ptr, row_pointers); png_write_png (png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL); //png_read_image (png_ptr, info_ptr);// status = 0; png_free (png_ptr, row_pointers); png_failure: png_create_info_struct_failed: png_destroy_write_struct (&png_ptr, &info_ptr); png_create_write_struct_failed: fclose (fp); fopen_failed: return status; #endif } int bgFrameBufferCounter = 0; void video_dumpBackGroundBuffer() { if (v->_curPagePtr1 != v->_pagePtrs[0]) return; uint8_t bgBuffer[320 * 200 * 3]; bgDumpFrameBuffer(v->_curPagePtr1, bgBuffer, 0, 0); char path[256]; //sprintf(path,"%4d%s.png",traceFrameBufferCounter,comment); sprintf(path, "bg%4d.png", bgFrameBufferCounter++); bgSaveAsSpecifiedPNG(path, bgBuffer); } #endif