src/devices/dev_ps2_gif.c

/*
 *  Copyright (C) 2003-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *   
 *
 *  $Id: dev_ps2_gif.c,v 1.35 2007/06/15 19:57:33 debug Exp $
 *  
 *  COMMENT: PlayStation 2 "gif" graphics device
 *
 *  TODO:  Convert dev_fb_access() accesses into direct framebuffer reads and
 *         writes, to improve performance.
 *
 *  TODO 2:  The way things are now, rgb bytes are copied from emulated
 *           space to the framebuffer as rgb, but on X Windows servers on
 *           big-endian machines that should be bgr.  (?) Hm...
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "cpu.h"
#include "device.h"
#include "devices.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"


#define DEV_PS2_GIF_LENGTH              0x10000

#define PS2_FB_ADDR     0x60000000ULL   /*  hopefully nothing else here  */


struct gif_data {
        struct cpu      *cpu;
        int             xsize, ysize;
        int             bytes_per_pixel;
        int             transparent_text;
        struct vfb_data *vfb_data;
};


/*
 *  test_triangle():
 *
 *  Draw a triangle:
 */
void test_triangle(struct gif_data *d,
        int x1, int y1, int r1, int g1, int b1,
        int x2, int y2, int r2, int g2, int b2,
        int x3, int y3, int r3, int g3, int b3)
{
        unsigned char *line;
        int y, tmp, scale = 32768;
        int xofs, xlen, savedxlen, xdir, x;
        int r, g, b;                    /*  scaled  */
        int xstart, xstop;              /*  scaled  */
        int rstart, rstop;              /*  scaled  */
        int gstart, gstop;              /*  scaled  */
        int bstart, bstop;              /*  scaled  */
        int rpx, gpx, bpx;              /*  scaled  */
        int xpy12, xpy13, xpy23;
        int rpy12, rpy13, rpy23;
        int gpy12, gpy13, gpy23;
        int bpy12, bpy13, bpy23;

        CHECK_ALLOCATION(line = malloc(d->xsize * d->bytes_per_pixel));

        if (y2 > y3) {
                tmp = x2; x2 = x3; x3 = tmp;
                tmp = y2; y2 = y3; y3 = tmp;
                tmp = r2; r2 = r3; r3 = tmp;
                tmp = g2; g2 = g3; g3 = tmp;
                tmp = b2; b2 = b3; b3 = tmp;
        }

        if (y1 > y2) {
                tmp = x1; x1 = x2; x2 = tmp;
                tmp = y1; y1 = y2; y2 = tmp;
                tmp = r1; r1 = r2; r2 = tmp;
                tmp = g1; g1 = g2; g2 = tmp;
                tmp = b1; b1 = b2; b2 = tmp;
        }

        if (y1 > y3) {
                tmp = x1; x1 = x3; x3 = tmp;
                tmp = y1; y1 = y3; y3 = tmp;
                tmp = r1; r1 = r3; r3 = tmp;
                tmp = g1; g1 = g3; g3 = tmp;
                tmp = b1; b1 = b3; b3 = tmp;
        }

        /*  X change per line:  */
        xpy12 = (y2-y1)? scale*(x2-x1)/(y2-y1) : 0;
        xpy13 = (y3-y1)? scale*(x3-x1)/(y3-y1) : 0;
        xpy23 = (y3-y2)? scale*(x3-x2)/(y3-y2) : 0;

        /*  Color change per line:  */
        rpy12 = (y2-y1)? scale*(r2-r1)/(y2-y1) : 0;
        rpy13 = (y3-y1)? scale*(r3-r1)/(y3-y1) : 0;
        rpy23 = (y3-y2)? scale*(r3-r2)/(y3-y2) : 0;

        gpy12 = (y2-y1)? scale*(g2-g1)/(y2-y1) : 0;
        gpy13 = (y3-y1)? scale*(g3-g1)/(y3-y1) : 0;
        gpy23 = (y3-y2)? scale*(g3-g2)/(y3-y2) : 0;

        bpy12 = (y2-y1)? scale*(b2-b1)/(y2-y1) : 0;
        bpy13 = (y3-y1)? scale*(b3-b1)/(y3-y1) : 0;
        bpy23 = (y3-y2)? scale*(b3-b2)/(y3-y2) : 0;

        xstart = xstop = x1 * scale;
        rstart = rstop = r1 * scale;
        gstart = gstop = g1 * scale;
        bstart = bstop = b1 * scale;

        for (y=y1; y<=y3; y++) {
                if (xstart < xstop)
                        xofs = xstart/scale, xlen = (xstop-xstart)/scale + 1;
                else
                        xofs = xstop/scale, xlen = (xstart-xstop)/scale + 1;

                savedxlen = xlen;
                xdir = (xstart < xstop)? 1 : -1;
                r = rstart; g = gstart; b = bstart;

                rpx = (xstop-xstart)? (rstop-rstart) / ((xstop-xstart)
                    / scale) : 0;
                gpx = (xstop-xstart)? (gstop-gstart) / ((xstop-xstart)
                    / scale) : 0;
                bpx = (xstop-xstart)? (bstop-bstart) / ((xstop-xstart)
                    / scale): 0;

                x = xstart / scale;
                while (xlen > 0) {
                        if (x>=0 && x<d->xsize) {
                                int c;
                                c = r/scale;
                                line[x * d->bytes_per_pixel + 0] = c<0?
                                    0 : (c > 255? 255 : c);
                                c = g/scale;
                                line[x * d->bytes_per_pixel + 1] = c<0?
                                    0 : (c > 255? 255 : c);
                                c = b/scale;
                                line[x * d->bytes_per_pixel + 2] = c<0?
                                    0 : (c > 255? 255 : c);
                        }
                        r += rpx;
                        g += gpx;
                        b += bpx;
                        x += xdir;
                        xlen --;
                }

                dev_fb_access(d->cpu, d->cpu->mem,
                    (y*d->xsize + xofs) * d->bytes_per_pixel,
                    line + xofs * d->bytes_per_pixel,
                    savedxlen * d->bytes_per_pixel,
                    MEM_WRITE, d->vfb_data);

                if (y<y2) {
                        xstart += xpy12;
                        rstart += rpy12;
                        gstart += gpy12;
                        bstart += bpy12;
                } else {
                        xstart += xpy23;
                        rstart += rpy23;
                        gstart += gpy23;
                        bstart += bpy23;
                }
                xstop += xpy13;
                rstop += rpy13;
                gstop += gpy13;
                bstop += bpy13;

                if (y==y2) {
                        xstart = x2 * scale;
                        rstart = r2 * scale;
                        gstart = g2 * scale;
                        bstart = b2 * scale;
                }
        }
}


DEVICE_ACCESS(ps2_gif)
{
        unsigned int i;
        struct gif_data *d = extra;

        if (relative_addr + len > DEV_PS2_GIF_LENGTH)
                return 0;

        if (writeflag==MEM_READ) {
                debug("[ gif read from addr 0x%x, len=%i ]\n",
                    (int)relative_addr, (int)len);
        } else {
                if (data[0] == 0x08 && data[1] == 0x80) {
                        /*  Possibly "initialize 640x480 mode":  */
                        debug("[ gif: initialize video mode (?) ]\n");
                } else if (data[0] == 0x04 && data[1] == 0x00 && len > 300) {
                        /*  Possibly "output 8x16 character":  */
                        int xbase, ybase, xsize, ysize, x, y;

                        xbase = data[9*4 + 0] + (data[9*4 + 1] << 8);
                        ybase = data[9*4 + 2] + (data[9*4 + 3] << 8);

                        xsize = data[12*4 + 0] + (data[12*4 + 1] << 8);
                        ysize = data[13*4 + 0] + (data[13*4 + 1] << 8);
                        ysize &= ~0xf;  /*  multple of 16  */

                        /*  debug("[ gif: putchar at (%i,%i), size (%i,%i) "
                            "]\n", xbase, ybase, xsize, ysize);  */

                        /*
                         *  NetBSD and Linux:
                         *
                         *  [ gif write to addr 0x0 (len=608):
                         *  04 00 00 00 00 00 00 10, 0e 00 00 00 00 00 00 00,
                         *  00 00 00 00 00 00 0a 00, 50 00 00 00 00 00 00 00,
                         *  00 00 00 00 00 00 00 00, 51 00 00 00 00 00 00 00,
                         *  08 00 00 00 16 00 00 00, 52 00 00 00 00 00 00 00,
                         *  00 00 00 00 00 00 00 00, 53 00 00 00 00 00 00 00,
                         *  20 80 00 00 00 00 00 08, 00 00 00 00 00 00 00 00,
                         *  00 00 aa 80 00 00 aa 80, 00 00 aa 80 00 00 aa 80,
                         *  00 00 aa 80 00 00 aa 80, 00 00 aa 80 00 00 aa 80,
                         *  aa aa 00 80 aa aa 00 80, 00 00 aa 80 00 00 aa 80,
                         *  00 00 aa 80 00 00 aa 80, 00 00 aa 80 00 00 aa 80,
                         */

                        /*
                        fatal("[ gif write to addr 0x%x (len=%i):",
                            (int)relative_addr, (int)len);
                        for (i=0; i<len; i++) {
                                fatal(" %02x", data[i]);
                                if ((i & 7) == 7)
                                        fatal(",");
                                if ((i & 31) == 31)
                                        fatal("\n");
                        }
                        fatal(" ]\n");
                        */

                        for (y=0; y<ysize; y++) {
                                int fb_addr = (xbase + (ybase+y) * d->xsize)
                                    * d->bytes_per_pixel;
                                int addr = (24 + y*xsize) * 4;
                                for (x=0; x<xsize; x++) {
                                        /*  There are three bytes (r,g,b) at
                                            data[addr + 0] .. [addr + 2].
                                            TODO: This should be translated to a
                                            direct update of the framebuffer. */

                                        dev_fb_access(d->cpu, d->cpu->mem,
                                            fb_addr, data + addr, 3, MEM_WRITE,
                                            d->vfb_data);

                                        fb_addr += d->bytes_per_pixel;
                                        addr += 4;
                                }
                        }
                } else if (data[0] == 0x04 && data[1] == 0x80 && len == 0x50) {
                        /*  blockcopy  */
                        int y_source, y_dest, x_source, x_dest, x_size, y_size;
                        x_source = data[8*4 + 0] + ((data[8*4 + 1]) << 8);
                        y_source = data[8*4 + 2] + ((data[8*4 + 3]) << 8);
                        x_dest   = data[9*4 + 0] + ((data[9*4 + 1]) << 8);
                        y_dest   = data[9*4 + 2] + ((data[9*4 + 3]) << 8);
                        x_size   = data[12*4 + 0] + ((data[12*4 + 1]) << 8);
                        y_size   = data[13*4 + 0] + ((data[13*4 + 1]) << 8);

                        /*  debug("[ gif: blockcopy (%i,%i) -> (%i,%i), size="
                            "(%i,%i) ]\n", x_source,y_source, x_dest,y_dest,
                            x_size,y_size);  */

                        framebuffer_blockcopyfill(d->vfb_data, 0, 0,0,0,
                            x_dest, y_dest, x_dest + x_size - 1, y_dest +
                            y_size - 1, x_source, y_source);
                } else if (data[8] == 0x10 && data[9] == 0x55 && len == 48) {
                        /*  Linux "clear":  This is used by linux to clear the
                            lowest 16 pixels of the framebuffer.  */
                        int xbase, ybase, xend, yend;

                        xbase = (data[8*4 + 0] + (data[8*4 + 1] << 8)) / 16;
                        ybase = (data[8*4 + 2] + (data[8*4 + 3] << 8)) / 16;
                        xend  = (data[8*5 + 0] + (data[8*5 + 1] << 8)) / 16;
                        yend  = (data[8*5 + 2] + (data[8*5 + 3] << 8)) / 16;

                        /*  debug("[ gif: linux \"clear\" (%i,%i)-(%i,%i) ]\n",
                            xbase, ybase, xend, yend);  */

                        framebuffer_blockcopyfill(d->vfb_data, 1, 0,0,0,
                            xbase, ybase, xend - 1, yend - 1, 0,0);
                } else if (data[0] == 0x07 && data[1] == 0x80 && len == 128) {
                        /*  NetBSD "output cursor":  */
                        int xbase, ybase, xend, yend, x, y;

                        xbase = (data[20*4 + 0] + (data[20*4 + 1] << 8)) / 16;
                        ybase = (data[20*4 + 2] + (data[20*4 + 3] << 8)) / 16;
                        xend  = (data[28*4 + 0] + (data[28*4 + 1] << 8)) / 16;
                        yend  = (data[28*4 + 2] + (data[28*4 + 3] << 8)) / 16;

                        /*  debug("[ gif: NETBSD cursor at (%i,%i)-(%i,%i) ]\n",
                            xbase, ybase, xend, yend);  */

                        /*  Output the cursor to framebuffer memory:  */

                        for (y=ybase; y<=yend; y++)
                                for (x=xbase; x<=xend; x++) {
                                        int fb_addr = (x + y * d->xsize) *
                                            d->bytes_per_pixel;
                                        unsigned char pixels[3];

                                        dev_fb_access(d->cpu, d->cpu->mem,
                                            fb_addr, pixels, sizeof(pixels),
                                            MEM_READ, d->vfb_data);

                                        pixels[0] = 0xff - pixels[0];
                                        pixels[1] = 0xff - pixels[1];
                                        pixels[2] = 0xff - pixels[2];

                                        dev_fb_access(d->cpu, d->cpu->mem,
                                            fb_addr, pixels, sizeof(pixels),
                                            MEM_WRITE, d->vfb_data);
                                }
                } else if (data[0] == 0x01 && data[1] == 0x00 && len == 80) {
                        /*  Linux "output cursor":  */
                        int xbase, ybase, xend, yend, x, y;

                        xbase = (data[7*8 + 0] + (data[7*8 + 1] << 8)) / 16;
                        ybase = (data[7*8 + 2] + (data[7*8 + 3] << 8)) / 16;
                        xend  = (data[8*8 + 0] + (data[8*8 + 1] << 8)) / 16;
                        yend  = (data[8*8 + 2] + (data[8*8 + 3] << 8)) / 16;

                        debug("[ gif: LINUX cursor at (%i,%i)-(%i,%i) ]\n",
                            xbase, ybase, xend, yend);

                        /*  Output the cursor to framebuffer memory:  */

                        for (y=ybase; y<=yend; y++)
                                for (x=xbase; x<=xend; x++) {
                                        int fb_addr = (x + y * d->xsize) *
                                            d->bytes_per_pixel;
                                        unsigned char pixels[3];

                                        dev_fb_access(d->cpu, d->cpu->mem,
                                            fb_addr, pixels, sizeof(pixels),
                                            MEM_READ, d->vfb_data);

                                        pixels[0] = 0xff - pixels[0];
                                        pixels[1] = 0xff - pixels[1];
                                        pixels[2] = 0xff - pixels[2];

                                        dev_fb_access(d->cpu, d->cpu->mem,
                                            fb_addr, pixels, sizeof(pixels),
                                            MEM_WRITE, d->vfb_data);
                                }
                } else {                /*  Unknown command:  */
                        fatal("[ gif write to addr 0x%x (len=%i):",
                            (int)relative_addr, len);
                        for (i=0; i<len; i++)
                                fatal(" %02x", data[i]);
                        fatal(" ]\n");
/*                      fatal("Unknown gif command.\n");
                        cpu->running = 0;
*/              }
        }

        return 1;
}


/*
 *  devinit_ps2_gif():
 *
 *  Attached to separate memory by devinit_ps2_gs().
 */
DEVINIT(ps2_gif)
{
        struct gif_data *d;

        CHECK_ALLOCATION(d = malloc(sizeof(struct gif_data)));
        memset(d, 0, sizeof(struct gif_data));

        d->transparent_text = 0;
        d->cpu = devinit->machine->cpus[0];             /*  TODO  */
        d->xsize = 640; d->ysize = 480;
        d->bytes_per_pixel = 3;

        d->vfb_data = dev_fb_init(devinit->machine, devinit->machine->memory,
            PS2_FB_ADDR, VFB_PLAYSTATION2,
            d->xsize, d->ysize, d->xsize, d->ysize, 24, "Playstation 2");
        if (d->vfb_data == NULL) {
                fprintf(stderr, "could not initialize fb, out of memory\n");
                exit(1);
        }

#if 0
        test_triangle(d, 300,50, 255,0,0,  50,150, 0,255,0,  600,400, 0,0,255);
        test_triangle(d, 310,210, 128,32,0,  175,410, 0,32,0,
            500,470, 125,255,125);
        test_triangle(d, 100,450, 255,255,0,  250,370, 0,255,255,
            400,470, 255,0,255);
#endif

        memory_device_register(devinit->machine->memory, devinit->name,
            devinit->addr, DEV_PS2_GIF_LENGTH, dev_ps2_gif_access, d,
            DM_DEFAULT, NULL);

        return 1;
}

1	dpavlin	4	/*
2	dpavlin	34	* Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3	dpavlin	4	*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	42	* $Id: dev_ps2_gif.c,v 1.35 2007/06/15 19:57:33 debug Exp $
29	dpavlin	4	*
30	dpavlin	42	* COMMENT: PlayStation 2 "gif" graphics device
31	dpavlin	4	*
32			* TODO: Convert dev_fb_access() accesses into direct framebuffer reads and
33			* writes, to improve performance.
34			*
35			* TODO 2: The way things are now, rgb bytes are copied from emulated
36			* space to the framebuffer as rgb, but on X Windows servers on
37			* big-endian machines that should be bgr. (?) Hm...
38			*/
39
40			#include <stdio.h>
41			#include <stdlib.h>
42			#include <string.h>
43
44			#include "cpu.h"
45			#include "device.h"
46			#include "devices.h"
47			#include "machine.h"
48			#include "memory.h"
49			#include "misc.h"
50
51
52			#define DEV_PS2_GIF_LENGTH 0x10000
53
54			#define PS2_FB_ADDR 0x60000000ULL /* hopefully nothing else here */
55
56
57			struct gif_data {
58			struct cpu *cpu;
59			int xsize, ysize;
60			int bytes_per_pixel;
61			int transparent_text;
62			struct vfb_data *vfb_data;
63			};
64
65
66			/*
67			* test_triangle():
68			*
69			* Draw a triangle:
70			*/
71			void test_triangle(struct gif_data *d,
72			int x1, int y1, int r1, int g1, int b1,
73			int x2, int y2, int r2, int g2, int b2,
74			int x3, int y3, int r3, int g3, int b3)
75			{
76	dpavlin	42	unsigned char *line;
77	dpavlin	4	int y, tmp, scale = 32768;
78			int xofs, xlen, savedxlen, xdir, x;
79			int r, g, b; /* scaled */
80			int xstart, xstop; /* scaled */
81			int rstart, rstop; /* scaled */
82			int gstart, gstop; /* scaled */
83			int bstart, bstop; /* scaled */
84			int rpx, gpx, bpx; /* scaled */
85			int xpy12, xpy13, xpy23;
86			int rpy12, rpy13, rpy23;
87			int gpy12, gpy13, gpy23;
88			int bpy12, bpy13, bpy23;
89
90	dpavlin	42	CHECK_ALLOCATION(line = malloc(d->xsize * d->bytes_per_pixel));
91
92	dpavlin	4	if (y2 > y3) {
93			tmp = x2; x2 = x3; x3 = tmp;
94			tmp = y2; y2 = y3; y3 = tmp;
95			tmp = r2; r2 = r3; r3 = tmp;
96			tmp = g2; g2 = g3; g3 = tmp;
97			tmp = b2; b2 = b3; b3 = tmp;
98			}
99
100			if (y1 > y2) {
101			tmp = x1; x1 = x2; x2 = tmp;
102			tmp = y1; y1 = y2; y2 = tmp;
103			tmp = r1; r1 = r2; r2 = tmp;
104			tmp = g1; g1 = g2; g2 = tmp;
105			tmp = b1; b1 = b2; b2 = tmp;
106			}
107
108			if (y1 > y3) {
109			tmp = x1; x1 = x3; x3 = tmp;
110			tmp = y1; y1 = y3; y3 = tmp;
111			tmp = r1; r1 = r3; r3 = tmp;
112			tmp = g1; g1 = g3; g3 = tmp;
113			tmp = b1; b1 = b3; b3 = tmp;
114			}
115
116			/* X change per line: */
117			xpy12 = (y2-y1)? scale*(x2-x1)/(y2-y1) : 0;
118			xpy13 = (y3-y1)? scale*(x3-x1)/(y3-y1) : 0;
119			xpy23 = (y3-y2)? scale*(x3-x2)/(y3-y2) : 0;
120
121			/* Color change per line: */
122			rpy12 = (y2-y1)? scale*(r2-r1)/(y2-y1) : 0;
123			rpy13 = (y3-y1)? scale*(r3-r1)/(y3-y1) : 0;
124			rpy23 = (y3-y2)? scale*(r3-r2)/(y3-y2) : 0;
125
126			gpy12 = (y2-y1)? scale*(g2-g1)/(y2-y1) : 0;
127			gpy13 = (y3-y1)? scale*(g3-g1)/(y3-y1) : 0;
128			gpy23 = (y3-y2)? scale*(g3-g2)/(y3-y2) : 0;
129
130			bpy12 = (y2-y1)? scale*(b2-b1)/(y2-y1) : 0;
131			bpy13 = (y3-y1)? scale*(b3-b1)/(y3-y1) : 0;
132			bpy23 = (y3-y2)? scale*(b3-b2)/(y3-y2) : 0;
133
134			xstart = xstop = x1 * scale;
135			rstart = rstop = r1 * scale;
136			gstart = gstop = g1 * scale;
137			bstart = bstop = b1 * scale;
138
139			for (y=y1; y<=y3; y++) {
140			if (xstart < xstop)
141			xofs = xstart/scale, xlen = (xstop-xstart)/scale + 1;
142			else
143			xofs = xstop/scale, xlen = (xstart-xstop)/scale + 1;
144
145			savedxlen = xlen;
146			xdir = (xstart < xstop)? 1 : -1;
147			r = rstart; g = gstart; b = bstart;
148
149			rpx = (xstop-xstart)? (rstop-rstart) / ((xstop-xstart)
150			/ scale) : 0;
151			gpx = (xstop-xstart)? (gstop-gstart) / ((xstop-xstart)
152			/ scale) : 0;
153			bpx = (xstop-xstart)? (bstop-bstart) / ((xstop-xstart)
154			/ scale): 0;
155
156			x = xstart / scale;
157			while (xlen > 0) {
158			if (x>=0 && x<d->xsize) {
159			int c;
160			c = r/scale;
161			line[x * d->bytes_per_pixel + 0] = c<0?
162			0 : (c > 255? 255 : c);
163			c = g/scale;
164			line[x * d->bytes_per_pixel + 1] = c<0?
165			0 : (c > 255? 255 : c);
166			c = b/scale;
167			line[x * d->bytes_per_pixel + 2] = c<0?
168			0 : (c > 255? 255 : c);
169			}
170			r += rpx;
171			g += gpx;
172			b += bpx;
173			x += xdir;
174			xlen --;
175			}
176
177			dev_fb_access(d->cpu, d->cpu->mem,
178			(yd->xsize + xofs) d->bytes_per_pixel,
179			line + xofs * d->bytes_per_pixel,
180			savedxlen * d->bytes_per_pixel,
181			MEM_WRITE, d->vfb_data);
182
183			if (y<y2) {
184			xstart += xpy12;
185			rstart += rpy12;
186			gstart += gpy12;
187			bstart += bpy12;
188			} else {
189			xstart += xpy23;
190			rstart += rpy23;
191			gstart += gpy23;
192			bstart += bpy23;
193			}
194			xstop += xpy13;
195			rstop += rpy13;
196			gstop += gpy13;
197			bstop += bpy13;
198
199			if (y==y2) {
200			xstart = x2 * scale;
201			rstart = r2 * scale;
202			gstart = g2 * scale;
203			bstart = b2 * scale;
204			}
205			}
206			}
207
208
209	dpavlin	22	DEVICE_ACCESS(ps2_gif)
210	dpavlin	4	{
211	dpavlin	22	unsigned int i;
212	dpavlin	4	struct gif_data *d = extra;
213
214			if (relative_addr + len > DEV_PS2_GIF_LENGTH)
215			return 0;
216
217			if (writeflag==MEM_READ) {
218			debug("[ gif read from addr 0x%x, len=%i ]\n",
219			(int)relative_addr, (int)len);
220			} else {
221			if (data[0] == 0x08 && data[1] == 0x80) {
222			/* Possibly "initialize 640x480 mode": */
223			debug("[ gif: initialize video mode (?) ]\n");
224			} else if (data[0] == 0x04 && data[1] == 0x00 && len > 300) {
225			/* Possibly "output 8x16 character": */
226			int xbase, ybase, xsize, ysize, x, y;
227
228			xbase = data[94 + 0] + (data[94 + 1] << 8);
229			ybase = data[94 + 2] + (data[94 + 3] << 8);
230
231			xsize = data[124 + 0] + (data[124 + 1] << 8);
232			ysize = data[134 + 0] + (data[134 + 1] << 8);
233			ysize &= ~0xf; /* multple of 16 */
234
235			/* debug("[ gif: putchar at (%i,%i), size (%i,%i) "
236			"]\n", xbase, ybase, xsize, ysize); */
237
238			/*
239			* NetBSD and Linux:
240			*
241	dpavlin	22	* [ gif write to addr 0x0 (len=608):
242			* 04 00 00 00 00 00 00 10, 0e 00 00 00 00 00 00 00,
243			* 00 00 00 00 00 00 0a 00, 50 00 00 00 00 00 00 00,
244			* 00 00 00 00 00 00 00 00, 51 00 00 00 00 00 00 00,
245			* 08 00 00 00 16 00 00 00, 52 00 00 00 00 00 00 00,
246			* 00 00 00 00 00 00 00 00, 53 00 00 00 00 00 00 00,
247			* 20 80 00 00 00 00 00 08, 00 00 00 00 00 00 00 00,
248			* 00 00 aa 80 00 00 aa 80, 00 00 aa 80 00 00 aa 80,
249			* 00 00 aa 80 00 00 aa 80, 00 00 aa 80 00 00 aa 80,
250			* aa aa 00 80 aa aa 00 80, 00 00 aa 80 00 00 aa 80,
251			* 00 00 aa 80 00 00 aa 80, 00 00 aa 80 00 00 aa 80,
252	dpavlin	4	*/
253
254			/*
255			fatal("[ gif write to addr 0x%x (len=%i):",
256			(int)relative_addr, (int)len);
257			for (i=0; i<len; i++) {
258			fatal(" %02x", data[i]);
259			if ((i & 7) == 7)
260			fatal(",");
261			if ((i & 31) == 31)
262			fatal("\n");
263			}
264			fatal(" ]\n");
265			*/
266
267			for (y=0; y<ysize; y++) {
268			int fb_addr = (xbase + (ybase+y) * d->xsize)
269			* d->bytes_per_pixel;
270			int addr = (24 + yxsize) 4;
271			for (x=0; x<xsize; x++) {
272	dpavlin	22	/* There are three bytes (r,g,b) at
273			data[addr + 0] .. [addr + 2].
274			TODO: This should be translated to a
275			direct update of the framebuffer. */
276	dpavlin	4
277			dev_fb_access(d->cpu, d->cpu->mem,
278	dpavlin	22	fb_addr, data + addr, 3, MEM_WRITE,
279			d->vfb_data);
280	dpavlin	4
281			fb_addr += d->bytes_per_pixel;
282			addr += 4;
283			}
284			}
285	dpavlin	22	} else if (data[0] == 0x04 && data[1] == 0x80 && len == 0x50) {
286			/* blockcopy */
287	dpavlin	4	int y_source, y_dest, x_source, x_dest, x_size, y_size;
288			x_source = data[84 + 0] + ((data[84 + 1]) << 8);
289			y_source = data[84 + 2] + ((data[84 + 3]) << 8);
290			x_dest = data[94 + 0] + ((data[94 + 1]) << 8);
291			y_dest = data[94 + 2] + ((data[94 + 3]) << 8);
292			x_size = data[124 + 0] + ((data[124 + 1]) << 8);
293			y_size = data[134 + 0] + ((data[134 + 1]) << 8);
294
295	dpavlin	22	/* debug("[ gif: blockcopy (%i,%i) -> (%i,%i), size="
296			"(%i,%i) ]\n", x_source,y_source, x_dest,y_dest,
297			x_size,y_size); */
298	dpavlin	4
299	dpavlin	22	framebuffer_blockcopyfill(d->vfb_data, 0, 0,0,0,
300			x_dest, y_dest, x_dest + x_size - 1, y_dest +
301			y_size - 1, x_source, y_source);
302			} else if (data[8] == 0x10 && data[9] == 0x55 && len == 48) {
303			/* Linux "clear": This is used by linux to clear the
304			lowest 16 pixels of the framebuffer. */
305	dpavlin	4	int xbase, ybase, xend, yend;
306
307			xbase = (data[84 + 0] + (data[84 + 1] << 8)) / 16;
308			ybase = (data[84 + 2] + (data[84 + 3] << 8)) / 16;
309			xend = (data[85 + 0] + (data[85 + 1] << 8)) / 16;
310			yend = (data[85 + 2] + (data[85 + 3] << 8)) / 16;
311
312	dpavlin	22	/* debug("[ gif: linux \"clear\" (%i,%i)-(%i,%i) ]\n",
313			xbase, ybase, xend, yend); */
314	dpavlin	4
315	dpavlin	22	framebuffer_blockcopyfill(d->vfb_data, 1, 0,0,0,
316			xbase, ybase, xend - 1, yend - 1, 0,0);
317			} else if (data[0] == 0x07 && data[1] == 0x80 && len == 128) {
318			/* NetBSD "output cursor": */
319	dpavlin	4	int xbase, ybase, xend, yend, x, y;
320
321			xbase = (data[204 + 0] + (data[204 + 1] << 8)) / 16;
322			ybase = (data[204 + 2] + (data[204 + 3] << 8)) / 16;
323			xend = (data[284 + 0] + (data[284 + 1] << 8)) / 16;
324			yend = (data[284 + 2] + (data[284 + 3] << 8)) / 16;
325
326	dpavlin	22	/* debug("[ gif: NETBSD cursor at (%i,%i)-(%i,%i) ]\n",
327			xbase, ybase, xend, yend); */
328	dpavlin	4
329			/* Output the cursor to framebuffer memory: */
330
331			for (y=ybase; y<=yend; y++)
332			for (x=xbase; x<=xend; x++) {
333	dpavlin	22	int fb_addr = (x + y * d->xsize) *
334			d->bytes_per_pixel;
335	dpavlin	4	unsigned char pixels[3];
336
337			dev_fb_access(d->cpu, d->cpu->mem,
338			fb_addr, pixels, sizeof(pixels),
339			MEM_READ, d->vfb_data);
340
341			pixels[0] = 0xff - pixels[0];
342			pixels[1] = 0xff - pixels[1];
343			pixels[2] = 0xff - pixels[2];
344
345			dev_fb_access(d->cpu, d->cpu->mem,
346			fb_addr, pixels, sizeof(pixels),
347			MEM_WRITE, d->vfb_data);
348			}
349	dpavlin	22	} else if (data[0] == 0x01 && data[1] == 0x00 && len == 80) {
350			/* Linux "output cursor": */
351	dpavlin	4	int xbase, ybase, xend, yend, x, y;
352
353			xbase = (data[78 + 0] + (data[78 + 1] << 8)) / 16;
354			ybase = (data[78 + 2] + (data[78 + 3] << 8)) / 16;
355			xend = (data[88 + 0] + (data[88 + 1] << 8)) / 16;
356			yend = (data[88 + 2] + (data[88 + 3] << 8)) / 16;
357
358	dpavlin	22	debug("[ gif: LINUX cursor at (%i,%i)-(%i,%i) ]\n",
359			xbase, ybase, xend, yend);
360	dpavlin	4
361			/* Output the cursor to framebuffer memory: */
362
363			for (y=ybase; y<=yend; y++)
364			for (x=xbase; x<=xend; x++) {
365	dpavlin	22	int fb_addr = (x + y * d->xsize) *
366			d->bytes_per_pixel;
367	dpavlin	4	unsigned char pixels[3];
368
369			dev_fb_access(d->cpu, d->cpu->mem,
370			fb_addr, pixels, sizeof(pixels),
371			MEM_READ, d->vfb_data);
372
373			pixels[0] = 0xff - pixels[0];
374			pixels[1] = 0xff - pixels[1];
375			pixels[2] = 0xff - pixels[2];
376
377			dev_fb_access(d->cpu, d->cpu->mem,
378			fb_addr, pixels, sizeof(pixels),
379			MEM_WRITE, d->vfb_data);
380			}
381			} else { /* Unknown command: */
382	dpavlin	22	fatal("[ gif write to addr 0x%x (len=%i):",
383			(int)relative_addr, len);
384	dpavlin	4	for (i=0; i<len; i++)
385			fatal(" %02x", data[i]);
386			fatal(" ]\n");
387			/* fatal("Unknown gif command.\n");
388			cpu->running = 0;
389			*/ }
390			}
391
392			return 1;
393			}
394
395
396			/*
397			* devinit_ps2_gif():
398			*
399			* Attached to separate memory by devinit_ps2_gs().
400			*/
401	dpavlin	22	DEVINIT(ps2_gif)
402	dpavlin	4	{
403			struct gif_data *d;
404
405	dpavlin	42	CHECK_ALLOCATION(d = malloc(sizeof(struct gif_data)));
406	dpavlin	4	memset(d, 0, sizeof(struct gif_data));
407
408			d->transparent_text = 0;
409			d->cpu = devinit->machine->cpus[0]; /* TODO */
410			d->xsize = 640; d->ysize = 480;
411			d->bytes_per_pixel = 3;
412
413			d->vfb_data = dev_fb_init(devinit->machine, devinit->machine->memory,
414			PS2_FB_ADDR, VFB_PLAYSTATION2,
415	dpavlin	12	d->xsize, d->ysize, d->xsize, d->ysize, 24, "Playstation 2");
416	dpavlin	4	if (d->vfb_data == NULL) {
417			fprintf(stderr, "could not initialize fb, out of memory\n");
418			exit(1);
419			}
420
421			#if 0
422	dpavlin	22	test_triangle(d, 300,50, 255,0,0, 50,150, 0,255,0, 600,400, 0,0,255);
423			test_triangle(d, 310,210, 128,32,0, 175,410, 0,32,0,
424			500,470, 125,255,125);
425			test_triangle(d, 100,450, 255,255,0, 250,370, 0,255,255,
426			400,470, 255,0,255);
427	dpavlin	4	#endif
428
429			memory_device_register(devinit->machine->memory, devinit->name,
430			devinit->addr, DEV_PS2_GIF_LENGTH, dev_ps2_gif_access, d,
431	dpavlin	20	DM_DEFAULT, NULL);
432	dpavlin	4
433			return 1;
434			}
435