lcd.c

   1 #include <string.h>
   2
   3 #include "refresh.h"
   4 #include "palette.h"
   5 #include "defs.h"
   6 #include "regs.h"
   7 #include "hw.h"
   8 #include "mem.h"
   9 #include "lcd.h"
  10 #include "rc.h"
  11 #include "fb.h"
  12 #ifdef USE_ASM
  13 #include "asm.h"
  14 #endif
  15
  16 struct lcd lcd;
  17
  18 struct scan scan;
  19
  20 #define BG (scan.bg)
  21 #define WND (scan.wnd)
  22 #define BUF (scan.buf)
  23 #define PRI (scan.pri)
  24
  25 #define PAL1 (scan.pal1)
  26 #define PAL2 (scan.pal2)
  27 #define PAL4 (scan.pal4)
  28
  29 #define VS (scan.vs) /* vissprites */
  30 #define NS (scan.ns)
  31
  32 #define L (scan.l) /* line */
  33 #define X (scan.x) /* screen position */
  34 #define Y (scan.y)
  35 #define S (scan.s) /* tilemap position */
  36 #define T (scan.t)
  37 #define U (scan.u) /* position within tile */
  38 #define V (scan.v)
  39 #define WX (scan.wx)
  40 #define WY (scan.wy)
  41 #define WT (scan.wt)
  42 #define WV (scan.wv)
  43
  44 byte patpix[4096][8][8];
  45 byte patdirty[1024];
  46 byte anydirty;
  47
  48 # define MAX_SCALE 4
  49 static int scale = 1;
  50 static int density = 0;
  51
  52 static int rgb332;
  53
  54 static int sprsort = 1;
  55 static int sprdebug;
  56
  57 #define DEF_PAL { 0x98d0e0, 0x68a0b0, 0x60707C, 0x2C3C3C }
  58
  59 static int dmg_pal[4][4] = { DEF_PAL, DEF_PAL, DEF_PAL, DEF_PAL };
  60
  61 static int usefilter, filterdmg;
  62 static int filter[3][4] = {
  63         { 195,  25,   0,  35 },
  64         {  25, 170,  25,  35 },
  65         {  25,  60, 125,  40 }
  66 };
  67
  68 rcvar_t lcd_exports[] =
  69 {
  70         RCV_INT("scale", &scale, "scaling factor"),
  71         RCV_INT("density", &density, "density!=scale: blank scanlines"),
  72         RCV_BOOL("rgb332", &rgb332, "hi-color game hack in 8bit mode"),
  73         RCV_VECTOR("dmg_bgp", dmg_pal[0], 4, "colors for bg palette"),
  74         RCV_VECTOR("dmg_wndp", dmg_pal[1], 4, "colors for window palette"),
  75         RCV_VECTOR("dmg_obp0", dmg_pal[2], 4, "colors for sprite pal 1"),
  76         RCV_VECTOR("dmg_obp1", dmg_pal[3], 4, "colors for sprite pal 2"),
  77         RCV_BOOL("sprsort", &sprsort, "speedhack: disable sprite sorting"),
  78         RCV_BOOL("sprdebug", &sprdebug, "debug sprite visibility"),
  79         RCV_BOOL("colorfilter", &usefilter, "washed out look like a real CGB"),
  80         RCV_BOOL("filterdmg", &filterdmg, "like colorfilter but for DMG"),
  81         RCV_VECTOR("red", filter[0], 4, "filter values for red"),
  82         RCV_VECTOR("green", filter[1], 4, "filter values for green"),
  83         RCV_VECTOR("blue", filter[2], 4, "filter values for blue"),
  84         RCV_END
  85 };
  86
  87 static byte *vdest;
  88
  89 #if defined(ALLOW_UNALIGNED_IO) && defined(__GNUC__)
  90 #include <stdint.h>
  91 static __inline void memcpy8(void *__restrict dest, const void *__restrict src)
  92 {
  93         typedef uint64_t u64a __attribute__((__may_alias__));
  94         u64a *d = dest;  u64a const* s = src;
  95         *d = *s;
  96 }
  97 #define MEMCPY8(d, s) memcpy8(d, s)
  98 #else
  99 #define MEMCPY8(d, s) memcpy((d), (s), 8)
 100 #endif
 101
 102
 103
 104
 105 #ifndef ASM_UPDATEPATPIX
 106 void updatepatpix()
 107 {
 108         int i, j, k;
 109         int a, c;
 110         byte *vram = lcd.vbank[0];
 111
 112         if (!anydirty) return;
 113         for (i = 0; i < 1024; i++)
 114         {
 115                 if (i == 384) i = 512;
 116                 if (i == 896) break;
 117                 if (!patdirty[i]) continue;
 118                 patdirty[i] = 0;
 119                 for (j = 0; j < 8; j++)
 120                 {
 121                         a = ((i<<4) | (j<<1));
 122                         for (k = 0; k < 8; k++)
 123                         {
 124                                 c = vram[a] & (1<<k) ? 1 : 0;
 125                                 c |= vram[a+1] & (1<<k) ? 2 : 0;
 126                                 patpix[i+1024][j][k] = c;
 127                         }
 128                         for (k = 0; k < 8; k++)
 129                                 patpix[i][j][k] =
 130                                         patpix[i+1024][j][7-k];
 131                 }
 132                 for (j = 0; j < 8; j++)
 133                 {
 134                         for (k = 0; k < 8; k++)
 135                         {
 136                                 patpix[i+2048][j][k] =
 137                                         patpix[i][7-j][k];
 138                                 patpix[i+3072][j][k] =
 139                                         patpix[i+1024][7-j][k];
 140                         }
 141                 }
 142         }
 143         anydirty = 0;
 144 }
 145 #endif /* ASM_UPDATEPATPIX */
 146
 147
 148
 149 void tilebuf()
 150 {
 151         int i, cnt;
 152         int base;
 153         byte *tilemap, *attrmap;
 154         int *tilebuf;
 155         int *wrap;
 156         static int wraptable[64] =
 157         {
 158                 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
 159                 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,-32
 160         };
 161
 162         base = ((R_LCDC & LCDC_BIT_BG_MAP)?0x1C00:0x1800) + (T<<5) + S;
 163         tilemap = lcd.vbank[0] + base;
 164         attrmap = lcd.vbank[1] + base;
 165         tilebuf = BG;
 166         wrap = wraptable + S;
 167         cnt = ((WX + 7) >> 3) + 1;
 168
 169         if (hw.cgb)
 170         {
 171                 if (R_LCDC & LCDC_BIT_TILE_SEL)
 172                         for (i = cnt; i > 0; i--)
 173                         {
 174                                 *(tilebuf++) = *tilemap
 175                                         | (((int)*attrmap & 0x08) << 6)
 176                                         | (((int)*attrmap & 0x60) << 5);
 177                                 *(tilebuf++) = (((int)*attrmap & 0x07) << 2);
 178                                 attrmap += *wrap + 1;
 179                                 tilemap += *(wrap++) + 1;
 180                         }
 181                 else
 182                         for (i = cnt; i > 0; i--)
 183                         {
 184                                 *(tilebuf++) = (256 + ((n8)*tilemap))
 185                                         | (((int)*attrmap & 0x08) << 6)
 186                                         | (((int)*attrmap & 0x60) << 5);
 187                                 *(tilebuf++) = (((int)*attrmap & 0x07) << 2);
 188                                 attrmap += *wrap + 1;
 189                                 tilemap += *(wrap++) + 1;
 190                         }
 191         }
 192         else
 193         {
 194                 if (R_LCDC & LCDC_BIT_TILE_SEL)
 195                         for (i = cnt; i > 0; i--)
 196                         {
 197                                 *(tilebuf++) = *(tilemap++);
 198                                 tilemap += *(wrap++);
 199                         }
 200                 else
 201                         for (i = cnt; i > 0; i--)
 202                         {
 203                                 *(tilebuf++) = (256 + ((n8)*(tilemap++)));
 204                                 tilemap += *(wrap++);
 205                         }
 206         }
 207
 208         if (WX >= 160) return;
 209
 210         base = ((R_LCDC & LCDC_BIT_WIN_MAP)?0x1C00:0x1800) + (WT<<5);
 211         tilemap = lcd.vbank[0] + base;
 212         attrmap = lcd.vbank[1] + base;
 213         tilebuf = WND;
 214         cnt = ((160 - WX) >> 3) + 1;
 215
 216         if (hw.cgb)
 217         {
 218                 if (R_LCDC & LCDC_BIT_TILE_SEL)
 219                         for (i = cnt; i > 0; i--)
 220                         {
 221                                 *(tilebuf++) = *(tilemap++)
 222                                         | (((int)*attrmap & 0x08) << 6)
 223                                         | (((int)*attrmap & 0x60) << 5);
 224                                 *(tilebuf++) = (((int)*(attrmap++)&7) << 2);
 225                         }
 226                 else
 227                         for (i = cnt; i > 0; i--)
 228                         {
 229                                 *(tilebuf++) = (256 + ((n8)*(tilemap++)))
 230                                         | (((int)*attrmap & 0x08) << 6)
 231                                         | (((int)*attrmap & 0x60) << 5);
 232                                 *(tilebuf++) = (((int)*(attrmap++)&7) << 2);
 233                         }
 234         }
 235         else
 236         {
 237                 if (R_LCDC & LCDC_BIT_TILE_SEL)
 238                         for (i = cnt; i > 0; i--)
 239                                 *(tilebuf++) = *(tilemap++);
 240                 else
 241                         for (i = cnt; i > 0; i--)
 242                                 *(tilebuf++) = (256 + ((n8)*(tilemap++)));
 243         }
 244 }
 245
 246
 247 void bg_scan()
 248 {
 249         int cnt;
 250         byte *src, *dest;
 251         int *tile;
 252
 253         if (WX <= 0) return;
 254         cnt = WX;
 255         tile = BG;
 256         dest = BUF;
 257
 258         src = patpix[*(tile++)][V] + U;
 259         memcpy(dest, src, 8-U);
 260         dest += 8-U;
 261         cnt -= 8-U;
 262         if (cnt <= 0) return;
 263         while (cnt >= 8)
 264         {
 265                 src = patpix[*(tile++)][V];
 266                 MEMCPY8(dest, src);
 267                 dest += 8;
 268                 cnt -= 8;
 269         }
 270         src = patpix[*tile][V];
 271         while (cnt--)
 272                 *(dest++) = *(src++);
 273 }
 274
 275 void wnd_scan()
 276 {
 277         int cnt;
 278         byte *src, *dest;
 279         int *tile;
 280
 281         if (WX >= 160) return;
 282         cnt = 160 - WX;
 283         tile = WND;
 284         dest = BUF + WX;
 285
 286         while (cnt >= 8)
 287         {
 288                 src = patpix[*(tile++)][WV];
 289                 MEMCPY8(dest, src);
 290                 dest += 8;
 291                 cnt -= 8;
 292         }
 293         src = patpix[*tile][WV];
 294         while (cnt--)
 295                 *(dest++) = *(src++);
 296 }
 297
 298 static void blendcpy(byte *dest, byte *src, byte b, int cnt)
 299 {
 300         while (cnt--) *(dest++) = *(src++) | b;
 301 }
 302
 303 static int priused(void *attr)
 304 {
 305         un32 *a = attr;
 306         return (int)((a[0]|a[1]|a[2]|a[3]|a[4]|a[5]|a[6]|a[7])&0x80808080);
 307 }
 308
 309 void bg_scan_pri()
 310 {
 311         int cnt, i;
 312         byte *src, *dest;
 313
 314         if (WX <= 0) return;
 315         i = S;
 316         cnt = WX;
 317         dest = PRI;
 318         src = lcd.vbank[1] + ((R_LCDC & LCDC_BIT_BG_MAP)?0x1C00:0x1800) + (T<<5);
 319
 320         if (!priused(src))
 321         {
 322                 memset(dest, 0, cnt);
 323                 return;
 324         }
 325
 326         memset(dest, src[i++&31]&128, 8-U);
 327         dest += 8-U;
 328         cnt -= 8-U;
 329         if (cnt <= 0) return;
 330         while (cnt >= 8)
 331         {
 332                 memset(dest, src[i++&31]&128, 8);
 333                 dest += 8;
 334                 cnt -= 8;
 335         }
 336         memset(dest, src[i&31]&128, cnt);
 337 }
 338
 339 void wnd_scan_pri()
 340 {
 341         int cnt, i;
 342         byte *src, *dest;
 343
 344         if (WX >= 160) return;
 345         i = 0;
 346         cnt = 160 - WX;
 347         dest = PRI + WX;
 348         src = lcd.vbank[1] + ((R_LCDC & LCDC_BIT_WIN_MAP)?0x1C00:0x1800) + (WT<<5);
 349
 350         if (!priused(src))
 351         {
 352                 memset(dest, 0, cnt);
 353                 return;
 354         }
 355
 356         while (cnt >= 8)
 357         {
 358                 memset(dest, src[i++]&128, 8);
 359                 dest += 8;
 360                 cnt -= 8;
 361         }
 362         memset(dest, src[i]&128, cnt);
 363 }
 364
 365 #ifndef ASM_BG_SCAN_COLOR
 366 void bg_scan_color()
 367 {
 368         int cnt;
 369         byte *src, *dest;
 370         int *tile;
 371
 372         if (WX <= 0) return;
 373         cnt = WX;
 374         tile = BG;
 375         dest = BUF;
 376
 377         src = patpix[*(tile++)][V] + U;
 378         blendcpy(dest, src, *(tile++), 8-U);
 379         dest += 8-U;
 380         cnt -= 8-U;
 381         if (cnt <= 0) return;
 382         while (cnt >= 8)
 383         {
 384                 src = patpix[*(tile++)][V];
 385                 blendcpy(dest, src, *(tile++), 8);
 386                 dest += 8;
 387                 cnt -= 8;
 388         }
 389         src = patpix[*(tile++)][V];
 390         blendcpy(dest, src, *(tile++), cnt);
 391 }
 392 #endif
 393
 394 void wnd_scan_color()
 395 {
 396         int cnt;
 397         byte *src, *dest;
 398         int *tile;
 399
 400         if (WX >= 160) return;
 401         cnt = 160 - WX;
 402         tile = WND;
 403         dest = BUF + WX;
 404
 405         while (cnt >= 8)
 406         {
 407                 src = patpix[*(tile++)][WV];
 408                 blendcpy(dest, src, *(tile++), 8);
 409                 dest += 8;
 410                 cnt -= 8;
 411         }
 412         src = patpix[*(tile++)][WV];
 413         blendcpy(dest, src, *(tile++), cnt);
 414 }
 415
 416 static void recolor(byte *buf, byte fill, int cnt)
 417 {
 418         while (cnt--) *(buf++) |= fill;
 419 }
 420
 421 void spr_count()
 422 {
 423         int i;
 424         struct obj *o;
 425
 426         NS = 0;
 427         if (!(R_LCDC & LCDC_BIT_OBJ_EN)) return;
 428
 429         o = lcd.oam.obj;
 430
 431         for (i = 40; i; i--, o++)
 432         {
 433                 if (L >= o->y || L + 16 < o->y)
 434                         continue;
 435                 if (L + 8 >= o->y && !(R_LCDC & LCDC_BIT_OBJ_SIZE))
 436                         continue;
 437                 if (++NS == 10) break;
 438         }
 439 }
 440
 441 void spr_enum()
 442 {
 443         int i, j;
 444         struct obj *o;
 445         struct vissprite ts[10];
 446         int v, pat;
 447         int l, x;
 448
 449         NS = 0;
 450         if (!(R_LCDC & LCDC_BIT_OBJ_EN)) return;
 451
 452         o = lcd.oam.obj;
 453
 454         for (i = 40; i; i--, o++)
 455         {
 456                 if (L >= o->y || L + 16 < o->y)
 457                         continue;
 458                 if (L + 8 >= o->y && !(R_LCDC & LCDC_BIT_OBJ_SIZE))
 459                         continue;
 460                 VS[NS].x = (int)o->x - 8;
 461                 v = L - (int)o->y + 16;
 462                 if (hw.cgb)
 463                 {
 464                         pat = o->pat | (((int)o->flags & 0x60) << 5)
 465                                 | (((int)o->flags & 0x08) << 6);
 466                         VS[NS].pal = 32 + ((o->flags & 0x07) << 2);
 467                 }
 468                 else
 469                 {
 470                         pat = o->pat | (((int)o->flags & 0x60) << 5);
 471                         VS[NS].pal = 32 + ((o->flags & 0x10) >> 2);
 472                 }
 473                 VS[NS].pri = (o->flags & 0x80) >> 7;
 474                 if ((R_LCDC & LCDC_BIT_OBJ_SIZE))
 475                 {
 476                         pat &= ~1;
 477                         if (v >= 8)
 478                         {
 479                                 v -= 8;
 480                                 pat++;
 481                         }
 482                         if (o->flags & 0x40) pat ^= 1;
 483                 }
 484                 VS[NS].buf = patpix[pat][v];
 485                 if (++NS == 10) break;
 486         }
 487         if (!sprsort || hw.cgb) return;
 488         /* not quite optimal but it finally works! */
 489         for (i = 0; i < NS; i++)
 490         {
 491                 l = 0;
 492                 x = VS[0].x;
 493                 for (j = 1; j < NS; j++)
 494                 {
 495                         if (VS[j].x < x)
 496                         {
 497                                 l = j;
 498                                 x = VS[j].x;
 499                         }
 500                 }
 501                 ts[i] = VS[l];
 502                 VS[l].x = 160;
 503         }
 504         memcpy(VS, ts, sizeof ts);
 505 }
 506
 507 void spr_scan()
 508 {
 509         int i, x;
 510         byte pal, b, ns = NS;
 511         byte *src, *dest, *bg, *pri;
 512         struct vissprite *vs;
 513         static byte bgdup[256];
 514
 515         if (!ns) return;
 516
 517         memcpy(bgdup, BUF, 256);
 518         vs = &VS[ns-1];
 519
 520         for (; ns; ns--, vs--)
 521         {
 522                 x = vs->x;
 523                 if (x >= 160) continue;
 524                 if (x <= -8) continue;
 525                 if (x < 0)
 526                 {
 527                         src = vs->buf - x;
 528                         dest = BUF;
 529                         i = 8 + x;
 530                 }
 531                 else
 532                 {
 533                         src = vs->buf;
 534                         dest = BUF + x;
 535                         if (x > 152) i = 160 - x;
 536                         else i = 8;
 537                 }
 538                 pal = vs->pal;
 539                 if (vs->pri)
 540                 {
 541                         bg = bgdup + (dest - BUF);
 542                         while (i--)
 543                         {
 544                                 b = src[i];
 545                                 if (b && !(bg[i]&3)) dest[i] = pal|b;
 546                         }
 547                 }
 548                 else if (hw.cgb)
 549                 {
 550                         bg = bgdup + (dest - BUF);
 551                         pri = PRI + (dest - BUF);
 552                         while (i--)
 553                         {
 554                                 b = src[i];
 555                                 if (b && (!pri[i] || !(bg[i]&3)))
 556                                         dest[i] = pal|b;
 557                         }
 558                 }
 559                 else while (i--) if (src[i]) dest[i] = pal|src[i];
 560                 /* else while (i--) if (src[i]) dest[i] = 31 + ns; */
 561         }
 562         if (sprdebug) for (i = 0; i < NS; i++) BUF[i<<1] = 36;
 563 }
 564
 565
 566
 567
 568
 569
 570 void lcd_begin()
 571 {
 572         if (fb.indexed)
 573         {
 574                 if (rgb332) pal_set332();
 575                 else pal_expire();
 576         }
 577         while (scale * 160 > fb.w || scale * 144 > fb.h) scale--;
 578         vdest = fb.ptr + ((fb.w*fb.pelsize)>>1)
 579                 - (80*fb.pelsize) * scale
 580                 + ((fb.h>>1) - 72*scale) * fb.pitch;
 581         WY = R_WY;
 582 }
 583
 584 void lcd_linetovram() {
 585         int i, work_scale;
 586         byte scalebuf[160*4*MAX_SCALE], *dest;
 587         if (density > scale) density = scale;
 588         if (scale == 1 || fb.delegate_scaling) density = 1;
 589
 590         work_scale = fb.delegate_scaling ? 1: scale;
 591
 592         dest = (density != 1) ? scalebuf : vdest;
 593         if(work_scale > MAX_SCALE) {
 594                 die("error: no code available to scale > %d!", MAX_SCALE);
 595         }
 596
 597         switch (work_scale)
 598         {
 599         case 0:
 600         case 1:
 601                 switch (fb.pelsize)
 602                 {
 603                 case 1:
 604                         refresh_1(dest, BUF, PAL1, 160);
 605                         break;
 606                 case 2:
 607                         refresh_2(dest, BUF, PAL2, 160);
 608                         break;
 609                 case 3:
 610                         refresh_3(dest, BUF, PAL4, 160);
 611                         break;
 612                 case 4:
 613                         refresh_4(dest, BUF, PAL4, 160);
 614                         break;
 615                 }
 616                 break;
 617         case 2:
 618                 switch (fb.pelsize)
 619                 {
 620                 case 1:
 621                         refresh_2(dest, BUF, PAL2, 160);
 622                         break;
 623                 case 2:
 624                         refresh_4(dest, BUF, PAL4, 160);
 625                         break;
 626                 case 3:
 627                         refresh_3_2x(dest, BUF, PAL4, 160);
 628                         break;
 629                 case 4:
 630                         refresh_4_2x(dest, BUF, PAL4, 160);
 631                         break;
 632                 }
 633                 break;
 634         case 3:
 635                 switch (fb.pelsize)
 636                 {
 637                 case 1:
 638                         refresh_3(dest, BUF, PAL4, 160);
 639                         break;
 640                 case 2:
 641                         refresh_2_3x(dest, BUF, PAL2, 160);
 642                         break;
 643                 case 3:
 644                         refresh_3_3x(dest, BUF, PAL4, 160);
 645                         break;
 646                 case 4:
 647                         refresh_4_3x(dest, BUF, PAL4, 160);
 648                         break;
 649                 }
 650                 break;
 651         case 4:
 652                 switch (fb.pelsize)
 653                 {
 654                 case 1:
 655                         refresh_4(dest, BUF, PAL4, 160);
 656                         break;
 657                 case 2:
 658                         refresh_4_2x(dest, BUF, PAL4, 160);
 659                         break;
 660                 case 3:
 661                         refresh_3_4x(dest, BUF, PAL4, 160);
 662                         break;
 663                 case 4:
 664                         refresh_4_4x(dest, BUF, PAL4, 160);
 665                         break;
 666                 }
 667                 break;
 668         default:
 669                 break;
 670         }
 671
 672         if (density != 1)
 673         {
 674                 for (i = 0; i < scale; i++)
 675                 {
 676                         if ((i < density) || ((density <= 0) && !(i&1)))
 677                                 memcpy(vdest, scalebuf, 160 * fb.pelsize * scale);
 678                         vdest += fb.pitch;
 679                 }
 680         }
 681         else vdest += fb.pitch * work_scale;
 682 }
 683
 684 void lcd_refreshline()
 685 {
 686         static int WL = 0;
 687
 688         if (!fb.enabled) return;
 689
 690         if (!(R_LCDC & LCDC_BIT_LCD_EN))
 691                 return; /* should not happen... */
 692
 693         updatepatpix();
 694
 695         L = R_LY;
 696         X = R_SCX;
 697         Y = (R_SCY + L) & 0xff;
 698         S = X >> 3;
 699         T = Y >> 3;
 700         U = X & 7;
 701         V = Y & 7;
 702         if (L == 0) { WY = R_WY; WL = 0; }
 703
 704         WX = R_WX - 7;
 705         if (WY>L || WY<0 || WY>143 || WX<-7 || WX>159 || !(R_LCDC & LCDC_BIT_WIN_EN))
 706                 WX = 160;
 707         else {
 708                 /* in order to have these offsets correct we need to count
 709                    the number of lines that displayed a window */
 710                 WT = WL >> 3;
 711                 WV = WL & 7;
 712                 ++WL;
 713         }
 714
 715         spr_enum();
 716
 717         tilebuf();
 718         if (hw.cgb)
 719         {
 720                 bg_scan_color();
 721                 wnd_scan_color();
 722                 if (NS)
 723                 {
 724                         bg_scan_pri();
 725                         wnd_scan_pri();
 726                 }
 727         }
 728         else
 729         {
 730                 bg_scan();
 731                 wnd_scan();
 732                 recolor(BUF+WX, 0x04, 160-WX);
 733         }
 734         spr_scan();
 735
 736         if (fb.dirty) memset(fb.ptr, 0, fb.pitch * fb.h);
 737         fb.dirty = 0;
 738
 739         lcd_linetovram();
 740 }
 741
 742
 743
 744
 745
 746
 747
 748 static void updatepalette(int i)
 749 {
 750         int c, r, g, b, y, u, v, rr, gg;
 751
 752         c = (lcd.pal[i<<1] | ((int)lcd.pal[(i<<1)|1] << 8)) & 0x7FFF;
 753         r = (c & 0x001F) << 3;
 754         g = (c & 0x03E0) >> 2;
 755         b = (c & 0x7C00) >> 7;
 756         r |= (r >> 5);
 757         g |= (g >> 5);
 758         b |= (b >> 5);
 759
 760         if (usefilter && (filterdmg || hw.cgb))
 761         {
 762                 rr = ((r * filter[0][0] + g * filter[0][1] + b * filter[0][2]) >> 8) + filter[0][3];
 763                 gg = ((r * filter[1][0] + g * filter[1][1] + b * filter[1][2]) >> 8) + filter[1][3];
 764                 b = ((r * filter[2][0] + g * filter[2][1] + b * filter[2][2]) >> 8) + filter[2][3];
 765                 r = rr;
 766                 g = gg;
 767         }
 768
 769         if (fb.yuv)
 770         {
 771                 y = (((r *  263) + (g * 516) + (b * 100)) >> 10) + 16;
 772                 u = (((r *  450) - (g * 377) - (b *  73)) >> 10) + 128;
 773                 v = (((r * -152) - (g * 298) + (b * 450)) >> 10) + 128;
 774                 if (y < 0) y = 0;
 775                 if (y > 255) y = 255;
 776                 if (u < 0) u = 0;
 777                 if (u > 255) u = 255;
 778                 if (v < 0) v = 0;
 779                 if (v > 255) v = 255;
 780                 PAL4[i] = (y<<fb.cc[0].l) | (y<<fb.cc[3].l)
 781                         | (u<<fb.cc[1].l) | (v<<fb.cc[2].l);
 782                 return;
 783         }
 784
 785         if (fb.indexed)
 786         {
 787                 pal_release(PAL1[i]);
 788                 c = pal_getcolor(c, r, g, b);
 789                 PAL1[i] = c;
 790                 PAL2[i] = (c<<8) | c;
 791                 PAL4[i] = (c<<24) | (c<<16) | (c<<8) | c;
 792                 return;
 793         }
 794
 795         r = (r >> fb.cc[0].r) << fb.cc[0].l;
 796         g = (g >> fb.cc[1].r) << fb.cc[1].l;
 797         b = (b >> fb.cc[2].r) << fb.cc[2].l;
 798         c = r|g|b;
 799
 800         switch (fb.pelsize)
 801         {
 802         case 1:
 803                 PAL1[i] = c;
 804                 PAL2[i] = (c<<8) | c;
 805                 PAL4[i] = (c<<24) | (c<<16) | (c<<8) | c;
 806                 break;
 807         case 2:
 808                 PAL2[i] = c;
 809                 PAL4[i] = (c<<16) | c;
 810                 break;
 811         case 3:
 812         case 4:
 813                 PAL4[i] = c;
 814                 break;
 815         }
 816 }
 817
 818 void pal_write(int i, byte b)
 819 {
 820         if (lcd.pal[i] == b) return;
 821         lcd.pal[i] = b;
 822         updatepalette(i>>1);
 823 }
 824
 825 void pal_write_dmg(int i, int mapnum, byte d)
 826 {
 827         int j;
 828         int *cmap = dmg_pal[mapnum];
 829         int c, r, g, b;
 830
 831         if (hw.cgb) return;
 832
 833         /* if (mapnum >= 2) d = 0xe4; */
 834         for (j = 0; j < 8; j += 2)
 835         {
 836                 c = cmap[(d >> j) & 3];
 837                 r = (c & 0xf8) >> 3;
 838                 g = (c & 0xf800) >> 6;
 839                 b = (c & 0xf80000) >> 9;
 840                 c = r|g|b;
 841                 /* FIXME - handle directly without faking cgb */
 842                 pal_write(i+j, c & 0xff);
 843                 pal_write(i+j+1, c >> 8);
 844         }
 845 }
 846
 847 void vram_write(int a, byte b)
 848 {
 849         lcd.vbank[R_VBK&1][a] = b;
 850         if (a >= 0x1800) return;
 851         patdirty[((R_VBK&1)<<9)+(a>>4)] = 1;
 852         anydirty = 1;
 853 }
 854
 855 void vram_dirty()
 856 {
 857         anydirty = 1;
 858         memset(patdirty, 1, sizeof patdirty);
 859 }
 860
 861 void pal_dirty()
 862 {
 863         int i;
 864         if (!hw.cgb)
 865         {
 866                 pal_write_dmg(0, 0, R_BGP);
 867                 pal_write_dmg(8, 1, R_BGP);
 868                 pal_write_dmg(64, 2, R_OBP0);
 869                 pal_write_dmg(72, 3, R_OBP1);
 870         }
 871         for (i = 0; i < 64; i++)
 872                 updatepalette(i);
 873 }
 874
 875 void lcd_reset()
 876 {
 877         memset(&lcd, 0, sizeof lcd);
 878         lcd_begin();
 879         vram_dirty();
 880         pal_dirty();
 881 }
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897