code.vuplus.com Git - vuplus_dvbapp/blob - 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
 325 void gPixmap::blit(const gPixmap &src, const eRect &_pos, const gRegion &clip, int flag)
 326 {
 327 //      eDebug("blit: -> %d.%d %d:%d -> %d.%d %d:%d, flags=%d",
 328 //              _pos.x(), _pos.y(), _pos.width(), _pos.height(),
 329 //              clip.extends.x(), clip.extends.y(), clip.extends.width(), clip.extends.height(),
 330 //              flag);
 331         eRect pos = _pos;
 332
 333 //      eDebug("source size: %d %d", src.size().width(), src.size().height());
 334
 335         if (!(flag & blitScale)) /* pos' size is valid only when scaling */
 336                 pos = eRect(pos.topLeft(), src.size());
 337         else if (pos.size() == src.size()) /* no scaling required */
 338                 flag &= ~blitScale;
 339
 340         int scale_x = FIX, scale_y = FIX;
 341
 342         if (flag & blitScale)
 343         {
 344                 ASSERT(src.size().width());
 345                 ASSERT(src.size().height());
 346                 scale_x = pos.size().width() * FIX / src.size().width();
 347                 scale_y = pos.size().height() * FIX / src.size().height();
 348         }
 349
 350 //      eDebug("SCALE %x %x", scale_x, scale_y);
 351
 352         for (unsigned int i=0; i<clip.rects.size(); ++i)
 353         {
 354 //              eDebug("clip rect: %d %d %d %d", clip.rects[i].x(), clip.rects[i].y(), clip.rects[i].width(), clip.rects[i].height());
 355                 eRect area = pos; /* pos is the virtual (pre-clipping) area on the dest, which can be larger/smaller than src if scaling is enabled */
 356                 area&=clip.rects[i];
 357                 area&=eRect(ePoint(0, 0), size());
 358
 359                 if (area.empty())
 360                         continue;
 361
 362                 eRect srcarea = area;
 363                 srcarea.moveBy(-pos.x(), -pos.y());
 364
 365 //              eDebug("srcarea before scale: %d %d %d %d",
 366 //                      srcarea.x(), srcarea.y(), srcarea.width(), srcarea.height());
 367
 368                 if (flag & blitScale)
 369                         srcarea = eRect(srcarea.x() * FIX / scale_x, srcarea.y() * FIX / scale_y, srcarea.width() * FIX / scale_x, srcarea.height() * FIX / scale_y);
 370
 371 //              eDebug("srcarea after scale: %d %d %d %d",
 372 //                      srcarea.x(), srcarea.y(), srcarea.width(), srcarea.height());
 373
 374                 if ((surface->data_phys && src.surface->data_phys) && (gAccel::getInstance()))
 375                         if (!gAccel::getInstance()->blit(surface, src.surface, area, srcarea, flag))
 376                                 continue;
 377
 378                 if (flag & blitScale)
 379                 {
 380                         eWarning("unimplemented: scale on non-accel surfaces");
 381                         continue;
 382                 }
 383
 384 #ifdef SET_RIGHT_HALF_VFD_SKIN
 385                 if ((surface->bpp == 8) && (src.surface->bpp==8))
 386                 {
 387                         __u8 *srcptr=(__u8*)src.surface->data;
 388                         __u8 *dstptr=(__u8*)surface->data;
 389                         __u8 *nomptr = new __u8[area.width()];
 390                         unsigned char gray_max = 0;
 391                         unsigned char gray_min = 255;
 392                         unsigned char index = 0;
 393                         unsigned char gray_value = 0;
 394                         gRGB pixdata;
 395 //                      printf("[bilt]srcarea.left:%d, src.surface->bypp : %d,srcarea.top() :%d,src.surface->stride : %d\n",srcarea.left(),src.surface->bypp,srcarea.top(),src.surface->stride);
 396                         srcptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
 397 //                      nomptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
 398                         dstptr+=area.left()*surface->bypp+area.top()*surface->stride;
 399                         if(src.surface->clut.colors != 0)
 400                         {
 401                                 for (int y=0; y<area.height(); y++)
 402                                 {
 403                                         for(int x=0;x<area.width();x++)
 404                                         {
 405                                                 index = (unsigned char)(*(srcptr+x+y*src.surface->stride));
 406                                                 pixdata = src.surface->clut.data[index];
 407                                                 gray_value = ((pixdata.r+pixdata.g +pixdata.b)/3);
 408         //                                      printf("%3d ",gray_value);
 409                                                 if(gray_value > gray_max)
 410                                                         gray_max = gray_value;
 411                                                 if(gray_value < gray_min)
 412                                                         gray_min = gray_value;
 413                                         }
 414         //                              printf("\n");
 415                                 }
 416                         }
 417 //                      printf("\n[bilt] ### gray_min : %d, gray_max : %d\n\n",gray_min,gray_max);
 418                         for (int y=0; y<area.height(); y++)
 419                         {
 420                                 if(src.surface->clut.colors != 0)
 421                                 {
 422                                         for(int x=0;x<area.width();x++)
 423                                         {
 424                                                 pixdata = src.surface->clut.data[*(srcptr+x)];
 425                                                 gray_value = ((pixdata.r+pixdata.g +pixdata.b)/3);
 426                                                 if(gray_max==gray_min)
 427                                                         *(nomptr+x)=gray_value;
 428 /*                                              else if(y == 0 || y == area.height()-1 || x == 0 || x == area.width()-1)
 429                                                         *(nomptr+x) = 255;*/
 430                                                 else
 431                                                         *(nomptr+x)=( ((gray_value - gray_min)*255)/(gray_max-gray_min) );
 432         //                                      printf("%3d ",*(nomptr+x));
 433                                         }
 434         //                              printf("\n");
 435                                 }
 436                                 else
 437                                 {
 438                                         for(int x=0;x<area.width();x++)
 439                                         {
 440 /*                                              if(y == 0 || y == area.height()-1 || x == 0 || x == area.width()-1)
 441                                                         *(nomptr+x) = 255;
 442                                                 else
 443                                                         *(nomptr+x)=*(srcptr+x);*/
 444                                                 *(nomptr+x)=*(srcptr+x);
 445 //                                              printf("%3d ",*(nomptr+x));
 446                                         }
 447 //                                      printf("\n");
 448                                 }
 449                                 if (flag & (blitAlphaTest|blitAlphaBlend))
 450                                 {
 451                       // no real alphatest yet
 452                                         int width=area.width();
 453 //                                      unsigned char *src=(unsigned char*)srcptr;
 454                                         unsigned char *src=(unsigned char*)nomptr;
 455                                         unsigned char *dst=(unsigned char*)dstptr;
 456                                                 // use duff's device here!
 457                                         while (width--)
 458                                         {
 459                                                 if (!*src)
 460                                                 {
 461                                                         src++;
 462                                                         dst++;
 463                                                 } else
 464                                                         *dst++=*src++;
 465                                         }
 466                                 } else
 467 //                                      memcpy(dstptr, srcptr, area.width()*surface->bypp);
 468                                         memcpy(dstptr, nomptr, area.width()*surface->bypp);
 469                                 srcptr+=src.surface->stride;
 470                                 dstptr+=surface->stride;
 471                         }
 472                         delete [] nomptr;
 473 #else
 474                 if ((surface->bpp == 8) && (src.surface->bpp==8))
 475                 {
 476                         __u8 *srcptr=(__u8*)src.surface->data;
 477                         __u8 *dstptr=(__u8*)surface->data;
 478
 479                         srcptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
 480                         dstptr+=area.left()*surface->bypp+area.top()*surface->stride;
 481                         for (int y=0; y<area.height(); y++)
 482                         {
 483                                 if (flag & (blitAlphaTest|blitAlphaBlend))
 484                                 {
 485                       // no real alphatest yet
 486                                         int width=area.width();
 487                                         unsigned char *src=(unsigned char*)srcptr;
 488                                         unsigned char *dst=(unsigned char*)dstptr;
 489                                                 // use duff's device here!
 490                                         while (width--)
 491                                         {
 492                                                 if (!*src)
 493                                                 {
 494                                                         src++;
 495                                                         dst++;
 496                                                 } else
 497                                                         *dst++=*src++;
 498                                         }
 499                                 } else
 500                                         memcpy(dstptr, srcptr, area.width()*surface->bypp);
 501                                 srcptr+=src.surface->stride;
 502                                 dstptr+=surface->stride;
 503                         }
 504 #endif
 505                 } else if ((surface->bpp == 32) && (src.surface->bpp==32))
 506                 {
 507                         __u32 *srcptr=(__u32*)src.surface->data;
 508                         __u32 *dstptr=(__u32*)surface->data;
 509
 510                         srcptr+=srcarea.left()+srcarea.top()*src.surface->stride/4;
 511                         dstptr+=area.left()+area.top()*surface->stride/4;
 512                         for (int y=0; y<area.height(); y++)
 513                         {
 514                                 if (flag & blitAlphaTest)
 515                                 {
 516                                         int width=area.width();
 517                                         unsigned long *src=(unsigned long*)srcptr;
 518                                         unsigned long *dst=(unsigned long*)dstptr;
 519
 520                                         while (width--)
 521                                         {
 522                                                 if (!((*src)&0xFF000000))
 523                                                 {
 524                                                         src++;
 525                                                         dst++;
 526                                                 } else
 527                                                         *dst++=*src++;
 528                                         }
 529                                 } else if (flag & blitAlphaBlend)
 530                                 {
 531                                         // uh oh. this is only until hardware accel is working.
 532
 533                                         int width=area.width();
 534                                                         // ARGB color space!
 535                                         unsigned char *src=(unsigned char*)srcptr;
 536                                         unsigned char *dst=(unsigned char*)dstptr;
 537
 538 #define BLEND(x, y, a) (y + ((x-y) * a)/256)
 539                                         while (width--)
 540                                         {
 541                                                 unsigned char sa = src[3];
 542                                                 unsigned char sr = src[2];
 543                                                 unsigned char sg = src[1];
 544                                                 unsigned char sb = src[0];
 545
 546                                                 unsigned char da = dst[3];
 547                                                 unsigned char dr = dst[2];
 548                                                 unsigned char dg = dst[1];
 549                                                 unsigned char db = dst[0];
 550
 551                                                 dst[3] = BLEND(0xFF, da, sa);
 552                                                 dst[2] = BLEND(sr, dr, sa);
 553                                                 dst[1] = BLEND(sg, dg, sa);
 554                                                 dst[0] = BLEND(sb, db, sa);
 555 #undef BLEND
 556
 557                                                 src += 4; dst += 4;
 558                                         }
 559                                 } else
 560                                         memcpy(dstptr, srcptr, area.width()*surface->bypp);
 561                                 srcptr+=src.surface->stride/4;
 562                                 dstptr+=surface->stride/4;
 563                         }
 564                 } else if ((surface->bpp == 32) && (src.surface->bpp==8))
 565                 {
 566                         __u8 *srcptr=(__u8*)src.surface->data;
 567                         __u8 *dstptr=(__u8*)surface->data; // !!
 568                         __u32 pal[256];
 569
 570                         for (int i=0; i<256; ++i)
 571                         {
 572                                 if (src.surface->clut.data && (i<src.surface->clut.colors))
 573                                         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);
 574                                 else
 575                                         pal[i]=0x010101*i;
 576                                 pal[i]^=0xFF000000;
 577                         }
 578
 579                         srcptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
 580                         dstptr+=area.left()*surface->bypp+area.top()*surface->stride;
 581                         for (int y=0; y<area.height(); y++)
 582                         {
 583                                 int width=area.width();
 584                                 unsigned char *psrc=(unsigned char*)srcptr;
 585                                 __u32 *dst=(__u32*)dstptr;
 586                                 if (flag & blitAlphaTest)
 587                                         blit_8i_to_32_at(dst, psrc, pal, width);
 588                                 else if (flag & blitAlphaBlend)
 589                                         blit_8i_to_32_ab(dst, psrc, pal, width);
 590                                 else
 591                                         blit_8i_to_32(dst, psrc, pal, width);
 592                                 srcptr+=src.surface->stride;
 593                                 dstptr+=surface->stride;
 594                         }
 595                 } else if ((surface->bpp == 16) && (src.surface->bpp==8))
 596                 {
 597                         __u8 *srcptr=(__u8*)src.surface->data;
 598                         __u8 *dstptr=(__u8*)surface->data; // !!
 599                         __u32 pal[256];
 600
 601                         for (int i=0; i<256; ++i)
 602                         {
 603                                 __u32 icol;
 604                                 if (src.surface->clut.data && (i<src.surface->clut.colors))
 605                                         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);
 606                                 else
 607                                         icol=0x010101*i;
 608 #if BYTE_ORDER == LITTLE_ENDIAN
 609                                 pal[i] = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
 610 #else
 611                                 pal[i] = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
 612 #endif
 613                                 pal[i]^=0xFF000000;
 614                         }
 615
 616                         srcptr+=srcarea.left()*src.surface->bypp+srcarea.top()*src.surface->stride;
 617                         dstptr+=area.left()*surface->bypp+area.top()*surface->stride;
 618
 619                         if (flag & blitAlphaBlend)
 620                                 eWarning("ignore unsupported 8bpp -> 16bpp alphablend!");
 621
 622                         for (int y=0; y<area.height(); y++)
 623                         {
 624                                 int width=area.width();
 625                                 unsigned char *psrc=(unsigned char*)srcptr;
 626                                 __u16 *dst=(__u16*)dstptr;
 627                                 if (flag & blitAlphaTest)
 628                                         blit_8i_to_16_at(dst, psrc, pal, width);
 629                                 else
 630                                         blit_8i_to_16(dst, psrc, pal, width);
 631                                 srcptr+=src.surface->stride;
 632                                 dstptr+=surface->stride;
 633                         }
 634                 } else if ((surface->bpp == 16) && (src.surface->bpp==32))
 635                 {
 636                         __u8 *srcptr=(__u8*)src.surface->data;
 637                         __u8 *dstptr=(__u8*)surface->data;
 638
 639                         srcptr+=srcarea.left()+srcarea.top()*src.surface->stride;
 640                         dstptr+=area.left()+area.top()*surface->stride;
 641
 642                         if (flag & blitAlphaBlend)
 643                                 eWarning("ignore unsupported 32bpp -> 16bpp alphablend!");
 644
 645                         for (int y=0; y<area.height(); y++)
 646                         {
 647                                 int width=area.width();
 648                                 __u32 *srcp=(__u32*)srcptr;
 649                                 __u16 *dstp=(__u16*)dstptr;
 650
 651                                 if (flag & blitAlphaTest)
 652                                 {
 653                                         while (width--)
 654                                         {
 655                                                 if (!((*srcp)&0xFF000000))
 656                                                 {
 657                                                         srcp++;
 658                                                         dstp++;
 659                                                 } else
 660                                                 {
 661                                                         __u32 icol = *srcp++;
 662 #if BYTE_ORDER == LITTLE_ENDIAN
 663                                                         *dstp++ = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
 664 #else
 665                                                         *dstp++ = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
 666 #endif
 667                                                 }
 668                                         }
 669                                 } else
 670                                 {
 671                                         while (width--)
 672                                         {
 673                                                 __u32 icol = *srcp++;
 674 #if BYTE_ORDER == LITTLE_ENDIAN
 675                                                 *dstp++ = bswap_16(((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19);
 676 #else
 677                                                 *dstp++ = ((icol & 0xFF) >> 3) << 11 | ((icol & 0xFF00) >> 10) << 5 | (icol & 0xFF0000) >> 19;
 678 #endif
 679                                         }
 680                                 }
 681                                 srcptr+=src.surface->stride;
 682                                 dstptr+=surface->stride;
 683                         }
 684                 } else
 685                         eWarning("cannot blit %dbpp from %dbpp", surface->bpp, src.surface->bpp);
 686         }
 687 }
 688
 689 #undef FIX
 690
 691 void gPixmap::mergePalette(const gPixmap &target)
 692 {
 693         if ((!surface->clut.colors) || (!target.surface->clut.colors))
 694                 return;
 695
 696         gColor *lookup=new gColor[surface->clut.colors];
 697
 698         for (int i=0; i<surface->clut.colors; i++)
 699                 lookup[i].color=target.surface->clut.findColor(surface->clut.data[i]);
 700
 701         delete [] surface->clut.data;
 702         surface->clut.colors=target.surface->clut.colors;
 703         surface->clut.data=new gRGB[surface->clut.colors];
 704         memcpy(surface->clut.data, target.surface->clut.data, sizeof(gRGB)*surface->clut.colors);
 705
 706         __u8 *dstptr=(__u8*)surface->data;
 707
 708         for (int ay=0; ay<surface->y; ay++)
 709         {
 710                 for (int ax=0; ax<surface->x; ax++)
 711                         dstptr[ax]=lookup[dstptr[ax]];
 712                 dstptr+=surface->stride;
 713         }
 714
 715         delete [] lookup;
 716 }
 717
 718 static inline int sgn(int a)
 719 {
 720         if (a < 0)
 721                 return -1;
 722         else if (!a)
 723                 return 0;
 724         else
 725                 return 1;
 726 }
 727
 728 void gPixmap::line(const gRegion &clip, ePoint start, ePoint dst, gColor color)
 729 {
 730         __u8 *srf8 = 0;
 731         __u16 *srf16 = 0;
 732         __u32 *srf32 = 0;
 733         int stride = surface->stride;
 734
 735         if (clip.rects.empty())
 736                 return;
 737
 738         __u16 col16;
 739         __u32 col = 0;
 740         if (surface->bpp == 8)
 741                 srf8 = (__u8*)surface->data;
 742         else
 743         {
 744                 srf32 = (__u32*)surface->data;
 745                 if (surface->clut.data && color < surface->clut.colors)
 746                         col=(surface->clut.data[color].a<<24)|(surface->clut.data[color].r<<16)|(surface->clut.data[color].g<<8)|(surface->clut.data[color].b);
 747                 else
 748                         col=0x10101*color;
 749                 col^=0xFF000000;
 750         }
 751
 752         if (surface->bpp == 16)
 753 #if BYTE_ORDER == LITTLE_ENDIAN
 754                 col16=bswap_16(((col & 0xFF) >> 3) << 11 | ((col & 0xFF00) >> 10) << 5 | (col & 0xFF0000) >> 19);
 755 #else
 756                 col16=((col & 0xFF) >> 3) << 11 | ((col & 0xFF00) >> 10) << 5 | (col & 0xFF0000) >> 19;
 757 #endif
 758
 759         int xa = start.x(), ya = start.y(), xb = dst.x(), yb = dst.y();
 760         int dx, dy, x, y, s1, s2, e, temp, swap, i;
 761         dy=abs(yb-ya);
 762         dx=abs(xb-xa);
 763         s1=sgn(xb-xa);
 764         s2=sgn(yb-ya);
 765         x=xa;
 766         y=ya;
 767         if (dy>dx)
 768         {
 769                 temp=dx;
 770                 dx=dy;
 771                 dy=temp;
 772                 swap=1;
 773         } else
 774                 swap=0;
 775         e = 2*dy-dx;
 776
 777         int lasthit = 0;
 778         for(i=1; i<=dx; i++)
 779         {
 780                                 /* i don't like this clipping loop, but the only */
 781                                 /* other choice i see is to calculate the intersections */
 782                                 /* before iterating through the pixels. */
 783
 784                                 /* one could optimize this because of the ordering */
 785                                 /* of the bands. */
 786
 787                 lasthit = 0;
 788                 int a = lasthit;
 789
 790                         /* if last pixel was invisble, first check bounding box */
 791                 if (a == -1)
 792                 {
 793                                 /* check if we just got into the bbox again */
 794                         if (clip.extends.contains(x, y))
 795                                 lasthit = a = 0;
 796                         else
 797                                 goto fail;
 798                 } else if (!clip.rects[a].contains(x, y))
 799                 {
 800                         do
 801                         {
 802                                 ++a;
 803                                 if ((unsigned int)a == clip.rects.size())
 804                                         a = 0;
 805                                 if (a == lasthit)
 806                                 {
 807                                         goto fail;
 808                                         lasthit = -1;
 809                                 }
 810                         } while (!clip.rects[a].contains(x, y));
 811                         lasthit = a;
 812                 }
 813
 814                 if (srf8)
 815                         srf8[y * stride + x] = color;
 816                 else if (srf16)
 817                         srf16[y * stride/2 + x] = col16;
 818                 else
 819                         srf32[y * stride/4 + x] = col;
 820 fail:
 821                 while (e>=0)
 822                 {
 823                         if (swap==1)
 824                                 x+=s1;
 825                         else
 826                                 y+=s2;
 827                         e-=2*dx;
 828                 }
 829
 830                 if (swap==1)
 831                         y+=s2;
 832                 else
 833                         x+=s1;
 834                 e+=2*dy;
 835         }
 836 }
 837
 838 gColor gPalette::findColor(const gRGB &rgb) const
 839 {
 840                 /* grayscale? */
 841         if (!data)
 842                 return (rgb.r + rgb.g + rgb.b) / 3;
 843
 844         int difference=1<<30, best_choice=0;
 845         for (int t=0; t<colors; t++)
 846         {
 847                 int ttd;
 848                 int td=(signed)(rgb.r-data[t].r); td*=td; td*=(255-data[t].a);
 849                 ttd=td;
 850                 if (ttd>=difference)
 851                         continue;
 852                 td=(signed)(rgb.g-data[t].g); td*=td; td*=(255-data[t].a);
 853                 ttd+=td;
 854                 if (ttd>=difference)
 855                         continue;
 856                 td=(signed)(rgb.b-data[t].b); td*=td; td*=(255-data[t].a);
 857                 ttd+=td;
 858                 if (ttd>=difference)
 859                         continue;
 860                 td=(signed)(rgb.a-data[t].a); td*=td; td*=255;
 861                 ttd+=td;
 862                 if (ttd>=difference)
 863                         continue;
 864                 if (!ttd)
 865                         return t;
 866                 difference=ttd;
 867                 best_choice=t;
 868         }
 869         return best_choice;
 870 }
 871
 872 DEFINE_REF(gPixmap);
 873
 874 gPixmap::~gPixmap()
 875 {
 876         if (must_delete_surface)
 877                 delete surface;
 878 }
 879
 880 gPixmap::gPixmap(gSurface *surface)
 881         :surface(surface), must_delete_surface(false)
 882 {
 883 }
 884
 885 gPixmap::gPixmap(eSize size, int bpp, int accel)
 886         :must_delete_surface(true)
 887 {
 888         surface = new gSurface(size, bpp, accel);
 889 }
 890