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