[fceu.git] / boards / n106.c

/* FCE Ultra - NES/Famicom Emulator
 *
 * Copyright notice for this file:
 *  Copyright (C) 2002 Xodnizel
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "mapinc.h"

static uint16 IRQCount;
static uint8 IRQa;

static uint8 WRAM[8192];
static uint8 IRAM[128];

static DECLFR(AWRAM)
{
  return(WRAM[A-0x6000]);
}

static DECLFW(BWRAM)
{
  WRAM[A-0x6000]=V;
}

void Mapper19_ESI(void);

static uint8 NTAPage[4];

static uint8 dopol;
static uint8 gorfus;
static uint8 gorko;

static void NamcoSound(int Count);
static void NamcoSoundHack(void);
static void DoNamcoSound(int32 *Wave, int Count);
static void DoNamcoSoundHQ(void);
static void SyncHQ(int32 ts);

static int is210;        /* Lesser mapper. */

static uint8 PRG[3];
static uint8 CHR[8];

static SFORMAT N106_StateRegs[]={
  {PRG,3,"PRG"},
  {CHR,8,"CHR"},
  {NTAPage,4,"NTA"},
  {0}
};

static void SyncPRG(void)
{
  setprg8(0x8000,PRG[0]);
  setprg8(0xa000,PRG[1]);
  setprg8(0xc000,PRG[2]);
  setprg8(0xe000,0x3F);
}

static void FP_FASTAPASS(1) NamcoIRQHook(int a)
{
  if(IRQa)
  {
    IRQCount+=a;
    if(IRQCount>=0x7FFF)
    {
      X6502_IRQBegin(FCEU_IQEXT);
      IRQa=0;
      IRQCount=0x7FFF; //7FFF;
    }
  }
}

static DECLFR(Namco_Read4800)
{
  uint8 ret=IRAM[dopol&0x7f];
  /* Maybe I should call NamcoSoundHack() here? */
  #ifdef FCEUDEF_DEBUGGER
  if(!fceuindbg)
  #endif
    if(dopol&0x80)
      dopol=(dopol&0x80)|((dopol+1)&0x7f);
  return ret;
}

static DECLFR(Namco_Read5000)
{
  return(IRQCount);
}

static DECLFR(Namco_Read5800)
{
  return(IRQCount>>8);
}

static void FASTAPASS(2) DoNTARAMROM(int w, uint8 V)
{
  NTAPage[w]=V;
  if(V>=0xE0)
    setntamem(NTARAM+((V&1)<<10), 1, w);
  else
  {
    V&=CHRmask1[0];
    setntamem(CHRptr[0]+(V<<10), 0, w);
  }
}

static void FixNTAR(void)
{
  int x;
  for(x=0;x<4;x++)
     DoNTARAMROM(x,NTAPage[x]);
}

static void FASTAPASS(2) DoCHRRAMROM(int x, uint8 V)
{
  CHR[x]=V;
  if(!is210 && !((gorfus>>((x>>2)+6))&1) && (V>=0xE0))
  {
    // printf("BLAHAHA: %d, %02x\n",x,V);
    //setchr1r(0x10,x<<10,V&7);
  }
  else
    setchr1(x<<10,V);
}

static void FixCRR(void)
{
  int x;
  for(x=0;x<8;x++)
     DoCHRRAMROM(x,CHR[x]);
}

static DECLFW(Mapper19C0D8_write)
{
  DoNTARAMROM((A-0xC000)>>11,V);
}

static uint32 FreqCache[8];
static uint32 EnvCache[8];
static uint32 LengthCache[8];

static void FixCache(int a,int V)
{
  int w=(a>>3)&0x7;
  switch(a&0x07)
  {
    case 0x00:FreqCache[w]&=~0x000000FF;FreqCache[w]|=V;break;
    case 0x02:FreqCache[w]&=~0x0000FF00;FreqCache[w]|=V<<8;break;
    case 0x04:FreqCache[w]&=~0x00030000;FreqCache[w]|=(V&3)<<16;
              LengthCache[w]=(8-((V>>2)&7))<<2;
              break;
    case 0x07:EnvCache[w]=(double)(V&0xF)*576716;break;
  }
}

static DECLFW(Mapper19_write)
{
  A&=0xF800;
  if(A>=0x8000 && A<=0xb800)
    DoCHRRAMROM((A-0x8000)>>11,V);
  else switch(A)
  {
    case 0x4800:
         if(dopol&0x40)
         {
           if(FSettings.SndRate)
           {
             NamcoSoundHack();
             GameExpSound.Fill=NamcoSound;
             GameExpSound.HiFill=DoNamcoSoundHQ;
             GameExpSound.HiSync=SyncHQ;
           }
           FixCache(dopol,V);
         }
         IRAM[dopol&0x7f]=V;
         if(dopol&0x80)
           dopol=(dopol&0x80)|((dopol+1)&0x7f);
         break;
    case 0xf800:
         dopol=V;break;
    case 0x5000:
         IRQCount&=0xFF00;IRQCount|=V;X6502_IRQEnd(FCEU_IQEXT);break;
    case 0x5800:
         IRQCount&=0x00ff;IRQCount|=(V&0x7F)<<8;
         IRQa=V&0x80;
         X6502_IRQEnd(FCEU_IQEXT);
         break;
    case 0xE000:
         gorko=V&0xC0;
         PRG[0]=V&0x3F;
         SyncPRG();
         break;
    case 0xE800:
         gorfus=V&0xC0;
         FixCRR();
         PRG[1]=V&0x3F;
         SyncPRG();
         break;
    case 0xF000:
         PRG[2]=V&0x3F;
         SyncPRG();
         break;
  }
}

static int dwave=0;

static void NamcoSoundHack(void)
{
  int32 z,a;
  if(FSettings.soundq>=1)
  {
    DoNamcoSoundHQ();
    return;
  }
  z=((SOUNDTS<<16)/soundtsinc)>>4;
  a=z-dwave;
  if(a) DoNamcoSound(&Wave[dwave], a);
  dwave+=a;
}

static void NamcoSound(int Count)
{
  int32 z,a;
  z=((SOUNDTS<<16)/soundtsinc)>>4;
  a=z-dwave;
  if(a) DoNamcoSound(&Wave[dwave], a);
  dwave=0;
}

static uint32 PlayIndex[8];
static int32 vcount[8];
static int32 CVBC;

#define TOINDEX        (16+1)

// 16:15
static void SyncHQ(int32 ts)
{
  CVBC=ts;
}


/* Things to do:
        1        Read freq low
        2        Read freq mid
        3        Read freq high
        4        Read envelope
        ...?
*/

static INLINE uint32 FetchDuff(uint32 P, uint32 envelope)
{
  uint32 duff;
  duff=IRAM[((IRAM[0x46+(P<<3)]+(PlayIndex[P]>>TOINDEX))&0xFF)>>1];
  if((IRAM[0x46+(P<<3)]+(PlayIndex[P]>>TOINDEX))&1)
    duff>>=4;
  duff&=0xF;
  duff=(duff*envelope)>>16;
  return(duff);
}

static void DoNamcoSoundHQ(void)
{
  int32 P,V;
  int32 cyclesuck=(((IRAM[0x7F]>>4)&7)+1)*15;

  for(P=7;P>=(7-((IRAM[0x7F]>>4)&7));P--)
  {
    if((IRAM[0x44+(P<<3)]&0xE0) && (IRAM[0x47+(P<<3)]&0xF))
    {
      uint32 freq;
      int32 vco;
      uint32 duff2,lengo,envelope;

      vco=vcount[P];
      freq=FreqCache[P];
      envelope=EnvCache[P];
      lengo=LengthCache[P];

      duff2=FetchDuff(P,envelope);
      for(V=CVBC<<1;V<SOUNDTS<<1;V++)
      {
        WaveHi[V>>1]+=duff2;
        if(!vco)
        {
          PlayIndex[P]+=freq;
          while((PlayIndex[P]>>TOINDEX)>=lengo) PlayIndex[P]-=lengo<<TOINDEX;
          duff2=FetchDuff(P,envelope);
          vco=cyclesuck;
        }
        vco--;
      }
      vcount[P]=vco;
    }
  }
  CVBC=SOUNDTS;
}


static void DoNamcoSound(int32 *Wave, int Count)
{
  int P,V;
  for(P=7;P>=7-((IRAM[0x7F]>>4)&7);P--)
  {
    if((IRAM[0x44+(P<<3)]&0xE0) && (IRAM[0x47+(P<<3)]&0xF))
    {
      int32 inc;
      uint32 freq;
      int32 vco;
      uint32 duff,duff2,lengo,envelope;

      vco=vcount[P];
      freq=FreqCache[P];
      envelope=EnvCache[P];
      lengo=LengthCache[P];

      if(!freq) {/*printf("Ack");*/  continue;}

      {
        int c=((IRAM[0x7F]>>4)&7)+1;
        inc=(long double)(FSettings.SndRate<<15)/((long double)freq*21477272/((long double)0x400000*c*45));
      }

      duff=IRAM[(((IRAM[0x46+(P<<3)]+PlayIndex[P])&0xFF)>>1)];
      if((IRAM[0x46+(P<<3)]+PlayIndex[P])&1)
        duff>>=4;
      duff&=0xF;
      duff2=(duff*envelope)>>19;
      for(V=0;V<Count*16;V++)
      {
        if(vco>=inc)
        {
          PlayIndex[P]++;
          if(PlayIndex[P]>=lengo)
            PlayIndex[P]=0;
          vco-=inc;
          duff=IRAM[(((IRAM[0x46+(P<<3)]+PlayIndex[P])&0xFF)>>1)];
          if((IRAM[0x46+(P<<3)]+PlayIndex[P])&1)
            duff>>=4;
          duff&=0xF;
          duff2=(duff*envelope)>>19;
        }
        Wave[V>>4]+=duff2;
        vco+=0x8000;
      }
      vcount[P]=vco;
    }
  }
}

static void Mapper19_StateRestore(int version)
{
  SyncPRG();
  FixNTAR();
  FixCRR();
  int x;
  for(x=0x40;x<0x80;x++)
     FixCache(x,IRAM[x]);
}

static void M19SC(void)
{
  if(FSettings.SndRate)
    Mapper19_ESI();
}

void Mapper19_ESI(void)
{
  GameExpSound.RChange=M19SC;
  memset(vcount,0,sizeof(vcount));
  memset(PlayIndex,0,sizeof(PlayIndex));
  CVBC=0;
}

void NSFN106_Init(void)
{
  SetWriteHandler(0xf800,0xffff,Mapper19_write);
  SetWriteHandler(0x4800,0x4fff,Mapper19_write);
  SetReadHandler(0x4800,0x4fff,Namco_Read4800);
  Mapper19_ESI();
}

static int battery=0;

static void N106_Power(void)
{
  int x;
  SetReadHandler(0x8000,0xFFFF,CartBR);
  SetWriteHandler(0x8000,0xffff,Mapper19_write);
  SetWriteHandler(0x4020,0x5fff,Mapper19_write);
  if(!is210)
  {
    SetWriteHandler(0xc000,0xdfff,Mapper19C0D8_write);
    SetReadHandler(0x4800,0x4fff,Namco_Read4800);
    SetReadHandler(0x5000,0x57ff,Namco_Read5000);
    SetReadHandler(0x5800,0x5fff,Namco_Read5800);
    NTAPage[0]=NTAPage[1]=NTAPage[2]=NTAPage[3]=0xFF;
    FixNTAR();
  }

  SetReadHandler(0x6000,0x7FFF,AWRAM);
  SetWriteHandler(0x6000,0x7FFF,BWRAM);
  FCEU_CheatAddRAM(8,0x6000,WRAM);

  gorfus=0xFF;
  SyncPRG();
  FixCRR();

  if(!battery)
  {
    FCEU_dwmemset(WRAM,0,8192);
    FCEU_dwmemset(IRAM,0,128);
  }
  for(x=0x40;x<0x80;x++)
     FixCache(x,IRAM[x]);
}

void Mapper19_Init(CartInfo *info)
{
  is210=0;
  battery=info->battery;
  info->Power=N106_Power;

  MapIRQHook=NamcoIRQHook;
  GameStateRestore=Mapper19_StateRestore;
  GameExpSound.RChange=M19SC;

  if(FSettings.SndRate)
    Mapper19_ESI();

  AddExState(WRAM, 8192, 0, "WRAM");
  AddExState(IRAM, 128, 0, "IRAM");
  AddExState(N106_StateRegs, ~0, 0, 0);

  if(info->battery)
  {
    info->SaveGame[0]=WRAM;
    info->SaveGameLen[0]=8192;
    info->SaveGame[1]=IRAM;
    info->SaveGameLen[1]=128;
  }
}

static void Mapper210_StateRestore(int version)
{
  SyncPRG();
  FixCRR();
}

void Mapper210_Init(CartInfo *info)
{
  is210=1;
  GameStateRestore=Mapper210_StateRestore;
  info->Power=N106_Power;
  AddExState(WRAM, 8192, 0, "WRAM");
  AddExState(N106_StateRegs, ~0, 0, 0);
}
Commit	Line	Data
d97315ac	1	/* FCE Ultra - NES/Famicom Emulator
	2	*
	3	* Copyright notice for this file:
	4	* Copyright (C) 2002 Xodnizel
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
43725da7	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
d97315ac	19	*/
	20
	21	#include "mapinc.h"
	22
	23	static uint16 IRQCount;
	24	static uint8 IRQa;
	25
386f5371	26	static uint8 WRAM[8192];
386f5371	27	static uint8 IRAM[128];
d97315ac	28
	29	static DECLFR(AWRAM)
	30	{
	31	return(WRAM[A-0x6000]);
	32	}
	33
	34	static DECLFW(BWRAM)
	35	{
	36	WRAM[A-0x6000]=V;
	37	}
	38
	39	void Mapper19_ESI(void);
	40
	41	static uint8 NTAPage[4];
	42
	43	static uint8 dopol;
	44	static uint8 gorfus;
	45	static uint8 gorko;
	46
	47	static void NamcoSound(int Count);
	48	static void NamcoSoundHack(void);
	49	static void DoNamcoSound(int32 *Wave, int Count);
386f5371	50	static void DoNamcoSoundHQ(void);
d97315ac	51	static void SyncHQ(int32 ts);
	52
	53	static int is210; /* Lesser mapper. */
	54
	55	static uint8 PRG[3];
	56	static uint8 CHR[8];
	57
	58	static SFORMAT N106_StateRegs[]={
	59	{PRG,3,"PRG"},
	60	{CHR,8,"CHR"},
	61	{NTAPage,4,"NTA"},
	62	{0}
	63	};
	64
	65	static void SyncPRG(void)
	66	{
	67	setprg8(0x8000,PRG[0]);
	68	setprg8(0xa000,PRG[1]);
	69	setprg8(0xc000,PRG[2]);
	70	setprg8(0xe000,0x3F);
	71	}
	72
43725da7	73	static void FP_FASTAPASS(1) NamcoIRQHook(int a)
d97315ac	74	{
	75	if(IRQa)
	76	{
	77	IRQCount+=a;
	78	if(IRQCount>=0x7FFF)
	79	{
	80	X6502_IRQBegin(FCEU_IQEXT);
	81	IRQa=0;
	82	IRQCount=0x7FFF; //7FFF;
	83	}
	84	}
	85	}
	86
	87	static DECLFR(Namco_Read4800)
	88	{
	89	uint8 ret=IRAM[dopol&0x7f];
	90	/* Maybe I should call NamcoSoundHack() here? */
43725da7	91	#ifdef FCEUDEF_DEBUGGER
d97315ac	92	if(!fceuindbg)
43725da7	93	#endif
d97315ac	94	if(dopol&0x80)
	95	dopol=(dopol&0x80)\|((dopol+1)&0x7f);
	96	return ret;
	97	}
	98
	99	static DECLFR(Namco_Read5000)
	100	{
	101	return(IRQCount);
	102	}
	103
	104	static DECLFR(Namco_Read5800)
	105	{
	106	return(IRQCount>>8);
	107	}
	108
43725da7	109	static void FASTAPASS(2) DoNTARAMROM(int w, uint8 V)
d97315ac	110	{
	111	NTAPage[w]=V;
	112	if(V>=0xE0)
	113	setntamem(NTARAM+((V&1)<<10), 1, w);
	114	else
	115	{
	116	V&=CHRmask1[0];
	117	setntamem(CHRptr[0]+(V<<10), 0, w);
	118	}
	119	}
	120
	121	static void FixNTAR(void)
	122	{
	123	int x;
	124	for(x=0;x<4;x++)
	125	DoNTARAMROM(x,NTAPage[x]);
	126	}
	127
43725da7	128	static void FASTAPASS(2) DoCHRRAMROM(int x, uint8 V)
d97315ac	129	{
	130	CHR[x]=V;
	131	if(!is210 && !((gorfus>>((x>>2)+6))&1) && (V>=0xE0))
	132	{
	133	// printf("BLAHAHA: %d, %02x\n",x,V);
	134	//setchr1r(0x10,x<<10,V&7);
	135	}
	136	else
	137	setchr1(x<<10,V);
	138	}
	139
	140	static void FixCRR(void)
	141	{
	142	int x;
	143	for(x=0;x<8;x++)
	144	DoCHRRAMROM(x,CHR[x]);
	145	}
	146
	147	static DECLFW(Mapper19C0D8_write)
	148	{
	149	DoNTARAMROM((A-0xC000)>>11,V);
	150	}
	151
	152	static uint32 FreqCache[8];
	153	static uint32 EnvCache[8];
	154	static uint32 LengthCache[8];
	155
	156	static void FixCache(int a,int V)
	157	{
	158	int w=(a>>3)&0x7;
	159	switch(a&0x07)
	160	{
	161	case 0x00:FreqCache[w]&=~0x000000FF;FreqCache[w]\|=V;break;
	162	case 0x02:FreqCache[w]&=~0x0000FF00;FreqCache[w]\|=V<<8;break;
	163	case 0x04:FreqCache[w]&=~0x00030000;FreqCache[w]\|=(V&3)<<16;
	164	LengthCache[w]=(8-((V>>2)&7))<<2;
	165	break;
	166	case 0x07:EnvCache[w]=(double)(V&0xF)*576716;break;
	167	}
	168	}
	169
	170	static DECLFW(Mapper19_write)
	171	{
	172	A&=0xF800;
	173	if(A>=0x8000 && A<=0xb800)
	174	DoCHRRAMROM((A-0x8000)>>11,V);
	175	else switch(A)
	176	{
	177	case 0x4800:
	178	if(dopol&0x40)
	179	{
	180	if(FSettings.SndRate)
	181	{
	182	NamcoSoundHack();
	183	GameExpSound.Fill=NamcoSound;
386f5371	184	GameExpSound.HiFill=DoNamcoSoundHQ;
d97315ac	185	GameExpSound.HiSync=SyncHQ;
	186	}
	187	FixCache(dopol,V);
	188	}
	189	IRAM[dopol&0x7f]=V;
	190	if(dopol&0x80)
	191	dopol=(dopol&0x80)\|((dopol+1)&0x7f);
	192	break;
	193	case 0xf800:
	194	dopol=V;break;
	195	case 0x5000:
	196	IRQCount&=0xFF00;IRQCount\|=V;X6502_IRQEnd(FCEU_IQEXT);break;
	197	case 0x5800:
	198	IRQCount&=0x00ff;IRQCount\|=(V&0x7F)<<8;
	199	IRQa=V&0x80;
	200	X6502_IRQEnd(FCEU_IQEXT);
	201	break;
	202	case 0xE000:
	203	gorko=V&0xC0;
	204	PRG[0]=V&0x3F;
	205	SyncPRG();
	206	break;
	207	case 0xE800:
	208	gorfus=V&0xC0;
	209	FixCRR();
	210	PRG[1]=V&0x3F;
	211	SyncPRG();
	212	break;
	213	case 0xF000:
	214	PRG[2]=V&0x3F;
	215	SyncPRG();
	216	break;
	217	}
	218	}
	219
	220	static int dwave=0;
	221
	222	static void NamcoSoundHack(void)
	223	{
	224	int32 z,a;
d97315ac	225	if(FSettings.soundq>=1)
	226	{
	227	DoNamcoSoundHQ();
	228	return;
	229	}
d97315ac	230	z=((SOUNDTS<<16)/soundtsinc)>>4;
d97315ac	231	a=z-dwave;
386f5371	232	if(a) DoNamcoSound(&Wave[dwave], a);
d97315ac	233	dwave+=a;
	234	}
	235
	236	static void NamcoSound(int Count)
	237	{
	238	int32 z,a;
	239	z=((SOUNDTS<<16)/soundtsinc)>>4;
	240	a=z-dwave;
386f5371	241	if(a) DoNamcoSound(&Wave[dwave], a);
d97315ac	242	dwave=0;
	243	}
	244
	245	static uint32 PlayIndex[8];
	246	static int32 vcount[8];
	247	static int32 CVBC;
	248
	249	#define TOINDEX (16+1)
	250
	251	// 16:15
	252	static void SyncHQ(int32 ts)
	253	{
	254	CVBC=ts;
	255	}
	256
	257
	258	/* Things to do:
	259	1 Read freq low
	260	2 Read freq mid
	261	3 Read freq high
	262	4 Read envelope
	263	...?
	264	*/
	265
	266	static INLINE uint32 FetchDuff(uint32 P, uint32 envelope)
	267	{
	268	uint32 duff;
	269	duff=IRAM[((IRAM[0x46+(P<<3)]+(PlayIndex[P]>>TOINDEX))&0xFF)>>1];
	270	if((IRAM[0x46+(P<<3)]+(PlayIndex[P]>>TOINDEX))&1)
	271	duff>>=4;
	272	duff&=0xF;
	273	duff=(duff*envelope)>>16;
	274	return(duff);
	275	}
	276
d97315ac	277	static void DoNamcoSoundHQ(void)
d97315ac	278	{
43725da7	279	int32 P,V;
d97315ac	280	int32 cyclesuck=(((IRAM[0x7F]>>4)&7)+1)*15;
	281
	282	for(P=7;P>=(7-((IRAM[0x7F]>>4)&7));P--)
	283	{
	284	if((IRAM[0x44+(P<<3)]&0xE0) && (IRAM[0x47+(P<<3)]&0xF))
	285	{
	286	uint32 freq;
	287	int32 vco;
	288	uint32 duff2,lengo,envelope;
	289
	290	vco=vcount[P];
	291	freq=FreqCache[P];
	292	envelope=EnvCache[P];
	293	lengo=LengthCache[P];
	294
	295	duff2=FetchDuff(P,envelope);
	296	for(V=CVBC<<1;V<SOUNDTS<<1;V++)
	297	{
	298	WaveHi[V>>1]+=duff2;
	299	if(!vco)
	300	{
	301	PlayIndex[P]+=freq;
	302	while((PlayIndex[P]>>TOINDEX)>=lengo) PlayIndex[P]-=lengo<<TOINDEX;
	303	duff2=FetchDuff(P,envelope);
	304	vco=cyclesuck;
	305	}
	306	vco--;
	307	}
	308	vcount[P]=vco;
	309	}
	310	}
	311	CVBC=SOUNDTS;
	312	}
386f5371	313
d97315ac	314
	315	static void DoNamcoSound(int32 *Wave, int Count)
	316	{
	317	int P,V;
	318	for(P=7;P>=7-((IRAM[0x7F]>>4)&7);P--)
	319	{
	320	if((IRAM[0x44+(P<<3)]&0xE0) && (IRAM[0x47+(P<<3)]&0xF))
	321	{
	322	int32 inc;
	323	uint32 freq;
	324	int32 vco;
	325	uint32 duff,duff2,lengo,envelope;
	326
	327	vco=vcount[P];
	328	freq=FreqCache[P];
	329	envelope=EnvCache[P];
	330	lengo=LengthCache[P];
	331
	332	if(!freq) {/printf("Ack");/ continue;}
	333
	334	{
	335	int c=((IRAM[0x7F]>>4)&7)+1;
	336	inc=(long double)(FSettings.SndRate<<15)/((long double)freq21477272/((long double)0x400000c*45));
	337	}
	338
	339	duff=IRAM[(((IRAM[0x46+(P<<3)]+PlayIndex[P])&0xFF)>>1)];
	340	if((IRAM[0x46+(P<<3)]+PlayIndex[P])&1)
	341	duff>>=4;
	342	duff&=0xF;
	343	duff2=(duff*envelope)>>19;
	344	for(V=0;V<Count*16;V++)
	345	{
	346	if(vco>=inc)
	347	{
	348	PlayIndex[P]++;
	349	if(PlayIndex[P]>=lengo)
	350	PlayIndex[P]=0;
	351	vco-=inc;
	352	duff=IRAM[(((IRAM[0x46+(P<<3)]+PlayIndex[P])&0xFF)>>1)];
	353	if((IRAM[0x46+(P<<3)]+PlayIndex[P])&1)
	354	duff>>=4;
	355	duff&=0xF;
	356	duff2=(duff*envelope)>>19;
	357	}
	358	Wave[V>>4]+=duff2;
	359	vco+=0x8000;
	360	}
	361	vcount[P]=vco;
	362	}
	363	}
	364	}
	365
	366	static void Mapper19_StateRestore(int version)
	367	{
	368	SyncPRG();
	369	FixNTAR();
	370	FixCRR();
43725da7	371	int x;
d97315ac	372	for(x=0x40;x<0x80;x++)
	373	FixCache(x,IRAM[x]);
	374	}
	375
	376	static void M19SC(void)
	377	{
	378	if(FSettings.SndRate)
	379	Mapper19_ESI();
	380	}
	381
	382	void Mapper19_ESI(void)
	383	{
	384	GameExpSound.RChange=M19SC;
	385	memset(vcount,0,sizeof(vcount));
	386	memset(PlayIndex,0,sizeof(PlayIndex));
	387	CVBC=0;
	388	}
	389
	390	void NSFN106_Init(void)
	391	{
	392	SetWriteHandler(0xf800,0xffff,Mapper19_write);
	393	SetWriteHandler(0x4800,0x4fff,Mapper19_write);
	394	SetReadHandler(0x4800,0x4fff,Namco_Read4800);
	395	Mapper19_ESI();
	396	}
	397
	398	static int battery=0;
	399
	400	static void N106_Power(void)
	401	{
	402	int x;
	403	SetReadHandler(0x8000,0xFFFF,CartBR);
	404	SetWriteHandler(0x8000,0xffff,Mapper19_write);
	405	SetWriteHandler(0x4020,0x5fff,Mapper19_write);
	406	if(!is210)
	407	{
	408	SetWriteHandler(0xc000,0xdfff,Mapper19C0D8_write);
	409	SetReadHandler(0x4800,0x4fff,Namco_Read4800);
	410	SetReadHandler(0x5000,0x57ff,Namco_Read5000);
	411	SetReadHandler(0x5800,0x5fff,Namco_Read5800);
	412	NTAPage[0]=NTAPage[1]=NTAPage[2]=NTAPage[3]=0xFF;
	413	FixNTAR();
	414	}
	415
	416	SetReadHandler(0x6000,0x7FFF,AWRAM);
	417	SetWriteHandler(0x6000,0x7FFF,BWRAM);
	418	FCEU_CheatAddRAM(8,0x6000,WRAM);
	419
	420	gorfus=0xFF;
	421	SyncPRG();
	422	FixCRR();
	423
	424	if(!battery)
	425	{
	426	FCEU_dwmemset(WRAM,0,8192);
	427	FCEU_dwmemset(IRAM,0,128);
	428	}
	429	for(x=0x40;x<0x80;x++)
	430	FixCache(x,IRAM[x]);
	431	}
	432
	433	void Mapper19_Init(CartInfo *info)
	434	{
	435	is210=0;
436	battery=info->battery;
437	info->Power=N106_Power;
438
439	MapIRQHook=NamcoIRQHook;
440	GameStateRestore=Mapper19_StateRestore;
441	GameExpSound.RChange=M19SC;
442
443	if(FSettings.SndRate)
444	Mapper19_ESI();
445
446	AddExState(WRAM, 8192, 0, "WRAM");
386f5371	447	AddExState(IRAM, 128, 0, "IRAM");
d97315ac	448	AddExState(N106_StateRegs, ~0, 0, 0);
	449
	450	if(info->battery)
	451	{
	452	info->SaveGame[0]=WRAM;
	453	info->SaveGameLen[0]=8192;
	454	info->SaveGame[1]=IRAM;
	455	info->SaveGameLen[1]=128;
	456	}
	457	}
	458
	459	static void Mapper210_StateRestore(int version)
	460	{
	461	SyncPRG();
	462	FixCRR();
	463	}
	464
	465	void Mapper210_Init(CartInfo *info)
	466	{
	467	is210=1;
	468	GameStateRestore=Mapper210_StateRestore;
	469	info->Power=N106_Power;
	470	AddExState(WRAM, 8192, 0, "WRAM");
386f5371	471	AddExState(N106_StateRegs, ~0, 0, 0);
d97315ac	472	}