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