[BACK]Return to pcg.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / xmil / io

Diff for /xmil/io/pcg.c between versions 1.2 and 1.13

version 1.2, 2004/08/03 11:02:00 version 1.13, 2004/08/20 23:01:16
Line 2 Line 2
 #include        "z80core.h"  #include        "z80core.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "x1_io.h"  #include        "nevent.h"
 #include        "x1_crtc.h"  
 #include        "x1_vram.h"  
 #include        "vram.h"  #include        "vram.h"
   #include        "makescrn.h"
 #include        "font.h"  #include        "font.h"
   
   
 static void pcgsync(void) {  static void waithsync(void) {
   
         *(UINT32 *)&pcg.r.vsync = 0;          SINT32  clock;
         *(UINT32 *)&pcg.r.roff0 = 0;          SINT32  h;
   
   //      必ず hsyncを待つ？
   //      if (corestat.vsync) {
   //              return;
   //      }
           clock = nevent_getwork(NEVENT_FRAMES) << 8;
           h = clock % crtc.e.rasterclock8;
           h = crtc.e.rasterdisp8 - h;
           if (h < 0) {
                   h += crtc.e.rasterclock8;
           }
           CPU_REMCLOCK -= (h >> 8);
 }  }
   
   
 static UINT pcg_offset(void) {  static UINT pcg_offset(void) {
   
         if (tram[TRAM_ATR + 0x07ff] & 0x20) {          if (tram[TRAM_ATR + 0x07ff] & 0x20) {
Line 49  static UINT knj_offset(void) { Line 61  static UINT knj_offset(void) {
         return(0x7ff);          return(0x7ff);
 }  }
   
 static UINT nowsyncoffset(void) {  static UINT nowsyncoffset(UINT *line) {
   
           SINT32  clock;
           UINT    h;
           UINT    v;
         UINT    ret;          UINT    ret;
   
         ret = (((v_cnt - crtc.CRT_YL) / crtc.fnty) + crtc.TXT_YL) * crtc.TXT_XL          clock = nevent_getwork(NEVENT_FRAMES);
                                                                                                                         + crtc.TXT_TOP;          if (corestat.vsync) {
         if (pccore.HSYNC_CLK) {                  clock += corestat.dispclock;
                 ret += (h_cnt * crtc.TXT_XL) / pccore.HSYNC_CLK;          }
         }          clock = clock << 8;
           v = clock / crtc.e.rasterclock8;
           h = clock - (v * crtc.e.rasterclock8);
           if (crtc.s.SCRN_BITS & SCRN_24KHZ) {
                   v = v >> 1;
           }
           ret = v / crtc.e.fonty;
           *line = (v - (ret * crtc.e.fonty)) & 7;
           ret = (ret * crtc.s.reg[CRTCREG_HDISP]) + crtc.e.pos;
           ret += (h * crtc.s.reg[CRTCREG_HDISP]) / crtc.e.rasterclock8;
         if (ret >= 0x0800) {          if (ret >= 0x0800) {
                 ret = 0x07ff;           // オーバーフロー                  ret = 0x07ff;           // オーバーフロー
         }          }
Line 70  void IOOUTCALL pcg_o(UINT port, REG8 val Line 93  void IOOUTCALL pcg_o(UINT port, REG8 val
   
         UINT    chr;          UINT    chr;
         UINT    off;          UINT    off;
         UINT    l;          UINT    line;
   
         if (crtc.SCRN_BITS & SCRN_PCGMODE) {          if (crtc.s.SCRN_BITS & SCRN_PCGMODE) {
                   waithsync();
                 off = pcg_offset();                  off = pcg_offset();
                 chr = tram[TRAM_ANK + off];                  chr = tram[TRAM_ANK + off];
                 if (tram[TRAM_KNJ + off] & 0x90) {                  if (tram[TRAM_KNJ + off] & 0x90) {
                         chr &= 0xfe;                          chr = chr & (~1);
                         l = port & 15;                          line = port & 15;
                 }                  }
                 else {                  else {
                         l = (port >> 1) & 7;                          line = (port >> 1) & 7;
                 }  
                 switch(port >> 8) {  
                         case 0x15:  
                                 pcg.d.b[chr][l] = value;  
                                 break;  
   
                         case 0x16:  
                                 pcg.d.r[chr][l] = value;  
                                 break;  
   
                         case 0x17:  
                                 pcg.d.g[chr][l] = value;  
                                 break;  
                 }                  }
         }          }
         else {          else {
                 off = nowsyncoffset();                                          // 990622 puni                  off = nowsyncoffset(&line);
                 chr = tram[TRAM_ANK + off];                  chr = tram[TRAM_ANK + off];
                 if (pcg.r.vsync) {          }
                         pcgsync();          chr += (port & 0x0300) - 0x100;
                 }          if (pcg.d[(chr << 3) + line] != value) {
                 switch(port & 0xff00) {                  pcg.d[(chr << 3) + line] = value;
                         case 0x1500:                  scrnallflash = TRUE;
                                 pcg.d.b[chr][pcg.r.woff1] = value;  
                                 pcg.r.woff1 = (pcg.r.woff1 + 1) & 7;  
                                 break;  
   
                         case 0x1600:  
                                 pcg.d.r[chr][pcg.r.woff2] = value;  
                                 pcg.r.woff2 = (pcg.r.woff2 + 1) & 7;  
                                 break;  
   
                         case 0x1700:  
                                 pcg.d.g[chr][pcg.r.woff4] = value;  
                                 pcg.r.woff4 = (pcg.r.woff4 + 1) & 7;  
                                 break;  
                 }  
         }          }
 }  }
   
 REG8 IOINPCALL pcg_i(UINT port) {  REG8 IOINPCALL pcg_i(UINT port) {
   
           UINT    upper;
           UINT    line;
         UINT    off;          UINT    off;
         int             l;          UINT    chr;
         BYTE    chr,knj,val;          UINT    knj;
           UINT    addr;
   
         val = 0xff;          upper = port & 0x0300;
         if (crtc.SCRN_BITS & SCRN_PCGMODE) {          if (crtc.s.SCRN_BITS & SCRN_PCGMODE) {
                 l = port & 0x0f;                  waithsync();
                 if ((port & 0xff00) == 0x1400) {                  line = port & 0x0f;
                   if (!upper) {
                         off = knj_offset();                          off = knj_offset();
                         chr = tram[TRAM_ANK + off];                          chr = tram[TRAM_ANK + off];
                         knj = tram[TRAM_KNJ + off];                          knj = tram[TRAM_KNJ + off];
                         if (knj & 0x80) {                          if (knj & 0x80) {
                                 DWORD p;                                  addr = ((((knj & 0x1f) << 8) + chr) << 4) + line;
                                 p = ((((DWORD)knj << 8) | chr) & 0x1fff) << 4;  
                                 if (knj & 0x40) {                                  if (knj & 0x40) {
                                         val = font_knjx1t[p + l + FONTX1T_LR];                                          addr += FONTX1T_LR;
                                 }  
                                 else {  
                                         val = font_knjx1t[p + l];  
                                 }                                  }
                                   return(font_knjx1t[addr]);
                         }                          }
                         else if (crtc.SCRN_BITS & SCRN_CPUFONT) {                          else if (crtc.s.SCRN_BITS & SCRN_CPUFONT) {
                                 val = font_txt[(chr << 4) + l];                                  return(font_txt[(chr << 4) + line]);
                         }                          }
                         else {                          else {
                                 val = font_ank[(chr << 3) + (l >> 1)];                                  line >>= 1;
                         }                          }
                 }                  }
                 else {                  else {
                         off = pcg_offset();                          off = pcg_offset();
                         chr = tram[TRAM_ANK + off];                          chr = tram[TRAM_ANK + off];
                         if (tram[TRAM_KNJ + off] & 0x90) {                          if (tram[TRAM_KNJ + off] & 0x90) {
                                 chr &= 0xfe;                                  chr = chr & (~1);
                         }                          }
                         else {                          else {
                                 l >>= 1;                                  line >>= 1;
                         }  
                         switch(port & 0xff00) {  
                                 case 0x1500:  
                                         val = pcg.d.b[chr][l];  
                                         break;  
   
                                 case 0x1600:  
                                         val = pcg.d.r[chr][l];  
                                         break;  
   
                                 case 0x1700:  
                                         val = pcg.d.g[chr][l];  
                                         break;  
                         }                          }
                 }                  }
         }          }
         else {          else {
                 off = nowsyncoffset();                                  // 990622 puni                  off = nowsyncoffset(&line);
                 chr = tram[TRAM_ANK + off];                  chr = tram[TRAM_ANK + off];
                 if (pcg.r.vsync) {  
                         pcgsync();  
                 }  
                 switch(port >> 8) {  
                         case 0x14:  
                                 val = font_ank[(chr << 3) + pcg.r.roff0];  
                                 pcg.r.roff0 = (pcg.r.roff0 + 1) & 7;  
                                 break;  
   
                         case 0x15:  
                                 val = pcg.d.b[chr][pcg.r.roff1];  
                                 pcg.r.roff1 = (pcg.r.roff1 + 1) & 7;  
                                 break;  
   
                         case 0x16:  
                                 val = pcg.d.r[chr][pcg.r.roff2];  
                                 pcg.r.roff2 = (pcg.r.roff2 + 1) & 7;  
                                 break;  
   
                         case 0x17:  
                                 val = pcg.d.g[chr][pcg.r.roff4];  
                                 pcg.r.roff4 = (pcg.r.roff4 + 1) & 7;  
                                 break;  
                 }  
         }          }
         return(val);          if (!upper) {
                   return(font_ank[(chr << 3) + line]);
           }
           else {
                   chr += upper - 0x100;
                   return(pcg.d[(chr << 3) + line]);
           }
 }  }
   
   
Line 215  void pcg_initialize(void) { Line 182  void pcg_initialize(void) {
 }  }
   
 void pcg_reset(void) {  void pcg_reset(void) {
   
         pcgsync();  
 }  }
   
Removed from v.1.2  
changed lines
  Added in v.1.13

RetroPC.NET-CVS <cvs@retropc.net>