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(_FM77L4)
  12 #include "../hd46505.h"
  13 #endif
  14
  15 extern config_t config;
  16
  17 namespace FM7 {
  18
  19 void DISPLAY::draw_screen()
  20 {
  21 #if 1
  22         this->draw_screen2();
  23 #else /* 1 */
  24         int y;
  25         int x;
  26         scrntype_t *p, *pp, *p2;
  27         uint32_t yoff_d1, yoff_d2;
  28         uint16_t wx_begin = -1, wx_end = -1, wy_low = 1024, wy_high = -1;
  29         bool scan_line = config.scan_line;
  30         bool ff = force_update;
  31         int dmode = display_mode;
  32 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
  33         {
  34                 wx_begin = window_xbegin;
  35                 wx_end   = window_xend;
  36                 wy_low   = window_low;
  37                 wy_high  = window_high;
  38                 bool _flag = window_opened;
  39                 if((wx_begin < wx_end) && (wy_low < wy_high)) {
  40                         window_opened = true;
  41                 } else {
  42                         window_opened = false;
  43                 }
  44                 if(_flag != window_opened) {
  45                         vram_wrote_shadow = true;
  46                 }
  47         }
  48 #endif
  49 #if defined(_FM77AV_VARIANTS)
  50         yoff_d2 = 0;
  51         yoff_d1 = 0;
  52 #else
  53         //if(!(vram_wrote_shadow)) return;
  54         yoff_d1 = yoff_d2 = offset_point;
  55 #endif
  56         int ylines;
  57         int xpixels;
  58         switch(dmode) {
  59         case DISPLAY_MODE_8_200L:
  60                 xpixels = 640;
  61                 ylines = 200;
  62                 break;
  63         case DISPLAY_MODE_1_400L:
  64         case DISPLAY_MODE_8_400L:
  65                 xpixels = 640;
  66                 ylines = 400;
  67                 break;
  68         default:
  69                 xpixels = 320;
  70                 ylines = 200;
  71                 break;
  72         }
  73 # if !defined(FIXED_FRAMEBUFFER_SIZE)
  74         emu->set_vm_screen_size(xpixels, ylines, WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_WIDTH_ASPECT, WINDOW_HEIGHT_ASPECT);
  75 # endif
  76         emu->set_vm_screen_lines(ylines);
  77         if(!crt_flag) {
  78                 if(crt_flag_bak) {
  79                         clean_display();
  80                 }
  81                 crt_flag_bak = crt_flag;
  82                 return;
  83         }
  84         crt_flag_bak = crt_flag;
  85         if(!(vram_wrote_shadow | ff)) return;
  86         vram_wrote_shadow = false;
  87
  88         _render_command_data_t cmd;
  89         memset(cmd, 0x00, sizeof(cmd));
  90
  91         uint32_t yoff_d = 0;
  92         int wpixels = xpixels >> 3;
  93         for(y = 0;  y < ylines; y += 8) {
  94                 for(yy = 0; yy < 8; yy++) {
  95                                 if(!(vram_draw_table[y + yy] | ff)) continue;
  96                                 vram_draw_table[y + yy] = false;
  97 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
  98                                 int dpage;
  99                                 dpage = vram_display_block;
 100                                 bool window_inv = false;
 101                                 if((check_window(dmode, yy + y)) && (dmode != DISPLAY_MODE_256k)) {
 102                                         if((wx_begin > 0) && (wx_begin < wx_end) && (wx_begin < wpixels)) {
 103                                                 yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 104                                                 if(display_page_bak == 1) yoff_d += 0xc000;
 105                                                 draw_window(dmode, yy + y, 0, wx_begin,
 106                                                                                  yoff_d1, yoff_d2, yoff_d);
 107                                                 yoff_d = (dpage != 0) ? 0x00000 : 0x18000;
 108                                                 if(display_page_bak == 1) yoff_d += 0xc000;
 109                                                 draw_window(dmode, yy + y,
 110                                                                         wx_begin, ((wx_end >= wpixels) ? wpixels : wx_end) - wx_begin,
 111                                                                         yoff_d1, yoff_d2, yoff_d); // if 0?
 112                                                 if(wx_end < wpixels) {
 113                                                         yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 114                                                         if(display_page_bak == 1) yoff_d += 0xc000;
 115                                                         draw_window(dmode, yy + y, wx_end,  wpixels - wx_end,
 116                                                                                   yoff_d1, yoff_d2, yoff_d);
 117                                                 }
 118                                         } else {
 119                                                 yoff_d = (dpage != 0) ? 0x00000 : 0x18000;
 120                                                 if(display_page_bak == 1) yoff_d += 0xc000;
 121                                                 draw_window(dmode, yy + y, 0, wx_end,
 122                                                                         yoff_d1, yoff_d2, yoff_d); // if 0?
 123                                                 if(wx_end < wpixels) {
 124                                                         yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 125                                                         if(display_page_bak == 1) yoff_d += 0xc000;
 126                                                         draw_window(dmode, yy + y, wx_end , wpixels - wx_end,
 127                                                                                 yoff_d1, yoff_d2, yoff_d);
 128                                                 }
 129                                         }
 130                                 } else {
 131                                         yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 132                                         if(display_page_bak == 1) yoff_d += 0xc000;
 133                                         draw_line(dmode, yy + y, yoff_d1, yoff_d2, yoff_d);
 134                                 }
 135                                 // Copy line
 136 #elif defined(_FM77AV_VARIANTS)
 137                                 if(display_page_bak == 1) yoff_d += 0xc000;
 138                                 draw_line(dmode, yy + y, yoff_d1, yoff_d2, yoff_d);
 139                                 // Copy line
 140 #elif defined(_FM77L4)
 141                                 draw_line(dmode, yy + y, yoff_d1, yoff_d2, yoff_d);
 142                                 // Copy line
 143 #else
 144                                 draw_line(dmode, yy + y, yoff_d1, yoff_d2, yoff_d);
 145                                 // Copy line
 146 #endif
 147                 }
 148         }
 149 #endif /* 1 */
 150 }
 151
 152 void DISPLAY::draw_screen2()
 153 {
 154         int y;
 155         int x;
 156         scrntype_t *p, *pp, *p2;
 157         int yoff;
 158         int yy;
 159         int k;
 160         //uint32_t rgbmask;
 161         uint32_t yoff_d1, yoff_d2;
 162         uint16_t wx_begin, wx_end, wy_low, wy_high;
 163         bool scan_line = config.scan_line;
 164         bool ff = force_update;
 165
 166 #if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 167         {
 168                 wx_begin = window_xbegin;
 169                 wx_end   = window_xend;
 170                 wy_low   = window_low;
 171                 wy_high  = window_high;
 172                 bool _flag = window_opened;
 173                 if((wx_begin < wx_end) && (wy_low < wy_high)) {
 174                         window_opened = true;
 175                 } else {
 176                         window_opened = false;
 177                 }
 178                 if(_flag != window_opened) {
 179                         vram_wrote_shadow = true;
 180                 }
 181         }
 182 #endif
 183 //      frame_skip_count_draw++;
 184 #if defined(_FM77AV_VARIANTS)
 185         yoff_d2 = 0;
 186         yoff_d1 = 0;
 187 #else
 188         //if(!(vram_wrote_shadow)) return;
 189         yoff_d1 = yoff_d2 = offset_point;
 190 #endif
 191         // Set blank
 192         int ylines;
 193         int xpixels;
 194         switch(display_mode) {
 195         case DISPLAY_MODE_8_200L:
 196                 xpixels = 640;
 197                 ylines = 200;
 198                 break;
 199         case DISPLAY_MODE_8_400L:
 200                 xpixels = 640;
 201                 ylines = 400;
 202                 break;
 203         default:
 204                 xpixels = 320;
 205                 ylines = 200;
 206                 break;
 207         }
 208 # if !defined(FIXED_FRAMEBUFFER_SIZE)
 209         emu->set_vm_screen_size(xpixels, ylines, WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_WIDTH_ASPECT, WINDOW_HEIGHT_ASPECT);
 210 # endif
 211         emu->set_vm_screen_lines(ylines);
 212         if(!crt_flag) {
 213                 if(crt_flag_bak) {
 214                         scrntype_t *ppp;
 215 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 216                         for(y = 0; y < ylines; y += 8) {
 217                                 for(yy = 0; yy < 8; yy++) {
 218                                         vram_draw_table[y + yy] = false;
 219                                         ppp = emu->get_screen_buffer(y + yy);
 220                                         if(ppp != NULL) memset(ppp, 0x00, xpixels * sizeof(scrntype_t));
 221                                 }
 222                         }
 223 #else
 224                         for(y = 0; y < 400; y += 8) {
 225                                 for(yy = 0; yy < 8; yy++) {
 226                                         vram_draw_table[y + yy] = false;
 227                                         ppp = emu->get_screen_buffer(y + yy);
 228                                         if(ppp != NULL) memset(ppp, 0x00, 640 * sizeof(scrntype_t));
 229                                 }
 230                         }
 231 #endif
 232
 233                 }
 234                 crt_flag_bak = crt_flag;
 235                 return;
 236         }
 237         crt_flag_bak = crt_flag;
 238         if(!(vram_wrote_shadow | ff)) return;
 239         vram_wrote_shadow = false;
 240         if(display_mode == DISPLAY_MODE_8_200L) {
 241                 _render_command_data_t cmd;
 242                 uint32_t yoff_d = 0;
 243                 int ii;
 244                 yoff = 0;
 245 #if defined(USE_GREEN_DISPLAY)
 246                 if(use_green_monitor) {
 247                         cmd.palette = dpalette_pixel_green;
 248                 } else {
 249                         cmd.palette = dpalette_pixel;
 250                 }
 251 #else
 252                 cmd.palette = dpalette_pixel;
 253 #endif
 254                 for(int i = 0; i < 3; i++) {
 255                         cmd.data[i] = gvram_shadow;
 256                         cmd.baseaddress[i] = i * 0x4000;
 257                         cmd.voffset[i] = yoff;
 258                         cmd.is_render[i] = false;
 259                 }
 260                 if(!multimode_dispflags[0]) cmd.is_render[0] = true;
 261                 if(!multimode_dispflags[1]) cmd.is_render[1] = true;
 262                 if(!multimode_dispflags[2]) cmd.is_render[2] = true;
 263                 cmd.bit_trans_table[0] = (_bit_trans_table_t*)(&(bit_trans_table_2[0][0])); // B
 264                 cmd.bit_trans_table[1] = (_bit_trans_table_t*)(&(bit_trans_table_1[0][0])); // R
 265                 cmd.bit_trans_table[2] = (_bit_trans_table_t*)(&(bit_trans_table_0[0][0])); // G
 266                 cmd.xzoom = 1;
 267                 cmd.addrmask = 0x3fff;
 268                 cmd.addrmask2 = 0x3fff;
 269                 cmd.begin_pos = 0;
 270                 cmd.shift = 5;
 271                 cmd.render_width = 80;
 272                 for(y = 0; y < 200; y += 8) {
 273                         for(yy = 0; yy < 8; yy++) {
 274
 275                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 276                                 vram_draw_table[y + yy] = false;
 277 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 278                                 p = emu->get_screen_buffer(y + yy);
 279                                 p2 = NULL;
 280 #else
 281                                 p = emu->get_screen_buffer((y + yy) * 2);
 282                                 p2 = emu->get_screen_buffer((y + yy) * 2 + 1);
 283 #endif
 284                                 if(p == NULL) continue;
 285                                 yoff = (y + yy) * 80;
 286                                 for(int i = 0; i < 3; i++) {
 287                                         cmd.voffset[i] = yoff;
 288                                 }
 289
 290 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 291                                 int dpage;
 292                                 dpage = vram_display_block;
 293                                 bool window_inv = false;
 294                                 if(window_opened && (wy_low <= (y + yy)) && (wy_high > (y + yy))) {
 295                                         if((wx_begin > 0) && (wx_begin < wx_end) && (wx_begin < 80)) {
 296                                                 // Window : left
 297                                                 cmd.begin_pos = 0;
 298                                                 window_inv = false;
 299                                                 int _wend = wx_end;
 300                                                 if(_wend >= 80) _wend = 80;
 301                                                 cmd.render_width = wx_begin;
 302                                                 yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 303                                                 if(display_page_bak == 1) yoff_d += 0xc000;
 304                                                 for(int i = 0; i < 3; i++) {
 305                                                         cmd.baseaddress[i] = yoff_d + (i * 0x4000);
 306                                                 }
 307                                                 if(cmd.render_width > 0) {
 308                                                         if(cmd.render_width > 80) cmd.render_width = 80;
 309                                                 }
 310                                                 Render8Colors_Line(&cmd, p, p2, scan_line);
 311
 312                                                 // Center
 313                                                 cmd.begin_pos = wx_begin;
 314                                                 cmd.render_width = _wend - wx_begin;
 315                                                 yoff_d = (dpage != 0) ? 0x00000 : 0x18000;
 316                                                 if(display_page_bak == 1) yoff_d += 0xc000;
 317                                                 for(int i = 0; i < 3; i++) {
 318                                                         cmd.baseaddress[i] = yoff_d + (i * 0x4000);
 319                                                 }
 320                                                 if(cmd.render_width > 0) {
 321                                                         if(cmd.render_width > 80) cmd.render_width = 80;
 322                                                 }
 323                                                 Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), &(p2[cmd.begin_pos * 8]) , scan_line);
 324                                                 // Right
 325                                                 if(wx_end < 80) {
 326                                                         cmd.begin_pos = wx_end;
 327                                                         cmd.render_width = 80 - wx_end;
 328                                                         yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 329                                                         if(display_page_bak == 1) yoff_d += 0xc000;
 330                                                         for(int i = 0; i < 3; i++) {
 331                                                                 cmd.baseaddress[i] = yoff_d + (i * 0x4000);
 332                                                         }
 333                                                         if(cmd.render_width > 0) {
 334                                                                 if(cmd.render_width > 80) cmd.render_width = 80;
 335                                                         }
 336                                                         Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), &(p2[cmd.begin_pos * 8]), scan_line);
 337                                                 }
 338                                                 continue;
 339                                         } else if((wx_begin <= 0) && (wx_begin < wx_end) && (wx_end >= 0)) {
 340                                                 // Left
 341                                                 cmd.begin_pos = 0;
 342                                                 cmd.render_width = wx_end;
 343                                                 yoff_d = (dpage != 0) ? 0x00000 : 0x18000;
 344                                                 if(display_page_bak == 1) yoff_d += 0xc000;
 345                                                 for(int i = 0; i < 3; i++) {
 346                                                         cmd.baseaddress[i] = yoff_d + (i * 0x4000);
 347                                                 }
 348                                                 if(cmd.render_width > 0) {
 349                                                         if(cmd.render_width > 80) cmd.render_width = 80;
 350                                                 }
 351                                                 if(cmd.render_width > 0) Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), &(p2[cmd.begin_pos * 8]), scan_line);
 352                                                 // Right
 353                                                 if(wx_end < 80) {
 354                                                         cmd.begin_pos = wx_end;
 355                                                         cmd.render_width = 80 - wx_end;
 356                                                         yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 357                                                         if(display_page_bak == 1) yoff_d += 0xc000;
 358                                                         for(int i = 0; i < 3; i++) {
 359                                                                 cmd.baseaddress[i] = yoff_d + (i * 0x4000);
 360                                                         }
 361                                                         if(cmd.render_width > 0) {
 362                                                                 if(cmd.render_width > 80) cmd.render_width = 80;
 363                                                         }
 364                                                         Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), &(p2[cmd.begin_pos * 8]), scan_line);
 365                                                 }
 366                                                 continue;
 367                                         }
 368                                 }
 369 #endif
 370                                 //cmd.begin_pos = 0;
 371                                 //cmd.render_width = 80;
 372 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 373                                 yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 374 #else
 375                                 yoff_d = 0;
 376 #endif
 377 #if defined(_FM77AV_VARIANTS)
 378                                 if(display_page_bak == 1) yoff_d += 0xc000;
 379                                 for(int i = 0; i < 3; i++) {
 380                                         cmd.baseaddress[i] = yoff_d + (i * 0x4000);
 381                                         cmd.data[i] = gvram_shadow;
 382                                         cmd.voffset[i] = yoff;
 383                                 }
 384 #else
 385 //                              for(int i = 0; i < 3; i++) {
 386 //                                      cmd.baseaddress[i] = i * 0x4000;
 387 //                              }
 388 #endif
 389
 390                                 Render8Colors_Line(&cmd, p, p2, scan_line);
 391 #if defined(FIXED_FRAMEBUFFER_SIZE)
 392                                 //CopyDrawnData(p, p2, 80, scan_line);
 393 #endif
 394                         }
 395                 }
 396                 if(ff) force_update = false;
 397                 return;
 398         }
 399 #if defined(_FM77L4)
 400         if(display_mode == DISPLAY_MODE_1_400L) {
 401                 int ii;
 402                 uint8_t *regs = l4crtc->get_regs();
 403                 cursor_start = (int)(regs[10] & 0x1f);
 404                 cursor_end = (int)(regs[11] & 0x1f);
 405                 cursor_type = (int)((regs[10] & 0x60) >> 5);
 406                 text_xmax = (int)((uint16_t)regs[1] << 1);
 407                 text_lines = (int)((regs[9] & 0x1f) + 1);
 408                 text_ymax = (int)(regs[6] & 0x7f);
 409                 yoff = 0;
 410                 // Green display had only connected to FM-8, FM-7/NEW7 and FM-77.
 411                 for(y = 0; y < 400; y += 8) {
 412                         bool renderf = false;
 413                         uint32_t naddr;
 414                         uint8_t bitcode;
 415                         uint8_t charcode;
 416                         uint8_t attr_code;
 417                         scrntype_t on_color;
 418                         int xlim, ylim;
 419                         bool do_green;
 420                         if((y & 0x0f) == 0) {
 421                                 for(yy = 0; yy < 16; yy++) renderf |= vram_draw_table[y + yy];
 422                                 renderf = renderf | ff;
 423                                 if(renderf) {
 424                                         for(yy = 0; yy < 16; yy++) vram_draw_table[y + yy] = true;
 425                                 }
 426                         }
 427                         if(use_green_monitor) {
 428                                 for(yy = 0; yy < 8; yy++) {
 429                                         if(!(vram_draw_table[y + yy] | ff)) continue;
 430                                         vram_draw_table[y + yy] = false;
 431                                         p = emu->get_screen_buffer(y + yy);
 432                                         if(p == NULL) continue;
 433                                         yoff = (y + yy) * 80;
 434                                         for(x = 0; x < 10; x++) {
 435                                                 for(ii = 0; ii < 8; ii++) {
 436                                                         GETVRAM_1_400L_GREEN(yoff + ii, p);
 437                                                         p += 8;
 438                                                 }
 439                                                 yoff += 8;
 440                                         }
 441                                 }
 442                                 do_green = true;
 443                         } else {
 444                                 for(yy = 0; yy < 8; yy++) {
 445                                         if(!(vram_draw_table[y + yy] | ff)) continue;
 446                                         vram_draw_table[y + yy] = false;
 447                                         p = emu->get_screen_buffer(y + yy);
 448                                         if(p == NULL) continue;
 449                                         yoff = (y + yy) * 80;
 450                                         for(x = 0; x < 10; x++) {
 451                                                 for(ii = 0; ii < 8; ii++) {
 452                                                         GETVRAM_1_400L(yoff + ii, p);
 453                                                         p += 8;
 454                                                 }
 455                                                 yoff += 8;
 456                                         }
 457                                 }
 458                                 do_green = false;
 459                         }
 460                         // Draw Text
 461                         if(renderf) {
 462                                 bool reverse;
 463                                 bool display_char;
 464                                 int raster;
 465                                 bool cursor_rev;
 466                                 uint8_t bitdata;
 467                                 if(text_width40) {
 468                                         xlim = 40;
 469                                 } else {
 470                                         xlim = 80;
 471                                 }
 472
 473                                 for(x = 0; x < xlim; x++) {
 474                                         naddr = (text_start_addr.w.l + ((y / text_lines) * text_xmax + x) * 2) & 0x0ffe;
 475                                         charcode = text_vram[naddr];
 476                                         attr_code = text_vram[naddr + 1];
 477
 478                                         on_color = GETVRAM_TEXTCOLOR(attr_code, do_green);
 479
 480                                         display_char = ((attr_code & 0x10) == 0);
 481                                         reverse = ((attr_code & 0x08) != 0);
 482
 483                                         for(yy = 0; yy < 16; yy++) {
 484                                                 raster = y % text_lines;
 485                                                 bitdata = 0x00;
 486                                                 p = emu->get_screen_buffer(y + yy);
 487                                                 if(p == NULL) continue;
 488                                                 if((raster < 16) && (display_char || text_blink)) {
 489                                                         bitdata = subsys_cg_l4[(uint32_t)charcode * 16 + (uint32_t)raster];
 490                                                 }
 491                                                 cursor_rev = false;
 492                                                 if((naddr == (uint32_t)(cursor_addr.w.l)) && (cursor_type != 1) &&
 493                                                    (text_blink || (cursor_type == 0))) {
 494                                                         if((raster >= cursor_start) && (raster <= cursor_end)) {
 495                                                                 cursor_rev = true;
 496                                                         }
 497                                                 }
 498                                                 bitdata = GETVRAM_TEXTPIX(bitdata, reverse, cursor_rev);
 499                                                 if(bitdata != 0) {
 500                                                         if(text_width40) {
 501                                                                         scrntype_t *pp = &(p[x * 2]);
 502                                                                         for(ii = 0; ii < 8; ii++) {
 503                                                                                 if((bitdata & 0x80) != 0) {
 504                                                                                         p[0] = on_color;
 505                                                                                         p[1] = on_color;
 506                                                                                 }
 507                                                                                 bitdata <<= 1;
 508                                                                                 p += 2;
 509                                                                         }
 510                                                         } else {
 511                                                                 scrntype_t *pp = &(p[x * 2]);
 512                                                                 for(ii = 0; ii < 8; ii++) {
 513                                                                         if((bitdata & 0x80) != 0) {
 514                                                                                 p[0] = on_color;
 515                                                                         }
 516                                                                         bitdata <<= 1;
 517                                                                         p += 1;
 518                                                                 }
 519                                                         }
 520                                                 }
 521                                         }
 522                                 }
 523                         }
 524                 }
 525                 if(ff) force_update = false;
 526                 return;
 527         }
 528 #endif
 529 # if defined(_FM77AV_VARIANTS)
 530         if(display_mode == DISPLAY_MODE_4096) {
 531                 uint32_t mask = 0;
 532                 int ii;
 533                 yoff = 0;
 534                 if(!multimode_dispflags[0]) mask = 0x00f;
 535                 if(!multimode_dispflags[1]) mask = mask | 0x0f0;
 536                 if(!multimode_dispflags[2]) mask = mask | 0xf00;
 537                 for(y = 0; y < 200; y += 4) {
 538                         for(yy = 0; yy < 4; yy++) {
 539                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 540                                 vram_draw_table[y + yy] = false;
 541
 542 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 543                                 p = emu->get_screen_buffer(y + yy);
 544                                 p2 = NULL;
 545 #else
 546                                 p = emu->get_screen_buffer((y + yy) * 2 );
 547                                 p2 = emu->get_screen_buffer((y + yy) * 2 + 1);
 548 #endif
 549                                 if(p == NULL) continue;
 550                                 yoff = (y + yy) * 40;
 551 #  if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 552                                 if(window_opened && (wy_low <= (y + yy)) && (wy_high > (y + yy))) {
 553                                         for(x = 0; x < 40; x++) {
 554                                                 if((x >= wx_begin) && (x < wx_end)) {
 555                                                         GETVRAM_4096(yoff, p, p2, mask, true, scan_line);
 556                                                 } else {
 557                                                         GETVRAM_4096(yoff, p, p2, mask, false, scan_line);
 558                                                 }
 559 #if defined(FIXED_FRAMEBUFFER_SIZE)
 560                                                 p2 += 16;
 561                                                 p += 16;
 562 #else
 563                                                 p += 8;
 564 #endif
 565                                                 yoff++;
 566                                         }
 567                                 } else
 568 #  endif
 569                                 {
 570                                         for(x = 0; x < 5; x++) {
 571                                                 for(ii = 0; ii < 8; ii++) {
 572                                                         GETVRAM_4096(yoff + ii, p, p2, mask, false, scan_line);
 573 #if defined(FIXED_FRAMEBUFFER_SIZE)
 574                                                         p2 += 16;
 575                                                         p += 16;
 576 #else
 577                                                         p += 8;
 578 #endif
 579                                                 }
 580                                                 yoff += 8;
 581                                         }
 582                                 }
 583                         }
 584
 585                 }
 586                 if(ff) force_update = false;
 587                 return;
 588         }
 589 #  if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
 590         else if(display_mode == DISPLAY_MODE_8_400L) {
 591                 _render_command_data_t cmd;
 592                 int ii;
 593                 yoff = 0;
 594                 cmd.palette = dpalette_pixel;
 595                 for(int i = 0; i < 3; i++) {
 596                         cmd.data[i] = gvram_shadow;
 597                         cmd.baseaddress[i] = i * 0x8000;
 598                         cmd.voffset[i] = yoff;
 599                         cmd.is_render[i] = false;
 600                 }
 601                 if(!multimode_dispflags[0]) cmd.is_render[0] = true;
 602                 if(!multimode_dispflags[1]) cmd.is_render[1] = true;
 603                 if(!multimode_dispflags[2]) cmd.is_render[2] = true;
 604                 cmd.bit_trans_table[0] = (_bit_trans_table_t*)(&(bit_trans_table_2[0][0])); // B
 605                 cmd.bit_trans_table[1] = (_bit_trans_table_t*)(&(bit_trans_table_1[0][0])); // R
 606                 cmd.bit_trans_table[2] = (_bit_trans_table_t*)(&(bit_trans_table_0[0][0])); // G
 607                 cmd.xzoom = 1;
 608                 cmd.addrmask = 0x7fff;
 609                 cmd.addrmask2 = 0x7fff;
 610                 cmd.begin_pos = 0;
 611                 cmd.shift = 5;
 612                 cmd.render_width = 80;
 613                 for(y = 0; y < 400; y += 8) {
 614                         for(yy = 0; yy < 8; yy++) {
 615                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 616                                 vram_draw_table[y + yy] = false;
 617
 618                                 p = emu->get_screen_buffer(y + yy);
 619                                 if(p == NULL) continue;
 620                                 pp = p;
 621                                 yoff = (y + yy) * 80;
 622                                 for(int i = 0; i < 3; i++) {
 623                                         cmd.voffset[i] = yoff;
 624                                 }
 625                                 int dpage;
 626                                 bool window_inv = false;
 627                                 uint32_t yoff_d = 0;
 628                                 dpage = vram_display_block;
 629 #    if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 630                                 if(window_opened && (wy_low <= (y + yy)) && (wy_high > (y + yy))) {
 631                                         if((wx_begin > 0) && (wx_begin < wx_end) && (wx_begin < 80)) {
 632                                                 // Window : left
 633                                                 cmd.begin_pos = 0;
 634                                                 window_inv = false;
 635                                                 int _wend = wx_end;
 636                                                 if(_wend >= 80) _wend = 80;
 637                                                 cmd.render_width = wx_begin;
 638                                                 yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 639                                                 for(int i = 0; i < 3; i++) {
 640                                                         cmd.baseaddress[i] = yoff_d + (i * 0x8000);
 641                                                 }
 642                                                 if(cmd.render_width > 0) {
 643                                                         if(cmd.render_width > 80) cmd.render_width = 80;
 644                                                 }
 645                                                 Render8Colors_Line(&cmd, p, NULL, false);
 646
 647                                                 // Center
 648                                                 cmd.begin_pos = wx_begin;
 649                                                 cmd.render_width = _wend - wx_begin;
 650                                                 yoff_d = (dpage != 0) ? 0x00000 : 0x18000;
 651                                                 if(display_page_bak == 1) yoff_d += 0xc000;
 652                                                 for(int i = 0; i < 3; i++) {
 653                                                         cmd.baseaddress[i] = yoff_d + (i * 0x8000);
 654                                                 }
 655                                                 if(cmd.render_width > 0) {
 656                                                         if(cmd.render_width > 80) cmd.render_width = 80;
 657                                                 }
 658                                                 Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), NULL, false);
 659                                                 // Right
 660                                                 if(wx_end < 80) {
 661                                                         cmd.begin_pos = wx_end;
 662                                                         cmd.render_width = 80 - wx_end;
 663                                                         yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 664                                                         for(int i = 0; i < 3; i++) {
 665                                                                 cmd.baseaddress[i] = yoff_d + (i * 0x8000);
 666                                                         }
 667                                                         if(cmd.render_width > 0) {
 668                                                                 if(cmd.render_width > 80) cmd.render_width = 80;
 669                                                         }
 670                                                         Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), NULL, false);
 671                                                 }
 672                                                 continue;
 673                                         } else if((wx_begin <= 0) && (wx_begin < wx_end) && (wx_end >= 0)) {
 674                                                 // Left
 675                                                 cmd.begin_pos = 0;
 676                                                 cmd.render_width = wx_end;
 677                                                 yoff_d = (dpage != 0) ? 0x00000 : 0x18000;
 678                                                 for(int i = 0; i < 3; i++) {
 679                                                         cmd.baseaddress[i] = yoff_d + (i * 0x8000);
 680                                                 }
 681                                                 if(cmd.render_width > 0) {
 682                                                         if(cmd.render_width > 80) cmd.render_width = 80;
 683                                                 }
 684                                                 if(cmd.render_width > 0) Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), NULL, false);
 685                                                 // Right
 686                                                 if(wx_end < 80) {
 687                                                         cmd.begin_pos = wx_end;
 688                                                         cmd.render_width = 80 - wx_end;
 689                                                         yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 690                                                         for(int i = 0; i < 3; i++) {
 691                                                                 cmd.baseaddress[i] = yoff_d + (i * 0x8000);
 692                                                         }
 693                                                         if(cmd.render_width > 0) {
 694                                                                 if(cmd.render_width > 80) cmd.render_width = 80;
 695                                                         }
 696                                                         Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), NULL, false);
 697                                                 }
 698                                                 continue;
 699                                         }
 700                                 }
 701 #    endif
 702                                 // Not Opened
 703                                 cmd.begin_pos = 0;
 704                                 cmd.render_width = 80;
 705                                 yoff_d = (dpage != 0) ? 0x18000 : 0x00000;
 706                                 for(int i = 0; i < 3; i++) {
 707                                         cmd.baseaddress[i] = yoff_d + (i * 0x8000);
 708                                 }
 709                                 if(cmd.render_width > 0) {
 710                                         if(cmd.render_width > 80) cmd.render_width = 80;
 711                                 }
 712                                 Render8Colors_Line(&cmd, &(p[cmd.begin_pos * 8]), NULL, false);
 713                         }
 714                 }
 715                 if(ff) force_update = false;
 716                 return;
 717         } else if(display_mode == DISPLAY_MODE_256k) {
 718                 int ii;
 719                 //rgbmask = ~multimode_dispmask;
 720                 //
 721                 for(y = 0; y < 200; y += 4) {
 722                         for(yy = 0; yy < 4; yy++) {
 723                                 if(!(vram_draw_table[y + yy] | ff)) continue;
 724                                 vram_draw_table[y + yy] = false;
 725 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 726                                 p = emu->get_screen_buffer(y + yy);
 727                                 p2 = NULL;
 728 #else
 729                                 p = emu->get_screen_buffer((y + yy) * 2 );
 730                                 p2 = emu->get_screen_buffer((y + yy) * 2 + 1);
 731 #endif
 732                                 if(p == NULL) continue;
 733                                 pp = p;
 734                                 yoff = (y + yy) * 40;
 735                                 {
 736                                         for(x = 0; x < 5; x++) {
 737                                                 for(ii = 0; ii < 8; ii++) {
 738                                                         GETVRAM_256k(yoff + ii, p, p2, scan_line);
 739 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 740                                                         p += 8;
 741 #else
 742                                                         p += 16;
 743                                                         p2 += 16;
 744 #endif
 745                                                 }
 746                                                 yoff += 8;
 747                                         }
 748                                 }
 749                         }
 750                 }
 751                 if(ff) force_update = false;
 752                 return;
 753         }
 754 #  endif // _FM77AV40
 755 # endif //_FM77AV_VARIANTS
 756 }
 757
 758 bool DISPLAY::screen_update(void)
 759 {
 760         if(crt_flag) {
 761                 bool f = screen_update_flag;
 762                 screen_update_flag = false;
 763                 return f;
 764         } else {
 765                 if(crt_flag_bak) return true;
 766         }
 767         return false;
 768 }
 769
 770 void DISPLAY::reset_screen_update(void)
 771 {
 772         screen_update_flag = false;
 773 }
 774
 775 void DISPLAY::CopyDrawnData(scrntype_t* src, scrntype_t* dst, int width, bool scan_line)
 776 {
 777         if(dst == NULL) return;
 778         if(src == NULL) return;
 779 #if defined(_RGB555) || defined(_RGBA565)
 780         static const int shift_factor = 2;
 781 #else // 24bit
 782         static const int shift_factor = 3;
 783 #endif
 784         scrntype_vec8_t* vsrc = (scrntype_vec8_t*)src;
 785         scrntype_vec8_t* vdst = (scrntype_vec8_t*)dst;
 786         __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd;
 787         __DECL_ALIGNED(32) scrntype_vec8_t sline;
 788
 789         if(scan_line) {
 790 __DECL_VECTORIZED_LOOP
 791                 for(int i = 0; i < 8; i++) {
 792                         sline.w[i] = (scrntype_t)RGBA_COLOR(31, 31, 31, 255);
 793                 }
 794 __DECL_VECTORIZED_LOOP
 795                 for(int i = 0; i < width; i++) {
 796                         tmp_dd.v = vsrc[i].v;
 797                         tmp_dd.v = tmp_dd.v >> shift_factor;
 798                         tmp_dd.v = tmp_dd.v & sline.v;
 799                         vdst[i].v = tmp_dd.v;
 800                 }
 801         } else {
 802 __DECL_VECTORIZED_LOOP
 803                 for(int i = 0; i < width; i++) {
 804                         tmp_dd.v = vsrc[i].v;
 805                         vdst[i].v = tmp_dd.v;
 806                 }
 807         }
 808 }
 809
 810
 811 #if defined(_FM77L4)
 812 scrntype_t DISPLAY::GETVRAM_TEXTCOLOR(uint8_t attr, bool do_green)
 813 {
 814         int color = attr & 0x07;
 815         int r, g, b;
 816
 817         static const int green_g_table[16] = {0, 24, 48, 64, 80, 96, 112, 128,
 818                                                                                   140, 155, 175, 186, 210, 220, 240, 255};
 819         if(do_green) {
 820                 if((attr & 0x20) != 0) color += 8;
 821                 r = b = 0;
 822                 g = green_g_table[color];
 823                 if(color >= 10) {
 824                         r = (color - 9) * 16;
 825                         b = (color - 9) * 16;
 826                 }
 827         } else {
 828                 if((attr & 0x20) != 0) {
 829                         g = ((color & 4) != 0) ? 255 : 0;
 830                         r = ((color & 2) != 0) ? 255 : 0;
 831                         b = ((color & 1) != 0) ? 255 : 0;
 832                 } else {
 833                         g = ((color & 4) != 0) ? 128 : 0;
 834                         r = ((color & 2) != 0) ? 128 : 0;
 835                         b = ((color & 1) != 0) ? 128 : 0;
 836                 }
 837         }
 838         return RGBA_COLOR(r, g, b, 255);
 839 }
 840
 841 uint8_t DISPLAY::GETVRAM_TEXTPIX(uint8_t bitdata, bool reverse, bool cursor_rev)
 842 {
 843         uint8_t ret = bitdata;
 844         if(reverse) {
 845                 ret = (uint8_t)(~ret);
 846         }
 847         if(cursor_rev) {
 848             ret = (uint8_t)(~ret);
 849         }
 850         return ret;
 851 }
 852
 853 void DISPLAY::GETVRAM_1_400L(int yoff, scrntype_t *p)
 854 {
 855         uint8_t pixel;
 856         uint32_t yoff_d;
 857         if(p == NULL) return;
 858         yoff_d = yoff & 0x7fff;
 859         pixel = gvram_shadow[yoff_d];
 860         uint16_vec8_t *ppx = (uint16_vec8_t *)(&(bit_trans_table_0[pixel][0]));
 861         __DECL_ALIGNED(16) uint16_vec8_t tmp_d;
 862         __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd;
 863         scrntype_vec8_t *vp = (scrntype_vec8_t *)p;
 864
 865         tmp_d.v = ppx->v;
 866         tmp_d.v = tmp_d.v >> 5;
 867
 868 __DECL_VECTORIZED_LOOP
 869         for(int i = 0; i < 8; i++) {
 870                 tmp_dd.w[i] = dpalette_pixel[tmp_d.w[i]];
 871         }
 872
 873         vp->v = tmp_dd.v;
 874 }
 875
 876 void DISPLAY::GETVRAM_1_400L_GREEN(int yoff, scrntype_t *p)
 877 {
 878         uint8_t pixel;
 879         uint32_t yoff_d;
 880         if(p == NULL) return;
 881         yoff_d = yoff & 0x7fff;
 882         pixel = gvram_shadow[yoff_d];
 883         uint16_vec8_t *ppx = (uint16_vec8_t *)(&(bit_trans_table_0[pixel][0]));
 884         __DECL_ALIGNED(16) uint16_vec8_t tmp_d;
 885         __DECL_ALIGNED(32) scrntype_vec8_t tmp_dd;
 886         scrntype_vec8_t *vp = (scrntype_vec8_t *)p;
 887
 888         tmp_d.v = ppx->v;
 889         tmp_d.v = tmp_d.v >> 5;
 890
 891 __DECL_VECTORIZED_LOOP
 892         for(int i = 0; i < 8; i++) {
 893                 tmp_dd.w[i] = dpalette_pixel_green[tmp_d.w[i]];
 894         }
 895         vp->v = tmp_dd.v;
 896
 897 }
 898 #endif
 899
 900
 901 #if defined(_FM77AV_VARIANTS)
 902 void DISPLAY::GETVRAM_4096(int yoff, scrntype_t *p, scrntype_t *px,
 903                                                    uint32_t mask,
 904                                                    bool window_inv,
 905                                                    bool scan_line)
 906 {
 907         uint32_t b3, r3, g3;
 908         uint8_t  bb[4], rr[4], gg[4];
 909         __DECL_ALIGNED(16) uint16_vec8_t pixels;
 910         __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};
 911         scrntype_t b, r, g;
 912         uint32_t idx;;
 913         scrntype_t pixel;
 914         uint32_t yoff_d1;
 915         uint32_t yoff_d2;
 916 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 917         int dpage = vram_display_block;
 918 # endif
 919         if(p == NULL) return;
 920
 921         yoff_d1 = yoff;
 922         yoff_d2 = yoff;
 923 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
 924         if(window_inv) {
 925                 if(dpage == 0) {
 926                         dpage = 1;
 927                 } else {
 928                         dpage = 0;
 929                 }
 930         }
 931         if(dpage != 0) {
 932                 yoff_d1 += 0x18000;
 933                 yoff_d2 += 0x18000;
 934         }
 935 # endif
 936         bb[0] = gvram_shadow[yoff_d1];
 937         bb[1] = gvram_shadow[yoff_d1 + 0x02000];
 938         rr[0] = gvram_shadow[yoff_d1 + 0x04000];
 939         rr[1] = gvram_shadow[yoff_d1 + 0x06000];
 940         gg[0] = gvram_shadow[yoff_d1 + 0x08000];
 941         gg[1] = gvram_shadow[yoff_d1 + 0x0a000];
 942
 943         bb[2] = gvram_shadow[yoff_d2 + 0x0c000];
 944         bb[3] = gvram_shadow[yoff_d2 + 0x0e000];
 945         rr[2] = gvram_shadow[yoff_d2 + 0x10000];
 946         rr[3] = gvram_shadow[yoff_d2 + 0x12000];
 947         gg[2] = gvram_shadow[yoff_d2 + 0x14000];
 948         gg[3] = gvram_shadow[yoff_d2 + 0x16000];
 949
 950         uint16_t *p0, *p1, *p2, *p3;
 951 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 952         __DECL_ALIGNED(sizeof(scrntype_t) * 8) scrntype_t tmp_dd[8];
 953 #else
 954         __DECL_ALIGNED(sizeof(scrntype_t) * 8) scrntype_t tmp_dd[16];
 955 #endif
 956         __DECL_ALIGNED(16) uint16_vec8_t tmp_g, tmp_r, tmp_b;
 957         __v8hi *vp0, *vp1, *vp2, *vp3;
 958         // G
 959         vp0 = (__v8hi*)(&(bit_trans_table_0[gg[0]][0]));
 960         vp1 = (__v8hi*)(&(bit_trans_table_1[gg[1]][0]));
 961         vp2 = (__v8hi*)(&(bit_trans_table_2[gg[2]][0]));
 962         vp3 = (__v8hi*)(&(bit_trans_table_3[gg[3]][0]));
 963         tmp_g.v = *vp0;
 964         tmp_g.v = tmp_g.v | *vp1;
 965         tmp_g.v = tmp_g.v | *vp2;
 966         tmp_g.v = tmp_g.v | *vp3;
 967         // R
 968         vp0 = (__v8hi*)(&(bit_trans_table_0[rr[0]][0]));
 969         vp1 = (__v8hi*)(&(bit_trans_table_1[rr[1]][0]));
 970         vp2 = (__v8hi*)(&(bit_trans_table_2[rr[2]][0]));
 971         vp3 = (__v8hi*)(&(bit_trans_table_3[rr[3]][0]));
 972         tmp_r.v = *vp0;
 973         tmp_r.v = tmp_r.v | *vp1;
 974         tmp_r.v = tmp_r.v | *vp2;
 975         tmp_r.v = tmp_r.v | *vp3;
 976
 977         // B
 978         vp0 = (__v8hi*)(&(bit_trans_table_0[bb[0]][0]));
 979         vp1 = (__v8hi*)(&(bit_trans_table_1[bb[1]][0]));
 980         vp2 = (__v8hi*)(&(bit_trans_table_2[bb[2]][0]));
 981         vp3 = (__v8hi*)(&(bit_trans_table_3[bb[3]][0]));
 982         tmp_b.v = *vp0;
 983         tmp_b.v = tmp_b.v | *vp1;
 984         tmp_b.v = tmp_b.v | *vp2;
 985         tmp_b.v = tmp_b.v | *vp3;
 986
 987         __v8hi *mp = (__v8hi*)__masks;
 988         tmp_g.v = tmp_g.v << 4;
 989         tmp_b.v = tmp_b.v >> 4;
 990         pixels.v = tmp_b.v;
 991         pixels.v = pixels.v | tmp_r.v;
 992         pixels.v = pixels.v | tmp_g.v;
 993         pixels.v = pixels.v & *mp;
 994
 995
 996         scrntype_vec8_t *vp = (scrntype_vec8_t*)p;
 997         scrntype_vec8_t *dp = (scrntype_vec8_t*)tmp_dd;
 998 #if !defined(FIXED_FRAMEBUFFER_SIZE)
 999 __DECL_VECTORIZED_LOOP
1000         for(int i = 0; i < 8; i++) {
1001                 tmp_dd[i] = analog_palette_pixel[pixels[i]];
1002         }
1003         vp->v = dp->v;
1004 #else
1005 __DECL_VECTORIZED_LOOP
1006         for(int i = 0; i < 8; i++) {
1007                 tmp_dd[i * 2] = tmp_dd[i * 2 + 1] = analog_palette_pixel[pixels.w[i]];;
1008         }
1009         scrntype_vec8_t *vpx = (scrntype_vec8_t*)px;
1010         __DECL_ALIGNED(32) scrntype_vec8_t vmask;
1011 __DECL_VECTORIZED_LOOP
1012         for(int i = 0; i < 2; i++) {
1013                 vp[i].v = dp[i].v;
1014         }
1015         if(scan_line) {
1016 /* Fancy scanline */
1017 __DECL_VECTORIZED_LOOP
1018                 for(int i = 0; i < 2; i++) {
1019 #if defined(_RGB888) || defined(_RGBA888)
1020                         dp[i].v = dp[i].v >> 3;
1021 #elif defined(_RGB555)
1022                         dp[i].v = dp[i].v >> 2;
1023 #elif defined(_RGB565)
1024                         dp[i].v = dp[i].v >> 2;
1025 #endif
1026                 }
1027 __DECL_VECTORIZED_LOOP
1028                 for(int i = 0; i < 8; i++) {
1029                         vmask.w[i] = (const scrntype_t)RGBA_COLOR(31, 31, 31, 255);
1030                 }
1031 __DECL_VECTORIZED_LOOP
1032                 for(int i = 0; i < 2; i++) {
1033                         dp[i].v = dp[i].v & vmask.v;
1034                         vpx[i].v = dp[i].v;
1035                 }
1036         } else {
1037 __DECL_VECTORIZED_LOOP
1038                 for(int i = 0; i < 2; i++) {
1039                         vpx[i].v = dp[i].v;
1040                 }
1041         }
1042 #endif
1043 }
1044 #endif
1045
1046 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
1047
1048 void DISPLAY::GETVRAM_256k(int yoff, scrntype_t *p, scrntype_t *px, bool scan_line)
1049 {
1050         uint32_t b3, r3, g3;
1051         uint32_t b4, r4, g4;
1052         uint32_t btmp, rtmp, gtmp;
1053
1054         scrntype_t b, r, g;
1055         scrntype_t pixel;
1056         uint32_t _bit;
1057         int _shift;
1058         int cp;
1059         uint32_t yoff_d1;
1060         uint32_t yoff_d2;
1061         if(p == NULL) return;
1062
1063         r3 = g3 = b3 = 0;
1064         r4 = g4 = b4 = 0;
1065         r = g = b = 0;
1066
1067         yoff_d1 = yoff;
1068         yoff_d2 = yoff;
1069
1070         uint8_t  bb[8], rr[8], gg[8];
1071
1072         __DECL_ALIGNED(16) uint16_vec8_t _btmp;
1073         __DECL_ALIGNED(16) uint16_vec8_t _rtmp;
1074         __DECL_ALIGNED(16) uint16_vec8_t _gtmp;
1075         uint16_vec8_t *vp0, *vp1, *vp2, *vp3, *vp4, *vp5;
1076 #if !defined(FIXED_FRAMEBUFFER_SIZE)
1077         __DECL_ALIGNED(sizeof(scrntype_t) * 8) scrntype_t tmp_dd[8];
1078 #else
1079         __DECL_ALIGNED(sizeof(scrntype_t) * 8) scrntype_t tmp_dd[16];
1080 #endif
1081 //      if(mask & 0x01) {
1082         if(!multimode_dispflags[0]) {
1083                 // B
1084                 bb[0] = gvram_shadow[yoff_d1];
1085                 bb[1] = gvram_shadow[yoff_d1 + 0x02000];
1086
1087                 bb[2] = gvram_shadow[yoff_d2 + 0x0c000];
1088                 bb[3] = gvram_shadow[yoff_d2 + 0x0e000];
1089
1090                 bb[4] = gvram_shadow[yoff_d1 + 0x18000];
1091                 bb[5] = gvram_shadow[yoff_d1 + 0x1a000];
1092
1093                 vp0 = (uint16_vec8_t*)(&(bit_trans_table_0[bb[0]][0]));
1094                 vp1 = (uint16_vec8_t*)(&(bit_trans_table_1[bb[1]][0]));
1095                 vp2 = (uint16_vec8_t*)(&(bit_trans_table_2[bb[2]][0]));
1096                 vp3 = (uint16_vec8_t*)(&(bit_trans_table_3[bb[3]][0]));
1097                 vp4 = (uint16_vec8_t*)(&(bit_trans_table_4[bb[4]][0]));
1098                 vp5 = (uint16_vec8_t*)(&(bit_trans_table_5[bb[5]][0]));
1099                 _btmp.v = vp0->v;
1100                 _btmp.v = _btmp.v | vp1->v;
1101                 _btmp.v = _btmp.v | vp2->v;
1102                 _btmp.v = _btmp.v | vp3->v;
1103                 _btmp.v = _btmp.v | vp4->v;
1104                 _btmp.v = _btmp.v | vp5->v;
1105         } else {
1106 __DECL_VECTORIZED_LOOP
1107                 for(int i = 0; i < 8; i++) {
1108                         _btmp.w[i] = 0;
1109                 }
1110         }
1111         if(!multimode_dispflags[1]) {
1112                 //if(mask & 0x02) {
1113                 // R
1114                 rr[0] = gvram_shadow[yoff_d1 + 0x04000];
1115                 rr[1] = gvram_shadow[yoff_d1 + 0x06000];
1116
1117                 rr[2] = gvram_shadow[yoff_d2 + 0x10000];
1118                 rr[3] = gvram_shadow[yoff_d2 + 0x12000];
1119
1120                 rr[4] = gvram_shadow[yoff_d1 + 0x1c000];
1121                 rr[5] = gvram_shadow[yoff_d1 + 0x1e000];
1122
1123                 vp0 = (uint16_vec8_t*)(&(bit_trans_table_0[rr[0]][0]));
1124                 vp1 = (uint16_vec8_t*)(&(bit_trans_table_1[rr[1]][0]));
1125                 vp2 = (uint16_vec8_t*)(&(bit_trans_table_2[rr[2]][0]));
1126                 vp3 = (uint16_vec8_t*)(&(bit_trans_table_3[rr[3]][0]));
1127                 vp4 = (uint16_vec8_t*)(&(bit_trans_table_4[rr[4]][0]));
1128                 vp5 = (uint16_vec8_t*)(&(bit_trans_table_5[rr[5]][0]));
1129                 _rtmp.v = vp0->v;
1130                 _rtmp.v = _rtmp.v | vp1->v;
1131                 _rtmp.v = _rtmp.v | vp2->v;
1132                 _rtmp.v = _rtmp.v | vp3->v;
1133                 _rtmp.v = _rtmp.v | vp4->v;
1134                 _rtmp.v = _rtmp.v | vp5->v;
1135         } else {
1136 __DECL_VECTORIZED_LOOP
1137                 for(int i = 0; i < 8; i++) {
1138                         _rtmp.w[i] = 0;
1139                 }
1140         }
1141         if(!multimode_dispflags[2]) {
1142                 //if(mask & 0x04) {
1143                 // G
1144                 gg[0] = gvram_shadow[yoff_d1 + 0x08000];
1145                 gg[1] = gvram_shadow[yoff_d1 + 0x0a000];
1146
1147                 gg[2] = gvram_shadow[yoff_d2 + 0x14000];
1148                 gg[3] = gvram_shadow[yoff_d2 + 0x16000];
1149
1150                 gg[4] = gvram_shadow[yoff_d1 + 0x20000];
1151                 gg[5] = gvram_shadow[yoff_d1 + 0x22000];
1152
1153                 vp0 = (uint16_vec8_t*)(&(bit_trans_table_0[gg[0]][0]));
1154                 vp1 = (uint16_vec8_t*)(&(bit_trans_table_1[gg[1]][0]));
1155                 vp2 = (uint16_vec8_t*)(&(bit_trans_table_2[gg[2]][0]));
1156                 vp3 = (uint16_vec8_t*)(&(bit_trans_table_3[gg[3]][0]));
1157                 vp4 = (uint16_vec8_t*)(&(bit_trans_table_4[gg[4]][0]));
1158                 vp5 = (uint16_vec8_t*)(&(bit_trans_table_5[gg[5]][0]));
1159                 _gtmp.v = vp0->v;
1160                 _gtmp.v = _gtmp.v | vp1->v;
1161                 _gtmp.v = _gtmp.v | vp2->v;
1162                 _gtmp.v = _gtmp.v | vp3->v;
1163                 _gtmp.v = _gtmp.v | vp4->v;
1164                 _gtmp.v = _gtmp.v | vp5->v;
1165         } else {
1166 __DECL_VECTORIZED_LOOP
1167                 for(int i = 0; i < 8; i++) {
1168                         _gtmp.w[i] = 0;
1169                 }
1170         }
1171
1172         scrntype_vec8_t* vpp = (scrntype_vec8_t*)p;
1173         scrntype_vec8_t* dp = (scrntype_vec8_t*)tmp_dd;
1174 #if !defined(FIXED_FRAMEBUFFER_SIZE)
1175 __DECL_VECTORIZED_LOOP
1176         for(int i = 0; i < 8; i++) {
1177                 tmp_dd[i] = RGB_COLOR(_rtmp.w[i], _gtmp.w[i], _btmp.w[i]);
1178         }
1179         vpp->v = dp->v;
1180 #else
1181 __DECL_VECTORIZED_LOOP
1182         for(int i = 0; i < 8; i++) {
1183                 tmp_dd[i * 2] = tmp_dd[i * 2 + 1] = RGB_COLOR(_rtmp.w[i], _gtmp.w[i], _btmp.w[i]);
1184         }
1185
1186 __DECL_VECTORIZED_LOOP
1187         for(int i = 0; i < 2; i++) {
1188                 vpp[i].v = dp[i].v;
1189         }
1190         scrntype_vec8_t* vpx = (scrntype_vec8_t*)px;
1191         if(scan_line) {
1192 /* Fancy scanline */
1193 __DECL_VECTORIZED_LOOP
1194                 for(int i = 0; i < 2; i++) {
1195 #if defined(_RGB888) || defined(_RGBA888)
1196                         dp[i].v = dp[i].v >> 3;
1197 #elif defined(_RGB555)
1198                         dp[i].v = dp[i].v >> 2;
1199 #elif defined(_RGB565)
1200                         dp[i].v = dp[i].v >> 2;
1201 #endif
1202                 }
1203                 __DECL_ALIGNED(32) scrntype_vec8_t scanline_data;
1204 __DECL_VECTORIZED_LOOP
1205                 for(int i = 0; i < 8; i++) {
1206                         scanline_data.w[i] = RGBA_COLOR(31, 31, 31, 255);
1207                 }
1208 __DECL_VECTORIZED_LOOP
1209                 for(int i = 0; i < 2; i++) {
1210                         dp[i].v = dp[i].v & scanline_data.v;
1211                         vpx[i].v = dp[i].v;
1212                 }
1213         } else {
1214                 for(int i = 0; i < 2; i++) {
1215                         vpx[i].v = dp[i].v;
1216                 }
1217         }
1218 #endif
1219 }
1220 #endif
1221
1222 }