bitmap.c revision 331722 
1/*-
2 * Copyright (c) 1991-1997 S��ren Schmidt
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer,
10 *    in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 *    derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: stable/11/lib/libvgl/bitmap.c 331722 2018-03-29 02:50:57Z eadler $");
31
32#include <sys/types.h>
33#include <signal.h>
34#include <sys/fbio.h>
35#include "vgl.h"
36
37#define min(x, y)	(((x) < (y)) ? (x) : (y))
38
39static byte mask[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};
40static int color2bit[16] = {0x00000000, 0x00000001, 0x00000100, 0x00000101,
41			    0x00010000, 0x00010001, 0x00010100, 0x00010101,
42			    0x01000000, 0x01000001, 0x01000100, 0x01000101,
43			    0x01010000, 0x01010001, 0x01010100, 0x01010101};
44
45static void
46WriteVerticalLine(VGLBitmap *dst, int x, int y, int width, byte *line)
47{
48  int i, pos, last, planepos, start_offset, end_offset, offset;
49  int len;
50  unsigned int word = 0;
51  byte *address;
52  byte *VGLPlane[4];
53
54  switch (dst->Type) {
55  case VIDBUF4:
56  case VIDBUF4S:
57    start_offset = (x & 0x07);
58    end_offset = (x + width) & 0x07;
59    i = (width + start_offset) / 8;
60    if (end_offset)
61	i++;
62    VGLPlane[0] = VGLBuf;
63    VGLPlane[1] = VGLPlane[0] + i;
64    VGLPlane[2] = VGLPlane[1] + i;
65    VGLPlane[3] = VGLPlane[2] + i;
66    pos = 0;
67    planepos = 0;
68    last = 8 - start_offset;
69    while (pos < width) {
70      word = 0;
71      while (pos < last && pos < width)
72	word = (word<<1) | color2bit[line[pos++]&0x0f];
73      VGLPlane[0][planepos] = word;
74      VGLPlane[1][planepos] = word>>8;
75      VGLPlane[2][planepos] = word>>16;
76      VGLPlane[3][planepos] = word>>24;
77      planepos++;
78      last += 8;
79    }
80    planepos--;
81    if (end_offset) {
82      word <<= (8 - end_offset);
83      VGLPlane[0][planepos] = word;
84      VGLPlane[1][planepos] = word>>8;
85      VGLPlane[2][planepos] = word>>16;
86      VGLPlane[3][planepos] = word>>24;
87    }
88    if (start_offset || end_offset)
89      width+=8;
90    width /= 8;
91    outb(0x3ce, 0x01); outb(0x3cf, 0x00);		/* set/reset enable */
92    outb(0x3ce, 0x08); outb(0x3cf, 0xff);		/* bit mask */
93    for (i=0; i<4; i++) {
94      outb(0x3c4, 0x02);
95      outb(0x3c5, 0x01<<i);
96      outb(0x3ce, 0x04);
97      outb(0x3cf, i);
98      pos = VGLAdpInfo.va_line_width*y + x/8;
99      if (dst->Type == VIDBUF4) {
100	if (end_offset)
101	  VGLPlane[i][planepos] |= dst->Bitmap[pos+planepos] & mask[end_offset];
102	if (start_offset)
103	  VGLPlane[i][0] |= dst->Bitmap[pos] & ~mask[start_offset];
104	bcopy(&VGLPlane[i][0], dst->Bitmap + pos, width);
105      } else {	/* VIDBUF4S */
106	if (end_offset) {
107	  offset = VGLSetSegment(pos + planepos);
108	  VGLPlane[i][planepos] |= dst->Bitmap[offset] & mask[end_offset];
109	}
110	offset = VGLSetSegment(pos);
111	if (start_offset)
112	  VGLPlane[i][0] |= dst->Bitmap[offset] & ~mask[start_offset];
113	for (last = width; ; ) {
114	  len = min(VGLAdpInfo.va_window_size - offset, last);
115	  bcopy(&VGLPlane[i][width - last], dst->Bitmap + offset, len);
116	  pos += len;
117	  last -= len;
118	  if (last <= 0)
119	    break;
120	  offset = VGLSetSegment(pos);
121	}
122      }
123    }
124    break;
125  case VIDBUF8X:
126    address = dst->Bitmap + VGLAdpInfo.va_line_width * y + x/4;
127    for (i=0; i<4; i++) {
128      outb(0x3c4, 0x02);
129      outb(0x3c5, 0x01 << ((x + i)%4));
130      for (planepos=0, pos=i; pos<width; planepos++, pos+=4)
131        address[planepos] = line[pos];
132      if ((x + i)%4 == 3)
133	++address;
134    }
135    break;
136  case VIDBUF8S:
137    pos = dst->VXsize * y + x;
138    while (width > 0) {
139      offset = VGLSetSegment(pos);
140      i = min(VGLAdpInfo.va_window_size - offset, width);
141      bcopy(line, dst->Bitmap + offset, i);
142      line += i;
143      pos += i;
144      width -= i;
145    }
146    break;
147  case VIDBUF16S:
148  case VIDBUF24S:
149  case VIDBUF32S:
150    width = width * dst->PixelBytes;
151    pos = (dst->VXsize * y + x) * dst->PixelBytes;
152    while (width > 0) {
153      offset = VGLSetSegment(pos);
154      i = min(VGLAdpInfo.va_window_size - offset, width);
155      bcopy(line, dst->Bitmap + offset, i);
156      line += i;
157      pos += i;
158      width -= i;
159    }
160    break;
161  case VIDBUF8:
162  case MEMBUF:
163    address = dst->Bitmap + dst->VXsize * y + x;
164    bcopy(line, address, width);
165    break;
166  case VIDBUF16:
167  case VIDBUF24:
168  case VIDBUF32:
169    address = dst->Bitmap + (dst->VXsize * y + x) * dst->PixelBytes;
170    bcopy(line, address, width * dst->PixelBytes);
171    break;
172  default:
173    ;
174  }
175}
176
177static void
178ReadVerticalLine(VGLBitmap *src, int x, int y, int width, byte *line)
179{
180  int i, bit, pos, count, planepos, start_offset, end_offset, offset;
181  int width2, len;
182  byte *address;
183  byte *VGLPlane[4];
184
185  switch (src->Type) {
186  case VIDBUF4S:
187    start_offset = (x & 0x07);
188    end_offset = (x + width) & 0x07;
189    count = (width + start_offset) / 8;
190    if (end_offset)
191      count++;
192    VGLPlane[0] = VGLBuf;
193    VGLPlane[1] = VGLPlane[0] + count;
194    VGLPlane[2] = VGLPlane[1] + count;
195    VGLPlane[3] = VGLPlane[2] + count;
196    for (i=0; i<4; i++) {
197      outb(0x3ce, 0x04);
198      outb(0x3cf, i);
199      pos = VGLAdpInfo.va_line_width*y + x/8;
200      for (width2 = count; width2 > 0; ) {
201	offset = VGLSetSegment(pos);
202	len = min(VGLAdpInfo.va_window_size - offset, width2);
203	bcopy(src->Bitmap + offset, &VGLPlane[i][count - width2], len);
204	pos += len;
205	width2 -= len;
206      }
207    }
208    goto read_planar;
209  case VIDBUF4:
210    address = src->Bitmap + VGLAdpInfo.va_line_width * y + x/8;
211    start_offset = (x & 0x07);
212    end_offset = (x + width) & 0x07;
213    count = (width + start_offset) / 8;
214    if (end_offset)
215      count++;
216    VGLPlane[0] = VGLBuf;
217    VGLPlane[1] = VGLPlane[0] + count;
218    VGLPlane[2] = VGLPlane[1] + count;
219    VGLPlane[3] = VGLPlane[2] + count;
220    for (i=0; i<4; i++) {
221      outb(0x3ce, 0x04);
222      outb(0x3cf, i);
223      bcopy(address, &VGLPlane[i][0], count);
224    }
225read_planar:
226    pos = 0;
227    planepos = 0;
228    bit = 7 - start_offset;
229    while (pos < width) {
230      for (; bit >= 0 && pos < width; bit--, pos++) {
231        line[pos] = (VGLPlane[0][planepos] & (1<<bit) ? 1 : 0) |
232                    ((VGLPlane[1][planepos] & (1<<bit) ? 1 : 0) << 1) |
233                    ((VGLPlane[2][planepos] & (1<<bit) ? 1 : 0) << 2) |
234                    ((VGLPlane[3][planepos] & (1<<bit) ? 1 : 0) << 3);
235      }
236      planepos++;
237      bit = 7;
238    }
239    break;
240  case VIDBUF8X:
241    address = src->Bitmap + VGLAdpInfo.va_line_width * y + x/4;
242    for (i=0; i<4; i++) {
243      outb(0x3ce, 0x04);
244      outb(0x3cf, (x + i)%4);
245      for (planepos=0, pos=i; pos<width; planepos++, pos+=4)
246        line[pos] = address[planepos];
247      if ((x + i)%4 == 3)
248	++address;
249    }
250    break;
251  case VIDBUF8S:
252    pos = src->VXsize * y + x;
253    while (width > 0) {
254      offset = VGLSetSegment(pos);
255      i = min(VGLAdpInfo.va_window_size - offset, width);
256      bcopy(src->Bitmap + offset, line, i);
257      line += i;
258      pos += i;
259      width -= i;
260    }
261    break;
262  case VIDBUF16S:
263  case VIDBUF24S:
264  case VIDBUF32S:
265    width = width * src->PixelBytes;
266    pos = (src->VXsize * y + x) * src->PixelBytes;
267    while (width > 0) {
268      offset = VGLSetSegment(pos);
269      i = min(VGLAdpInfo.va_window_size - offset, width);
270      bcopy(src->Bitmap + offset, line, i);
271      line += i;
272      pos += i;
273      width -= i;
274    }
275    break;
276  case VIDBUF8:
277  case MEMBUF:
278    address = src->Bitmap + src->VXsize * y + x;
279    bcopy(address, line, width);
280    break;
281  case VIDBUF16:
282  case VIDBUF24:
283  case VIDBUF32:
284    address = src->Bitmap + (src->VXsize * y + x) * src->PixelBytes;
285    bcopy(address, line, width * src->PixelBytes);
286    break;
287  default:
288    ;
289  }
290}
291
292int
293__VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy,
294	      VGLBitmap *dst, int dstx, int dsty, int width, int hight)
295{
296  int srcline, dstline;
297
298  if (srcx>src->VXsize || srcy>src->VYsize
299	|| dstx>dst->VXsize || dsty>dst->VYsize)
300    return -1;
301  if (srcx < 0) {
302    width=width+srcx; dstx-=srcx; srcx=0;
303  }
304  if (srcy < 0) {
305    hight=hight+srcy; dsty-=srcy; srcy=0;
306  }
307  if (dstx < 0) {
308    width=width+dstx; srcx-=dstx; dstx=0;
309  }
310  if (dsty < 0) {
311    hight=hight+dsty; srcy-=dsty; dsty=0;
312  }
313  if (srcx+width > src->VXsize)
314     width=src->VXsize-srcx;
315  if (srcy+hight > src->VYsize)
316     hight=src->VYsize-srcy;
317  if (dstx+width > dst->VXsize)
318     width=dst->VXsize-dstx;
319  if (dsty+hight > dst->VYsize)
320     hight=dst->VYsize-dsty;
321  if (width < 0 || hight < 0)
322     return -1;
323  if (src->Type == MEMBUF) {
324    for (srcline=srcy, dstline=dsty; srcline<srcy+hight; srcline++, dstline++) {
325      WriteVerticalLine(dst, dstx, dstline, width,
326	(src->Bitmap+(srcline*src->VXsize)+srcx));
327    }
328  }
329  else if (dst->Type == MEMBUF) {
330    for (srcline=srcy, dstline=dsty; srcline<srcy+hight; srcline++, dstline++) {
331      ReadVerticalLine(src, srcx, srcline, width,
332	 (dst->Bitmap+(dstline*dst->VXsize)+dstx));
333    }
334  }
335  else {
336    byte buffer[2048];	/* XXX */
337    byte *p;
338
339    if (width > sizeof(buffer)) {
340      p = malloc(width);
341      if (p == NULL)
342	return 1;
343    } else {
344      p = buffer;
345    }
346    for (srcline=srcy, dstline=dsty; srcline<srcy+hight; srcline++, dstline++) {
347      ReadVerticalLine(src, srcx, srcline, width, p);
348      WriteVerticalLine(dst, dstx, dstline, width, p);
349    }
350    if (width > sizeof(buffer))
351      free(p);
352  }
353  return 0;
354}
355
356int
357VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy,
358	      VGLBitmap *dst, int dstx, int dsty, int width, int hight)
359{
360  int error;
361
362  VGLMouseFreeze(dstx, dsty, width, hight, 0);
363  error = __VGLBitmapCopy(src, srcx, srcy, dst, dstx, dsty, width, hight);
364  VGLMouseUnFreeze();
365  return error;
366}
367
368VGLBitmap
369*VGLBitmapCreate(int type, int xsize, int ysize, byte *bits)
370{
371  VGLBitmap *object;
372
373  if (type != MEMBUF)
374    return NULL;
375  if (xsize < 0 || ysize < 0)
376    return NULL;
377  object = (VGLBitmap *)malloc(sizeof(*object));
378  if (object == NULL)
379    return NULL;
380  object->Type = type;
381  object->Xsize = xsize;
382  object->Ysize = ysize;
383  object->VXsize = xsize;
384  object->VYsize = ysize;
385  object->Xorigin = 0;
386  object->Yorigin = 0;
387  object->Bitmap = bits;
388  return object;
389}
390
391void
392VGLBitmapDestroy(VGLBitmap *object)
393{
394  if (object->Bitmap)
395    free(object->Bitmap);
396  free(object);
397}
398
399int
400VGLBitmapAllocateBits(VGLBitmap *object)
401{
402  object->Bitmap = (byte *)malloc(object->VXsize*object->VYsize);
403  if (object->Bitmap == NULL)
404    return -1;
405  return 0;
406}
407