![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to videl.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 / falcon|
Return to videl.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / falcon |
1.1 root 1: /*
2: Hatari - videl.c
3:
4: This file is distributed under the GNU Public License, version 2 or at
5: your option any later version. Read the file gpl.txt for details.
6:
7: Falcon Videl emulation. The Videl is the graphics shifter chip of the Falcon.
8: It supports free programmable resolutions with 1, 2, 4, 8 or 16 bits per
9: pixel.
10:
11: This file originally came from the Aranym project and has been heavily
12: modified to work for Hatari (but the kudos for the great Videl emulation
13: code goes to the people from the Aranym project of course).
14: */
15: const char VIDEL_rcsid[] = "Hatari $Id: videl.c,v 1.17 2007/12/18 20:35:55 thothy Exp $";
16:
17: #include "main.h"
18: #include "configuration.h"
19: #include "ioMem.h"
20: #include "hostscreen.h"
21: #include "screen.h"
22: #include "stMemory.h"
23: #include "video.h"
24: #include "videl.h"
25: #include <SDL_endian.h>
26:
27:
28: #define handleRead(a) IoMem_ReadByte(a)
29: #define handleReadW(a) IoMem_ReadWord(a)
30: #define Atari2HostAddr(a) (&STRam[a])
31:
32: #define VIDEL_DEBUG 0
33:
34: #if VIDEL_DEBUG
35: #define Dprintf(a) printf a
36: #else
37: #define Dprintf(a)
38: #endif
39:
40: #define HW 0xff8200
41: #define VIDEL_COLOR_REGS_BEGIN 0xff9800
42: #define VIDEL_COLOR_REGS_END 0xffa200
43:
44:
45: static int width, height, bpp, since_last_change;
46: static BOOL hostColorsSync;
47:
48: /* Autozoom */
49: static int zoomwidth, prev_scrwidth;
50: static int zoomheight, prev_scrheight;
51: static int *zoomxtable;
52: static int *zoomytable;
53:
54: static void VIDEL_renderScreenNoZoom(void);
55: static void VIDEL_renderScreenZoom(void);
56:
57:
58: // Called upon startup and when CPU encounters a RESET instruction.
59: void VIDEL_reset(void)
60: {
61: since_last_change = 0;
62:
63: hostColorsSync = FALSE;
64:
65: /* Autozoom */
66: zoomwidth=prev_scrwidth=0;
67: zoomheight=prev_scrheight=0;
68: zoomxtable=NULL;
69: zoomytable=NULL;
70:
71: // default resolution to boot with
72: width = 640;
73: height = 480;
74: HostScreen_setWindowSize( width, height, 8 );
75: }
76:
77: // monitor write access to Falcon and ST/E color palette registers
78: void VIDEL_ColorRegsWrite(void)
79: {
80: hostColorsSync = FALSE;
81: }
82:
83: void VIDEL_ShiftModeWriteWord(void)
84: {
85: Dprintf(("VIDEL f_shift: %06x = 0x%x\n", IoAccessBaseAddress, handleReadW(HW+0x66)));
86: bUseSTShifter = FALSE;
87: }
88:
89: static long VIDEL_getVideoramAddress(void)
90: {
91: return (handleRead(HW + 1) << 16) | (handleRead(HW + 3) << 8) | handleRead(HW + 0x0d);
92: }
93:
94: static int VIDEL_getScreenBpp(void)
95: {
96: int f_shift = handleReadW(HW + 0x66);
97: int st_shift = handleRead(HW + 0x60);
98: /* to get bpp, we must examine f_shift and st_shift.
99: * f_shift is valid if any of bits no. 10, 8 or 4
100: * is set. Priority in f_shift is: 10 ">" 8 ">" 4, i.e.
101: * if bit 10 set then bit 8 and bit 4 don't care...
102: * If all these bits are 0 and ST shifter is written
103: * after Falcon one, get display depth from st_shift
104: * (as for ST and STE)
105: */
106: int bits_per_pixel;
107: if (f_shift & 0x400) /* Falcon: 2 colors */
108: bits_per_pixel = 1;
109: else if (f_shift & 0x100) /* Falcon: hicolor */
110: bits_per_pixel = 16;
111: else if (f_shift & 0x010) /* Falcon: 8 bitplanes */
112: bits_per_pixel = 8;
113: else if (!bUseSTShifter) /* Falcon: 4 bitplanes */
114: bits_per_pixel = 4;
115: else if (st_shift == 0)
116: bits_per_pixel = 4;
117: else if (st_shift == 0x01)
118: bits_per_pixel = 2;
119: else /* if (st_shift == 0x02) */
120: bits_per_pixel = 1;
121:
122: // Dprintf(("Videl works in %d bpp, f_shift=%04x, st_shift=%d", bits_per_pixel, f_shift, st_shift));
123:
124: return bits_per_pixel;
125: }
126:
127: static int VIDEL_getScreenWidth(void)
128: {
129: return handleReadW(HW + 0x10) * 16 / VIDEL_getScreenBpp();
130: }
131:
132: static int VIDEL_getScreenHeight(void)
133: {
134: int vdb = handleReadW(HW + 0xa8);
135: int vde = handleReadW(HW + 0xaa);
136: int vmode = handleReadW(HW + 0xc2);
137:
138: /* visible y resolution:
139: * Graphics display starts at line VDB and ends at line
140: * VDE. If interlace mode off unit of VC-registers is
141: * half lines, else lines.
142: */
143: int yres = vde - vdb;
144: if (!(vmode & 0x02)) // interlace
145: yres >>= 1;
146: if (vmode & 0x01) // double
147: yres >>= 1;
148:
149: return yres;
150: }
151:
152:
153: /** map the correct colortable into the correct pixel format
154: */
155: static void VIDEL_updateColors(void)
156: {
157: //Dprintf(("ColorUpdate in progress\n"));
158:
159: int i, r, g, b, colors = 1 << bpp;
160:
161: #define F_COLORS(i) handleRead(VIDEL_COLOR_REGS_BEGIN + (i))
162: #define STE_COLORS(i) handleRead(0xff8240 + (i))
163:
164: if (!bUseSTShifter) {
165: for (i = 0; i < colors; i++) {
166: int offset = i << 2;
167: r = F_COLORS(offset) & 0xfc;
168: r |= r>>6;
169: g = F_COLORS(offset + 1) & 0xfc;
170: g |= g>>6;
171: b = F_COLORS(offset + 3) & 0xfc;
172: b |= b>>6;
173: HostScreen_setPaletteColor(i, r,g,b);
174: }
175: HostScreen_updatePalette(colors);
176: } else {
177: for (i = 0; i < colors; i++) {
178: int offset = i << 1;
179: r = STE_COLORS(offset) & 0x0f;
180: r = ((r & 7)<<1)|(r>>3);
181: r |= r<<4;
182: g = (STE_COLORS(offset + 1)>>4) & 0x0f;
183: g = ((g & 7)<<1)|(g>>3);
184: g |= g<<4;
185: b = STE_COLORS(offset + 1) & 0x0f;
186: b = ((b & 7)<<1)|(b>>3);
187: b |= b<<4;
188: HostScreen_setPaletteColor(i, r,g,b);
189: }
190: HostScreen_updatePalette(colors);
191: }
192:
193: hostColorsSync = TRUE;
194: }
195:
196:
197: void VIDEL_ZoomModeChanged(void)
198: {
199: /* User selected another zoom mode, so set a new screen resolution now */
200: HostScreen_setWindowSize(width, height, bpp >= 8 ? bpp : 8);
201: }
202:
203:
204: void VIDEL_renderScreen(void)
205: {
206: int vw = VIDEL_getScreenWidth();
207: int vh = VIDEL_getScreenHeight();
208: int vbpp = VIDEL_getScreenBpp();
209:
210: if (since_last_change > 2) {
211: if (vw > 0 && vw != width) {
212: Dprintf(("CH width %d\n", width));
213: width = vw;
214: since_last_change = 0;
215: }
216: if (vh > 0 && vh != height) {
217: Dprintf(("CH height %d\n", width));
218: height = vh;
219: since_last_change = 0;
220: }
221: if (vbpp != bpp) {
222: Dprintf(("CH bpp %d\n", vbpp));
223: bpp = vbpp;
224: since_last_change = 0;
225: }
226: }
227: if (since_last_change == 3) {
228: HostScreen_setWindowSize( width, height, bpp >= 8 ? bpp : 8 );
229: }
230: if (since_last_change < 4) {
231: since_last_change++;
232: return;
233: }
234:
235: if (!HostScreen_renderBegin())
236: return;
237:
238: if (ConfigureParams.Screen.bZoomLowRes) {
239: VIDEL_renderScreenZoom();
240: } else {
241: VIDEL_renderScreenNoZoom();
242: }
243:
244: HostScreen_renderEnd();
245:
246: HostScreen_update1( FALSE );
247: }
248:
249:
250: static void VIDEL_renderScreenNoZoom(void)
251: {
252: int vw = VIDEL_getScreenWidth();
253: int vh = VIDEL_getScreenHeight();
254:
255: int lineoffset = handleReadW(HW + 0x0e) & 0x01ff; // 9 bits
256: int linewidth = handleReadW(HW + 0x10) & 0x03ff; // 10 bits
257: /*
258: I think this implementation is naive:
259: indeed, I suspect that we should instead skip lineoffset
260: words each time we have read "more" than linewidth words
261: (possibly "more" because of the number of bit planes).
262: Moreover, the 1 bit plane mode is particular;
263: while doing some experiments on my Falcon, it seems to
264: behave like the 4 bit planes mode.
265: At last, we have also to take into account the 4 bits register
266: located at the word $ffff8264 (bit offset). This register makes
267: the semantics of the lineoffset register change a little.
268: int bitoffset = handleReadW(HW + 0x64) & 0x000f;
269: The meaning of this register in True Color mode is not clear
270: for me at the moment (and my experiments on the Falcon don't help
271: me).
272: */
273: int nextline = linewidth + lineoffset;
274:
275: if (bpp < 16 && !hostColorsSync) {
276: VIDEL_updateColors();
277: }
278:
279: VIDEL_ConvertScreenNoZoom(vw, vh, bpp, nextline);
280: }
281:
282:
283: void VIDEL_ConvertScreenNoZoom(int vw, int vh, int vbpp, int nextline)
284: {
285: int scrpitch = HostScreen_getPitch();
286:
287: long atariVideoRAM = VIDEL_getVideoramAddress();
288:
289: uint16 *fvram = (uint16 *) Atari2HostAddr(atariVideoRAM);
290: uint8 *hvram = HostScreen_getVideoramAddress();
291:
292: int hscrolloffset = (handleRead(HW + 0x65) & 0x0f);
293:
294: /* Clip to SDL_Surface dimensions */
295: int scrwidth = HostScreen_getWidth();
296: int scrheight = HostScreen_getHeight();
297: int vw_clip = vw;
298: int vh_clip = vh;
299: if (vw>scrwidth) vw_clip = scrwidth;
300: if (vh>scrheight) vh_clip = scrheight;
301:
302: /* Horizontal scroll register set? */
303: if (hscrolloffset) {
304: /* Yes, so we need to adjust offset to next line: */
305: nextline += vbpp;
306: }
307:
308: /* Center screen */
309: hvram += ((scrheight-vh_clip)>>1)*scrpitch;
310: hvram += ((scrwidth-vw_clip)>>1)*HostScreen_getBpp();
311:
312: /* Render */
313: if (vbpp < 16) {
314: /* Bitplanes modes */
315:
316: // The SDL colors blitting...
317: uint8 color[16];
318:
319: // FIXME: The byte swap could be done here by enrolling the loop into 2 each by 8 pixels
320: switch ( HostScreen_getBpp() ) {
321: case 1:
322: {
323: uint16 *fvram_line = fvram;
324: uint8 *hvram_line = hvram;
325: int h;
326:
327: for (h = 0; h < vh_clip; h++) {
328: uint16 *fvram_column = fvram_line;
329: uint8 *hvram_column = hvram_line;
330: int w;
331:
332: /* First 16 pixels: */
333: HostScreen_bitplaneToChunky(fvram_column, vbpp, color);
334: memcpy(hvram_column, color+hscrolloffset, 16-hscrolloffset);
335: hvram_column += 16-hscrolloffset;
336: fvram_column += vbpp;
337: /* Now the main part of the line: */
338: for (w = 1; w < (vw_clip+15)>>4; w++) {
339: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
340: memcpy(hvram_column, color, 16);
341: hvram_column += 16;
342: fvram_column += vbpp;
343: }
344: /* Last pixels of the line for fine scrolling: */
345: if (hscrolloffset) {
346: HostScreen_bitplaneToChunky(fvram_column, vbpp, color);
347: memcpy(hvram_column, color, hscrolloffset);
348: }
349:
350: hvram_line += scrpitch;
351: fvram_line += nextline;
352: }
353: }
354: break;
355: case 2:
356: {
357: uint16 *fvram_line = fvram;
358: uint16 *hvram_line = (uint16 *)hvram;
359: int h;
360:
361: for (h = 0; h < vh_clip; h++) {
362: uint16 *fvram_column = fvram_line;
363: uint16 *hvram_column = hvram_line;
364: int w;
365:
366: for (w = 0; w < (vw_clip+15)>>4; w++) {
367: int j;
368: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
369:
370: for (j=0; j<16; j++) {
371: *hvram_column++ = HostScreen_getPaletteColor( color[j] );
372: }
373:
374: fvram_column += vbpp;
375: }
376:
377: hvram_line += scrpitch>>1;
378: fvram_line += nextline;
379: }
380: }
381: break;
382: case 3:
383: {
384: uint16 *fvram_line = fvram;
385: uint8 *hvram_line = hvram;
386: int h;
387:
388: for (h = 0; h < vh_clip; h++) {
389: uint16 *fvram_column = fvram_line;
390: uint8 *hvram_column = hvram_line;
391: int w;
392:
393: for (w = 0; w < (vw_clip+15)>>4; w++) {
394: int j;
395: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
396:
397: for (j=0; j<16; j++) {
398: uint32 tmpColor = HostScreen_getPaletteColor( color[j] );
399: putBpp24Pixel( hvram_column, tmpColor );
400: hvram_column += 3;
401: }
402:
403: fvram_column += vbpp;
404: }
405:
406: hvram_line += scrpitch;
407: fvram_line += nextline;
408: }
409: }
410: break;
411: case 4:
412: {
413: uint16 *fvram_line = fvram;
414: uint32 *hvram_line = (uint32 *)hvram;
415: int h;
416:
417: for (h = 0; h < vh_clip; h++) {
418: uint16 *fvram_column = fvram_line;
419: uint32 *hvram_column = hvram_line;
420: int w;
421:
422: for (w = 0; w < (vw_clip+15)>>4; w++) {
423: int j;
424: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
425:
426: for (j=0; j<16; j++) {
427: *hvram_column++ = HostScreen_getPaletteColor( color[j] );
428: }
429:
430: fvram_column += vbpp;
431: }
432:
433: hvram_line += scrpitch>>2;
434: fvram_line += nextline;
435: }
436: }
437: break;
438: }
439:
440: } else {
441:
442: // Falcon TC (High Color)
443: switch ( HostScreen_getBpp() ) {
444: case 1:
445: {
446: /* FIXME: when Videl switches to 16bpp, set the palette to 3:3:2 */
447: uint16 *fvram_line = fvram;
448: uint8 *hvram_line = hvram;
449: int h;
450:
451: for (h = 0; h < vh_clip; h++) {
452: uint16 *fvram_column = fvram_line;
453: uint8 *hvram_column = hvram_line;
454: int w, tmp;
455:
456: for (w = 0; w < vw_clip; w++) {
457:
458: tmp = SDL_SwapBE16(*fvram_column);
459:
460: *hvram_column = ((tmp>>13) & 7) << 5;
461: *hvram_column |= ((tmp>>8) & 7) << 2;
462: *hvram_column |= ((tmp>>2) & 3);
463:
464: hvram_column++;
465: fvram_column++;
466: }
467:
468: hvram_line += scrpitch;
469: fvram_line += nextline;
470: }
471: }
472: break;
473: case 2:
474: {
475: uint16 *fvram_line = fvram;
476: uint16 *hvram_line = (uint16 *)hvram;
477: int h;
478:
479: for (h = 0; h < vh_clip; h++) {
480: #if SDL_BYTEORDER == SDL_BIG_ENDIAN
481: //FIXME: here might be a runtime little/big video endian switch like:
482: // if ( /* videocard memory in Motorola endian format */ false)
483: memcpy(hvram_line, fvram_line, vw_clip<<1);
484: #else
485: int w;
486: uint16 *fvram_column = fvram_line;
487: uint16 *hvram_column = hvram_line;
488:
489: for (w = 0; w < vw_clip; w++) {
490: // byteswap with SDL asm macros
491: *hvram_column++ = SDL_SwapBE16(*fvram_column++);
492: }
493: #endif // SDL_BYTEORDER == SDL_BIG_ENDIAN
494:
495: hvram_line += scrpitch>>1;
496: fvram_line += nextline;
497: }
498: }
499: break;
500: case 3:
501: {
502: uint16 *fvram_line = fvram;
503: uint8 *hvram_line = hvram;
504: int h;
505:
506: for (h = 0; h < vh_clip; h++) {
507: uint16 *fvram_column = fvram_line;
508: uint8 *hvram_column = hvram_line;
509: int w;
510:
511: for (w = 0; w < vw_clip; w++) {
512: int data = *fvram_column++;
513:
514: uint32 tmpColor =
515: HostScreen_getColor(
516: (uint8) (data & 0xf8),
517: (uint8) ( ((data & 0x07) << 5) |
518: ((data >> 11) & 0x3c)),
519: (uint8) ((data >> 5) & 0xf8));
520:
521: putBpp24Pixel( hvram_column, tmpColor );
522:
523: hvram_column += 3;
524: }
525:
526: hvram_line += scrpitch;
527: fvram_line += nextline;
528: }
529: }
530: break;
531: case 4:
532: {
533: uint16 *fvram_line = fvram;
534: uint32 *hvram_line = (uint32 *)hvram;
535: int h;
536:
537: for (h = 0; h < vh_clip; h++) {
538: uint16 *fvram_column = fvram_line;
539: uint32 *hvram_column = hvram_line;
540: int w;
541:
542: for (w = 0; w < vw_clip; w++) {
543: int data = *fvram_column++;
544:
545: *hvram_column++ =
546: HostScreen_getColor(
547: (uint8) (data & 0xf8),
548: (uint8) ( ((data & 0x07) << 5) |
549: ((data >> 11) & 0x3c)),
550: (uint8) ((data >> 5) & 0xf8));
551: }
552:
553: hvram_line += scrpitch>>2;
554: fvram_line += nextline;
555: }
556: }
557: break;
558: }
559: }
560: }
561:
562:
563: static void VIDEL_renderScreenZoom(void)
564: {
565: /* Atari screen infos */
566: int vw = VIDEL_getScreenWidth();
567: int vh = VIDEL_getScreenHeight();
568:
569: int lineoffset = handleReadW(HW + 0x0e) & 0x01ff; // 9 bits
570: int linewidth = handleReadW(HW + 0x10) & 0x03ff; // 10 bits
571: /* same remark as before: too naive */
572: int nextline = linewidth + lineoffset;
573:
574: if ((vw<32) || (vh<32)) return;
575:
576: if (bpp<16 && !hostColorsSync) {
577: VIDEL_updateColors();
578: }
579:
580: VIDEL_ConvertScreenZoom(vw, vh, bpp, nextline);
581: }
582:
583:
584: void VIDEL_ConvertScreenZoom(int vw, int vh, int vbpp, int nextline)
585: {
586: int i, j, w, h, cursrcline;
587:
588: uint16 *fvram = (uint16 *) Atari2HostAddr(VIDEL_getVideoramAddress());
589:
590: /* Host screen infos */
591: int scrpitch = HostScreen_getPitch();
592: int scrwidth = HostScreen_getWidth();
593: int scrheight = HostScreen_getHeight();
594: int scrbpp = HostScreen_getBpp();
595: uint8 *hvram = (uint8 *) HostScreen_getVideoramAddress();
596:
597: int hscrolloffset = (handleRead(HW + 0x65) & 0x0f);
598:
599: /* Horizontal scroll register set? */
600: if (hscrolloffset) {
601: /* Yes, so we need to adjust offset to next line: */
602: nextline += vbpp;
603: }
604:
605: /* Integer zoom coef ? */
606: if (/*(bx_options.autozoom.integercoefs) &&*/ (scrwidth>=vw) && (scrheight>=vh)) {
607: int coefx = scrwidth/vw;
608: int coefy = scrheight/vh;
609:
610: scrwidth = vw * coefx;
611: scrheight = vh * coefy;
612:
613: /* Center screen */
614: hvram += ((HostScreen_getHeight()-scrheight)>>1)*scrpitch;
615: hvram += ((HostScreen_getWidth()-scrwidth)>>1)*scrbpp;
616: }
617:
618: /* New zoom ? */
619: if ((zoomwidth != vw) || (scrwidth != prev_scrwidth)) {
620: if (zoomxtable) {
621: free(zoomxtable);
622: }
623: zoomxtable = malloc(sizeof(int)*scrwidth);
624: for (i=0; i<scrwidth; i++) {
625: zoomxtable[i] = (vw*i)/scrwidth;
626: }
627: zoomwidth = vw;
628: prev_scrwidth = scrwidth;
629: }
630: if ((zoomheight != vh) || (scrheight != prev_scrheight)) {
631: if (zoomytable) {
632: free(zoomytable);
633: }
634: zoomytable = malloc(sizeof(int)*scrheight);
635: for (i=0; i<scrheight; i++) {
636: zoomytable[i] = (vh*i)/scrheight;
637: }
638: zoomheight = vh;
639: prev_scrheight = scrheight;
640: }
641:
642: cursrcline = -1;
643:
644: if (vbpp<16) {
645: uint8 color[16];
646:
647: /* Bitplanes modes */
648: switch(scrbpp) {
649: case 1:
650: {
651: /* One complete planar 2 chunky line */
652: uint8 *p2cline = malloc(sizeof(uint8)*vw);
653:
654: uint16 *fvram_line;
655: uint8 *hvram_line = hvram;
656:
657: for (h = 0; h < scrheight; h++) {
658: fvram_line = fvram + (zoomytable[h] * nextline);
659:
660: /* Recopy the same line ? */
661: if (zoomytable[h] == cursrcline) {
662: memcpy(hvram_line, hvram_line-scrpitch, scrwidth*scrbpp);
663: } else {
664: uint16 *fvram_column = fvram_line;
665: uint8 *hvram_column = p2cline;
666:
667: /* First 16 pixels of a new line */
668: HostScreen_bitplaneToChunky(fvram_column, vbpp, color);
669: memcpy(hvram_column, color+hscrolloffset, 16-hscrolloffset);
670: hvram_column += 16-hscrolloffset;
671: fvram_column += vbpp;
672: /* Convert main part of the new line */
673: for (w=1; w < (vw+15)>>4; w++) {
674: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
675: memcpy(hvram_column, color, 16);
676: hvram_column += 16;
677: fvram_column += vbpp;
678: }
679: /* Last pixels of the line for fine scrolling: */
680: if (hscrolloffset) {
681: HostScreen_bitplaneToChunky(fvram_column, vbpp, color);
682: memcpy(hvram_column, color, hscrolloffset);
683: }
684:
685: /* Zoom a new line */
686: for (w=0; w<scrwidth; w++) {
687: hvram_line[w] = p2cline[zoomxtable[w]];
688: }
689: }
690:
691: hvram_line += scrpitch;
692: cursrcline = zoomytable[h];
693: }
694:
695: free(p2cline);
696: }
697: break;
698: case 2:
699: {
700: /* One complete planar 2 chunky line */
701: uint16 *p2cline = malloc(sizeof(uint16)*vw);
702:
703: uint16 *fvram_line = fvram;
704: uint16 *hvram_line = (uint16 *)hvram;
705:
706: for (h = 0; h < scrheight; h++) {
707: fvram_line = fvram + (zoomytable[h] * nextline);
708:
709: /* Recopy the same line ? */
710: if (zoomytable[h] == cursrcline) {
711: memcpy(hvram_line, hvram_line-(scrpitch>>1), scrwidth*scrbpp);
712: } else {
713: uint16 *fvram_column = fvram_line;
714: uint16 *hvram_column = p2cline;
715:
716: /* Convert a new line */
717: for (w=0; w < (vw+15)>>4; w++) {
718: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
719:
720: for (j=0; j<16; j++) {
721: *hvram_column++ = HostScreen_getPaletteColor( color[j] );
722: }
723:
724: fvram_column += vbpp;
725: }
726:
727: /* Zoom a new line */
728: for (w=0; w<scrwidth; w++) {
729: hvram_line[w] = p2cline[zoomxtable[w]];
730: }
731: }
732:
733: hvram_line += scrpitch>>1;
734: cursrcline = zoomytable[h];
735: }
736:
737: free(p2cline);
738: }
739: break;
740: case 3:
741: {
742: /* One complete planar 2 chunky line */
743: uint8 *p2cline = malloc(sizeof(uint8)*vw*3);
744:
745: uint16 *fvram_line;
746: uint8 *hvram_line = hvram;
747:
748: for (h = 0; h < scrheight; h++) {
749: fvram_line = fvram + (zoomytable[h] * nextline);
750:
751: /* Recopy the same line ? */
752: if (zoomytable[h] == cursrcline) {
753: memcpy(hvram_line, hvram_line-scrpitch, scrwidth*scrbpp);
754: } else {
755: uint16 *fvram_column = fvram_line;
756: uint8 *hvram_column = p2cline;
757:
758: /* Convert a new line */
759: for (w=0; w < (vw+15)>>4; w++) {
760: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
761:
762: for (j=0; j<16; j++) {
763: uint32 tmpColor = HostScreen_getPaletteColor( color[j] );
764: putBpp24Pixel( hvram_column, tmpColor );
765: hvram_column += 3;
766: }
767:
768: fvram_column += vbpp;
769: }
770:
771: /* Zoom a new line */
772: for (w=0; w<scrwidth; w++) {
773: hvram_line[w*3] = p2cline[zoomxtable[w]*3];
774: hvram_line[w*3+1] = p2cline[zoomxtable[w]*3+1];
775: hvram_line[w*3+2] = p2cline[zoomxtable[w]*3+2];
776: }
777: }
778:
779: hvram_line += scrpitch;
780: cursrcline = zoomytable[h];
781: }
782:
783: free(p2cline);
784: }
785: break;
786: case 4:
787: {
788: /* One complete planar 2 chunky line */
789: uint32 *p2cline = malloc(sizeof(uint32)*vw);
790:
791: uint16 *fvram_line;
792: uint32 *hvram_line = (uint32 *)hvram;
793:
794: for (h = 0; h < scrheight; h++) {
795: fvram_line = fvram + (zoomytable[h] * nextline);
796:
797: /* Recopy the same line ? */
798: if (zoomytable[h] == cursrcline) {
799: memcpy(hvram_line, hvram_line-(scrpitch>>2), scrwidth*scrbpp);
800: } else {
801: uint16 *fvram_column = fvram_line;
802: uint32 *hvram_column = p2cline;
803:
804: /* Convert a new line */
805: for (w=0; w < (vw+15)>>4; w++) {
806: HostScreen_bitplaneToChunky( fvram_column, vbpp, color );
807:
808: for (j=0; j<16; j++) {
809: *hvram_column++ = HostScreen_getPaletteColor( color[j] );
810: }
811:
812: fvram_column += vbpp;
813: }
814:
815: /* Zoom a new line */
816: for (w=0; w<scrwidth; w++) {
817: hvram_line[w] = p2cline[zoomxtable[w]];
818: }
819: }
820:
821: hvram_line += scrpitch>>2;
822: cursrcline = zoomytable[h];
823: }
824:
825: free(p2cline);
826: }
827: break;
828: }
829: } else {
830: /* Falcon TrueColour mode */
831:
832: switch(scrbpp) {
833: case 1:
834: {
835: /* FIXME: when Videl switches to 16bpp, set the palette to 3:3:2 */
836: uint16 *fvram_line;
837: uint8 *hvram_line = hvram;
838:
839: for (h = 0; h < scrheight; h++) {
840: uint16 *fvram_column;
841: uint8 *hvram_column;
842:
843: fvram_line = fvram + (zoomytable[h] * nextline);
844: fvram_column = fvram_line;
845: hvram_column = hvram_line;
846:
847: /* Recopy the same line ? */
848: if (zoomytable[h] == cursrcline) {
849: memcpy(hvram_line, hvram_line-scrpitch, scrwidth*scrbpp);
850: } else {
851: for (w = 0; w < scrwidth; w++) {
852: uint16 srcword;
853: uint8 dstbyte;
854:
855: srcword = SDL_SwapBE16(fvram_column[zoomxtable[w]]);
856:
857: dstbyte = ((srcword>>13) & 7) << 5;
858: dstbyte |= ((srcword>>8) & 7) << 2;
859: dstbyte |= ((srcword>>2) & 3);
860:
861: *hvram_column++ = dstbyte;
862: }
863: }
864:
865: hvram_line += scrpitch;
866: cursrcline = zoomytable[h];
867: }
868: }
869: break;
870: case 2:
871: {
872: uint16 *fvram_line;
873: uint16 *hvram_line = (uint16 *)hvram;
874:
875: for (h = 0; h < scrheight; h++) {
876: uint16 *fvram_column;
877: uint16 *hvram_column;
878:
879: fvram_line = fvram + (zoomytable[h] * nextline);
880: fvram_column = fvram_line;
881: hvram_column = hvram_line;
882:
883: /* Recopy the same line ? */
884: if (zoomytable[h] == cursrcline) {
885: memcpy(hvram_line, hvram_line-(scrpitch>>1), scrwidth*scrbpp);
886: } else {
887: for (w = 0; w < scrwidth; w++) {
888: uint16 srcword;
889:
890: srcword = SDL_SwapBE16(fvram_column[zoomxtable[w]]);
891: *hvram_column++ = srcword;
892: }
893: }
894:
895: hvram_line += scrpitch>>1;
896: cursrcline = zoomytable[h];
897: }
898: }
899: break;
900: case 3:
901: {
902: uint16 *fvram_line;
903: uint8 *hvram_line = hvram;
904:
905: for (h = 0; h < scrheight; h++) {
906: uint16 *fvram_column;
907: uint8 *hvram_column;
908:
909: fvram_line = fvram + (zoomytable[h] * nextline);
910: fvram_column = fvram_line;
911: hvram_column = hvram_line;
912:
913: /* Recopy the same line ? */
914: if (zoomytable[h] == cursrcline) {
915: memcpy(hvram_line, hvram_line-scrpitch, scrwidth*scrbpp);
916: } else {
917: for (w = 0; w < scrwidth; w++) {
918: uint16 srcword;
919: uint32 dstlong;
920:
921: srcword = fvram_column[zoomxtable[w]];
922:
923: dstlong = HostScreen_getColor(
924: (uint8) (srcword & 0xf8),
925: (uint8) ( ((srcword & 0x07) << 5) |
926: ((srcword >> 11) & 0x3c)),
927: (uint8) ((srcword >> 5) & 0xf8));
928:
929: putBpp24Pixel( hvram_column, dstlong );
930: hvram_column += 3;
931: }
932: }
933:
934: hvram_line += scrpitch;
935: cursrcline = zoomytable[h];
936: }
937: }
938: break;
939: case 4:
940: {
941: uint16 *fvram_line;
942: uint32 *hvram_line = (uint32 *)hvram;
943:
944: for (h = 0; h < scrheight; h++) {
945: uint16 *fvram_column;
946: uint32 *hvram_column;
947:
948: fvram_line = fvram + (zoomytable[h] * nextline);
949: fvram_column = fvram_line;
950: hvram_column = hvram_line;
951:
952: /* Recopy the same line ? */
953: if (zoomytable[h] == cursrcline) {
954: memcpy(hvram_line, hvram_line-(scrpitch>>2), scrwidth*scrbpp);
955: } else {
956: for (w = 0; w < scrwidth; w++) {
957: uint16 srcword;
958:
959: srcword = fvram_column[zoomxtable[w]];
960:
961: *hvram_column++ =
962: HostScreen_getColor(
963: (uint8) (srcword & 0xf8),
964: (uint8) ( ((srcword & 0x07) << 5) |
965: ((srcword >> 11) & 0x3c)),
966: (uint8) ((srcword >> 5) & 0xf8));
967: }
968: }
969:
970: hvram_line += scrpitch>>2;
971: cursrcline = zoomytable[h];
972: }
973: }
974: break;
975: }
976: }
977: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.