source/src/vm/fm7/vram.cpp

   1 /*
   2  * Common source code project -> FM-7 -> Display -> Vram access
   3  * (C) 2015 K.Ohta <whatisthis.sowhat _at_ gmail.com>
   4  * History:
   5  *  Sep 27, 2015 : Split from display.cpp .
   6  */
   7
   8 #include "vm.h"
   9 #include "emu.h"
  10 #include "fm7_display.h"
  11 #if defined(_OPENMP)
  12 #include <omp.h>
  13 #endif
  14
  15 uint8_t DISPLAY::read_vram_l4_400l(uint32_t addr, uint32_t offset)
  16 {
  17 #if defined(_FM77L4)
  18         if(addr < 0x8000) {
  19                 if(workram) {
  20                         uint32_t raddr = addr & 0x3fff;
  21                         if((multimode_accessmask & 0x04) == 0) {
  22                                 return gvram[0x8000 + (raddr + offset) & 0x7fff];
  23                         }
  24                         return 0xff;
  25                 }
  26                 pagemod = addr & 0x4000;
  27                 return gvram[((addr + offset) & mask) | pagemod];
  28         } else if(addr < 0x9800) {
  29                 return textvram[addr & 0x0fff];
  30         } else { // $9800-$bfff
  31                 return subrom_l4[addr - 0x9800];
  32         }
  33 #endif
  34         return 0xff;
  35 }
  36
  37 void DISPLAY::write_vram_l4_400l(uint32_t addr, uint32_t offset, uint32_t data)
  38 {
  39 #if defined(_FM77L4)
  40         if(addr < 0x8000) {
  41                 if(workram) {
  42                         uint32_t raddr = addr & 0x3fff;
  43                         if((multimode_accessmask & 0x04) == 0) {
  44                                 gvram[0x8000 + (raddr + offset) & 0x7fff] = (uint8_t)data;
  45                         }
  46                         return;
  47                 }
  48                 pagemod = addr & 0x4000;
  49                 gvram[((addr + offset) & mask) | pagemod] = (uint8_t)data;
  50         } else if(addr < 0x9800) {
  51                 textvram[addr & 0x0fff] = (uint8_t)data;
  52         } else { // $9800-$bfff
  53                 //return subrom_l4[addr - 0x9800];
  54         }
  55         return;
  56 #endif
  57 }
  58
  59
  60
  61 void DISPLAY::draw_screen()
  62 {
  63 //#if !defined(_FM77AV_VARIANTS)
  64         this->draw_screen2();
  65 //#endif
  66 }
  67
  68 extern config_t config;
  69 void DISPLAY::draw_screen2()
  70 {
  71         int y;
  72         int x;
  73         scrntype_t *p, *pp, *p2;
  74         int yoff;
  75         int yy;
  76         int k;
  77         //uint32_t rgbmask;
  78         uint32_t yoff_d1, yoff_d2;
  79         uint16_t wx_begin, wx_end, wy_low, wy_high;
  80         bool scan_line = config.scan_line;
  81         bool ff = force_update;
  82
  83 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
  84         {
  85                 wx_begin = window_xbegin;
  86                 wx_end   = window_xend;
  87                 wy_low   = window_low;
  88                 wy_high  = window_high;
  89                 bool _flag = window_opened;
  90                 if((wx_begin < wx_end) && (wy_low < wy_high)) {
  91                         window_opened = true;
  92                 } else {
  93                         window_opened = false;
  94                 }
  95                 if(_flag != window_opened) {
  96                         vram_wrote_shadow = true;
  97                 }
  98         }
  99 #endif
 100 //      frame_skip_count_draw++;
 101 #if defined(_FM77AV_VARIANTS)
 102         yoff_d2 = 0;
 103         yoff_d1 = 0;
 104 #else
 105         //if(!(vram_wrote_shadow)) return;
 106         yoff_d1 = yoff_d2 = offset_point;
 107 #endif
 108         // Set blank
 109         int ylines;
 110         int xpixels;
 111         switch(display_mode) {
 112         case DISPLAY_MODE_8_200L:
 113                 xpixels = 640;
 114                 ylines = 200;
 115                 break;
 116         case DISPLAY_MODE_8_400L:
 117                 xpixels = 640;
 118                 ylines = 400;
 119                 break;
 120         default:
 121                 xpixels = 320;
 122                 ylines = 200;
 123                 break;
 124         }
 125 # if !defined(FIXED_FRAMEBUFFER_SIZE)
 126         emu->set_vm_screen_size(xpixels, ylines, WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_WIDTH_ASPECT, WINDOW_HEIGHT_ASPECT);
 127 # endif
 128         emu->set_vm_screen_lines(ylines);
 129         if(!crt_flag) {
 130                 if(crt_flag_bak) {
 131                         scrntype_t *ppp;
 132 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 133                         for(y = 0; y < ylines; y += 8) {
 134                                 for(yy = 0; yy < 8; yy++) {
 135                                         vram_draw_table[y + yy] = false;
 136                                         ppp = emu->get_screen_buffer(y + yy);
 137                                         if(ppp != NULL) memset(ppp, 0x00, xpixels * sizeof(scrntype_t));
 138                                 }
 139                         }
 140 #else
 141                         for(y = 0; y < 400; y += 8) {
 142                                 for(yy = 0; yy < 8; yy++) {
 143                                         vram_draw_table[y + yy] = false;
 144                                         ppp = emu->get_screen_buffer(y + yy);
 145                                         if(ppp != NULL) memset(ppp, 0x00, 640 * sizeof(scrntype_t));
 146                                 }
 147                         }
 148 #endif
 149
 150                 }
 151                 crt_flag_bak = crt_flag;
 152                 return;
 153         }
 154         crt_flag_bak = crt_flag;
 155         if(!(vram_wrote_shadow | ff)) return;
 156         vram_wrote_shadow = false;
 157         if(display_mode == DISPLAY_MODE_8_200L) {
 158                 int ii;
 159                 yoff = 0;
 160 #ifdef USE_GREEN_DISPLAY
 161                 if((config.dipswitch & FM7_DIPSW_GREEN_DISPLAY) != 0) {
 162                         // Green display had only connected to FM-8, FM-7/NEW7 and FM-77.
 163                         for(y = 0; y < 200; y += 8) {
 164                                 for(yy = 0; yy < 8; yy++) {
 165                                         if(!(vram_draw_table[y + yy] | ff)) continue;
 166                                         vram_draw_table[y + yy] = false;
 167 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 168                                         p = emu->get_screen_buffer(y + yy);
 169                                         p2 = NULL;
 170 #else
 171                                         p = emu->get_screen_buffer((y + yy) * 2);
 172                                         p2 = emu->get_screen_buffer((y + yy) * 2 + 1);
 173 #endif
 174                                         if(p == NULL) continue;
 175                                         yoff = (y + yy) * 80;
 176                                         {
 177                                                 for(x = 0; x < 10; x++) {
 178                                                         for(ii = 0; ii < 8; ii++) {
 179                                                                 GETVRAM_8_200L_GREEN(yoff + ii, p, p2, false, scan_line);
 180 #if defined(FIXED_FRAMEBUFFER_SIZE)
 181                                                                 p2 += 8;
 182 #endif
 183                                                                 p += 8;
 184                                                         }
 185                                                         yoff += 8;
 186                                                 }
 187                                         }
 188                                 }
 189                         }
 190                         if(ff) force_update = false;
 191                         return;
 192                 }
 193 #endif
 194                 for(y = 0; y < 200; y += 8) {
 195                         for(yy = 0; yy < 8; yy++) {
 196
 197                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 198                                 vram_draw_table[y + yy] = false;
 199 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 200                                 p = emu->get_screen_buffer(y + yy);
 201                                 p2 = NULL;
 202 #else
 203                                 p = emu->get_screen_buffer((y + yy) * 2);
 204                                 p2 = emu->get_screen_buffer((y + yy) * 2 + 1);
 205 #endif
 206                                 if(p == NULL) continue;
 207                                 yoff = (y + yy) * 80;
 208 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 209                                 if(window_opened && (wy_low <= (y + yy)) && (wy_high > (y + yy))) {
 210                                         for(x = 0; x < 80; x++) {
 211                                                 if((x >= wx_begin) && (x < wx_end)) {
 212                                                         GETVRAM_8_200L(yoff, p, p2, true, scan_line);
 213                                                 } else {
 214                                                         GETVRAM_8_200L(yoff, p, p2, false, scan_line);
 215                                                 }
 216 #if defined(FIXED_FRAMEBUFFER_SIZE)
 217                                                 p2 += 8;
 218 #endif
 219                                                 p += 8;
 220                                                 yoff++;
 221                                         }
 222                                 } else
 223 # endif
 224                                 {
 225                                         for(x = 0; x < 10; x++) {
 226                                                 for(ii = 0; ii < 8; ii++) {
 227                                                         GETVRAM_8_200L(yoff + ii, p, p2, false, scan_line);
 228 #if defined(FIXED_FRAMEBUFFER_SIZE)
 229                                                         p2 += 8;
 230 #endif
 231                                                         p += 8;
 232                                                 }
 233                                                 yoff += 8;
 234                                         }
 235                                 }
 236                         }
 237
 238                 }
 239                 if(ff) force_update = false;
 240                 return;
 241         }
 242 # if defined(_FM77AV_VARIANTS)
 243         if(display_mode == DISPLAY_MODE_4096) {
 244                 uint32_t mask = 0;
 245                 int ii;
 246                 yoff = 0;
 247                 if(!multimode_dispflags[0]) mask = 0x00f;
 248                 if(!multimode_dispflags[1]) mask = mask | 0x0f0;
 249                 if(!multimode_dispflags[2]) mask = mask | 0xf00;
 250                 for(y = 0; y < 200; y += 4) {
 251                         for(yy = 0; yy < 4; yy++) {
 252                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 253                                 vram_draw_table[y + yy] = false;
 254
 255 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 256                                 p = emu->get_screen_buffer(y + yy);
 257                                 p2 = NULL;
 258 #else
 259                                 p = emu->get_screen_buffer((y + yy) * 2 );
 260                                 p2 = emu->get_screen_buffer((y + yy) * 2 + 1);
 261 #endif
 262                                 if(p == NULL) continue;
 263                                 yoff = (y + yy) * 40;
 264 #  if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 265                                 if(window_opened && (wy_low <= (y + yy)) && (wy_high > (y + yy))) {
 266                                         for(x = 0; x < 40; x++) {
 267                                                 if((x >= wx_begin) && (x < wx_end)) {
 268                                                         GETVRAM_4096(yoff, p, p2, mask, true, scan_line);
 269                                                 } else {
 270                                                         GETVRAM_4096(yoff, p, p2, mask, false, scan_line);
 271                                                 }
 272 #if defined(FIXED_FRAMEBUFFER_SIZE)
 273                                                 p2 += 16;
 274                                                 p += 16;
 275 #else
 276                                                 p += 8;
 277 #endif
 278                                                 yoff++;
 279                                         }
 280                                 } else
 281 #  endif
 282                                 {
 283                                         for(x = 0; x < 5; x++) {
 284                                                 for(ii = 0; ii < 8; ii++) {
 285                                                         GETVRAM_4096(yoff + ii, p, p2, mask, false, scan_line);
 286 #if defined(FIXED_FRAMEBUFFER_SIZE)
 287                                                         p2 += 16;
 288                                                         p += 16;
 289 #else
 290                                                         p += 8;
 291 #endif
 292                                                 }
 293                                                 yoff += 8;
 294                                         }
 295                                 }
 296                         }
 297
 298                 }
 299                 if(ff) force_update = false;
 300                 return;
 301         }
 302 #  if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
 303         else if(display_mode == DISPLAY_MODE_8_400L) {
 304                 int ii;
 305                 yoff = 0;
 306                 //rgbmask = ~multimode_dispmask;
 307                 for(y = 0; y < 400; y += 8) {
 308                         for(yy = 0; yy < 8; yy++) {
 309                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 310                                 vram_draw_table[y + yy] = false;
 311
 312                                 p = emu->get_screen_buffer(y + yy);
 313                                 if(p == NULL) continue;
 314                                 pp = p;
 315                                 yoff = (y + yy) * 80;
 316 #    if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 317                                 if(window_opened && (wy_low <= (y + yy)) && (wy_high  > (y + yy))) {
 318                                         for(x = 0; x < 80; x++) {
 319                                                 if((x >= wx_begin) && (x < wx_end)) {
 320                                                         GETVRAM_8_400L(yoff, p, true);
 321                                                 } else {
 322                                                         GETVRAM_8_400L(yoff, p, false);
 323                                                 }
 324                                                 p += 8;
 325                                                 yoff++;
 326                                         }
 327                                 } else
 328 #    endif
 329                                         for(x = 0; x < 10; x++) {
 330
 331                                                 for(ii = 0; ii < 8; ii++) {
 332                                                         GETVRAM_8_400L(yoff + ii, p);
 333                                                         p += 8;
 334                                                 }
 335                                                 yoff += 8;
 336                                         }
 337                         }
 338                 }
 339                 if(ff) force_update = false;
 340                 return;
 341         } else if(display_mode == DISPLAY_MODE_256k) {
 342                 int ii;
 343                 //rgbmask = ~multimode_dispmask;
 344                 //
 345                 for(y = 0; y < 200; y += 4) {
 346                         for(yy = 0; yy < 4; yy++) {
 347                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 348                                 vram_draw_table[y + yy] = false;
 349 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 350                                 p = emu->get_screen_buffer(y + yy);
 351                                 p2 = NULL;
 352 #else
 353                                 p = emu->get_screen_buffer((y + yy) * 2 );
 354                                 p2 = emu->get_screen_buffer((y + yy) * 2 + 1);
 355 #endif
 356                                 if(p == NULL) continue;
 357                                 pp = p;
 358                                 yoff = (y + yy) * 40;
 359                                 {
 360                                         for(x = 0; x < 5; x++) {
 361                                                 for(ii = 0; ii < 8; ii++) {
 362                                                         GETVRAM_256k(yoff + ii, p, p2, scan_line);
 363 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 364                                                         p += 8;
 365 #else
 366                                                         p += 16;
 367                                                         p2 += 16;
 368 #endif
 369                                                 }
 370                                                 yoff += 8;
 371                                         }
 372                                 }
 373                         }
 374                 }
 375                 if(ff) force_update = false;
 376                 return;
 377         }
 378 #  endif // _FM77AV40
 379 # endif //_FM77AV_VARIANTS
 380 }
 381
 382 bool DISPLAY::screen_update(void)
 383 {
 384         if(crt_flag) {
 385                 bool f = screen_update_flag;
 386                 screen_update_flag = false;
 387                 return f;
 388         } else {
 389                 if(crt_flag_bak) return true;
 390         }
 391         return false;
 392 }
 393
 394 void DISPLAY::reset_screen_update(void)
 395 {
 396         screen_update_flag = false;
 397 }
 398
 399 void DISPLAY::GETVRAM_8_200L(int yoff, scrntype_t *p,
 400                                                          scrntype_t *px,
 401                                                          bool window_inv,
 402                                                          bool scan_line)
 403 {
 404         uint8_t b, r, g;
 405         uint32_t yoff_d;
 406 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 407         int dpage = vram_display_block;
 408 #endif
 409         if(p == NULL) return;
 410         yoff_d = 0;
 411         yoff_d = (yoff + yoff_d) & 0x3fff;
 412
 413 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 414         if(window_inv) {
 415                 if(dpage == 0) {
 416                         dpage = 1;
 417                 } else {
 418                         dpage = 0;
 419                 }
 420         }
 421         if(dpage != 0) yoff_d += 0x18000;
 422 #endif
 423         b = r = g = 0;
 424 #if defined(_FM77AV_VARIANTS)
 425         if(display_page_bak == 1) yoff_d += 0xc000;
 426 #endif
 427         if(!multimode_dispflags[0]) b = gvram_shadow[yoff_d + 0x00000];
 428         if(!multimode_dispflags[1]) r = gvram_shadow[yoff_d + 0x04000];
 429         if(!multimode_dispflags[2]) g = gvram_shadow[yoff_d + 0x08000];
 430
 431         uint16_t *pg = &(bit_trans_table_0[g][0]);
 432         uint16_t *pr = &(bit_trans_table_1[r][0]);
 433         uint16_t *pb = &(bit_trans_table_2[b][0]);
 434         uint16_t tmp_d[8];
 435         scrntype_t tmp_dd[8];
 436
 437 __DECL_VECTORIZED_LOOP
 438         for(int i = 0; i < 8; i++) {
 439                 tmp_d[i] = pr[i];
 440                 tmp_d[i]  = tmp_d[i] | pg[i];
 441                 tmp_d[i]  = tmp_d[i] | pb[i];
 442                 tmp_d[i] = tmp_d[i] >> 5;
 443         }
 444
 445 __DECL_VECTORIZED_LOOP
 446         for(int i = 0; i < 8; i++) {
 447                 tmp_dd[i] = dpalette_pixel[tmp_d[i]];
 448         }
 449 #if defined(FIXED_FRAMEBUFFER_SIZE)
 450         if(scan_line) {
 451 /* Fancy scanline */
 452         #if defined(_RGB555) || defined(_RGBA565)
 453                 static const int shift_factor = 2;
 454         #else // 24bit
 455                 static const int shift_factor = 3;
 456         #endif
 457 __DECL_VECTORIZED_LOOP
 458                 for(int i = 0; i < 8; i++) {
 459                         p[i] = tmp_dd[i];
 460                         tmp_dd[i] = (tmp_dd[i] >> shift_factor) & (const scrntype_t)RGBA_COLOR(31, 31, 31, 255);;
 461                         px[i] = tmp_dd[i];
 462                 }
 463         } else {
 464 __DECL_VECTORIZED_LOOP
 465                 for(int i = 0; i < 8; i++) {
 466                         p[i] = tmp_dd[i];
 467                         px[i] = tmp_dd[i];
 468                 }
 469         }
 470 #else
 471 __DECL_VECTORIZED_LOOP
 472         for(int i = 0; i < 8; i++) {
 473                 p[i] = tmp_dd[i];
 474         }
 475 #endif
 476 }
 477
 478 #if defined(USE_GREEN_DISPLAY)
 479 void DISPLAY::GETVRAM_8_200L_GREEN(int yoff, scrntype_t *p,
 480                                                          scrntype_t *px,
 481                                                          bool window_inv,
 482                                                          bool scan_line)
 483 {
 484         uint8_t b, r, g;
 485         uint32_t yoff_d;
 486 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 487         int dpage = vram_display_block;
 488 #endif
 489         if(p == NULL) return;
 490         yoff_d = 0;
 491         yoff_d = (yoff + yoff_d) & 0x3fff;
 492
 493         b = r = g = 0;
 494         if(!multimode_dispflags[0]) b = gvram_shadow[yoff_d + 0x00000];
 495         if(!multimode_dispflags[1]) r = gvram_shadow[yoff_d + 0x04000];
 496         if(!multimode_dispflags[2]) g = gvram_shadow[yoff_d + 0x08000];
 497
 498         uint16_t *pg = &(bit_trans_table_0[g][0]);
 499         uint16_t *pr = &(bit_trans_table_1[r][0]);
 500         uint16_t *pb = &(bit_trans_table_2[b][0]);
 501         uint16_t tmp_d[8];
 502         scrntype_t tmp_dd[8];
 503
 504 __DECL_VECTORIZED_LOOP
 505         for(int i = 0; i < 8; i++) {
 506                 tmp_d[i] = pr[i];
 507                 tmp_d[i]  = tmp_d[i] | pg[i];
 508                 tmp_d[i]  = tmp_d[i] | pb[i];
 509                 tmp_d[i] = tmp_d[i] >> 5;
 510         }
 511
 512 __DECL_VECTORIZED_LOOP
 513         for(int i = 0; i < 8; i++) {
 514                 tmp_dd[i] = dpalette_pixel_green[tmp_d[i]];
 515         }
 516 #if defined(FIXED_FRAMEBUFFER_SIZE)
 517         if(scan_line) {
 518 /* Fancy scanline */
 519         #if defined(_RGB555) || defined(_RGBA565)
 520                 static const int shift_factor = 2;
 521         #else // 24bit
 522                 static const int shift_factor = 3;
 523         #endif
 524 __DECL_VECTORIZED_LOOP
 525                 for(int i = 0; i < 8; i++) {
 526                         p[i] = tmp_dd[i];
 527                         tmp_dd[i] = (tmp_dd[i] >> shift_factor) & (const scrntype_t)RGBA_COLOR(31, 31, 31, 255);;
 528                         px[i] = tmp_dd[i];
 529                 }
 530         } else {
 531 __DECL_VECTORIZED_LOOP
 532                 for(int i = 0; i < 8; i++) {
 533                         p[i] = tmp_dd[i];
 534                         px[i] = tmp_dd[i];
 535                 }
 536         }
 537 #else
 538 __DECL_VECTORIZED_LOOP
 539         for(int i = 0; i < 8; i++) {
 540                 p[i] = tmp_dd[i];
 541         }
 542 #endif
 543 }
 544 #endif
 545
 546 #if defined(_FM77AV_VARIANTS)
 547 void DISPLAY::GETVRAM_4096(int yoff, scrntype_t *p, scrntype_t *px,
 548                                                    uint32_t mask,
 549                                                    bool window_inv,
 550                                                    bool scan_line)
 551 {
 552         uint32_t b3, r3, g3;
 553         uint8_t  bb[4], rr[4], gg[4];
 554         uint16_t pixels[8];
 555         const uint16_t __masks[8] = {(uint16_t)mask, (uint16_t)mask, (uint16_t)mask, (uint16_t)mask, (uint16_t)mask, (uint16_t)mask, (uint16_t)mask, (uint16_t)mask};
 556         scrntype_t b, r, g;
 557         uint32_t idx;;
 558         scrntype_t pixel;
 559         uint32_t yoff_d1;
 560         uint32_t yoff_d2;
 561 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 562         int dpage = vram_display_block;
 563 # endif
 564         if(p == NULL) return;
 565
 566         yoff_d1 = yoff;
 567         yoff_d2 = yoff;
 568 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 569         if(window_inv) {
 570                 if(dpage == 0) {
 571                         dpage = 1;
 572                 } else {
 573                         dpage = 0;
 574                 }
 575         }
 576         if(dpage != 0) {
 577                 yoff_d1 += 0x18000;
 578                 yoff_d2 += 0x18000;
 579         }
 580 # endif
 581         bb[0] = gvram_shadow[yoff_d1];
 582         bb[1] = gvram_shadow[yoff_d1 + 0x02000];
 583         rr[0] = gvram_shadow[yoff_d1 + 0x04000];
 584         rr[1] = gvram_shadow[yoff_d1 + 0x06000];
 585
 586         gg[0] = gvram_shadow[yoff_d1 + 0x08000];
 587         gg[1] = gvram_shadow[yoff_d1 + 0x0a000];
 588
 589         bb[2] = gvram_shadow[yoff_d2 + 0x0c000];
 590         bb[3] = gvram_shadow[yoff_d2 + 0x0e000];
 591
 592         rr[2] = gvram_shadow[yoff_d2 + 0x10000];
 593         rr[3] = gvram_shadow[yoff_d2 + 0x12000];
 594         gg[2] = gvram_shadow[yoff_d2 + 0x14000];
 595         gg[3] = gvram_shadow[yoff_d2 + 0x16000];
 596
 597         uint16_t tmp_g[8], tmp_r[8], tmp_b[8];
 598         uint16_t *p0, *p1, *p2, *p3;
 599 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 600         scrntype_t tmp_dd[8];
 601 #else
 602         scrntype_t tmp_dd[16];
 603 #endif
 604         // G
 605         p0 = &(bit_trans_table_0[gg[0]][0]);
 606         p1 = &(bit_trans_table_1[gg[1]][0]);
 607         p2 = &(bit_trans_table_2[gg[2]][0]);
 608         p3 = &(bit_trans_table_3[gg[3]][0]);
 609 __DECL_VECTORIZED_LOOP
 610         for(int i = 0; i < 8; i++) {
 611                 tmp_g[i]  = p0[i];
 612                 tmp_g[i]  = tmp_g[i] | p1[i];
 613                 tmp_g[i]  = tmp_g[i] | p2[i];
 614                 tmp_g[i]  = tmp_g[i] | p3[i];
 615         }
 616         // R
 617         p0 = &(bit_trans_table_0[rr[0]][0]);
 618         p1 = &(bit_trans_table_1[rr[1]][0]);
 619         p2 = &(bit_trans_table_2[rr[2]][0]);
 620         p3 = &(bit_trans_table_3[rr[3]][0]);
 621 __DECL_VECTORIZED_LOOP
 622         for(int i = 0; i < 8; i++) {
 623                 tmp_r[i]  = p0[i];
 624                 tmp_r[i]  = tmp_r[i] | p1[i];
 625                 tmp_r[i]  = tmp_r[i] | p2[i];
 626                 tmp_r[i]  = tmp_r[i] | p3[i];
 627         }
 628         // B
 629         p0 = &(bit_trans_table_0[bb[0]][0]);
 630         p1 = &(bit_trans_table_1[bb[1]][0]);
 631         p2 = &(bit_trans_table_2[bb[2]][0]);
 632         p3 = &(bit_trans_table_3[bb[3]][0]);
 633 __DECL_VECTORIZED_LOOP
 634         for(int i = 0; i < 8; i++) {
 635                 tmp_b[i]  = p0[i];
 636                 tmp_b[i]  = tmp_b[i] | p1[i];
 637                 tmp_b[i]  = tmp_b[i] | p2[i];
 638                 tmp_b[i]  = tmp_b[i] | p3[i];
 639         }
 640 __DECL_VECTORIZED_LOOP
 641         for(int i = 0; i < 8; i++) {
 642                 tmp_g[i] <<= 4;
 643                 pixels[i] = tmp_b[i] >> 4;
 644                 pixels[i] = pixels[i] | tmp_r[i];
 645                 pixels[i] = pixels[i] | tmp_g[i];
 646                 pixels[i] = pixels[i] & __masks[i];
 647         }
 648         //for(int i = 0; i < 8; i++) {
 649         //      pixels[i] = pixels[i] & mask;
 650         //}
 651 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 652 __DECL_VECTORIZED_LOOP
 653         for(int i = 0; i < 8; i++) {
 654                 tmp_dd[i] = analog_palette_pixel[pixels[i]];
 655                 p[i] = tmp_dd[i];
 656         }
 657 #else
 658 __DECL_VECTORIZED_LOOP
 659         for(int i = 0; i < 8; i++) {
 660                 tmp_dd[i * 2] = tmp_dd[i * 2 + 1] = analog_palette_pixel[pixels[i]];;
 661         }
 662 __DECL_VECTORIZED_LOOP
 663         for(int i = 0; i < 16; i++) {
 664                 p[i] = tmp_dd[i];
 665         }
 666         if(scan_line) {
 667 /* Fancy scanline */
 668 __DECL_VECTORIZED_LOOP
 669                 for(int i = 0; i < 16; i++) {
 670 #if defined(_RGB888) || defined(_RGBA888)
 671                         tmp_dd[i] = tmp_dd[i] >> 3;
 672 #elif defined(_RGB555)
 673                         tmp_dd[i] = tmp_dd[i] >> 2;
 674 #elif defined(_RGB565)
 675                         tmp_dd[i] = tmp_dd[i] >> 2;
 676 #endif
 677                 }
 678 __DECL_VECTORIZED_LOOP
 679                 for(int i = 0; i < 16; i++) {
 680                         tmp_dd[i] = tmp_dd[i] & (const scrntype_t)RGBA_COLOR(31, 31, 31, 255);
 681                         px[i] = tmp_dd[i];
 682                 }
 683         } else {
 684 __DECL_VECTORIZED_LOOP
 685                 for(int i = 0; i < 16; i++) {
 686                         px[i] = tmp_dd[i];
 687                 }
 688         }
 689 #endif
 690
 691 }
 692 #endif
 693
 694 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
 695 void DISPLAY::GETVRAM_8_400L(int yoff, scrntype_t *p,
 696                                                          bool window_inv)
 697 {
 698         uint8_t b, r, g;
 699         uint32_t dot;
 700         uint32_t yoff_d;
 701 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 702         int dpage = vram_display_block;
 703 # endif
 704         if(p == NULL) return;
 705         yoff_d = yoff;
 706 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 707         if(window_inv) {
 708                 if(dpage == 0) {
 709                         dpage = 1;
 710                 } else {
 711                         dpage = 0;
 712                 }
 713         }
 714         if(dpage != 0) yoff_d += 0x18000;
 715 # endif
 716         b = r = g = 0;
 717         if(!multimode_dispflags[0]) b = gvram_shadow[yoff_d + 0x00000];
 718         if(!multimode_dispflags[1]) r = gvram_shadow[yoff_d + 0x08000];
 719         if(!multimode_dispflags[2]) g = gvram_shadow[yoff_d + 0x10000];
 720
 721         uint16_t *pg = &(bit_trans_table_0[g][0]);
 722         uint16_t *pr = &(bit_trans_table_1[r][0]);
 723         uint16_t *pb = &(bit_trans_table_2[b][0]);
 724         uint16_t tmp_d[8];
 725
 726 __DECL_VECTORIZED_LOOP
 727         for(int i = 0; i < 8; i++) {
 728                 tmp_d[i] = pg[i] | pr[i] | pb[i];
 729                 tmp_d[i] = tmp_d[i] >> 5;
 730         }
 731 __DECL_VECTORIZED_LOOP
 732         for(int i = 0; i < 8; i++) {
 733                 p[i] = dpalette_pixel[tmp_d[i]];
 734         }
 735 }
 736
 737 void DISPLAY::GETVRAM_256k(int yoff, scrntype_t *p, scrntype_t *px, bool scan_line)
 738 {
 739         uint32_t b3, r3, g3;
 740         uint32_t b4, r4, g4;
 741         uint32_t btmp, rtmp, gtmp;
 742
 743         scrntype_t b, r, g;
 744         scrntype_t pixel;
 745         uint32_t _bit;
 746         int _shift;
 747         int cp;
 748         uint32_t yoff_d1;
 749         uint32_t yoff_d2;
 750         if(p == NULL) return;
 751
 752         r3 = g3 = b3 = 0;
 753         r4 = g4 = b4 = 0;
 754         r = g = b = 0;
 755
 756         yoff_d1 = yoff;
 757         yoff_d2 = yoff;
 758
 759         uint8_t  bb[8], rr[8], gg[8];
 760         uint16_t *p0, *p1, *p2, *p3, *p4, *p5;
 761         uint32_t _btmp[8], _rtmp[8], _gtmp[8];
 762 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 763         scrntype_t tmp_dd[8];
 764 #else
 765         scrntype_t tmp_dd[16];
 766 #endif
 767 //      if(mask & 0x01) {
 768         if(!multimode_dispflags[0]) {
 769                 // B
 770                 bb[0] = gvram_shadow[yoff_d1];
 771                 bb[1] = gvram_shadow[yoff_d1 + 0x02000];
 772
 773                 bb[2] = gvram_shadow[yoff_d2 + 0x0c000];
 774                 bb[3] = gvram_shadow[yoff_d2 + 0x0e000];
 775
 776                 bb[4] = gvram_shadow[yoff_d1 + 0x18000];
 777                 bb[5] = gvram_shadow[yoff_d1 + 0x1a000];
 778
 779                 p0 = &(bit_trans_table_0[bb[0]][0]);
 780                 p1 = &(bit_trans_table_1[bb[1]][0]);
 781                 p2 = &(bit_trans_table_2[bb[2]][0]);
 782                 p3 = &(bit_trans_table_3[bb[3]][0]);
 783                 p4 = &(bit_trans_table_4[bb[4]][0]);
 784                 p5 = &(bit_trans_table_5[bb[5]][0]);
 785 __DECL_VECTORIZED_LOOP
 786                 for(int i = 0; i < 8; i++) {
 787                         _btmp[i] = p0[i];
 788                         _btmp[i] = _btmp[i] | p1[i];
 789                         _btmp[i] = _btmp[i] | p2[i];
 790                         _btmp[i] = _btmp[i] | p3[i];
 791                         _btmp[i] = _btmp[i] | p4[i];
 792                         _btmp[i] = _btmp[i] | p5[i];
 793                 }
 794         } else {
 795 __DECL_VECTORIZED_LOOP
 796                 for(int i = 0; i < 8; i++) {
 797                         _btmp[i] = 0;
 798                 }
 799         }
 800         if(!multimode_dispflags[1]) {
 801                 //if(mask & 0x02) {
 802                 // R
 803                 rr[0] = gvram_shadow[yoff_d1 + 0x04000];
 804                 rr[1] = gvram_shadow[yoff_d1 + 0x06000];
 805
 806                 rr[2] = gvram_shadow[yoff_d2 + 0x10000];
 807                 rr[3] = gvram_shadow[yoff_d2 + 0x12000];
 808
 809                 rr[4] = gvram_shadow[yoff_d1 + 0x1c000];
 810                 rr[5] = gvram_shadow[yoff_d1 + 0x1e000];
 811
 812                 p0 = &(bit_trans_table_0[rr[0]][0]);
 813                 p1 = &(bit_trans_table_1[rr[1]][0]);
 814                 p2 = &(bit_trans_table_2[rr[2]][0]);
 815                 p3 = &(bit_trans_table_3[rr[3]][0]);
 816                 p4 = &(bit_trans_table_4[rr[4]][0]);
 817                 p5 = &(bit_trans_table_5[rr[5]][0]);
 818 __DECL_VECTORIZED_LOOP
 819                 for(int i = 0; i < 8; i++) {
 820                         _rtmp[i] = p0[i];
 821                         _rtmp[i] = _rtmp[i] | p1[i];
 822                         _rtmp[i] = _rtmp[i] | p2[i];
 823                         _rtmp[i] = _rtmp[i] | p3[i];
 824                         _rtmp[i] = _rtmp[i] | p4[i];
 825                         _rtmp[i] = _rtmp[i] | p5[i];
 826                 }
 827         } else {
 828 __DECL_VECTORIZED_LOOP
 829                 for(int i = 0; i < 8; i++) {
 830                         _rtmp[i] = 0;
 831                 }
 832         }
 833         if(!multimode_dispflags[2]) {
 834                 //if(mask & 0x04) {
 835                 // G
 836                 gg[0] = gvram_shadow[yoff_d1 + 0x08000];
 837                 gg[1] = gvram_shadow[yoff_d1 + 0x0a000];
 838
 839                 gg[2] = gvram_shadow[yoff_d2 + 0x14000];
 840                 gg[3] = gvram_shadow[yoff_d2 + 0x16000];
 841
 842                 gg[4] = gvram_shadow[yoff_d1 + 0x20000];
 843                 gg[5] = gvram_shadow[yoff_d1 + 0x22000];
 844
 845                 p0 = &(bit_trans_table_0[gg[0]][0]);
 846                 p1 = &(bit_trans_table_1[gg[1]][0]);
 847                 p2 = &(bit_trans_table_2[gg[2]][0]);
 848                 p3 = &(bit_trans_table_3[gg[3]][0]);
 849                 p4 = &(bit_trans_table_4[gg[4]][0]);
 850                 p5 = &(bit_trans_table_5[gg[5]][0]);
 851 __DECL_VECTORIZED_LOOP
 852                 for(int i = 0; i < 8; i++) {
 853                         _gtmp[i] = p0[i];
 854                         _gtmp[i] = _gtmp[i] | p1[i];
 855                         _gtmp[i] = _gtmp[i] | p2[i];
 856                         _gtmp[i] = _gtmp[i] | p3[i];
 857                         _gtmp[i] = _gtmp[i] | p4[i];
 858                         _gtmp[i] = _gtmp[i] | p5[i];
 859                 }
 860         } else {
 861 __DECL_VECTORIZED_LOOP
 862                 for(int i = 0; i < 8; i++) {
 863                         _gtmp[i] = 0;
 864                 }
 865         }
 866 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 867 __DECL_VECTORIZED_LOOP
 868         for(int i = 0; i < 8; i++) {
 869                 tmp_dd[i] = RGB_COLOR(_rtmp[i], _gtmp[i], _btmp[i]);
 870                 p[i] = tmp_dd[i];
 871         }
 872 #else
 873 __DECL_VECTORIZED_LOOP
 874         for(int i = 0; i < 8; i++) {
 875                 tmp_dd[i * 2] = tmp_dd[i * 2 + 1] = RGB_COLOR(_rtmp[i], _gtmp[i], _btmp[i]);
 876         }
 877 __DECL_VECTORIZED_LOOP
 878         for(int i = 0; i < 16; i++) {
 879                 p[i] = tmp_dd[i];
 880         }
 881         if(scan_line) {
 882 /* Fancy scanline */
 883 __DECL_VECTORIZED_LOOP
 884                 for(int i = 0; i < 16; i++) {
 885 #if defined(_RGB888) || defined(_RGBA888)
 886                         tmp_dd[i] = tmp_dd[i] >> 3;
 887 #elif defined(_RGB555)
 888                         tmp_dd[i] = tmp_dd[i] >> 2;
 889 #elif defined(_RGB565)
 890                         tmp_dd[i] = tmp_dd[i] >> 2;
 891 #endif
 892                 }
 893 __DECL_VECTORIZED_LOOP
 894                 for(int i = 0; i < 16; i++) {
 895                         tmp_dd[i] = tmp_dd[i] & RGBA_COLOR(31, 31, 31, 256);
 896                         px[i] = tmp_dd[i];
 897                 }
 898         } else {
 899 __DECL_VECTORIZED_LOOP
 900                 for(int i = 0; i < 16; i++) {
 901                         px[i] = tmp_dd[i];
 902                 }
 903         }
 904 #endif
 905 }
 906 #endif