![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screenConvert.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to screenConvert.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari
3:
4: Screen conversion routines. We have a number of routines to convert ST screen to PC format.
5: We split these into Low,Medium and High each with 8/16-bit versions. To gain extra speed,
6: as almost half of the processing time can be spent in these routines, we check for any
7: changes from the previously displayed frame. AdjustLinePaletteRemap() sets a flag to
8: tell the routines if we need to totally update a line(ie full update, or palette/res change)
9: or if we just can do a difference check. To see how much of the screen updates each frame, simply
10: enable 'TEST_SCREEN_UPDATE'
11: We convert each screen 16 pixels at a time by use of a couple of look-up tables. These tables
12: convert from 2-plane format to bbp and then we can add two of these together to get 4-planes. This
13: keeps the tables small and thus improves speed. We then look these bbp values up as an RGB/Index value
14: to copy to the screen.
15: */
16:
1.1.1.2 root 17: #include <SDL.h>
18:
1.1 root 19: #include "main.h"
20: #include "screen.h"
21: #include "screenConvert.h"
22: #include "spec512.h"
23: #include "vdi.h"
24: #include "video.h"
25:
1.1.1.3 ! root 26: /*#define TEST_SCREEN_UPDATE*/ /* Enable to see partial screen update */
1.1 root 27:
28: int ScrX,ScrY; /* Locals */
29: int ScrUpdateFlag; /* Bit mask of how to update screen */
30: BOOL bScrDoubleY; /* TRUE if double on Y */
1.1.1.3 ! root 31: Uint32 PixelWorkspace[4]; /* Workspace to store pixels to so can print in right order for Spec512 */
1.1 root 32:
33: /* Remap tables to convert from plane format to byte-per-pixel (Upper is for 4-Planes so if shifted by 2) */
1.1.1.3 ! root 34: Uint32 Remap_2_Planes[256] = {
1.1 root 35: 0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00000100, 0x01000100, 0x00010100, 0x01010100,
36: 0x00000001, 0x01000001, 0x00010001, 0x01010001, 0x00000101, 0x01000101, 0x00010101, 0x01010101,
37: 0x02000000, 0x03000000, 0x02010000, 0x03010000, 0x02000100, 0x03000100, 0x02010100, 0x03010100,
38: 0x02000001, 0x03000001, 0x02010001, 0x03010001, 0x02000101, 0x03000101, 0x02010101, 0x03010101,
39: 0x00020000, 0x01020000, 0x00030000, 0x01030000, 0x00020100, 0x01020100, 0x00030100, 0x01030100,
40: 0x00020001, 0x01020001, 0x00030001, 0x01030001, 0x00020101, 0x01020101, 0x00030101, 0x01030101,
41: 0x02020000, 0x03020000, 0x02030000, 0x03030000, 0x02020100, 0x03020100, 0x02030100, 0x03030100,
42: 0x02020001, 0x03020001, 0x02030001, 0x03030001, 0x02020101, 0x03020101, 0x02030101, 0x03030101,
43: 0x00000200, 0x01000200, 0x00010200, 0x01010200, 0x00000300, 0x01000300, 0x00010300, 0x01010300,
44: 0x00000201, 0x01000201, 0x00010201, 0x01010201, 0x00000301, 0x01000301, 0x00010301, 0x01010301,
45: 0x02000200, 0x03000200, 0x02010200, 0x03010200, 0x02000300, 0x03000300, 0x02010300, 0x03010300,
46: 0x02000201, 0x03000201, 0x02010201, 0x03010201, 0x02000301, 0x03000301, 0x02010301, 0x03010301,
47: 0x00020200, 0x01020200, 0x00030200, 0x01030200, 0x00020300, 0x01020300, 0x00030300, 0x01030300,
48: 0x00020201, 0x01020201, 0x00030201, 0x01030201, 0x00020301, 0x01020301, 0x00030301, 0x01030301,
49: 0x02020200, 0x03020200, 0x02030200, 0x03030200, 0x02020300, 0x03020300, 0x02030300, 0x03030300,
50: 0x02020201, 0x03020201, 0x02030201, 0x03030201, 0x02020301, 0x03020301, 0x02030301, 0x03030301,
51: 0x00000002, 0x01000002, 0x00010002, 0x01010002, 0x00000102, 0x01000102, 0x00010102, 0x01010102,
52: 0x00000003, 0x01000003, 0x00010003, 0x01010003, 0x00000103, 0x01000103, 0x00010103, 0x01010103,
53: 0x02000002, 0x03000002, 0x02010002, 0x03010002, 0x02000102, 0x03000102, 0x02010102, 0x03010102,
54: 0x02000003, 0x03000003, 0x02010003, 0x03010003, 0x02000103, 0x03000103, 0x02010103, 0x03010103,
55: 0x00020002, 0x01020002, 0x00030002, 0x01030002, 0x00020102, 0x01020102, 0x00030102, 0x01030102,
56: 0x00020003, 0x01020003, 0x00030003, 0x01030003, 0x00020103, 0x01020103, 0x00030103, 0x01030103,
57: 0x02020002, 0x03020002, 0x02030002, 0x03030002, 0x02020102, 0x03020102, 0x02030102, 0x03030102,
58: 0x02020003, 0x03020003, 0x02030003, 0x03030003, 0x02020103, 0x03020103, 0x02030103, 0x03030103,
59: 0x00000202, 0x01000202, 0x00010202, 0x01010202, 0x00000302, 0x01000302, 0x00010302, 0x01010302,
60: 0x00000203, 0x01000203, 0x00010203, 0x01010203, 0x00000303, 0x01000303, 0x00010303, 0x01010303,
61: 0x02000202, 0x03000202, 0x02010202, 0x03010202, 0x02000302, 0x03000302, 0x02010302, 0x03010302,
62: 0x02000203, 0x03000203, 0x02010203, 0x03010203, 0x02000303, 0x03000303, 0x02010303, 0x03010303,
63: 0x00020202, 0x01020202, 0x00030202, 0x01030202, 0x00020302, 0x01020302, 0x00030302, 0x01030302,
64: 0x00020203, 0x01020203, 0x00030203, 0x01030203, 0x00020303, 0x01020303, 0x00030303, 0x01030303,
65: 0x02020202, 0x03020202, 0x02030202, 0x03030202, 0x02020302, 0x03020302, 0x02030302, 0x03030302,
66: 0x02020203, 0x03020203, 0x02030203, 0x03030203, 0x02020303, 0x03020303, 0x02030303, 0x03030303,
67: };
1.1.1.3 ! root 68:
! 69: Uint32 Remap_2_Planes_Upper[256] = {
1.1 root 70: 0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00000400, 0x04000400, 0x00040400, 0x04040400,
71: 0x00000004, 0x04000004, 0x00040004, 0x04040004, 0x00000404, 0x04000404, 0x00040404, 0x04040404,
72: 0x08000000, 0x0C000000, 0x08040000, 0x0C040000, 0x08000400, 0x0C000400, 0x08040400, 0x0C040400,
73: 0x08000004, 0x0C000004, 0x08040004, 0x0C040004, 0x08000404, 0x0C000404, 0x08040404, 0x0C040404,
74: 0x00080000, 0x04080000, 0x000C0000, 0x040C0000, 0x00080400, 0x04080400, 0x000C0400, 0x040C0400,
75: 0x00080004, 0x04080004, 0x000C0004, 0x040C0004, 0x00080404, 0x04080404, 0x000C0404, 0x040C0404,
76: 0x08080000, 0x0C080000, 0x080C0000, 0x0C0C0000, 0x08080400, 0x0C080400, 0x080C0400, 0x0C0C0400,
77: 0x08080004, 0x0C080004, 0x080C0004, 0x0C0C0004, 0x08080404, 0x0C080404, 0x080C0404, 0x0C0C0404,
78: 0x00000800, 0x04000800, 0x00040800, 0x04040800, 0x00000C00, 0x04000C00, 0x00040C00, 0x04040C00,
79: 0x00000804, 0x04000804, 0x00040804, 0x04040804, 0x00000C04, 0x04000C04, 0x00040C04, 0x04040C04,
80: 0x08000800, 0x0C000800, 0x08040800, 0x0C040800, 0x08000C00, 0x0C000C00, 0x08040C00, 0x0C040C00,
81: 0x08000804, 0x0C000804, 0x08040804, 0x0C040804, 0x08000C04, 0x0C000C04, 0x08040C04, 0x0C040C04,
82: 0x00080800, 0x04080800, 0x000C0800, 0x040C0800, 0x00080C00, 0x04080C00, 0x000C0C00, 0x040C0C00,
83: 0x00080804, 0x04080804, 0x000C0804, 0x040C0804, 0x00080C04, 0x04080C04, 0x000C0C04, 0x040C0C04,
84: 0x08080800, 0x0C080800, 0x080C0800, 0x0C0C0800, 0x08080C00, 0x0C080C00, 0x080C0C00, 0x0C0C0C00,
85: 0x08080804, 0x0C080804, 0x080C0804, 0x0C0C0804, 0x08080C04, 0x0C080C04, 0x080C0C04, 0x0C0C0C04,
86: 0x00000008, 0x04000008, 0x00040008, 0x04040008, 0x00000408, 0x04000408, 0x00040408, 0x04040408,
87: 0x0000000C, 0x0400000C, 0x0004000C, 0x0404000C, 0x0000040C, 0x0400040C, 0x0004040C, 0x0404040C,
88: 0x08000008, 0x0C000008, 0x08040008, 0x0C040008, 0x08000408, 0x0C000408, 0x08040408, 0x0C040408,
89: 0x0800000C, 0x0C00000C, 0x0804000C, 0x0C04000C, 0x0800040C, 0x0C00040C, 0x0804040C, 0x0C04040C,
90: 0x00080008, 0x04080008, 0x000C0008, 0x040C0008, 0x00080408, 0x04080408, 0x000C0408, 0x040C0408,
91: 0x0008000C, 0x0408000C, 0x000C000C, 0x040C000C, 0x0008040C, 0x0408040C, 0x000C040C, 0x040C040C,
92: 0x08080008, 0x0C080008, 0x080C0008, 0x0C0C0008, 0x08080408, 0x0C080408, 0x080C0408, 0x0C0C0408,
93: 0x0808000C, 0x0C08000C, 0x080C000C, 0x0C0C000C, 0x0808040C, 0x0C08040C, 0x080C040C, 0x0C0C040C,
94: 0x00000808, 0x04000808, 0x00040808, 0x04040808, 0x00000C08, 0x04000C08, 0x00040C08, 0x04040C08,
95: 0x0000080C, 0x0400080C, 0x0004080C, 0x0404080C, 0x00000C0C, 0x04000C0C, 0x00040C0C, 0x04040C0C,
96: 0x08000808, 0x0C000808, 0x08040808, 0x0C040808, 0x08000C08, 0x0C000C08, 0x08040C08, 0x0C040C08,
97: 0x0800080C, 0x0C00080C, 0x0804080C, 0x0C04080C, 0x08000C0C, 0x0C000C0C, 0x08040C0C, 0x0C040C0C,
98: 0x00080808, 0x04080808, 0x000C0808, 0x040C0808, 0x00080C08, 0x04080C08, 0x000C0C08, 0x040C0C08,
99: 0x0008080C, 0x0408080C, 0x000C080C, 0x040C080C, 0x00080C0C, 0x04080C0C, 0x000C0C0C, 0x040C0C0C,
100: 0x08080808, 0x0C080808, 0x080C0808, 0x0C0C0808, 0x08080C08, 0x0C080C08, 0x080C0C08, 0x0C0C0C08,
101: 0x0808080C, 0x0C08080C, 0x080C080C, 0x0C0C080C, 0x08080C0C, 0x0C080C0C, 0x080C0C0C, 0x0C0C0C0C,
102: };
1.1.1.3 ! root 103:
! 104: Uint32 Remap_1_Plane[16] = {
1.1 root 105: 0x00000000+BASECOLOUR_LONG, 0x01000000+BASECOLOUR_LONG, 0x00010000+BASECOLOUR_LONG, 0x01010000+BASECOLOUR_LONG, 0x00000100+BASECOLOUR_LONG, 0x01000100+BASECOLOUR_LONG, 0x00010100+BASECOLOUR_LONG, 0x01010100+BASECOLOUR_LONG,
106: 0x00000001+BASECOLOUR_LONG, 0x01000001+BASECOLOUR_LONG, 0x00010001+BASECOLOUR_LONG, 0x01010001+BASECOLOUR_LONG, 0x00000101+BASECOLOUR_LONG, 0x01000101+BASECOLOUR_LONG, 0x00010101+BASECOLOUR_LONG, 0x01010101+BASECOLOUR_LONG,
107: };
108:
1.1.1.2 root 109:
110: /*-----------------------------------------------------------------------*/
1.1 root 111: /*
112: Update the STRGBPalette[] array with current colours for this raster line.
113:
1.1.1.2 root 114: Return 'ScrUpdateFlag', 0x80000000=Full update, 0x40000000=Update as palette changed
1.1 root 115: */
116: int AdjustLinePaletteRemap(void)
117: {
1.1.1.2 root 118: unsigned short *actHBLPal;
119: static int endiantable[16] = {0,2,1,3,8,10,9,11,4,6,5,7,12,14,13,15};
120: int i;
121: int v;
122: /* Copy palette and convert to RGB in display format */
123: actHBLPal = pHBLPalettes + (ScrY<<4); /* offset in palette */
124: for(i=0; i<16; i++)
125: {
126: v=*actHBLPal;
127: actHBLPal+=1;
128: v=v&0x777;
1.1.1.3 ! root 129: #if SDL_BYTEORDER == SDL_BIG_ENDIAN
1.1.1.2 root 130: STRGBPalette[endiantable[i]] = ST2RGB[v];
131: #else
132: STRGBPalette[i] = ST2RGB[v];
133: #endif
134: }
1.1.1.3 ! root 135: ScrUpdateFlag = HBLPaletteMasks[ScrY];
1.1.1.2 root 136: return ScrUpdateFlag;
1.1 root 137: }
138:
1.1.1.2 root 139:
140: /*-----------------------------------------------------------------------*/
1.1 root 141: /*
142: Run updates to palette(STRGBPalette[]) until get to screen line we are to convert from
143: */
144: void Convert_StartFrame(void)
145: {
146: int ecx;
147: ecx=STScreenStartHorizLine; /* Get #lines before conversion starts */
148: if( ecx==0 ) return;
149: ScrY=0;
150: do
151: {
152: AdjustLinePaletteRemap(); /* Update palette */
153: ++ScrY;
154: --ecx;
155: }
156: while( ecx );
157: }
158:
159:
160:
161:
162:
163: #define LOW_BUILD_PIXELS_0 \
164: { \
165: ebx &= 0x0f0f0f0f; \
166: ecx &= 0x0f0f0f0f; \
167: eax = ebx >> 12; \
168: eax |= ebx; \
169: edx = ecx >> 12; \
170: edx |= ecx; \
171: ebx = edx; \
172: ebx &= 0x00ff; \
173: ecx = Remap_2_Planes_Upper[ebx]; \
174: ebx = eax; \
175: ebx &= 0x00ff; \
176: ecx += Remap_2_Planes[ebx]; \
177: }
178:
179: #define LOW_BUILD_PIXELS_1 \
180: { \
181: ebx = edx; \
182: ebx = ebx >> 8; \
183: ebx &= 0x00ff; \
184: ecx = Remap_2_Planes_Upper[ebx]; \
185: ebx = eax; \
186: ebx = ebx >> 8; \
187: ebx &= 0x00ff; \
188: ecx += Remap_2_Planes[ebx]; \
189: }
190:
191: #define LOW_BUILD_PIXELS_2 \
192: { \
193: ebx = *edi; \
194: ecx = *(edi+1); \
195: ebx &= 0xf0f0f0f0; \
196: ecx &= 0xf0f0f0f0; \
197: ebx = ebx >> 4; \
198: eax = ebx; \
199: ebx = ebx >> 12; \
200: eax |= ebx; \
201: ecx = ecx >> 4; \
202: edx = ecx; \
203: ecx = ecx >> 12; \
204: edx |= ecx; \
205: ebx = edx; \
206: ebx &= 0x00ff; \
207: ecx = Remap_2_Planes_Upper[ebx]; \
208: ebx = eax; \
209: ebx &= 0x00ff; \
210: ecx += Remap_2_Planes[ebx]; \
211: }
212:
213: #define LOW_BUILD_PIXELS_3 \
214: { \
215: ebx = edx; \
216: ebx = ebx >> 8; \
217: ebx &= 0x00ff; \
218: ecx = Remap_2_Planes_Upper[ebx]; \
219: ebx = eax; \
220: ebx = ebx >> 8; \
221: ebx &= 0x00ff; \
222: ecx += Remap_2_Planes[ebx]; \
223: }
224:
1.1.1.2 root 225:
226: #define MED_BUILD_PIXELS_0 \
227: { \
228: ebx &= 0x0f0f0f0f; \
229: eax = ebx; \
230: eax >>= 12; \
231: eax |= ebx; \
232: ebx = eax; \
233: ebx &= 0x000000ff; \
234: ecx = Remap_2_Planes[ebx]; \
235: }
236:
237: #define MED_BUILD_PIXELS_1 \
238: { \
239: ebx = eax; \
240: ebx >>=8; \
241: ebx &= 0x000000ff; \
242: ecx = Remap_2_Planes[ebx]; \
243: }
244:
245: #define MED_BUILD_PIXELS_2 \
246: { \
247: ebx = *edi; \
248: ebx &= 0xf0f0f0f0; \
249: ebx >>= 4; \
250: eax = ebx; \
251: ebx >>= 12; \
252: eax |= ebx; \
253: ebx = eax; \
254: ebx &= 0x000000ff; \
255: ecx = Remap_2_Planes[ebx]; \
256: }
257:
258: #define MED_BUILD_PIXELS_3 \
259: { \
260: ebx = eax; \
261: ebx >>= 8; \
262: ebx &= 0x000000ff; \
263: ecx = Remap_2_Planes[ebx]; \
264: }
265:
1.1.1.3 ! root 266:
! 267: /* Routines to create 'ecx' pixels - MUST be called in this order */
! 268: #define HIGH_BUILD_PIXELS_0 \
! 269: { \
! 270: eax = ebx; \
! 271: eax &= 0x0000000f; \
! 272: }
! 273: /*
! 274: __asm mov eax,ebx \
! 275: __asm and eax,0x0000000f
! 276: */
! 277:
! 278: #define HIGH_BUILD_PIXELS_1 \
! 279: { \
! 280: eax = ebx; \
! 281: eax >>= 4; \
! 282: eax &= 0x0000000f;\
! 283: }
! 284: /*
! 285: __asm mov eax,ebx \
! 286: __asm shr eax,4 \
! 287: __asm and eax,0x0000000f
! 288: */
! 289:
! 290: #define HIGH_BUILD_PIXELS_2 \
! 291: { \
! 292: eax = ebx; \
! 293: eax >>= 8; \
! 294: eax &= 0x0000000f;\
! 295: }
! 296: /*
! 297: __asm mov eax,ebx \
! 298: __asm shr eax,8 \
! 299: __asm and eax,0x0000000f
! 300: */
! 301:
! 302: #define HIGH_BUILD_PIXELS_3 \
! 303: { \
! 304: eax = ebx; \
! 305: eax >>= 12; \
! 306: eax &= 0x0000000f;\
! 307: }
! 308: /*
! 309: __asm mov eax,ebx \
! 310: __asm shr eax,12 \
! 311: __asm and eax,0x0000000f
! 312: */
! 313:
! 314:
! 315: /* Plot Low Resolution (320xH) 16-Bit pixels */
! 316: #define PLOT_LOW_320_16BIT(offset) \
! 317: { \
! 318: ebx = ecx; \
! 319: ebx &= 0x00ff; \
! 320: ecx = ecx >> 8; \
! 321: ebx = STRGBPalette[ebx]; \
! 322: esi[offset] = (unsigned short) ebx; \
! 323: ebx = ecx; \
! 324: ebx &= 0x00ff; \
! 325: ecx = ecx >> 8; \
! 326: ebx = STRGBPalette[ebx]; \
! 327: esi[offset+1] = (unsigned short) ebx; \
! 328: ebx = ecx; \
! 329: ebx &= 0x00ff; \
! 330: ecx = ecx >> 8; \
! 331: ebx = STRGBPalette[ebx]; \
! 332: esi[offset+2] = (unsigned short) ebx; \
! 333: ebx = ecx; \
! 334: ebx &= 0x00ff; \
! 335: ebx = STRGBPalette[ebx]; \
! 336: esi[offset+3] = (unsigned short) ebx; \
! 337: }
! 338:
! 339: /* Plot Low Resolution (640xH) 16-Bit pixels */
! 340: #define PLOT_LOW_640_16BIT(offset) \
! 341: { \
! 342: ebx = ecx; \
! 343: ebx &= 0x000000ff; \
! 344: ecx >>= 8; \
! 345: ebx = STRGBPalette[ebx]; \
! 346: esi[offset] = ebx; \
! 347: ebx = ecx; \
! 348: ebx &= 0x000000ff; \
! 349: ecx >>= 8; \
! 350: ebx = STRGBPalette[ebx]; \
! 351: esi[offset+1] = ebx; \
! 352: ebx = ecx; \
! 353: ebx &= 0x000000ff; \
! 354: ecx >>= 8; \
! 355: ebx = STRGBPalette[ebx]; \
! 356: esi[offset+2] = ebx; \
! 357: ebx = ecx; \
! 358: ebx &= 0x000000ff; \
! 359: ebx = STRGBPalette[ebx]; \
! 360: esi[offset+3] = ebx; \
! 361: }
! 362:
! 363: /* Plot Low Resolution (640xH) 16-Bit pixels (Double on Y) */
! 364: #define PLOT_LOW_640_16BIT_DOUBLE_Y(offset) \
! 365: { \
! 366: ebx = ecx; \
! 367: ebx &= 0x000000ff; \
! 368: ecx >>= 8; \
! 369: ebx = STRGBPalette[ebx]; \
! 370: esi[offset] = ebx; \
! 371: esi[offset+PCScreenBytesPerLine/4] = ebx; \
! 372: ebx = ecx; \
! 373: ebx &= 0x000000ff; \
! 374: ecx >>= 8; \
! 375: ebx = STRGBPalette[ebx]; \
! 376: esi[offset+1] = ebx; \
! 377: esi[offset+1+PCScreenBytesPerLine/4] = ebx; \
! 378: ebx = ecx; \
! 379: ebx &= 0x000000ff; \
! 380: ecx >>= 8; \
! 381: ebx = STRGBPalette[ebx]; \
! 382: esi[offset+2] = ebx; \
! 383: esi[offset+2+PCScreenBytesPerLine/4] = ebx; \
! 384: ebx = ecx; \
! 385: ebx &= 0x000000ff; \
! 386: ebx = STRGBPalette[ebx]; \
! 387: esi[offset+3] = ebx; \
! 388: esi[offset+3+PCScreenBytesPerLine/4] = ebx; \
! 389: }
! 390:
! 391:
1.1.1.2 root 392: /* Plot Medium Resolution(640xH) 16-Bit pixels */
393: #define PLOT_MED_640_16BIT(offset) \
394: { \
395: ebx = ecx; \
396: ebx &= 0x000000ff; \
397: ecx >>= 8; \
398: ebx = STRGBPalette[ebx]; \
399: esi[offset] = (Uint16)ebx; \
400: ebx = ecx; \
401: ebx &= 0x000000ff; \
402: ecx >>= 8; \
403: ebx = STRGBPalette[ebx]; \
404: esi[offset+1] = (Uint16)ebx; \
405: ebx = ecx; \
406: ebx &= 0x000000ff; \
407: ecx >>= 8; \
408: ebx = STRGBPalette[ebx]; \
409: esi[offset+2] = (Uint16)ebx; \
410: ebx = ecx; \
411: ebx &= 0x000000ff; \
412: ebx = STRGBPalette[ebx]; \
413: esi[offset+3] = (Uint16)ebx; \
414: }
415:
416: /* Plot Medium Resolution(640xH) 16-Bit pixels (Double on Y) */
417: #define PLOT_MED_640_16BIT_DOUBLE_Y(offset) \
418: { \
419: ebx = ecx; \
420: ebx &= 0x000000ff; \
421: ecx >>= 8; \
422: ebx = STRGBPalette[ebx]; \
423: esi[offset] = (Uint16)ebx; \
1.1.1.3 ! root 424: esi[offset+PCScreenBytesPerLine/2] = (Uint16)ebx; \
1.1.1.2 root 425: ebx = ecx; \
426: ebx &= 0x000000ff; \
427: ecx >>= 8; \
428: ebx = STRGBPalette[ebx]; \
429: esi[offset+1] = (Uint16)ebx; \
1.1.1.3 ! root 430: esi[offset+1+PCScreenBytesPerLine/2] = (Uint16)ebx; \
1.1.1.2 root 431: ebx = ecx; \
432: ebx &= 0x000000ff; \
433: ecx >>= 8; \
434: ebx = STRGBPalette[ebx]; \
435: esi[offset+2] = (Uint16)ebx; \
1.1.1.3 ! root 436: esi[offset+2+PCScreenBytesPerLine/2] = (Uint16)ebx; \
1.1.1.2 root 437: ebx = ecx; \
438: ebx &= 0x000000ff; \
439: ebx = STRGBPalette[ebx]; \
440: esi[offset+3] = (Uint16)ebx; \
1.1.1.3 ! root 441: esi[offset+3+PCScreenBytesPerLine/2] = (Uint16)ebx; \
! 442: }
! 443:
! 444:
! 445: /* Plot High Resolution (640xH) 8-Bit pixels */
! 446: #define PLOT_HIGH_640_8BIT(offset) \
! 447: { \
! 448: esi[offset] = Remap_1_Plane[eax]; \
1.1.1.2 root 449: }
450:
451:
452: /* Plot Spectrum512 Resolution(320xH) 16-Bit pixels */
453: #define PLOT_SPEC512_LEFT_LOW_320_16BIT(offset) \
454: { \
455: ecx &= 0x000000ff; \
456: ebx = STRGBPalette[ecx]; \
457: esi[offset] = (Uint16)ebx; \
458: }
459:
460: /* Plot Spectrum512 Resolution(320xH) 16-Bit pixels */
461: #define PLOT_SPEC512_MID_320_16BIT(offset) \
462: { \
463: ebx = ecx; \
464: ebx &= 0x000000ff; \
465: ecx >>= 8; \
466: ebx = STRGBPalette[ebx]; \
467: esi[offset] = (Uint16)ebx; \
468: ebx = ecx; \
469: ebx &= 0x000000ff; \
470: ecx >>= 8; \
471: ebx = STRGBPalette[ebx]; \
472: esi[offset+1] = (Uint16)ebx; \
473: ebx = ecx; \
474: ebx &= 0x000000ff; \
475: ecx >>= 8; \
476: ebx = STRGBPalette[ebx]; \
477: esi[offset+2] = (Uint16)ebx; \
478: ebx = ecx; \
479: ebx &= 0x000000ff; \
480: ebx = STRGBPalette[ebx]; \
481: esi[offset+3] = (Uint16)ebx; \
482: }
483:
484: /* Plot Spectrum512 Resolution(320xH) 16-Bit pixels */
485: #define PLOT_SPEC512_END_LOW_320_16BIT(offset) \
486: { \
487: ebx = ecx; \
488: ebx &= 0x000000ff; \
489: ecx >>= 8; \
490: ebx = STRGBPalette[ebx]; \
491: esi[offset] = (Uint16)ebx; \
492: ebx = ecx; \
493: ebx &= 0x000000ff; \
494: ecx >>= 8; \
495: ebx = STRGBPalette[ebx]; \
496: esi[offset+1] = (Uint16)ebx; \
497: ebx = ecx; \
498: ebx &= 0x000000ff; \
499: ecx >>= 8; \
500: ebx = STRGBPalette[ebx]; \
501: esi[offset+2] = (Uint16)ebx; \
502: }
1.1 root 503:
504:
505:
506: /* Conversion routines */
507: #include "convert/low320x16.c" /* LowRes To 320xH x 16-bit colour */
508: #include "convert/low640x16.c" /* LowRes To 640xH x 16-bit colour */
509: #include "convert/med640x16.c" /* MediumRes To 640xH x 16-bit colour */
510: #include "convert/low320x8.c" /* LowRes To 320xH x 8-bit colour */
511: #include "convert/low640x8.c" /* LowRes To 640xH x 8-bit colour */
512: #include "convert/med640x8.c" /* MediumRes To 640xH x 8-bit colour */
513: #include "convert/high640x8.c" /* HighRes To 640xH x 8-bit colour */
514: #include "convert/high640x1.c" /* HighRes To 640xH x 1-bit colour */
515: #include "convert/spec320x16.c" /* Spectrum 512 To 320xH x 16-bit colour */
516: #include "convert/spec640x16.c" /* Spectrum 512 To 640xH x 16-bit colour */
517:
518: #include "convert/vdi16.c" /* VDI x 16 colour */
519: #include "convert/vdi4.c" /* VDI x 4 colour */
520: #include "convert/vdi2.c" /* VDI x 2 colour */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.