fix color oled support
[enigma2.git] / lib / gdi / gpixmap.cpp
1 #include <cstdlib>
2 #include <cstring>
3 #include <lib/gdi/gpixmap.h>
4 #include <lib/gdi/region.h>
5 #include <lib/gdi/accel.h>
6 #include <byteswap.h>
7
8 #ifndef BYTE_ORDER
9 #error "no BYTE_ORDER defined!"
10 #endif
11
12 gLookup::gLookup()
13         :size(0), lookup(0)
14 {
15 }
16
17 gLookup::gLookup(int size, const gPalette &pal, const gRGB &start, const gRGB &end)
18         :size(0), lookup(0)
19 {
20         build(size, pal, start, end);
21 }
22
23 void gLookup::build(int _size, const gPalette &pal, const gRGB &start, const gRGB &end)
24 {
25         if (lookup)
26         {
27                 delete [] lookup;
28                 lookup=0;
29                 size=0;
30         }
31         size=_size;
32         if (!size)
33                 return;
34         lookup=new gColor[size];
35         
36         for (int i=0; i<size; i++)
37         {
38                 gRGB col;
39                 if (i)
40                 {
41                         int rdiff=-start.r+end.r;
42                         int gdiff=-start.g+end.g;
43                         int bdiff=-start.b+end.b;
44                         int adiff=-start.a+end.a;
45                         rdiff*=i; rdiff/=(size-1);
46                         gdiff*=i; gdiff/=(size-1);
47                         bdiff*=i; bdiff/=(size-1);
48                         adiff*=i; adiff/=(size-1);
49                         col.r=start.r+rdiff;
50                         col.g=start.g+gdiff;
51                         col.b=start.b+bdiff;
52                         col.a=start.a+adiff;
53                 } else
54                         col=start;
55                 lookup[i]=pal.findColor(col);
56         }
57 }
58
59 gSurface::gSurface()
60 {
61         x = 0;
62         y = 0;
63         bpp = 0;
64         bypp = 0;
65         stride = 0;
66         data = 0;
67         data_phys = 0;
68         clut.colors = 0;
69         clut.data = 0;
70         type = 0;
71 }
72
73 gSurface::gSurface(eSize size, int _bpp, int accel)
74 {
75         x = size.width();
76         y = size.height();
77         bpp = _bpp;
78
79         switch (bpp)
80         {
81         case 8:
82                 bypp = 1;
83                 break;
84         case 15:
85         case 16:
86                 bypp = 2;
87                 break;
88         case 24:                // never use 24bit mode
89         case 32:
90                 bypp = 4;
91                 break;
92         default:
93                 bypp = (bpp+7)/8;
94         }
95
96         stride = x*bypp;
97         
98         data = 0;
99         data_phys = 0;
100         
101         if (accel)
102         {
103                 stride += 63;
104                 stride &=~63;
105                 
106                 int pal_size = 0;
107                 if (bpp == 8)
108                         pal_size = 256 * 4;
109                 
110                 if (gAccel::getInstance())
111                         eDebug("accel memory: %d", gAccel::getInstance()->accelAlloc(data, data_phys, y * stride + pal_size));
112                 else
113                         eDebug("no accel available");
114         }
115         
116         clut.colors = 0;
117         clut.data = 0;
118
119         if (!data)
120                 data = new unsigned char [y * stride];
121         
122         type = 1;
123 }
124
125 gSurface::~gSurface()
126 {
127         if (type)
128         {
129                 if (data_phys)
130                         gAccel::getInstance()->accelFree(data_phys);
131                 else
132                         delete [] (unsigned char*)data;
133
134                 delete [] clut.data;
135         }
136 }
137
138 gPixmap *gPixmap::lock()
139 {
140         contentlock.lock(1);
141         return this;
142 }
143
144 void gPixmap::unlock()
145 {
146         contentlock.unlock(1);
147 }
148
149 void gPixmap::fill(const gRegion &region, const gColor &color)
150 {
151         unsigned int i;
152         for (i=0; i<region.rects.size(); ++i)
153         {
154                 const eRect &area = region.rects[i];
155                 if (area.empty())
156                         continue;
157
158                 if (surface->bpp == 8)
159                 {
160                         for (int y=area.top(); y<area.bottom(); y++)
161                                 memset(((__u8*)surface->data)+y*surface->stride+area.left(), color.color, area.width());
162                 } else if (surface->bpp == 16)
163                 {
164                         __u32 icol;
165
166                         if (surface->clut.data && color < surface->clut.colors)
167                                 icol=(surface->clut.data[color].a<<24)|(surface->clut.data[color].r<<16)|(surface->clut.data[color].g<<8)|(surface->clut.data[color].b);
168                         else
169                                 icol=0x10101*color;
170 #if BYTE_ORDER == LITTLE_ENDIAN
171                         __u16 col = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
172 #else
173                         __u16 col = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
174 #endif
175                         for (int y=area.top(); y<area.bottom(); y++)
176                         {
177                                 __u16 *dst=(__u16*)(((__u8*)surface->data)+y*surface->stride+area.left()*surface->bypp);
178                                 int x=area.width();
179                                 while (x--)
180                                         *dst++=col;
181                         }
182                 } else if (surface->bpp == 32)
183                 {
184                         __u32 col;
185
186                         if (surface->clut.data && color < surface->clut.colors)
187                                 col=(surface->clut.data[color].a<<24)|(surface->clut.data[color].r<<16)|(surface->clut.data[color].g<<8)|(surface->clut.data[color].b);
188                         else
189                                 col=0x10101*color;
190                         
191                         col^=0xFF000000;
192                         
193                         if (surface->data_phys && gAccel::getInstance())
194                                 if (!gAccel::getInstance()->fill(surface,  area, col))
195                                         continue;
196
197                         for (int y=area.top(); y<area.bottom(); y++)
198                         {
199                                 __u32 *dst=(__u32*)(((__u8*)surface->data)+y*surface->stride+area.left()*surface->bypp);
200                                 int x=area.width();
201                                 while (x--)
202                                         *dst++=col;
203                         }
204                 }       else
205                         eWarning("couldn't fill %d bpp", surface->bpp);
206         }
207 }
208
209 void gPixmap::fill(const gRegion &region, const gRGB &color)
210 {
211         unsigned int i;
212         for (i=0; i<region.rects.size(); ++i)
213         {
214                 const eRect &area = region.rects[i];
215                 if (area.empty())
216                         continue;
217
218                 if (surface->bpp == 32)
219                 {
220                         __u32 col;
221
222                         col = color.argb();
223                         col^=0xFF000000;
224
225                         if (surface->data_phys && gAccel::getInstance())
226                                 if (!gAccel::getInstance()->fill(surface,  area, col))
227                                         continue;
228
229                         for (int y=area.top(); y<area.bottom(); y++)
230                         {
231                                 __u32 *dst=(__u32*)(((__u8*)surface->data)+y*surface->stride+area.left()*surface->bypp);
232                                 int x=area.width();
233                                 while (x--)
234                                         *dst++=col;
235                         }
236                 } else if (surface->bpp == 16)
237                 {
238                         __u32 icol = color.argb();
239 #if BYTE_ORDER == LITTLE_ENDIAN
240                         __u16 col = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
241 #else
242                         __u16 col = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
243 #endif
244                         for (int y=area.top(); y<area.bottom(); y++)
245                         {
246                                 __u16 *dst=(__u16*)(((__u8*)surface->data)+y*surface->stride+area.left()*surface->bypp);
247                                 int x=area.width();
248                                 while (x--)
249                                         *dst++=col;
250                         }
251                 }       else
252                         eWarning("couldn't rgbfill %d bpp", surface->bpp);
253         }
254 }
255
256 static inline void blit_8i_to_32(__u32 *dst, __u8 *src, __u32 *pal, int width)
257 {
258         while (width--)
259                 *dst++=pal[*src++];
260 }
261
262 static inline void blit_8i_to_32_at(__u32 *dst, __u8 *src, __u32 *pal, int width)
263 {
264         while (width--)
265         {
266                 if (!(pal[*src]&0x80000000))
267                 {
268                         src++;
269                         dst++;
270                 } else
271                         *dst++=pal[*src++];
272         }
273 }
274
275 static inline void blit_8i_to_16(__u16 *dst, __u8 *src, __u32 *pal, int width)
276 {
277         while (width--)
278                 *dst++=pal[*src++] & 0xFFFF;
279 }
280
281 static inline void blit_8i_to_16_at(__u16 *dst, __u8 *src, __u32 *pal, int width)
282 {
283         while (width--)
284         {
285                 if (!(pal[*src]&0x80000000))
286                 {
287                         src++;
288                         dst++;
289                 } else
290                         *dst++=pal[*src++] & 0xFFFF;
291         }
292 }
293
294                 /* WARNING, this function is not endian safe! */
295 static void blit_8i_to_32_ab(__u32 *dst, __u8 *src, __u32 *pal, int width)
296 {
297         while (width--)
298         {
299 #define BLEND(x, y, a) (y + (((x-y) * a)>>8))
300                 __u32 srccol = pal[*src++];
301                 __u32 dstcol = *dst;
302                 unsigned char sb = srccol & 0xFF;
303                 unsigned char sg = (srccol >> 8) & 0xFF;
304                 unsigned char sr = (srccol >> 16) & 0xFF;
305                 unsigned char sa = (srccol >> 24) & 0xFF;
306
307                 unsigned char db = dstcol & 0xFF;
308                 unsigned char dg = (dstcol >> 8) & 0xFF;
309                 unsigned char dr = (dstcol >> 16) & 0xFF;
310                 unsigned char da = (dstcol >> 24) & 0xFF;
311
312                 da = BLEND(0xFF, da, sa) & 0xFF;
313                 dr = BLEND(sr, dr, sa) & 0xFF;
314                 dg = BLEND(sg, dg, sa) & 0xFF;
315                 db = BLEND(sb, db, sa) & 0xFF;
316
317 #undef BLEND
318                 *dst++ = db | (dg << 8) | (dr << 16) | (da << 24);
319         }
320 }
321
322 #define FIX 0x10000
323
324 void gPixmap::blit(const gPixmap &src, const eRect &_pos, const gRegion &clip, int flag)
325 {
326 //      eDebug("blit: -> %d.%d %d:%d -> %d.%d %d:%d, flags=%d",
327 //              _pos.x(), _pos.y(), _pos.width(), _pos.height(),
328 //              clip.extends.x(), clip.extends.y(), clip.extends.width(), clip.extends.height(),
329 //              flag);
330         eRect pos = _pos;
331         
332 //      eDebug("source size: %d %d", src.size().width(), src.size().height());
333         
334         if (!(flag & blitScale)) /* pos' size is valid only when scaling */
335                 pos = eRect(pos.topLeft(), src.size());
336         else if (pos.size() == src.size()) /* no scaling required */
337                 flag &= ~blitScale;
338
339         int scale_x = FIX, scale_y = FIX;
340         
341         if (flag & blitScale)
342         {
343                 ASSERT(src.size().width());
344                 ASSERT(src.size().height());
345                 scale_x = pos.size().width() * FIX / src.size().width();
346                 scale_y = pos.size().height() * FIX / src.size().height();
347         }
348         
349 //      eDebug("SCALE %x %x", scale_x, scale_y);
350
351         for (unsigned int i=0; i<clip.rects.size(); ++i)
352         {
353 //              eDebug("clip rect: %d %d %d %d", clip.rects[i].x(), clip.rects[i].y(), clip.rects[i].width(), clip.rects[i].height());
354                 eRect area = pos; /* pos is the virtual (pre-clipping) area on the dest, which can be larger/smaller than src if scaling is enabled */
355                 area&=clip.rects[i];
356                 area&=eRect(ePoint(0, 0), size());
357
358                 if (area.empty())
359                         continue;
360
361                 eRect srcarea = area;
362                 srcarea.moveBy(-pos.x(), -pos.y());
363
364 //              eDebug("srcarea before scale: %d %d %d %d",
365 //                      srcarea.x(), srcarea.y(), srcarea.width(), srcarea.height());
366                 
367                 if (flag & blitScale)
368                         srcarea = eRect(srcarea.x() * FIX / scale_x, srcarea.y() * FIX / scale_y, srcarea.width() * FIX / scale_x, srcarea.height() * FIX / scale_y);
369
370 //              eDebug("srcarea after scale: %d %d %d %d",
371 //                      srcarea.x(), srcarea.y(), srcarea.width(), srcarea.height());
372
373                 if ((surface->data_phys && src.surface->data_phys) && (gAccel::getInstance()))
374                         if (!gAccel::getInstance()->blit(surface, src.surface, area, srcarea, flag))
375                                 continue;
376
377                 if (flag & blitScale)
378                 {
379                         eWarning("unimplemented: scale on non-accel surfaces");
380                         continue;
381                 }
382
383                 if ((surface->bpp == 8) && (src.surface->bpp==8))
384                 {
385                         __u8 *srcptr=(__u8*)src.surface->data;
386                         __u8 *dstptr=(__u8*)surface->data;
387
388                         srcptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
389                         dstptr+=area.left()*surface->bypp+area.top()*surface->stride;
390                         for (int y=0; y<area.height(); y++)
391                         {
392                                 if (flag & (blitAlphaTest|blitAlphaBlend))
393                                 {
394                       // no real alphatest yet
395                                         int width=area.width();
396                                         unsigned char *src=(unsigned char*)srcptr;
397                                         unsigned char *dst=(unsigned char*)dstptr;
398                                                 // use duff's device here!
399                                         while (width--)
400                                         {
401                                                 if (!*src)
402                                                 {
403                                                         src++;
404                                                         dst++;
405                                                 } else
406                                                         *dst++=*src++;
407                                         }
408                                 } else
409                                         memcpy(dstptr, srcptr, area.width()*surface->bypp);
410                                 srcptr+=src.surface->stride;
411                                 dstptr+=surface->stride;
412                         }
413                 } else if ((surface->bpp == 32) && (src.surface->bpp==32))
414                 {
415                         __u32 *srcptr=(__u32*)src.surface->data;
416                         __u32 *dstptr=(__u32*)surface->data;
417
418                         srcptr+=srcarea.left()+srcarea.top()*src.surface->stride/4;
419                         dstptr+=area.left()+area.top()*surface->stride/4;
420                         for (int y=0; y<area.height(); y++)
421                         {
422                                 if (flag & blitAlphaTest)
423                                 {
424                                         int width=area.width();
425                                         unsigned long *src=(unsigned long*)srcptr;
426                                         unsigned long *dst=(unsigned long*)dstptr;
427
428                                         while (width--)
429                                         {
430                                                 if (!((*src)&0xFF000000))
431                                                 {
432                                                         src++;
433                                                         dst++;
434                                                 } else
435                                                         *dst++=*src++;
436                                         }
437                                 } else if (flag & blitAlphaBlend)
438                                 {
439                                         // uh oh. this is only until hardware accel is working.
440
441                                         int width=area.width();
442                                                         // ARGB color space!
443                                         unsigned char *src=(unsigned char*)srcptr;
444                                         unsigned char *dst=(unsigned char*)dstptr;
445
446 #define BLEND(x, y, a) (y + ((x-y) * a)/256)
447                                         while (width--)
448                                         {
449                                                 unsigned char sa = src[3];
450                                                 unsigned char sr = src[2];
451                                                 unsigned char sg = src[1];
452                                                 unsigned char sb = src[0];
453
454                                                 unsigned char da = dst[3];
455                                                 unsigned char dr = dst[2];
456                                                 unsigned char dg = dst[1];
457                                                 unsigned char db = dst[0];
458
459                                                 dst[3] = BLEND(0xFF, da, sa);
460                                                 dst[2] = BLEND(sr, dr, sa);
461                                                 dst[1] = BLEND(sg, dg, sa);
462                                                 dst[0] = BLEND(sb, db, sa);
463 #undef BLEND
464
465                                                 src += 4; dst += 4;
466                                         }
467                                 } else
468                                         memcpy(dstptr, srcptr, area.width()*surface->bypp);
469                                 srcptr+=src.surface->stride/4;
470                                 dstptr+=surface->stride/4;
471                         }
472                 } else if ((surface->bpp == 32) && (src.surface->bpp==8))
473                 {       
474                         __u8 *srcptr=(__u8*)src.surface->data;
475                         __u8 *dstptr=(__u8*)surface->data; // !!
476                         __u32 pal[256];
477
478                         for (int i=0; i<256; ++i)
479                         {
480                                 if (src.surface->clut.data && (i<src.surface->clut.colors))
481                                         pal[i]=(src.surface->clut.data[i].a<<24)|(src.surface->clut.data[i].r<<16)|(src.surface->clut.data[i].g<<8)|(src.surface->clut.data[i].b);
482                                 else
483                                         pal[i]=0x010101*i;
484                                 pal[i]^=0xFF000000;
485                         }
486
487                         srcptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
488                         dstptr+=area.left()*surface->bypp+area.top()*surface->stride;
489                         for (int y=0; y<area.height(); y++)
490                         {
491                                 int width=area.width();
492                                 unsigned char *psrc=(unsigned char*)srcptr;
493                                 __u32 *dst=(__u32*)dstptr;
494                                 if (flag & blitAlphaTest)
495                                         blit_8i_to_32_at(dst, psrc, pal, width);
496                                 else if (flag & blitAlphaBlend)
497                                         blit_8i_to_32_ab(dst, psrc, pal, width);
498                                 else
499                                         blit_8i_to_32(dst, psrc, pal, width);
500                                 srcptr+=src.surface->stride;
501                                 dstptr+=surface->stride;
502                         }
503                 } else if ((surface->bpp == 16) && (src.surface->bpp==8))
504                 {
505                         __u8 *srcptr=(__u8*)src.surface->data;
506                         __u8 *dstptr=(__u8*)surface->data; // !!
507                         __u32 pal[256];
508
509                         for (int i=0; i<256; ++i)
510                         {
511                                 __u32 icol;
512                                 if (src.surface->clut.data && (i<src.surface->clut.colors))
513                                         icol=(src.surface->clut.data[i].a<<24)|(src.surface->clut.data[i].r<<16)|(src.surface->clut.data[i].g<<8)|(src.surface->clut.data[i].b);
514                                 else
515                                         icol=0x010101*i;
516 #if BYTE_ORDER == LITTLE_ENDIAN
517                                 pal[i] = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
518 #else
519                                 pal[i] = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
520 #endif
521                                 pal[i]^=0xFF000000;
522                         }
523
524                         srcptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
525                         dstptr+=area.left()*surface->bypp+area.top()*surface->stride;
526
527                         if (flag & blitAlphaBlend)
528                                 eWarning("ignore unsupported 8bpp -> 16bpp alphablend!");
529
530                         for (int y=0; y<area.height(); y++)
531                         {
532                                 int width=area.width();
533                                 unsigned char *psrc=(unsigned char*)srcptr;
534                                 __u16 *dst=(__u16*)dstptr;
535                                 if (flag & blitAlphaTest)
536                                         blit_8i_to_16_at(dst, psrc, pal, width);
537                                 else
538                                         blit_8i_to_16(dst, psrc, pal, width);
539                                 srcptr+=src.surface->stride;
540                                 dstptr+=surface->stride;
541                         }
542                 } else if ((surface->bpp == 16) && (src.surface->bpp==32))
543                 {
544                         __u8 *srcptr=(__u8*)src.surface->data;
545                         __u8 *dstptr=(__u8*)surface->data;
546
547                         srcptr+=srcarea.left()+srcarea.top()*src.surface->stride;
548                         dstptr+=area.left()+area.top()*surface->stride;
549
550                         if (flag & blitAlphaBlend)
551                                 eWarning("ignore unsupported 32bpp -> 16bpp alphablend!");
552
553                         for (int y=0; y<area.height(); y++)
554                         {
555                                 int width=area.width();
556                                 __u32 *srcp=(__u32*)srcptr;
557                                 __u16 *dstp=(__u16*)dstptr;
558
559                                 if (flag & blitAlphaTest)
560                                 {
561                                         while (width--)
562                                         {
563                                                 if (!((*srcp)&0xFF000000))
564                                                 {
565                                                         srcp++;
566                                                         dstp++;
567                                                 } else
568                                                 {
569                                                         __u32 icol = *srcp++;
570 #if BYTE_ORDER == LITTLE_ENDIAN
571                                                         *dstp++ = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
572 #else
573                                                         *dstp++ = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
574 #endif
575                                                 }
576                                         }
577                                 } else
578                                 {
579                                         while (width--)
580                                         {
581                                                 __u32 icol = *srcp++;
582 #if BYTE_ORDER == LITTLE_ENDIAN
583                                                 *dstp++ = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
584 #else
585                                                 *dstp++ = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
586 #endif
587                                         }
588                                 }
589                                 srcptr+=src.surface->stride;
590                                 dstptr+=surface->stride;
591                         }
592                 } else
593                         eWarning("cannot blit %dbpp from %dbpp", surface->bpp, src.surface->bpp);
594         }
595 }
596
597 #undef FIX
598
599 void gPixmap::mergePalette(const gPixmap &target)
600 {
601         if ((!surface->clut.colors) || (!target.surface->clut.colors))
602                 return;
603
604         gColor *lookup=new gColor[surface->clut.colors];
605
606         for (int i=0; i<surface->clut.colors; i++)
607                 lookup[i].color=target.surface->clut.findColor(surface->clut.data[i]);
608         
609         delete [] surface->clut.data;
610         surface->clut.colors=target.surface->clut.colors;
611         surface->clut.data=new gRGB[surface->clut.colors];
612         memcpy(surface->clut.data, target.surface->clut.data, sizeof(gRGB)*surface->clut.colors);
613
614         __u8 *dstptr=(__u8*)surface->data;
615
616         for (int ay=0; ay<surface->y; ay++)
617         {
618                 for (int ax=0; ax<surface->x; ax++)
619                         dstptr[ax]=lookup[dstptr[ax]];
620                 dstptr+=surface->stride;
621         }
622         
623         delete [] lookup;
624 }
625
626 static inline int sgn(int a)
627 {
628         if (a < 0)
629                 return -1;
630         else if (!a)
631                 return 0;
632         else
633                 return 1;
634 }
635
636 void gPixmap::line(const gRegion &clip, ePoint start, ePoint dst, gColor color)
637 {
638         __u8 *srf8 = 0;
639         __u16 *srf16 = 0;
640         __u32 *srf32 = 0;
641         int stride = surface->stride;
642
643         if (clip.rects.empty())
644                 return;
645
646         __u16 col16;
647         __u32 col = 0;
648         if (surface->bpp == 8)
649                 srf8 = (__u8*)surface->data;
650         else
651         {
652                 srf32 = (__u32*)surface->data;
653                 if (surface->clut.data && color < surface->clut.colors)
654                         col=(surface->clut.data[color].a<<24)|(surface->clut.data[color].r<<16)|(surface->clut.data[color].g<<8)|(surface->clut.data[color].b);
655                 else
656                         col=0x10101*color;
657                 col^=0xFF000000;
658         }
659
660         if (surface->bpp == 16)
661 #if BYTE_ORDER == LITTLE_ENDIAN
662                 col16=bswap_16(((col & 0xFF) >> 3) << 11 | ((col & 0xFF00) >> 10) << 5 | (col & 0xFF0000) >> 19);
663 #else
664                 col16=((col & 0xFF) >> 3) << 11 | ((col & 0xFF00) >> 10) << 5 | (col & 0xFF0000) >> 19;
665 #endif
666
667         int xa = start.x(), ya = start.y(), xb = dst.x(), yb = dst.y();
668         int dx, dy, x, y, s1, s2, e, temp, swap, i;
669         dy=abs(yb-ya);
670         dx=abs(xb-xa);
671         s1=sgn(xb-xa);
672         s2=sgn(yb-ya);
673         x=xa;
674         y=ya;
675         if (dy>dx)
676         {
677                 temp=dx;
678                 dx=dy;
679                 dy=temp;
680                 swap=1;
681         } else
682                 swap=0;
683         e = 2*dy-dx;
684
685         int lasthit = 0;
686         for(i=1; i<=dx; i++)
687         {
688                                 /* i don't like this clipping loop, but the only */
689                                 /* other choice i see is to calculate the intersections */
690                                 /* before iterating through the pixels. */
691                                 
692                                 /* one could optimize this because of the ordering */
693                                 /* of the bands. */
694                                 
695                 lasthit = 0;
696                 int a = lasthit;
697                 
698                         /* if last pixel was invisble, first check bounding box */
699                 if (a == -1)
700                 {
701                                 /* check if we just got into the bbox again */
702                         if (clip.extends.contains(x, y))
703                                 lasthit = a = 0;
704                         else
705                                 goto fail;
706                 } else if (!clip.rects[a].contains(x, y))
707                 {
708                         do
709                         {
710                                 ++a;
711                                 if ((unsigned int)a == clip.rects.size())
712                                         a = 0;
713                                 if (a == lasthit)
714                                 {
715                                         goto fail;
716                                         lasthit = -1;
717                                 }
718                         } while (!clip.rects[a].contains(x, y));
719                         lasthit = a;
720                 }
721
722                 if (srf8)
723                         srf8[y * stride + x] = color;
724                 else if (srf16)
725                         srf16[y * stride/2 + x] = col16;
726                 else
727                         srf32[y * stride/4 + x] = col;
728 fail:
729                 while (e>=0)
730                 {
731                         if (swap==1)
732                                 x+=s1;
733                         else
734                                 y+=s2;
735                         e-=2*dx;
736                 }
737
738                 if (swap==1)
739                         y+=s2;
740                 else
741                         x+=s1;
742                 e+=2*dy;
743         }
744 }
745
746 gColor gPalette::findColor(const gRGB &rgb) const
747 {
748                 /* grayscale? */
749         if (!data)
750                 return (rgb.r + rgb.g + rgb.b) / 3;
751         
752         int difference=1<<30, best_choice=0;
753         for (int t=0; t<colors; t++)
754         {
755                 int ttd;
756                 int td=(signed)(rgb.r-data[t].r); td*=td; td*=(255-data[t].a);
757                 ttd=td;
758                 if (ttd>=difference)
759                         continue;
760                 td=(signed)(rgb.g-data[t].g); td*=td; td*=(255-data[t].a);
761                 ttd+=td;
762                 if (ttd>=difference)
763                         continue;
764                 td=(signed)(rgb.b-data[t].b); td*=td; td*=(255-data[t].a);
765                 ttd+=td;
766                 if (ttd>=difference)
767                         continue;
768                 td=(signed)(rgb.a-data[t].a); td*=td; td*=255;
769                 ttd+=td;
770                 if (ttd>=difference)
771                         continue;
772                 if (!ttd)
773                         return t;
774                 difference=ttd;
775                 best_choice=t;
776         }
777         return best_choice;
778 }
779
780 DEFINE_REF(gPixmap);
781
782 gPixmap::~gPixmap()
783 {
784         if (must_delete_surface)
785                 delete surface;
786 }
787
788 gPixmap::gPixmap(gSurface *surface)
789         :surface(surface), must_delete_surface(false)
790 {
791 }
792
793 gPixmap::gPixmap(eSize size, int bpp, int accel)
794         :must_delete_surface(true)
795 {
796         surface = new gSurface(size, bpp, accel);
797 }
798