ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/waterbox/pcfx/rainbow.cpp

820 lines
18 KiB
C++
Raw Blame History

/******************************************************************************/
/* Mednafen NEC PC-FX Emulation Module */
/******************************************************************************/
/* rainbow.cpp:
** Copyright (C) 2006-2016 Mednafen Team
**
** 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 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.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software Foundation, Inc.,
** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
/*
** MJPEG-like decoder based on the algorithm and Huffman data tables provided by David Michel
** of MagicEngine and MagicEngine-FX.
*/
#include "pcfx.h"
#include "rainbow.h"
#include "king.h"
#include "interrupt.h"
#include "jrevdct.h"
namespace MDFN_IEN_PCFX
{
static bool ChromaIP; // Bilinearly interpolate chroma channel
/* Y = luminance/luma, UV = chrominance/chroma */
struct HuffmanQuickLUTPair
{
uint8 val;
uint8 bitc; // Bit count for the code.
};
static const uint8 zigzag[63] =
{
0x01, 0x08, 0x10, 0x09, 0x02, 0x03, 0x0A, 0x11,
0x18, 0x20, 0x19, 0x12, 0x0B, 0x04, 0x05, 0x0C,
0x13, 0x1A, 0x21, 0x28, 0x30, 0x29, 0x22, 0x1B,
0x14, 0x0D, 0x06, 0x07, 0x0E, 0x15, 0x1C, 0x23,
0x2A, 0x31, 0x38, 0x39, 0x32, 0x2B, 0x24, 0x1D,
0x16, 0x0F, 0x17, 0x1E, 0x25, 0x2C, 0x33, 0x3A,
0x3B, 0x34, 0x2D, 0x26, 0x1F, 0x27, 0x2E, 0x35,
0x3C, 0x3D, 0x36, 0x2F, 0x37, 0x3E, 0x3F};
static const HuffmanQuickLUTPair ac_y_qlut[1 << 12] =
{
#include "rainbow_acy.inc"
};
static const HuffmanQuickLUTPair ac_uv_qlut[1 << 12] =
{
#include "rainbow_acuv.inc"
};
static const HuffmanQuickLUTPair dc_y_qlut[1 << 9] =
{
#include "rainbow_dcy.inc"
};
static const HuffmanQuickLUTPair dc_uv_qlut[1 << 8] =
{
#include "rainbow_dcuv.inc"
};
static uint8 *DecodeBuffer[2] = {NULL, NULL};
static int32 DecodeFormat[2]; // The format each buffer is in(-1 = invalid, 0 = palettized 8-bit, 1 = YUV)
static uint32 QuantTables[2][64], QuantTablesBase[2][64]; // 0 = Y, 1 = UV
static uint32 DecodeBufferWhichRead;
static int32 RasterReadPos;
static uint16 Control;
static uint16 NullRunY, NullRunU, NullRunV, HSync;
static uint16 HScroll;
static uint32 bits_buffer;
static uint32 bits_buffered_bits;
static int32 bits_bytes_left;
static void InitBits(int32 bcount)
{
bits_bytes_left = bcount;
bits_buffer = 0;
bits_buffered_bits = 0;
}
static INLINE uint8 FetchWidgywabbit(void)
{
if (bits_bytes_left <= 0)
return (0);
uint8 ret = KING_RB_Fetch();
if (ret == 0xFF)
KING_RB_Fetch();
bits_bytes_left--;
return (ret);
}
enum
{
MDFNBITS_PEEK = 1,
MDFNBITS_FUNNYSIGN = 2,
};
static INLINE uint32 GetBits(const unsigned int count, const unsigned int how = 0)
{
uint32 ret;
while (bits_buffered_bits < count)
{
bits_buffer <<= 8;
bits_buffer |= FetchWidgywabbit();
bits_buffered_bits += 8;
}
ret = (bits_buffer >> (bits_buffered_bits - count)) & ((1 << count) - 1);
if (!(how & MDFNBITS_PEEK))
bits_buffered_bits -= count;
if ((how & MDFNBITS_FUNNYSIGN) && count)
{
if (ret < (1U << (count - 1)))
ret += 1 - (1 << count);
}
return (ret);
}
// Note: SkipBits is intended to be called right after GetBits() with "how" MDFNBITS_PEEK,
// and the count pass to SkipBits must be less than or equal to the count passed to GetBits().
static INLINE void SkipBits(const unsigned int count)
{
bits_buffered_bits -= count;
}
static uint32 HappyColor; // Cached, calculated from null run yuv registers;
static void CalcHappyColor(void)
{
uint8 y_c = (int16)NullRunY + 0x80;
uint8 u_c = (int16)NullRunU + 0x80;
uint8 v_c = (int16)NullRunV + 0x80;
HappyColor = (y_c << 16) | (u_c << 8) | (v_c << 0);
}
static uint32 get_ac_coeff(const HuffmanQuickLUTPair *table, int32 *zeroes)
{
unsigned int numbits;
uint32 rawbits;
uint32 code;
rawbits = GetBits(12, MDFNBITS_PEEK);
code = table[rawbits].val;
SkipBits(table[rawbits].bitc);
numbits = code & 0xF;
*zeroes = code >> 4;
return (GetBits(numbits, MDFNBITS_FUNNYSIGN));
}
static uint32 get_dc_coeff(const HuffmanQuickLUTPair *table, int32 *zeroes, int maxbits)
{
uint32 code;
for (;;)
{
uint32 rawbits;
rawbits = GetBits(maxbits, MDFNBITS_PEEK);
code = table[rawbits].val;
SkipBits(table[rawbits].bitc);
if (code < 0xF)
{
*zeroes = 0;
return (GetBits(code, MDFNBITS_FUNNYSIGN));
}
else if (code == 0xF)
{
get_ac_coeff(ac_y_qlut, zeroes);
(*zeroes)++;
return (0);
}
else if (code >= 0x10)
{
code -= 0x10;
for (int i = 0; i < 64; i++)
{
// Y
uint32 coeff = (QuantTablesBase[0][i] * code) >> 2;
if (coeff < 1)
coeff = 1;
else if (coeff > 0xFE)
coeff = 0xFE;
QuantTables[0][i] = coeff;
// UV
if (i)
coeff = (QuantTablesBase[1][i] * code) >> 2;
else
coeff = (QuantTablesBase[1][i]) >> 2;
if (coeff < 1)
coeff = 1;
else if (coeff > 0xFE)
coeff = 0xFE;
QuantTables[1][i] = coeff;
}
}
}
}
static INLINE uint32 get_dc_y_coeff(int32 *zeroes)
{
return (get_dc_coeff(dc_y_qlut, zeroes, 9));
}
static uint32 get_dc_uv_coeff(void)
{
const HuffmanQuickLUTPair *table = dc_uv_qlut;
uint32 code;
uint32 rawbits = GetBits(8, MDFNBITS_PEEK);
code = table[rawbits].val;
SkipBits(table[rawbits].bitc);
return (GetBits(code, MDFNBITS_FUNNYSIGN));
}
static void decode(int32 *dct, const uint32 *QuantTable, const int32 dc, const HuffmanQuickLUTPair *table)
{
int32 coeff;
int zeroes;
int count;
int index;
dct[0] = (int16)(QuantTable[0] * dc);
count = 0;
do
{
coeff = get_ac_coeff(table, &zeroes);
if (!coeff)
{
if (!zeroes)
{
while (count < 63)
{
dct[zigzag[count++]] = 0;
}
break;
}
else if (zeroes == 1)
zeroes = 0xF;
}
while (zeroes-- && count < 63)
{
dct[zigzag[count++]] = 0;
}
zeroes = 0;
if (count < 63)
{
index = zigzag[count++];
dct[index] = (int16)(QuantTable[index] * coeff);
}
} while (count < 63);
}
#ifdef WANT_DEBUGGER
uint32 RAINBOW_GetRegister(const unsigned int id, char *special, const uint32 special_len)
{
uint32 value = 0xDEADBEEF;
if (id == RAINBOW_GSREG_RSCRLL)
value = HScroll;
else if (id == RAINBOW_GSREG_RCTRL)
value = Control;
else if (id == RAINBOW_GSREG_RNRY)
value = NullRunY;
else if (id == RAINBOW_GSREG_RNRU)
value = NullRunU;
else if (id == RAINBOW_GSREG_RNRV)
value = NullRunV;
else if (id == RAINBOW_GSREG_RHSYNC)
value = HSync;
return (value);
}
void RAINBOW_SetRegister(const unsigned int id, uint32 value)
{
if (id == RAINBOW_GSREG_RSCRLL)
HScroll = value & 0x1FF;
else if (id == RAINBOW_GSREG_RCTRL)
Control = value;
else if (id == RAINBOW_GSREG_RNRY)
NullRunY = value;
else if (id == RAINBOW_GSREG_RNRU)
NullRunU = value;
else if (id == RAINBOW_GSREG_RNRV)
NullRunV = value;
}
#endif
static uint32 LastLine[256];
static bool FirstDecode;
static bool GarbageData;
void RAINBOW_Init(bool arg_ChromaIP)
{
ChromaIP = arg_ChromaIP;
for (int i = 0; i < 2; i++)
{
DecodeBuffer[i] = new uint8[0x2000 * 4];
memset(DecodeBuffer[i], 0, 0x2000 * 4);
}
DecodeFormat[0] = DecodeFormat[1] = -1;
DecodeBufferWhichRead = 0;
GarbageData = FALSE;
FirstDecode = TRUE;
RasterReadPos = 0;
}
// RAINBOW base I/O port address: 0x200
#define REGSETBOFW(_reg, _data, _wb) \
{ \
(_reg) &= ~(0xFF << ((_wb)*8)); \
(_reg) |= (_data) << ((_wb)*8); \
}
#define REGSETBOFH REGSETBOFW
// The horizontal scroll register is set up kind of weird...D0-D7 of writes to $200 set the lower byte, D0-D7 of writes to $202 set the upper byte
void RAINBOW_Write8(uint32 A, uint8 V)
{
//printf("RAINBOW Wr8: %08x %02x\n", A, V);
switch (A & 0x1C)
{
case 0x00:
REGSETBOFH(HScroll, V, (A & 0x2) >> 1);
HScroll &= 0x1FF;
break;
case 0x04:
REGSETBOFH(Control, V, A & 0x3);
break;
case 0x08:
REGSETBOFH(NullRunY, V, A & 0x3);
CalcHappyColor();
break;
case 0x0C:
REGSETBOFH(NullRunU, V, A & 0x3);
CalcHappyColor();
break;
case 0x10:
REGSETBOFH(NullRunV, V, A & 0x3);
CalcHappyColor();
break;
case 0x14:
REGSETBOFH(HSync, V, A & 0x3);
break;
}
}
void RAINBOW_Write16(uint32 A, uint16 V)
{
int msh = A & 0x2;
//printf("RAINBOW Wr16: %08x %04x\n", A, V);
switch (A & 0x1C)
{
case 0x00:
REGSETBOFH(HScroll, V & 0xFF, (A & 0x2) >> 1);
HScroll &= 0x1FF;
break;
case 0x04:
REGSETHW(Control, V, msh);
break;
case 0x08:
REGSETHW(NullRunY, V, msh);
CalcHappyColor();
break;
case 0x0C:
REGSETHW(NullRunU, V, msh);
CalcHappyColor();
break;
case 0x10:
REGSETHW(NullRunV, V, msh);
CalcHappyColor();
break;
case 0x14:
REGSETHW(HSync, V, msh);
break;
}
}
void RAINBOW_ForceTransferReset(void)
{
RasterReadPos = 0;
DecodeFormat[0] = DecodeFormat[1] = -1;
}
void RAINBOW_SwapBuffers(void)
{
DecodeBufferWhichRead ^= 1;
RasterReadPos = 0;
}
void RAINBOW_DecodeBlock(bool arg_FirstDecode, bool Skip)
{
uint8 block_type;
int32 block_size;
int icount;
int which_buffer = DecodeBufferWhichRead ^ 1;
if (!(Control & 0x01))
{
puts("Rainbow decode when disabled!!");
return;
}
if (arg_FirstDecode)
{
FirstDecode = TRUE;
GarbageData = FALSE;
}
if (GarbageData)
icount = 0;
else
icount = 0x200;
do
{
do
{
while (KING_RB_Fetch() != 0xFF && icount > 0)
icount--;
block_type = KING_RB_Fetch();
//if(icount > 0 && block_type != 0xF0 && block_type != 0xF1 && block_type != 0xF2 && block_type != 0xF3 && block_type != 0xF8 && block_type != 0xFF)
//if(icount > 0 && block_type == 0x11)
// printf("%02x\n", block_type);
icount--;
} while (block_type != 0xF0 && block_type != 0xF1 && block_type != 0xF2 && block_type != 0xF3 && block_type != 0xF8 && block_type != 0xFF && icount > 0);
{
uint16 tmp;
tmp = KING_RB_Fetch() << 8;
tmp |= KING_RB_Fetch() << 0;
block_size = (int16)tmp;
}
block_size -= 2;
if (block_type == 0xFF && block_size <= 0)
for (int i = 0; i < 128; i++, icount--)
KING_RB_Fetch();
//fprintf(stderr, "Block: %d\n", block_size);
} while (block_size <= 0 && icount > 0);
//if(!GarbageData && icount < 500)
//{
// FXDBG("Partial garbage data. %d", icount);
//}
//printf("%d\n", icount);
if (icount <= 0)
{
FXDBG("Garbage data.");
GarbageData = TRUE;
//printf("Dooom: %d\n");
DecodeFormat[which_buffer] = 0;
memset(DecodeBuffer[which_buffer], 0, 0x2000);
goto BufferNoDecode;
}
if (block_type == 0xf8 || block_type == 0xff)
DecodeFormat[which_buffer] = 1;
else
DecodeFormat[which_buffer] = 0;
if (block_type == 0xF8 || block_type == 0xFF)
{
if (block_type == 0xFF)
{
for (int q = 0; q < 2; q++)
for (int i = 0; i < 64; i++)
{
uint8 meow = KING_RB_Fetch();
QuantTables[q][i] = meow;
QuantTablesBase[q][i] = meow;
}
block_size -= 128;
}
InitBits(block_size);
int32 dc_y = 0, dc_u = 0, dc_v = 0;
uint32 *dest_base = (uint32 *)DecodeBuffer[which_buffer];
for (int column = 0; column < 16; column++)
{
uint32 *dest_base_column = &dest_base[column * 16];
int zeroes = 0;
dc_y += get_dc_y_coeff(&zeroes);
if (zeroes) // If set, clear the number of columns
{
do
{
if (column < 16)
{
dest_base_column = &dest_base[column * 16];
for (int y = 0; y < 16; y++)
for (int x = 0; x < 16; x++)
dest_base_column[y * 256 + x] = HappyColor;
}
column++;
zeroes--;
} while (zeroes);
column--; // Fix for the column autoincrement in the while(zeroes) loop
dc_y = dc_u = dc_v = 0;
}
else
{
int32 dct_y[256];
int32 dct_u[64];
int32 dct_v[64];
// Y/Luma, 16x16 components
// ---------
// | A | C |
// |-------|
// | B | D |
// ---------
// A (0, 0)
decode(&dct_y[0x00], QuantTables[0], dc_y, ac_y_qlut);
// B (0, 1)
dc_y += get_dc_y_coeff(&zeroes);
decode(&dct_y[0x40], QuantTables[0], dc_y, ac_y_qlut);
// C (1, 0)
dc_y += get_dc_y_coeff(&zeroes);
decode(&dct_y[0x80], QuantTables[0], dc_y, ac_y_qlut);
// D (1, 1)
dc_y += get_dc_y_coeff(&zeroes);
decode(&dct_y[0xC0], QuantTables[0], dc_y, ac_y_qlut);
// U, 8x8 components
dc_u += get_dc_uv_coeff();
decode(&dct_u[0x00], QuantTables[1], dc_u, ac_uv_qlut);
// V, 8x8 components
dc_v += get_dc_uv_coeff();
decode(&dct_v[0x00], QuantTables[1], dc_v, ac_uv_qlut);
if (Skip)
continue;
j_rev_dct(&dct_y[0x00]);
j_rev_dct(&dct_y[0x40]);
j_rev_dct(&dct_y[0x80]);
j_rev_dct(&dct_y[0xC0]);
j_rev_dct(&dct_u[0x00]);
j_rev_dct(&dct_v[0x00]);
for (int y = 0; y < 16; y++)
for (int x = 0; x < 16; x++)
dest_base_column[y * 256 + x] = clamp_to_u8(dct_y[y * 8 + (x & 0x7) + ((x & 0x8) << 4)] + 0x80) << 16;
if (!ChromaIP)
{
for (int y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++)
{
uint32 component_uv = (clamp_to_u8(dct_u[y * 8 + x] + 0x80) << 8) | clamp_to_u8(dct_v[y * 8 + x] + 0x80);
dest_base_column[y * 512 + (256 * 0) + x * 2 + 0] |= component_uv;
dest_base_column[y * 512 + (256 * 0) + x * 2 + 1] |= component_uv;
dest_base_column[y * 512 + (256 * 1) + x * 2 + 0] |= component_uv;
dest_base_column[y * 512 + (256 * 1) + x * 2 + 1] |= component_uv;
}
}
}
else
{
for (int y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++)
{
uint32 component_uv = (clamp_to_u8(dct_u[y * 8 + x] + 0x80) << 8) | clamp_to_u8(dct_v[y * 8 + x] + 0x80);
dest_base_column[y * 512 + (256 * 1) + x * 2 + 0] |= component_uv;
}
}
}
}
}
// Do bilinear interpolation on the chroma channels:
if (!Skip && ChromaIP)
{
for (int y = 0; y < 16; y += 2)
{
uint32 *linebase = &dest_base[y * 256];
uint32 *linebase1 = &dest_base[(y + 1) * 256];
for (int x = 0; x < 254; x += 2)
{
unsigned int u, v;
u = (((linebase1[x] >> 8) & 0xFF) + ((linebase1[x + 2] >> 8) & 0xFF)) >> 1;
v = (((linebase1[x] >> 0) & 0xFF) + ((linebase1[x + 2] >> 0) & 0xFF)) >> 1;
linebase1[x + 1] = (linebase1[x + 1] & ~0xFFFF) | (u << 8) | v;
}
linebase1[0xFF] = (linebase1[0xFF] & ~0xFFFF) | (linebase1[0xFE] & 0xFFFF);
if (FirstDecode)
{
for (int x = 0; x < 256; x++)
linebase[x] = (linebase[x] & ~0xFFFF) | (linebase1[x] & 0xFFFF);
FirstDecode = 0;
}
else
for (int x = 0; x < 256; x++)
{
unsigned int u, v;
u = (((LastLine[x] >> 8) & 0xFF) + ((linebase1[x] >> 8) & 0xFF)) >> 1;
v = (((LastLine[x] >> 0) & 0xFF) + ((linebase1[x] >> 0) & 0xFF)) >> 1;
linebase[x] = (linebase[x] & ~0xFFFF) | (u << 8) | v;
}
memcpy(LastLine, linebase1, 256 * 4);
}
} // End chroma interpolation
} // end jpeg-like decoding
else
{
// Earlier code confines the set to F0,F1,F2, and F3.
// F0 = (4, 0xF), F1 = (3, 0x7), F2 = (0x2, 0x3), F3 = 0x1, 0x1)
const unsigned int plt_shift = 4 - (block_type & 0x3);
const unsigned int crl_mask = (1 << plt_shift) - 1;
int x = 0;
while (block_size > 0)
{
uint8 boot;
unsigned int rle_count;
boot = KING_RB_Fetch();
block_size--;
if (boot == 0xFF)
{
KING_RB_Fetch();
block_size--;
}
if (!(boot & crl_mask)) // Expand mode?
{
rle_count = KING_RB_Fetch();
block_size--;
if (rle_count == 0xFF)
{
KING_RB_Fetch();
block_size--;
}
rle_count++;
}
else
rle_count = boot & crl_mask;
for (unsigned int i = 0; i < rle_count; i++)
{
if (x >= 0x2000)
{
//puts("Oops");
break; // Don't overflow our decode buffer!
}
DecodeBuffer[which_buffer][x] = (boot >> plt_shift);
x++;
}
}
} // end RLE decoding
//for(int i = 0; i < 8 + block_size; i++)
// KING_RB_Fetch();
BufferNoDecode:;
}
void KING_Moo(void);
// NOTE: layer_or and palette_ptr are optimizations, the real RAINBOW chip knows not of such things.
int RAINBOW_FetchRaster(uint32 *linebuffer, uint32 layer_or, uint32 *palette_ptr)
{
int ret;
ret = DecodeFormat[DecodeBufferWhichRead];
if (linebuffer)
{
linebuffer = MDFN_ASSUME_ALIGNED(linebuffer, 8);
//
if (DecodeFormat[DecodeBufferWhichRead] == -1) // None
{
MDFN_FastArraySet(linebuffer, 0, 256);
}
else if (DecodeFormat[DecodeBufferWhichRead] == 1) // YUV
{
uint32 *in_ptr = (uint32 *)&DecodeBuffer[DecodeBufferWhichRead][RasterReadPos * 256 * 4];
if (Control & 0x2) // Endless scroll mode:
{
uint8 tmpss = HScroll;
for (int x = 0; x < 256; x++)
{
linebuffer[x] = in_ptr[tmpss] | layer_or;
tmpss++;
}
}
else // Non-endless
{
uint16 tmpss = HScroll & 0x1FF;
for (int x = 0; x < 256; x++)
{
linebuffer[x] = (tmpss < 256) ? (in_ptr[tmpss] | layer_or) : 0;
tmpss = (tmpss + 1) & 0x1FF;
}
}
MDFN_FastArraySet(in_ptr, 0, 256);
}
else if (DecodeFormat[DecodeBufferWhichRead] == 0) // Palette
{
uint8 *in_ptr = &DecodeBuffer[DecodeBufferWhichRead][RasterReadPos * 256];
if (Control & 0x2) // Endless scroll mode:
{
uint8 tmpss = HScroll;
for (int x = 0; x < 256; x++)
{
linebuffer[x] = in_ptr[tmpss] ? (palette_ptr[in_ptr[tmpss]] | layer_or) : 0;
tmpss++;
}
}
else // Non-endless
{
uint16 tmpss = HScroll & 0x1FF;
for (int x = 0; x < 256; x++)
{
linebuffer[x] = (tmpss < 256 && in_ptr[tmpss]) ? (palette_ptr[in_ptr[tmpss]] | layer_or) : 0;
tmpss = (tmpss + 1) & 0x1FF;
}
}
//MDFN_FastU32MemsetM8((uint32 *)in_ptr, 0, 256 / 4);
}
}
RasterReadPos = (RasterReadPos + 1) & 0xF;
if (!RasterReadPos)
DecodeFormat[DecodeBufferWhichRead] = -1; // Invalidate this buffer.
//printf("Fetch: %d, buffer: %d\n", RasterReadPos, DecodeBufferWhichRead);
return (ret);
}
void RAINBOW_Reset(void)
{
Control = 0;
NullRunY = NullRunU = NullRunV = 0;
HScroll = 0;
RasterReadPos = 0;
DecodeBufferWhichRead = 0;
memset(QuantTables, 0, sizeof(QuantTables));
memset(QuantTablesBase, 0, sizeof(QuantTablesBase));
DecodeFormat[0] = DecodeFormat[1] = -1;
CalcHappyColor();
}
}
Reference in New Issue View Git Blame Copy Permalink