[BACK]Return to keydisp.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / generic

Diff for /np2/generic/keydisp.c between versions 1.7 and 1.9

version 1.7, 2004/04/08 13:51:52 version 1.9, 2005/02/07 14:46:10
Line 11 Line 11
 typedef struct {  typedef struct {
         UINT16  posx;          UINT16  posx;
         UINT16  pals;          UINT16  pals;
 const BYTE      *data;  const UINT8     *data;
 } KDKEYPOS;  } KDKEYPOS;
   
 typedef struct {  typedef struct {
         BYTE    k[KEYDISP_NOTEMAX];          UINT8   k[KEYDISP_NOTEMAX];
         BYTE    r[KEYDISP_NOTEMAX];          UINT8   r[KEYDISP_NOTEMAX];
         UINT    remain;          UINT    remain;
         BYTE    flag;          UINT8   flag;
         BYTE    padding[3];          UINT8   padding[3];
 } KDCHANNEL;  } KDCHANNEL;
   
 typedef struct {  typedef struct {
         BYTE    ch;          UINT8   ch;
         BYTE    key;          UINT8   key;
 } KDDELAYE;  } KDDELAYE;
   
 typedef struct {  typedef struct {
         UINT    pos;          UINT    pos;
         UINT    rem;          UINT    rem;
         BYTE    warm;          UINT8   warm;
         BYTE    warmbase;          UINT8   warmbase;
 } KDDELAY;  } KDDELAY;
   
 typedef struct {  typedef struct {
         UINT16  fnum[4];          UINT16  fnum[4];
         BYTE    lastnote[4];          UINT8   lastnote[4];
         BYTE    flag;          UINT8   flag;
         BYTE    extflag;          UINT8   extflag;
 } KDFMCTRL;  } KDFMCTRL;
   
 typedef struct {  typedef struct {
         UINT16  fto[4];          UINT16  fto[4];
         BYTE    lastnote[4];          UINT8   lastnote[4];
         BYTE    flag;          UINT8   flag;
         BYTE    mix;          UINT8   mix;
         BYTE    padding[2];          UINT8   padding[2];
 } KDPSGCTRL;  } KDPSGCTRL;
   
 typedef struct {  typedef struct {
         BYTE            mode;          UINT8           mode;
         BYTE            dispflag;          UINT8           dispflag;
         BYTE            framepast;          UINT8           framepast;
         BYTE            keymax;          UINT8           keymax;
         BYTE            fmmax;          UINT8           fmmax;
         BYTE            psgmax;          UINT8           psgmax;
         BYTE            fmpos[KEYDISP_FMMAX];          UINT8           fmpos[KEYDISP_FMMAX];
         BYTE            psgpos[KEYDISP_PSGMAX];          UINT8           psgpos[KEYDISP_PSGMAX];
         UINT            fmreg[KEYDISP_FMMAX];          UINT            fmreg[KEYDISP_FMMAX];
         KDDELAY         delay;          KDDELAY         delay;
         KDCHANNEL       ch[KEYDISP_CHMAX];          KDCHANNEL       ch[KEYDISP_CHMAX];
         KDFMCTRL        fmctl[KEYDISP_FMMAX];          KDFMCTRL        fmctl[KEYDISP_FMMAX];
         KDPSGCTRL       psgctl[KEYDISP_PSGMAX];          KDPSGCTRL       psgctl[KEYDISP_PSGMAX];
         BYTE            pal8[KEYDISP_PALS];          UINT8           pal8[KEYDISP_PALS];
         UINT16          pal16[KEYDISP_LEVEL*2];          UINT16          pal16[KEYDISP_LEVEL*2];
         RGB32           pal32[KEYDISP_LEVEL*2];          RGB32           pal32[KEYDISP_LEVEL*2];
         KDKEYPOS        keypos[128];          KDKEYPOS        keypos[128];
Line 77  static KEYDISP  keydisp; Line 77  static KEYDISP  keydisp;
   
 // ---- event  // ---- event
   
 static void keyon(UINT ch, BYTE note) {  static void keyon(UINT ch, UINT8 note) {
   
         UINT            i;          UINT            i;
         KDCHANNEL       *kdch;          KDCHANNEL       *kdch;
Line 104  static void keyon(UINT ch, BYTE note) { Line 104  static void keyon(UINT ch, BYTE note) {
         }          }
 }  }
   
 static void keyoff(UINT ch, BYTE note) {  static void keyoff(UINT ch, UINT8 note) {
   
         UINT            i;          UINT            i;
         KDCHANNEL       *kdch;          KDCHANNEL       *kdch;
Line 136  static void chkeyoff(UINT ch) { Line 136  static void chkeyoff(UINT ch) {
   
 static void keyalloff(void) {  static void keyalloff(void) {
   
         BYTE    i;          UINT8   i;
   
         for (i=0; i<KEYDISP_CHMAX; i++) {          for (i=0; i<KEYDISP_CHMAX; i++) {
                 chkeyoff(i);                  chkeyoff(i);
Line 170  static void delayreset(void) { Line 170  static void delayreset(void) {
         keyalloff();          keyalloff();
 }  }
   
 static void delayexecevent(BYTE framepast) {  static void delayexecevent(UINT8 framepast) {
   
         KDDELAYE        *ebase;          KDDELAYE        *ebase;
         UINT            pos;          UINT            pos;
Line 225  static void delayexecevent(BYTE framepas Line 225  static void delayexecevent(BYTE framepas
         keydisp.delay.rem = rem;          keydisp.delay.rem = rem;
 }  }
   
 static void delaysetevent(BYTE ch, BYTE key) {  static void delaysetevent(UINT8 ch, UINT8 key) {
   
         KDDELAYE        *e;          KDDELAYE        *e;
   
Line 258  static void delaysetevent(BYTE ch, BYTE  Line 258  static void delaysetevent(BYTE ch, BYTE 
   
 // ---- FM  // ---- FM
   
 static BYTE getfmnote(UINT16 fnum) {  static UINT8 getfmnote(UINT16 fnum) {
   
         BYTE    ret;          UINT8   ret;
         int             i;          int             i;
   
         ret = (fnum >> 11) & 7;          ret = (fnum >> 11) & 7;
Line 288  static BYTE getfmnote(UINT16 fnum) { Line 288  static BYTE getfmnote(UINT16 fnum) {
         return(ret);          return(ret);
 }  }
   
 static void fmkeyoff(BYTE ch, KDFMCTRL *k) {  static void fmkeyoff(UINT8 ch, KDFMCTRL *k) {
   
         delaysetevent(keydisp.fmpos[ch], k->lastnote[0]);          delaysetevent(keydisp.fmpos[ch], k->lastnote[0]);
 }  }
   
 static void fmkeyon(BYTE ch, KDFMCTRL *k) {  static void fmkeyon(UINT8 ch, KDFMCTRL *k) {
   
         UINT    reg;          UINT    reg;
   
Line 301  static void fmkeyon(BYTE ch, KDFMCTRL *k Line 301  static void fmkeyon(BYTE ch, KDFMCTRL *k
         reg = keydisp.fmreg[ch] + 0xa0;          reg = keydisp.fmreg[ch] + 0xa0;
         k->fnum[0] = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];          k->fnum[0] = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];
         k->lastnote[0] = getfmnote(k->fnum[0]);          k->lastnote[0] = getfmnote(k->fnum[0]);
         delaysetevent(keydisp.fmpos[ch], (BYTE)(k->lastnote[0] | 0x80));          delaysetevent(keydisp.fmpos[ch], (UINT8)(k->lastnote[0] | 0x80));
 }  }
   
 static void fmkeyreset(void) {  static void fmkeyreset(void) {
Line 309  static void fmkeyreset(void) { Line 309  static void fmkeyreset(void) {
         ZeroMemory(keydisp.fmctl, sizeof(keydisp.fmctl));          ZeroMemory(keydisp.fmctl, sizeof(keydisp.fmctl));
 }  }
   
 void keydisp_fmkeyon(BYTE ch, BYTE value) {  void keydisp_fmkeyon(UINT8 ch, UINT8 value) {
   
         KDFMCTRL        *k;          KDFMCTRL        *k;
   
Line 333  void keydisp_fmkeyon(BYTE ch, BYTE value Line 333  void keydisp_fmkeyon(BYTE ch, BYTE value
   
 static void fmkeysync(void) {  static void fmkeysync(void) {
   
         BYTE            ch;          UINT8           ch;
         KDFMCTRL        *k;          KDFMCTRL        *k;
         UINT16          reg;          UINT16          reg;
         UINT16          fnum;          UINT16          fnum;
Line 343  static void fmkeysync(void) { Line 343  static void fmkeysync(void) {
                         reg = keydisp.fmreg[ch] + 0xa0;                          reg = keydisp.fmreg[ch] + 0xa0;
                         fnum = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];                          fnum = ((opn.reg[reg + 4] & 0x3f) << 8) + opn.reg[reg];
                         if (k->fnum[0] != fnum) {                          if (k->fnum[0] != fnum) {
                                 BYTE n;                                  UINT8 n;
                                 k->fnum[0] = fnum;                                  k->fnum[0] = fnum;
                                 n = getfmnote(fnum);                                  n = getfmnote(fnum);
                                 if (k->lastnote[0] != n) {                                  if (k->lastnote[0] != n) {
Line 351  static void fmkeysync(void) { Line 351  static void fmkeysync(void) {
                                 }                                  }
                                 k->lastnote[0] = n;                                  k->lastnote[0] = n;
                                 delaysetevent(keydisp.fmpos[ch],                                  delaysetevent(keydisp.fmpos[ch],
                                                                                         (BYTE)(k->lastnote[0] | 0x80));                                                                                          (UINT8)(k->lastnote[0] | 0x80));
                         }                          }
                 }                  }
         }          }
Line 362  static void fmkeysync(void) { Line 362  static void fmkeysync(void) {
   
 static const void *psgtbl[3] = {&psg1, &psg2, &psg3};  static const void *psgtbl[3] = {&psg1, &psg2, &psg3};
   
 static BYTE getpsgnote(UINT16 tone) {  static UINT8 getpsgnote(UINT16 tone) {
   
         BYTE    ret;          UINT8   ret;
         int             i;          int             i;
   
         ret = 60;          ret = 60;
Line 393  static BYTE getpsgnote(UINT16 tone) { Line 393  static BYTE getpsgnote(UINT16 tone) {
         return(ret);          return(ret);
 }  }
   
 static void psgmix(BYTE ch, PSGGEN psg) {  static void psgmix(UINT8 ch, PSGGEN psg) {
   
         KDPSGCTRL       *k;          KDPSGCTRL       *k;
   
         k = keydisp.psgctl + ch;          k = keydisp.psgctl + ch;
         if ((k->mix ^ psg->reg.mixer) & 7) {          if ((k->mix ^ psg->reg.mixer) & 7) {
                 BYTE i, bit, pos;                  UINT8 i, bit, pos;
                 k->mix = psg->reg.mixer;                  k->mix = psg->reg.mixer;
                 pos = keydisp.psgpos[ch];                  pos = keydisp.psgpos[ch];
                 for (i=0, bit=1; i<3; i++, pos++, bit<<=1) {                  for (i=0, bit=1; i<3; i++, pos++, bit<<=1) {
Line 411  static void psgmix(BYTE ch, PSGGEN psg)  Line 411  static void psgmix(BYTE ch, PSGGEN psg) 
                                 k->flag |= bit;                                  k->flag |= bit;
                                 k->fto[i] = LOADINTELWORD(psg->reg.tune[i]) & 0xfff;                                  k->fto[i] = LOADINTELWORD(psg->reg.tune[i]) & 0xfff;
                                 k->lastnote[i] = getpsgnote(k->fto[i]);                                  k->lastnote[i] = getpsgnote(k->fto[i]);
                                 delaysetevent(pos, (BYTE)(k->lastnote[i] | 0x80));                                  delaysetevent(pos, (UINT8)(k->lastnote[i] | 0x80));
                         }                          }
                 }                  }
         }          }
 }  }
   
 static void psgvol(BYTE ch, PSGGEN psg, BYTE i) {  static void psgvol(UINT8 ch, PSGGEN psg, UINT8 i) {
   
         KDPSGCTRL       *k;          KDPSGCTRL       *k;
         BYTE            bit;          UINT8           bit;
         BYTE            pos;          UINT8           pos;
         UINT16          tune;          UINT16          tune;
   
         k = keydisp.psgctl + ch;          k = keydisp.psgctl + ch;
Line 434  static void psgvol(BYTE ch, PSGGEN psg,  Line 434  static void psgvol(BYTE ch, PSGGEN psg, 
                         tune &= 0xfff;                          tune &= 0xfff;
                         k->fto[i] = tune;                          k->fto[i] = tune;
                         k->lastnote[i] = getpsgnote(tune);                          k->lastnote[i] = getpsgnote(tune);
                         delaysetevent(pos, (BYTE)(k->lastnote[i] | 0x80));                          delaysetevent(pos, (UINT8)(k->lastnote[i] | 0x80));
                 }                  }
         }          }
         else if (k->flag & bit) {          else if (k->flag & bit) {
Line 450  static void psgkeyreset(void) { Line 450  static void psgkeyreset(void) {
   
 void keydisp_psgmix(void *psg) {  void keydisp_psgmix(void *psg) {
   
         BYTE    c;          UINT8   c;
   
         if (keydisp.mode != KEYDISP_MODEFM) {          if (keydisp.mode != KEYDISP_MODEFM) {
                 return;                  return;
Line 463  void keydisp_psgmix(void *psg) { Line 463  void keydisp_psgmix(void *psg) {
         }          }
 }  }
   
 void keydisp_psgvol(void *psg, BYTE ch) {  void keydisp_psgvol(void *psg, UINT8 ch) {
   
         BYTE    c;          UINT8   c;
   
         if (keydisp.mode != KEYDISP_MODEFM) {          if (keydisp.mode != KEYDISP_MODEFM) {
                 return;                  return;
Line 480  void keydisp_psgvol(void *psg, BYTE ch)  Line 480  void keydisp_psgvol(void *psg, BYTE ch) 
   
 static void psgkeysync(void) {  static void psgkeysync(void) {
   
         BYTE            ch;          UINT8           ch;
         KDPSGCTRL       *k;          KDPSGCTRL       *k;
         BYTE            bit;          UINT8           bit;
         BYTE            i;          UINT8           i;
         BYTE            pos;          UINT8           pos;
         PSGGEN          psg;          PSGGEN          psg;
         UINT16          tune;          UINT16          tune;
         BYTE            n;          UINT8           n;
   
         for (ch=0, k=keydisp.psgctl; ch<keydisp.psgmax; ch++, k++) {          for (ch=0, k=keydisp.psgctl; ch<keydisp.psgmax; ch++, k++) {
                 psg = (PSGGEN)psgtbl[ch];                  psg = (PSGGEN)psgtbl[ch];
Line 502  static void psgkeysync(void) { Line 502  static void psgkeysync(void) {
                                         if (k->lastnote[i] != n) {                                          if (k->lastnote[i] != n) {
                                                 delaysetevent(pos, k->lastnote[i]);                                                  delaysetevent(pos, k->lastnote[i]);
                                                 k->lastnote[i] = n;                                                  k->lastnote[i] = n;
                                                 delaysetevent(pos, (BYTE)(n | 0x80));                                                  delaysetevent(pos, (UINT8)(n | 0x80));
                                         }                                          }
                                 }                                  }
                         }                          }
Line 513  static void psgkeysync(void) { Line 513  static void psgkeysync(void) {
   
 // ---- BOARD change...  // ---- BOARD change...
   
 static void setfmhdl(BYTE items, UINT base) {  static void setfmhdl(UINT8 items, UINT base) {
   
         while(items--) {          while(items--) {
                 if ((keydisp.keymax < KEYDISP_CHMAX) &&                  if ((keydisp.keymax < KEYDISP_CHMAX) &&
Line 529  static void setfmhdl(BYTE items, UINT ba Line 529  static void setfmhdl(BYTE items, UINT ba
         }          }
 }  }
   
 static void setpsghdl(BYTE items) {  static void setpsghdl(UINT8 items) {
   
         while(items--) {          while(items--) {
                 if ((keydisp.keymax <= (KEYDISP_CHMAX - 3)) &&                  if ((keydisp.keymax <= (KEYDISP_CHMAX - 3)) &&
Line 586  void keydisp_setfmboard(UINT b) { Line 586  void keydisp_setfmboard(UINT b) {
   
 // ---- MIDI  // ---- MIDI
   
 void keydisp_midi(const BYTE *cmd) {  void keydisp_midi(const UINT8 *cmd) {
   
         if (keydisp.mode != KEYDISP_MODEMIDI) {          if (keydisp.mode != KEYDISP_MODEMIDI) {
                 return;                  return;
Line 757  static BOOL draw1key(CMNVRAM *vram, KDCH Line 757  static BOOL draw1key(CMNVRAM *vram, KDCH
         return(FALSE);          return(FALSE);
 }  }
   
 static BOOL draw1ch(CMNVRAM *vram, BYTE framepast, KDCHANNEL *kdch) {  static BOOL draw1ch(CMNVRAM *vram, UINT8 framepast, KDCHANNEL *kdch) {
   
         BOOL    draw;          BOOL    draw;
         UINT    i;          UINT    i;
         BOOL    coll;          BOOL    coll;
         BYTE    nextf;          UINT8   nextf;
         UINT    j;          UINT    j;
   
         draw = FALSE;          draw = FALSE;
Line 863  void keydisp_setpal(CMNPALFN *palfn) { Line 863  void keydisp_setpal(CMNPALFN *palfn) {
         keydisp.dispflag |= KEYDISP_FLAGREDRAW;          keydisp.dispflag |= KEYDISP_FLAGREDRAW;
 }  }
   
 void keydisp_setmode(BYTE mode) {  void keydisp_setmode(UINT8 mode) {
   
         if (keydisp.mode != mode) {          if (keydisp.mode != mode) {
                 keydisp.mode = mode;                  keydisp.mode = mode;
Line 880  void keydisp_setmode(BYTE mode) { Line 880  void keydisp_setmode(BYTE mode) {
         }          }
 }  }
   
 void keydisp_setdelay(BYTE frames) {  void keydisp_setdelay(UINT8 frames) {
   
         keydisp.delay.warmbase = frames;          keydisp.delay.warmbase = frames;
         delayreset();          delayreset();
 }  }
   
 BYTE keydisp_process(BYTE framepast) {  UINT8 keydisp_process(UINT8 framepast) {
   
         int             keys;          int             keys;
         int             i;          int             i;
Removed from v.1.7  
changed lines
  Added in v.1.9

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