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