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

Diff for /np2/statsave.c between versions 1.2 and 1.9

version 1.2, 2003/10/17 03:52:24 version 1.9, 2003/10/20 13:54:27
Line 43  typedef struct { Line 43  typedef struct {
 enum {  enum {
         NP2FLAG_BIN                     = 0,          NP2FLAG_BIN                     = 0,
         NP2FLAG_TERM,          NP2FLAG_TERM,
         NP2FLAG_286,          NP2FLAG_CLOCK,
         NP2FLAG_CORE,  
         NP2FLAG_DMA,          NP2FLAG_DMA,
         NP2FLAG_EGC,          NP2FLAG_EGC,
         NP2FLAG_EXT,          NP2FLAG_EXT,
         NP2FLAG_EVT,          NP2FLAG_EVT,
         NP2FLAG_GIJ,          NP2FLAG_GIJ,
         NP2FLAG_FM,          NP2FLAG_FM,
         NP2FLAG_BEEP,  
         NP2FLAG_MIDI,          NP2FLAG_MIDI,
         NP2FLAG_DISK          NP2FLAG_DISK
 };  };
Line 350  static int flagload_common(NP2FFILE *f,  Line 348  static int flagload_common(NP2FFILE *f, 
   
 // -----  // -----
   
 static int flagsave_286(NP2FFILE *f, const STENTRY *t) {  static int flagload_clock(NP2FFILE *f, const STENTRY *t) {
   
         int             ret;  
   
         ret = flagsave_create(f, t);  
         if (ret != NP2FLAG_FAILURE) {  
                 ret |= flagsave_save(f, &i286r, sizeof(I286REGS));  
                 ret |= flagsave_save(f, &i286s, sizeof(I286STAT));  
                 ret |= flagsave_close(f);  
         }  
         return(ret);  
 }  
   
 static int flagload_286(NP2FFILE *f, const STENTRY *t) {  
   
         int             ret;  
   
         ret = flagload_load(f, &i286r, sizeof(I286REGS));  
         ret |= flagload_load(f, &i286s, sizeof(I286STAT));  
         (void)t;  
         return(ret);  
 }  
   
   
 // -----  
   
 static int flagload_core(NP2FFILE *f, const STENTRY *t) {  
   
         int             ret;          int             ret;
   
         ret = flagload_common(f, t);          ret = flagload_common(f, t);
         if (opna_rate) {          sound_changeclock();
                 pc.sampleclock = (pc.realclock / opna_rate) + 1;          beep_changeclock();
         }  
         else {  
                 pc.sampleclock = 0;  
         }  
         return(ret);          return(ret);
 }  }
   
Line 526  static int flagload_ext(NP2FFILE *f, con Line 494  static int flagload_ext(NP2FFILE *f, con
 // -----  // -----
   
 typedef struct {  typedef struct {
         SINT32          remainclock;  
         SINT32          baseclock;  
         UINT32          clock;  
         UINT            readyevents;          UINT            readyevents;
         UINT            waitevents;          UINT            waitevents;
 } NEVTSAVE;  } NEVTSAVE;
Line 567  static int flagsave_evt(NP2FFILE *f, con Line 532  static int flagsave_evt(NP2FFILE *f, con
         int                     ret;          int                     ret;
         UINT            i;          UINT            i;
   
         nevt.remainclock = nevent.remainclock;  
         nevt.baseclock = nevent.baseclock;  
         nevt.clock = nevent.clock;  
         nevt.readyevents = nevent.readyevents;          nevt.readyevents = nevent.readyevents;
         nevt.waitevents = nevent.waitevents;          nevt.waitevents = nevent.waitevents;
   
Line 628  static int flagload_evt(NP2FFILE *f, con Line 590  static int flagload_evt(NP2FFILE *f, con
   
         ret = flagload_load(f, &nevt, sizeof(nevt));          ret = flagload_load(f, &nevt, sizeof(nevt));
   
         nevent.remainclock = nevt.remainclock;  
         nevent.baseclock = nevt.baseclock;  
         nevent.clock = nevt.clock;  
         nevent.readyevents = 0;          nevent.readyevents = 0;
         nevent.waitevents = 0;          nevent.waitevents = 0;
   
Line 769  static int flagsave_fm(NP2FFILE *f, cons Line 728  static int flagsave_fm(NP2FFILE *f, cons
                 if (saveflg & FLAG_FM1A) {                  if (saveflg & FLAG_FM1A) {
                         ret |= flagsave_save(f, &fmtimer, sizeof(fmtimer));                          ret |= flagsave_save(f, &fmtimer, sizeof(fmtimer));
                         ret |= flagsave_save(f, &opn, sizeof(opn));                          ret |= flagsave_save(f, &opn, sizeof(opn));
                         CopyMemory(opnkey.keyreg, fm_keyreg, sizeof(fm_keyreg));                          CopyMemory(opnkey.keyreg, opngen.keyreg, sizeof(opngen.keyreg));
                         opnkey.extop[0] = opnch[2].extop;                          opnkey.extop[0] = opnch[2].extop;
                         opnkey.extop[1] = opnch[5].extop;                          opnkey.extop[1] = opnch[5].extop;
                         opnkey.extop[2] = opnch[8].extop;                          opnkey.extop[2] = opnch[8].extop;
Line 811  static void play_fmreg(BYTE num) { Line 770  static void play_fmreg(BYTE num) {
                 opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);                  opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
         }          }
         for (i=0; i<3; i++) {          for (i=0; i<3; i++) {
                 opngen_keyon(chbase + i, fm_keyreg[chbase + i]);                  opngen_keyon(chbase + i, opngen.keyreg[chbase + i]);
         }          }
 }  }
   
Line 894  static int flagload_fm(NP2FFILE *f, cons Line 853  static int flagload_fm(NP2FFILE *f, cons
                 ret |= flagload_load(f, &fmtimer, sizeof(fmtimer));                  ret |= flagload_load(f, &fmtimer, sizeof(fmtimer));
                 ret |= flagload_load(f, &opn, sizeof(opn));                  ret |= flagload_load(f, &opn, sizeof(opn));
                 ret |= flagload_load(f, &opnkey, sizeof(opnkey));                  ret |= flagload_load(f, &opnkey, sizeof(opnkey));
                 CopyMemory(fm_keyreg, &opnkey.keyreg, sizeof(fm_keyreg));                  CopyMemory(opngen.keyreg, &opnkey.keyreg, sizeof(opngen.keyreg));
                 opnch[2].extop = opnkey.extop[0];                  opnch[2].extop = opnkey.extop[0];
                 opnch[5].extop = opnkey.extop[1];                  opnch[5].extop = opnkey.extop[1];
                 opnch[8].extop = opnkey.extop[2];                  opnch[8].extop = opnkey.extop[2];
Line 1201  int statsave_save(const char *filename)  Line 1160  int statsave_save(const char *filename) 
         for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {          for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {
                 switch(np2tbl[i].type) {                  switch(np2tbl[i].type) {
                         case NP2FLAG_BIN:                          case NP2FLAG_BIN:
                         case NP2FLAG_CORE:                          case NP2FLAG_CLOCK:
                         case NP2FLAG_BEEP:  
                                 ret |= flagsave_common(&f, &np2tbl[i]);                                  ret |= flagsave_common(&f, &np2tbl[i]);
                                 break;                                  break;
   
Line 1210  int statsave_save(const char *filename)  Line 1168  int statsave_save(const char *filename) 
                                 ret |= flagsave_term(&f, &np2tbl[i]);                                  ret |= flagsave_term(&f, &np2tbl[i]);
                                 break;                                  break;
   
                         case NP2FLAG_286:  
                                 ret |= flagsave_286(&f, &np2tbl[i]);  
                                 break;  
   
                         case NP2FLAG_DMA:                          case NP2FLAG_DMA:
                                 ret |= flagsave_dma(&f, &np2tbl[i]);                                  ret |= flagsave_dma(&f, &np2tbl[i]);
                                 break;                                  break;
Line 1289  int statsave_check(const char *filename, Line 1243  int statsave_check(const char *filename,
                         if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {                          if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {
                                 switch(np2tbl[i].type) {                                  switch(np2tbl[i].type) {
                                         case NP2FLAG_BIN:                                          case NP2FLAG_BIN:
                                           case NP2FLAG_CLOCK:
                                                 ret |= flagcheck_versize(&f, &np2tbl[i], &e);                                                  ret |= flagcheck_versize(&f, &np2tbl[i], &e);
                                                 break;                                                  break;
   
Line 1296  int statsave_check(const char *filename, Line 1251  int statsave_check(const char *filename,
                                                 done = TRUE;                                                  done = TRUE;
                                                 break;                                                  break;
   
                                         case NP2FLAG_286:  
                                         case NP2FLAG_CORE:  
                                         case NP2FLAG_DMA:                                          case NP2FLAG_DMA:
                                         case NP2FLAG_EGC:                                          case NP2FLAG_EGC:
                                         case NP2FLAG_EXT:                                          case NP2FLAG_EXT:
                                         case NP2FLAG_EVT:                                          case NP2FLAG_EVT:
                                         case NP2FLAG_GIJ:                                          case NP2FLAG_GIJ:
                                         case NP2FLAG_BEEP:  
 #if defined(MIDICH)  #if defined(MIDICH)
                                         case NP2FLAG_MIDI:                                          case NP2FLAG_MIDI:
 #endif  #endif
Line 1368  int statsave_load(const char *filename)  Line 1320  int statsave_load(const char *filename) 
                 if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {                  if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {
                         switch(np2tbl[i].type) {                          switch(np2tbl[i].type) {
                                 case NP2FLAG_BIN:                                  case NP2FLAG_BIN:
                                 case NP2FLAG_BEEP:  
                                         ret |= flagload_common(&f, &np2tbl[i]);                                          ret |= flagload_common(&f, &np2tbl[i]);
                                         break;                                          break;
   
Line 1376  int statsave_load(const char *filename)  Line 1327  int statsave_load(const char *filename) 
                                         done = TRUE;                                          done = TRUE;
                                         break;                                          break;
   
                                 case NP2FLAG_286:                                  case NP2FLAG_CLOCK:
                                         ret |= flagload_286(&f, &np2tbl[i]);                                          ret |= flagload_clock(&f, &np2tbl[i]);
                                         break;  
   
                                 case NP2FLAG_CORE:  
                                         ret |= flagload_core(&f, &np2tbl[i]);  
                                         break;                                          break;
   
                                 case NP2FLAG_DMA:                                  case NP2FLAG_DMA:
Removed from v.1.2  
changed lines
  Added in v.1.9

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