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