Usermode/AxWin3 - Updated for PTY support
[tpg/acess2.git] / Usermode / Applications / axwin3_src / WM / video.c
1 /*
2  * Acess2 GUI (AxWin) Version 3
3  * - By John Hodge (thePowersGang)
4  *
5  * video.c
6  * - Video methods
7  */
8 #include <common.h>
9 #include <acess/sys.h>
10 #include <acess/devices/pty.h>
11 #include <acess/devices/pty_cmds.h>
12 #include <image.h>
13 #include "resources/cursor.h"
14 #include <stdio.h>
15 #include <video.h>
16 #include <wm.h>
17 #include <string.h>
18
19 // === IMPORTS ===
20 extern int      giTerminalFD_Input;
21
22 // === PROTOTYPES ===
23 void    Video_Setup(void);
24 void    Video_int_SetBufFmt(int NewFmt);
25 void    Video_SetCursorPos(short X, short Y);
26 void    Video_Update(void);
27 void    Video_FillRect(int X, int Y, int W, int H, uint32_t Color);
28
29 // === GLOBALS ===
30  int    giVideo_CursorX;
31  int    giVideo_CursorY;
32 uint32_t        *gpScreenBuffer;
33  int    giVideo_FirstDirtyLine;
34  int    giVideo_LastDirtyLine;
35
36 // === CODE ===
37 void Video_Setup(void)
38 {
39          int    rv;
40         
41         // Open terminal
42         #if 0
43         giTerminalFD = _SysOpen(gsTerminalDevice, OPENFLAG_READ|OPENFLAG_WRITE);
44         if( giTerminalFD == -1 )
45         {
46                 fprintf(stderr, "ERROR: Unable to open '%s' (%i)\n", gsTerminalDevice, _errno);
47                 exit(-1);
48         }
49         #else
50         giTerminalFD = 1;
51         giTerminalFD_Input = 0;
52         // Check that the console is a PTY
53         // - _SysIOCtl(..., 0, NULL) returns the type, which should be 2
54         rv = _SysIOCtl(1, DRV_IOCTL_TYPE, NULL);
55         if( rv != DRV_TYPE_TERMINAL )
56         {
57                 fprintf(stderr, "stdout is not a PTY, can't start (%i exp, %i got)\n",
58                         DRV_TYPE_TERMINAL, rv);
59                 _SysDebug("stdout is not an PTY, can't start");
60                 exit(-1);
61         }
62         #endif
63
64         // TODO: Check terminal echoback that it does support graphical modes
65         // And/or have terminal flags fetchable by the client
66
67         // Set mode to video
68         Video_int_SetBufFmt(PTYBUFFMT_FB);      
69
70         // Get dimensions
71         struct ptydims dims;
72         rv = _SysIOCtl( giTerminalFD, PTY_IOCTL_GETDIMS, &dims );
73         if( rv ) {
74                 perror("Can't get terminal dimensions (WTF?)");
75                 exit(-1);
76         }
77         giScreenWidth = dims.PW;
78         giScreenHeight = dims.PH;
79         if( giScreenWidth < 640 || giScreenHeight < 480 ) {
80                 Video_int_SetBufFmt(PTYBUFFMT_TEXT);
81                 _SysDebug("Resoltion too small, 640x480 reqd but %ix%i avail",
82                         giScreenWidth, giScreenHeight);
83                 exit(-1);
84         }
85         _SysDebug("AxWin3 running at %ix%i", dims.PW, dims.PH);
86
87         giVideo_LastDirtyLine = giScreenHeight;
88         
89         // Create local framebuffer (back buffer)
90         gpScreenBuffer = malloc( giScreenWidth*giScreenHeight*4 );
91
92         // Set cursor position and bitmap
93         {
94         Video_int_SetBufFmt(PTYBUFFMT_2DCMD);
95         struct ptycmd_header    hdr = {PTY2D_CMD_SETCURSORBMP,0,0};
96         size_t size = sizeof(hdr) + sizeof(cCursorBitmap) + cCursorBitmap.W*cCursorBitmap.H*4;
97         hdr.len_low = size / 4;
98         hdr.len_hi = size / (256*4);
99         _SysWrite(giTerminalFD, &hdr, sizeof(hdr));
100         _SysDebug("size = %i (%04x:%02x * 4)", size, hdr.len_hi, hdr.len_low);
101         _SysWrite(giTerminalFD, &cCursorBitmap, size-sizeof(hdr));
102         }
103         Video_SetCursorPos( giScreenWidth/2, giScreenHeight/2 );
104 }
105
106 void Video_Update(void)
107 {
108         #if 0
109          int    ofs = giVideo_FirstDirtyLine*giScreenWidth;
110          int    size = (giVideo_LastDirtyLine-giVideo_FirstDirtyLine)*giScreenWidth;
111         
112         if( giVideo_LastDirtyLine == 0 )        return; 
113
114         _SysDebug("Video_Update - Updating lines %i to %i (0x%x+0x%x px)",
115                 giVideo_FirstDirtyLine, giVideo_LastDirtyLine, ofs, size);
116         _SysSeek(giTerminalFD, ofs*4, SEEK_SET);
117         _SysDebug("Video_Update - Sending FD %i %p 0x%x", giTerminalFD, gpScreenBuffer+ofs, size*4);
118         _SysWrite(giTerminalFD, gpScreenBuffer+ofs, size*4);
119         _SysDebug("Video_Update - Done");
120         giVideo_FirstDirtyLine = giScreenHeight;
121         giVideo_LastDirtyLine = 0;
122         #else
123         size_t  size = giScreenHeight * giScreenWidth;
124         Video_int_SetBufFmt(PTYBUFFMT_FB);
125         _SysWrite(giTerminalFD, gpScreenBuffer, size*4);
126         #endif
127 }
128
129 void Video_int_SetBufFmt(int NewFmt)
130 {
131         static int current_fmt;
132         
133         if( current_fmt == NewFmt )
134                 return ;
135         
136         struct ptymode mode = {.InputMode = 0, .OutputMode = NewFmt};
137         int rv = _SysIOCtl( giTerminalFD, PTY_IOCTL_SETMODE, &mode );
138         if( rv ) {
139                 perror("Can't set PTY to framebuffer mode");
140                 exit(-1);
141         }
142         
143         current_fmt = NewFmt;
144 }
145
146 void Video_SetCursorPos(short X, short Y)
147 {
148         struct ptycmd_setcursorpos      cmd;
149         cmd.hdr.cmd = PTY2D_CMD_SETCURSORPOS;
150         cmd.hdr.len_low = sizeof(cmd)/4;
151         cmd.hdr.len_hi = 0;
152         cmd.x = giVideo_CursorX = X;
153         cmd.y = giVideo_CursorY = Y;
154
155         Video_int_SetBufFmt(PTYBUFFMT_2DCMD);   
156         _SysWrite(giTerminalFD, &cmd, sizeof(cmd));
157 }
158
159 void Video_FillRect(int X, int Y, int W, int H, uint32_t Colour)
160 {
161         uint32_t        *dest;
162          int    i;
163         
164         if(X < 0 || Y < 0)      return;
165         if(W >= giScreenWidth)  return;
166         if(H >= giScreenHeight) return;
167         if(X + W >= giScreenWidth)      W = giScreenWidth - W;
168         if(Y + H >= giScreenHeight)     W = giScreenHeight - H;
169         
170         dest = gpScreenBuffer + Y * giScreenWidth + X;
171         while(H --)
172         {
173                 for( i = W; i --; dest ++ )     *dest = Colour;
174                 dest += giScreenWidth - W;
175         }
176 }
177
178 /**
179  * \brief Blit an entire buffer to the screen
180  * \note Assumes Pitch = 4*W
181  */
182 void Video_Blit(uint32_t *Source, short DstX, short DstY, short W, short H)
183 {
184         uint32_t        *buf;
185         short   drawW = W;
186
187         if( DstX >= giScreenWidth)      return ;
188         if( DstY >= giScreenHeight)     return ;
189         // Drawing oob to left/top, clip
190         if( DstX < 0 ) {
191                 Source += -DstX;
192                 drawW -= -DstX;
193                 DstX = 0;
194         }
195         if( DstY < 0 ) {
196                 Source += (-DstY)*W;
197                 H -= -DstY;
198                 DstY = 0;
199         }
200         if( drawW < 0 ) return ;
201         // Drawing oob to the right, clip
202         if( DstX + drawW > giScreenWidth ) {
203                 //int oldw = drawW;
204                 drawW = giScreenWidth - DstX;
205         }
206         if( DstY + H > giScreenHeight )
207                 H = giScreenHeight - DstY;
208
209         if( W <= 0 || H <= 0 )  return;
210
211         giVideo_FirstDirtyLine = MIN(DstY, giVideo_FirstDirtyLine);
212         giVideo_LastDirtyLine  = MAX(DstY+H, giVideo_LastDirtyLine);
213         
214         buf = gpScreenBuffer + DstY*giScreenWidth + DstX;
215         if(drawW != giScreenWidth || W != giScreenWidth)
216         {
217                 while( H -- )
218                 {
219                         memcpy(buf, Source, drawW*4);
220                         Source += W;
221                         buf += giScreenWidth;
222                 }
223         }
224         else
225         {
226                 // Only valid if copying full scanlines on both ends
227                 memcpy(buf, Source, giScreenWidth*H*4);
228         }
229 }
230
231 tColour Video_AlphaBlend(tColour _orig, tColour _new, uint8_t _alpha)
232 {
233         uint16_t        ao,ro,go,bo;
234         uint16_t        an,rn,gn,bn;
235         if( _alpha == 0 )       return _orig;
236         if( _alpha == 255 )     return _new;
237         
238         ao = (_orig >> 24) & 0xFF;
239         ro = (_orig >> 16) & 0xFF;
240         go = (_orig >>  8) & 0xFF;
241         bo = (_orig >>  0) & 0xFF;
242         
243         an = (_new >> 24) & 0xFF;
244         rn = (_new >> 16) & 0xFF;
245         gn = (_new >>  8) & 0xFF;
246         bn = (_new >>  0) & 0xFF;
247
248         if( _alpha == 0x80 ) {
249                 ao = (ao + an) / 2;
250                 ro = (ro + rn) / 2;
251                 go = (go + gn) / 2;
252                 bo = (bo + bn) / 2;
253         }
254         else {
255                 ao = ao*(255-_alpha) + an*_alpha;
256                 ro = ro*(255-_alpha) + rn*_alpha;
257                 go = go*(255-_alpha) + gn*_alpha;
258                 bo = bo*(255-_alpha) + bn*_alpha;
259                 ao /= 255*2;
260                 ro /= 255*2;
261                 go /= 255*2;
262                 bo /= 255*2;
263         }
264
265         return (ao << 24) | (ro << 16) | (go << 8) | bo;
266 }
267

UCC git Repository :: git.ucc.asn.au