blob: 4e22d54631ada895937bbbcf0e91b93de72a46d3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
#include "../copyright"
uint16_t DSP2Op09Word1 = 0;
uint16_t DSP2Op09Word2 = 0;
bool DSP2Op05HasLen = false;
int32_t DSP2Op05Len = 0;
bool DSP2Op06HasLen = false;
int32_t DSP2Op06Len = 0;
uint8_t DSP2Op05Transparent = 0;
void DSP2_Op05(void)
{
uint8_t color;
// Overlay bitmap with transparency.
// Input:
//
// Bitmap 1: i[0] <=> i[size-1]
// Bitmap 2: i[size] <=> i[2*size-1]
//
// Output:
//
// Bitmap 3: o[0] <=> o[size-1]
//
// Processing:
//
// Process all 4-bit pixels (nibbles) in the bitmap
//
// if ( BM2_pixel == transparent_color )
// pixelout = BM1_pixel
// else
// pixelout = BM2_pixel
// The max size bitmap is limited to 255 because the size parameter is a byte
// I think size=0 is an error. The behavior of the chip on size=0 is to
// return the last value written to DR if you read DR on Op05 with
// size = 0. I don't think it's worth implementing this quirk unless it's
// proven necessary.
int32_t n;
uint8_t c1;
uint8_t c2;
uint8_t* p1 = DSP1.parameters;
uint8_t* p2 = &DSP1.parameters[DSP2Op05Len];
uint8_t* p3 = DSP1.output;
color = DSP2Op05Transparent & 0x0f;
for (n = 0; n < DSP2Op05Len; n++)
{
c1 = *p1++;
c2 = *p2++;
*p3++ = (((c2 >> 4) == color) ? c1 & 0xf0 : c2 & 0xf0) | (((c2 & 0x0f) == color) ? c1 & 0x0f : c2 & 0x0f);
}
}
void DSP2_Op01(void)
{
// Op01 size is always 32 bytes input and output.
// The hardware does strange things if you vary the size.
int32_t j;
uint8_t c0, c1, c2, c3;
uint8_t* p1 = DSP1.parameters;
uint8_t* p2a = DSP1.output;
uint8_t* p2b = &DSP1.output[16]; // halfway
// Process 8 blocks of 4 bytes each
for (j = 0; j < 8; j++)
{
c0 = *p1++;
c1 = *p1++;
c2 = *p1++;
c3 = *p1++;
*p2a++ = (c0 & 0x10) << 3 | (c0 & 0x01) << 6 | (c1 & 0x10) << 1 | (c1 & 0x01) << 4 | (c2 & 0x10) >> 1 | (c2 & 0x01) << 2 | (c3 & 0x10) >> 3 | (c3 & 0x01);
*p2a++ = (c0 & 0x20) << 2 | (c0 & 0x02) << 5 | (c1 & 0x20) | (c1 & 0x02) << 3 | (c2 & 0x20) >> 2 | (c2 & 0x02) << 1 | (c3 & 0x20) >> 4 | (c3 & 0x02) >> 1;
*p2b++ = (c0 & 0x40) << 1 | (c0 & 0x04) << 4 | (c1 & 0x40) >> 1 | (c1 & 0x04) << 2 | (c2 & 0x40) >> 3 | (c2 & 0x04) | (c3 & 0x40) >> 5 | (c3 & 0x04) >> 2;
*p2b++ = (c0 & 0x80) | (c0 & 0x08) << 3 | (c1 & 0x80) >> 2 | (c1 & 0x08) << 1 | (c2 & 0x80) >> 4 | (c2 & 0x08) >> 1 | (c3 & 0x80) >> 6 | (c3 & 0x08) >> 3;
}
}
void DSP2_Op06(void)
{
// Input:
// size
// bitmap
int32_t i, j;
for (i = 0, j = DSP2Op06Len - 1; i < DSP2Op06Len; i++, j--)
DSP1.output[j] = (DSP1.parameters[i] << 4) | (DSP1.parameters[i] >> 4);
}
bool DSP2Op0DHasLen = false;
int32_t DSP2Op0DOutLen = 0;
int32_t DSP2Op0DInLen = 0;
// Scale bitmap based on input length out output length
void DSP2_Op0D(void)
{
// (Modified) Overload's algorithm
int32_t i;
for(i = 0 ; i < DSP2Op0DOutLen ; i++)
{
int32_t j = i << 1;
int32_t pixel_offset_low = ((j * DSP2Op0DInLen) / DSP2Op0DOutLen) >> 1;
int32_t pixel_offset_high = (((j + 1) * DSP2Op0DInLen) / DSP2Op0DOutLen) >> 1;
uint8_t pixel_low = DSP1.parameters[pixel_offset_low] >> 4;
uint8_t pixel_high = DSP1.parameters[pixel_offset_high] & 0x0f;
DSP1.output[i] = (pixel_low << 4) | pixel_high;
}
}
|
