[picodrive.git] / Pico / sound / sound.c

// This is part of Pico Library\r
\r
// (c) Copyright 2004 Dave, All rights reserved.\r
// (c) Copyright 2006 notaz, All rights reserved.\r
// Free for non-commercial use.\r
\r
// For commercial use, separate licencing terms must be obtained.\r
\r
\r
#include <string.h>\r
#include "sound.h"\r
#include "ym2612.h"\r
#include "sn76496.h"\r
\r
#ifndef __GNUC__\r
#pragma warning (disable:4244)\r
#endif\r
\r
#if defined(_USE_MZ80)\r
#include "../../cpu/mz80/mz80.h"\r
#elif defined(_USE_DRZ80)\r
#include "../../cpu/DrZ80/drz80.h"\r
#endif\r
\r
#include "../PicoInt.h"\r
#include "../cd/pcm.h"\r
#include "mix.h"\r
\r
// master int buffer to mix to\r
static int PsndBuffer[2*44100/50];\r
\r
//int z80CycleAim = 0;\r
\r
// dac\r
short *dac_out;\r
unsigned short dac_info[312]; // pppppppp ppppllll, p - pos in buff, l - length to write for this sample\r
\r
// for Pico\r
int PsndRate=0;\r
int PsndLen=0; // number of mono samples, multiply by 2 for stereo\r
short *PsndOut=NULL; // PCM data buffer\r
\r
// from ym2612.c\r
extern int   *ym2612_dacen;\r
extern INT32 *ym2612_dacout;\r
void YM2612TimerHandler(int c,int cnt);\r
\r
// sn76496\r
extern int *sn76496_regs;\r
\r
\r
static void dac_recalculate()\r
{\r
  int i, dac_cnt, pos, len, lines = Pico.m.pal ? 312 : 262, mid = Pico.m.pal ? 68 : 93;\r
\r
  if(PsndLen <= lines) {\r
    // shrinking algo\r
    dac_cnt = 0;//lines - PsndLen;\r
    len=1; pos=0;\r
    dac_info[225] = 1;\r
\r
    for(i=226; i != 225; i++) {\r
      if (i >= lines) i = 0;\r
      len = 0;\r
      if(dac_cnt < 0) {\r
        len=1;\r
        pos++;\r
        dac_cnt += lines;\r
      }\r
      dac_cnt -= PsndLen;\r
      dac_info[i] = (pos<<4)|len;\r
    }\r
  } else {\r
    // stretching\r
    dac_cnt = PsndLen/2;\r
    pos=0;\r
    for(i = 225; i != 224; i++) {\r
      if (i >= lines) i = 0;\r
      len=0;\r
      while(dac_cnt >= 0) {\r
        dac_cnt -= lines;\r
        len++;\r
      }\r
      if (i == mid) // midpoint\r
        while(pos+len < PsndLen/2) {\r
          dac_cnt -= lines;\r
          len++;\r
        }\r
      dac_cnt += PsndLen;\r
      dac_info[i] = (pos<<4)|len;\r
      pos+=len;\r
    }\r
    // last sample\r
    for(len = 0, i = pos; i < PsndLen; i++) len++;\r
    dac_info[224] = (pos<<4)|len;\r
  }\r
//  dprintf("rate is %i, len %i", PsndRate, PsndLen);\r
//  for(i=0; i < lines; i++)\r
//    dprintf("%03i : %03i : %i", i, dac_info[i]>>4, dac_info[i]&0xf);\r
//exit(8);\r
}\r
\r
\r
void sound_reset()\r
{\r
  extern int z80stopCycle;\r
  void *ym2612_regs;\r
\r
  // init even if we are not going to use them, just in case we ever enable it\r
  YM2612Init(Pico.m.pal ? OSC_PAL/7 : OSC_NTSC/7, PsndRate);\r
  // also clear the internal registers+addr line\r
  ym2612_regs = YM2612GetRegs();\r
  memset(ym2612_regs, 0, 0x200+4);\r
\r
  SN76496_init(Pico.m.pal ? OSC_PAL/15 : OSC_NTSC/15, PsndRate);\r
\r
  // calculate PsndLen\r
  PsndLen=PsndRate/(Pico.m.pal ? 50 : 60);\r
\r
  // recalculate dac info\r
  dac_recalculate();\r
  z80stopCycle = 0;\r
}\r
\r
\r
// to be called after changing sound rate or chips\r
void sound_rerate()\r
{\r
  unsigned int state[28];\r
\r
  // not all rates are supported in MCD mode due to mp3 decoder\r
  if (PicoMCD & 1) {\r
    if (PsndRate != 11025 && PsndRate != 22050 && PsndRate != 44100) PsndRate = 22050;\r
    if (!(PicoOpt & 8)) PicoOpt |= 8;\r
  }\r
\r
  if ((PicoMCD & 1) && Pico_mcd->m.audio_track) Pico_mcd->m.audio_offset = mp3_get_offset();\r
  YM2612Init(Pico.m.pal ? OSC_PAL/7 : OSC_NTSC/7, PsndRate);\r
  // feed it back it's own registers, just like after loading state\r
  YM2612PicoStateLoad();\r
  if ((PicoMCD & 1) && Pico_mcd->m.audio_track)\r
    mp3_start_play(Pico_mcd->TOC.Tracks[Pico_mcd->m.audio_track].F, Pico_mcd->m.audio_offset);\r
\r
  memcpy(state, sn76496_regs, 28*4); // remember old state\r
  SN76496_init(Pico.m.pal ? OSC_PAL/15 : OSC_NTSC/15, PsndRate);\r
  memcpy(sn76496_regs, state, 28*4); // restore old state\r
\r
  // calculate PsndLen\r
  PsndLen=PsndRate/(Pico.m.pal ? 50 : 60);\r
\r
  // recalculate dac info\r
  dac_recalculate();\r
\r
  if (PicoMCD & 1)\r
    pcm_set_rate(PsndRate);\r
}\r
\r
\r
// This is called once per raster (aka line), but not necessarily for every line\r
void sound_timers_and_dac(int raster)\r
{\r
  int pos, len;\r
  int do_dac = PsndOut && (PicoOpt&1) && *ym2612_dacen;\r
//  int do_pcm = PsndOut && (PicoMCD&1) && (PicoOpt&0x400);\r
\r
  // Our raster lasts 63.61323/64.102564 microseconds (NTSC/PAL)\r
  YM2612PicoTick(1);\r
\r
  if (!do_dac /*&& !do_pcm*/) return;\r
\r
  pos=dac_info[raster], len=pos&0xf;\r
  if (!len) return;\r
\r
  pos>>=4;\r
\r
  if (do_dac) {\r
    short *d = PsndOut + pos*2;\r
    int dout = *ym2612_dacout;\r
    if(PicoOpt&8) {\r
      // some manual loop unrolling here :)\r
      d[0] = dout;\r
      if (len > 1) {\r
        d[2] = dout;\r
        if (len > 2) {\r
          d[4] = dout;\r
          if (len > 3)\r
            d[6] = dout;\r
        }\r
      }\r
    } else {\r
      short *d = PsndOut + pos;\r
      d[0] = dout;\r
      if (len > 1) {\r
        d[1] = dout;\r
        if (len > 2) {\r
          d[2] = dout;\r
          if (len > 3)\r
            d[3] = dout;\r
        }\r
      }\r
    }\r
  }\r
\r
#if 0\r
  if (do_pcm) {\r
    int *d = PsndBuffer;\r
    d += (PicoOpt&8) ? pos*2 : pos;\r
    pcm_update(d, len, 1);\r
  }\r
#endif\r
}\r
\r
\r
void sound_clear(void)\r
{\r
  if (PicoOpt & 8) memset32((int *) PsndOut, 0, PsndLen);\r
  else memset(PsndOut, 0, PsndLen<<1);\r
//  memset(PsndBuffer, 0, (PicoOpt & 8) ? (PsndLen<<3) : (PsndLen<<2));\r
}\r
\r
\r
int sound_render(int offset, int length)\r
{\r
  int *buf32 = PsndBuffer+offset;\r
  int stereo = (PicoOpt & 8) >> 3;\r
  // emulating CD && PCM option enabled && PCM chip on && have enabled channels\r
  int do_pcm = (PicoMCD&1) && (PicoOpt&0x400) && (Pico_mcd->pcm.control & 0x80) && Pico_mcd->pcm.enabled;\r
  offset <<= stereo;\r
\r
  // PSG\r
  if (PicoOpt & 2)\r
    SN76496Update(PsndOut+offset, length, stereo);\r
\r
  // Add in the stereo FM buffer\r
  if (PicoOpt & 1)\r
    YM2612UpdateOne(buf32, length, stereo, 1);\r
\r
  if (do_pcm)\r
    pcm_update(buf32, length, stereo);\r
\r
  // CDDA audio\r
//  if ((PicoMCD & 1) && (PicoOpt & 0x800))\r
//    mp3_update(PsndBuffer+offset, length, stereo);\r
\r
  // convert + limit to normal 16bit output\r
  if (stereo)\r
       mix_32_to_16l_stereo(PsndOut+offset, buf32, length);\r
  else mix_32_to_16_mono   (PsndOut+offset, buf32, length);\r
\r
  return 0;\r
}\r
\r
\r
\r
#if defined(_USE_MZ80)\r
\r
// memhandlers for mz80 core\r
unsigned char mz80_read(UINT32 a,  struct MemoryReadByte *w)  { return z80_read(a); }\r
void mz80_write(UINT32 a, UINT8 d, struct MemoryWriteByte *w) { z80_write(d, a); }\r
\r
// structures for mz80 core\r
static struct MemoryReadByte mz80_mem_read[]=\r
{\r
  {0x0000,0xffff,mz80_read},\r
  {(UINT32) -1,(UINT32) -1,NULL}\r
};\r
static struct MemoryWriteByte mz80_mem_write[]=\r
{\r
  {0x0000,0xffff,mz80_write},\r
  {(UINT32) -1,(UINT32) -1,NULL}\r
};\r
static struct z80PortRead mz80_io_read[] ={\r
  {(UINT16) -1,(UINT16) -1,NULL}\r
};\r
static struct z80PortWrite mz80_io_write[]={\r
  {(UINT16) -1,(UINT16) -1,NULL}\r
};\r
\r
#elif defined(_USE_DRZ80)\r
\r
static struct DrZ80 drZ80;\r
\r
static unsigned int DrZ80_rebasePC(unsigned short a)\r
{\r
  drZ80.Z80PC_BASE = (unsigned int) Pico.zram;\r
  return drZ80.Z80PC_BASE + a;\r
}\r
\r
static unsigned int DrZ80_rebaseSP(unsigned short a)\r
{\r
  drZ80.Z80SP_BASE = (unsigned int) Pico.zram;\r
  return drZ80.Z80SP_BASE + a;\r
}\r
\r
static unsigned char DrZ80_in(unsigned short p)\r
{\r
  return 0xff;\r
}\r
\r
static void DrZ80_out(unsigned short p,unsigned char d)\r
{\r
}\r
\r
static void DrZ80_irq_callback()\r
{\r
  drZ80.Z80_IRQ = 0; // lower irq when accepted\r
}\r
\r
#endif\r
\r
// z80 functionality wrappers\r
void z80_init()\r
{\r
#if defined(_USE_MZ80)\r
  struct mz80context z80;\r
\r
  // z80\r
  mz80init();\r
  // Modify the default context\r
  mz80GetContext(&z80);\r
\r
  // point mz80 stuff\r
  z80.z80Base=Pico.zram;\r
  z80.z80MemRead=mz80_mem_read;\r
  z80.z80MemWrite=mz80_mem_write;\r
  z80.z80IoRead=mz80_io_read;\r
  z80.z80IoWrite=mz80_io_write;\r
\r
  mz80SetContext(&z80);\r
\r
#elif defined(_USE_DRZ80)\r
\r
  memset(&drZ80, 0, sizeof(struct DrZ80));\r
  drZ80.z80_rebasePC=DrZ80_rebasePC;\r
  drZ80.z80_rebaseSP=DrZ80_rebaseSP;\r
  drZ80.z80_read8   =z80_read;\r
  drZ80.z80_read16  =z80_read16;\r
  drZ80.z80_write8  =z80_write;\r
  drZ80.z80_write16 =z80_write16;\r
  drZ80.z80_in      =DrZ80_in;\r
  drZ80.z80_out     =DrZ80_out;\r
  drZ80.z80_irq_callback=DrZ80_irq_callback;\r
#endif\r
}\r
\r
void z80_reset()\r
{\r
#if defined(_USE_MZ80)\r
  mz80reset();\r
#elif defined(_USE_DRZ80)\r
  memset(&drZ80, 0, 0x54);\r
  drZ80.Z80F  = (1<<2);  // set ZFlag\r
  drZ80.Z80F2 = (1<<2);  // set ZFlag\r
  drZ80.Z80IX = 0xFFFF << 16;\r
  drZ80.Z80IY = 0xFFFF << 16;\r
  drZ80.Z80IM = 0; // 1?\r
  drZ80.Z80PC = drZ80.z80_rebasePC(0);\r
  drZ80.Z80SP = drZ80.z80_rebaseSP(0x2000); // 0xf000 ?\r
#endif\r
  Pico.m.z80_fakeval = 0; // for faking when Z80 is disabled\r
}\r
\r
void z80_resetCycles()\r
{\r
#if defined(_USE_MZ80)\r
  mz80GetElapsedTicks(1);\r
#endif\r
}\r
\r
void z80_int()\r
{\r
#if defined(_USE_MZ80)\r
  mz80int(0);\r
#elif defined(_USE_DRZ80)\r
  drZ80.z80irqvector = 0xFF; // default IRQ vector RST opcode\r
  drZ80.Z80_IRQ = 1;\r
#endif\r
}\r
\r
// returns number of cycles actually executed\r
int z80_run(int cycles)\r
{\r
#if defined(_USE_MZ80)\r
  int ticks_pre = mz80GetElapsedTicks(0);\r
  mz80exec(cycles);\r
  return mz80GetElapsedTicks(0) - ticks_pre;\r
#elif defined(_USE_DRZ80)\r
  return cycles - DrZ80Run(&drZ80, cycles);\r
#else\r
  return cycles;\r
#endif\r
}\r
\r
void z80_pack(unsigned char *data)\r
{\r
#if defined(_USE_MZ80)\r
  struct mz80context mz80;\r
  *(int *)data = 0x00005A6D; // "mZ"\r
  mz80GetContext(&mz80);\r
  memcpy(data+4, &mz80.z80clockticks, sizeof(mz80)-5*4); // don't save base&memhandlers\r
#elif defined(_USE_DRZ80)\r
  *(int *)data = 0x015A7244; // "DrZ" v1\r
  drZ80.Z80PC = drZ80.z80_rebasePC(drZ80.Z80PC-drZ80.Z80PC_BASE);\r
  drZ80.Z80SP = drZ80.z80_rebaseSP(drZ80.Z80SP-drZ80.Z80SP_BASE);\r
  memcpy(data+4, &drZ80, 0x54);\r
#endif\r
}\r
\r
void z80_unpack(unsigned char *data)\r
{\r
#if defined(_USE_MZ80)\r
  if(*(int *)data == 0x00005A6D) { // "mZ" save?\r
    struct mz80context mz80;\r
    mz80GetContext(&mz80);\r
    memcpy(&mz80.z80clockticks, data+4, sizeof(mz80)-5*4);\r
    mz80SetContext(&mz80);\r
  } else {\r
    z80_reset();\r
    z80_int();\r
  }\r
#elif defined(_USE_DRZ80)\r
  if(*(int *)data == 0x015A7244) { // "DrZ" v1 save?\r
    memcpy(&drZ80, data+4, 0x54);\r
    // update bases\r
    drZ80.Z80PC = drZ80.z80_rebasePC(drZ80.Z80PC-drZ80.Z80PC_BASE);\r
    drZ80.Z80SP = drZ80.z80_rebaseSP(drZ80.Z80SP-drZ80.Z80SP_BASE);\r
  } else {\r
    z80_reset();\r
    drZ80.Z80IM = 1;\r
    z80_int(); // try to goto int handler, maybe we won't execute trash there?\r
  }\r
#endif\r
}\r
\r
void z80_exit()\r
{\r
#if defined(_USE_MZ80)\r
  mz80shutdown();\r
#endif\r
}\r
\r
#if defined(__DEBUG_PRINT) || defined(WIN32)\r
void z80_debug(char *dstr)\r
{\r
#if defined(_USE_DRZ80)\r
  sprintf(dstr, "%sZ80 state: PC: %04x SP: %04x\n", dstr, drZ80.Z80PC-drZ80.Z80PC_BASE, drZ80.Z80SP-drZ80.Z80SP_BASE);\r
#endif\r
}\r
#endif\r
Commit	Line	Data
cc68a136	1	// This is part of Pico Library\r
	2	\r
	3	// (c) Copyright 2004 Dave, All rights reserved.\r
	4	// (c) Copyright 2006 notaz, All rights reserved.\r
	5	// Free for non-commercial use.\r
	6	\r
	7	// For commercial use, separate licencing terms must be obtained.\r
	8	\r
	9	\r
	10	#include <string.h>\r
	11	#include "sound.h"\r
	12	#include "ym2612.h"\r
	13	#include "sn76496.h"\r
	14	\r
	15	#ifndef __GNUC__\r
	16	#pragma warning (disable:4244)\r
	17	#endif\r
	18	\r
	19	#if defined(_USE_MZ80)\r
	20	#include "../../cpu/mz80/mz80.h"\r
	21	#elif defined(_USE_DRZ80)\r
	22	#include "../../cpu/DrZ80/drz80.h"\r
	23	#endif\r
	24	\r
	25	#include "../PicoInt.h"\r
4f265db7	26	#include "../cd/pcm.h"\r
4f265db7	27	#include "mix.h"\r
cc68a136	28	\r
4f265db7	29	// master int buffer to mix to\r
4f265db7	30	static int PsndBuffer[2*44100/50];\r
cc68a136	31	\r
	32	//int z80CycleAim = 0;\r
	33	\r
	34	// dac\r
	35	short *dac_out;\r
	36	unsigned short dac_info[312]; // pppppppp ppppllll, p - pos in buff, l - length to write for this sample\r
	37	\r
	38	// for Pico\r
	39	int PsndRate=0;\r
	40	int PsndLen=0; // number of mono samples, multiply by 2 for stereo\r
	41	short *PsndOut=NULL; // PCM data buffer\r
	42	\r
	43	// from ym2612.c\r
	44	extern int *ym2612_dacen;\r
	45	extern INT32 *ym2612_dacout;\r
	46	void YM2612TimerHandler(int c,int cnt);\r
	47	\r
	48	// sn76496\r
	49	extern int *sn76496_regs;\r
	50	\r
	51	\r
	52	static void dac_recalculate()\r
	53	{\r
	54	int i, dac_cnt, pos, len, lines = Pico.m.pal ? 312 : 262, mid = Pico.m.pal ? 68 : 93;\r
	55	\r
	56	if(PsndLen <= lines) {\r
	57	// shrinking algo\r
	58	dac_cnt = 0;//lines - PsndLen;\r
	59	len=1; pos=0;\r
	60	dac_info[225] = 1;\r
	61	\r
	62	for(i=226; i != 225; i++) {\r
	63	if (i >= lines) i = 0;\r
	64	len = 0;\r
	65	if(dac_cnt < 0) {\r
	66	len=1;\r
	67	pos++;\r
	68	dac_cnt += lines;\r
	69	}\r
	70	dac_cnt -= PsndLen;\r
	71	dac_info[i] = (pos<<4)\|len;\r
	72	}\r
	73	} else {\r
	74	// stretching\r
	75	dac_cnt = PsndLen/2;\r
	76	pos=0;\r
	77	for(i = 225; i != 224; i++) {\r
	78	if (i >= lines) i = 0;\r
	79	len=0;\r
	80	while(dac_cnt >= 0) {\r
	81	dac_cnt -= lines;\r
	82	len++;\r
	83	}\r
4f265db7	84	if (i == mid) // midpoint\r
cc68a136	85	while(pos+len < PsndLen/2) {\r
	86	dac_cnt -= lines;\r
	87	len++;\r
	88	}\r
	89	dac_cnt += PsndLen;\r
	90	dac_info[i] = (pos<<4)\|len;\r
	91	pos+=len;\r
	92	}\r
	93	// last sample\r
	94	for(len = 0, i = pos; i < PsndLen; i++) len++;\r
	95	dac_info[224] = (pos<<4)\|len;\r
	96	}\r
	97	// dprintf("rate is %i, len %i", PsndRate, PsndLen);\r
	98	// for(i=0; i < lines; i++)\r
	99	// dprintf("%03i : %03i : %i", i, dac_info[i]>>4, dac_info[i]&0xf);\r
	100	//exit(8);\r
	101	}\r
	102	\r
	103	\r
	104	void sound_reset()\r
	105	{\r
	106	extern int z80stopCycle;\r
	107	void *ym2612_regs;\r
	108	\r
	109	// init even if we are not going to use them, just in case we ever enable it\r
	110	YM2612Init(Pico.m.pal ? OSC_PAL/7 : OSC_NTSC/7, PsndRate);\r
	111	// also clear the internal registers+addr line\r
	112	ym2612_regs = YM2612GetRegs();\r
	113	memset(ym2612_regs, 0, 0x200+4);\r
	114	\r
	115	SN76496_init(Pico.m.pal ? OSC_PAL/15 : OSC_NTSC/15, PsndRate);\r
	116	\r
	117	// calculate PsndLen\r
	118	PsndLen=PsndRate/(Pico.m.pal ? 50 : 60);\r
	119	\r
	120	// recalculate dac info\r
	121	dac_recalculate();\r
	122	z80stopCycle = 0;\r
	123	}\r
	124	\r
	125	\r
	126	// to be called after changing sound rate or chips\r
	127	void sound_rerate()\r
	128	{\r
	129	unsigned int state[28];\r
	130	\r
4f265db7	131	// not all rates are supported in MCD mode due to mp3 decoder\r
	132	if (PicoMCD & 1) {\r
	133	if (PsndRate != 11025 && PsndRate != 22050 && PsndRate != 44100) PsndRate = 22050;\r
	134	if (!(PicoOpt & 8)) PicoOpt \|= 8;\r
	135	}\r
	136	\r
	137	if ((PicoMCD & 1) && Pico_mcd->m.audio_track) Pico_mcd->m.audio_offset = mp3_get_offset();\r
cc68a136	138	YM2612Init(Pico.m.pal ? OSC_PAL/7 : OSC_NTSC/7, PsndRate);\r
	139	// feed it back it's own registers, just like after loading state\r
	140	YM2612PicoStateLoad();\r
4f265db7	141	if ((PicoMCD & 1) && Pico_mcd->m.audio_track)\r
4f265db7	142	mp3_start_play(Pico_mcd->TOC.Tracks[Pico_mcd->m.audio_track].F, Pico_mcd->m.audio_offset);\r
cc68a136	143	\r
	144	memcpy(state, sn76496_regs, 28*4); // remember old state\r
	145	SN76496_init(Pico.m.pal ? OSC_PAL/15 : OSC_NTSC/15, PsndRate);\r
	146	memcpy(sn76496_regs, state, 28*4); // restore old state\r
	147	\r
	148	// calculate PsndLen\r
	149	PsndLen=PsndRate/(Pico.m.pal ? 50 : 60);\r
	150	\r
	151	// recalculate dac info\r
	152	dac_recalculate();\r
4f265db7	153	\r
	154	if (PicoMCD & 1)\r
	155	pcm_set_rate(PsndRate);\r
cc68a136	156	}\r
	157	\r
	158	\r
	159	// This is called once per raster (aka line), but not necessarily for every line\r
4f265db7	160	void sound_timers_and_dac(int raster)\r
cc68a136	161	{\r
4f265db7	162	int pos, len;\r
	163	int do_dac = PsndOut && (PicoOpt&1) && *ym2612_dacen;\r
	164	// int do_pcm = PsndOut && (PicoMCD&1) && (PicoOpt&0x400);\r
	165	\r
	166	// Our raster lasts 63.61323/64.102564 microseconds (NTSC/PAL)\r
	167	YM2612PicoTick(1);\r
	168	\r
	169	if (!do_dac /&& !do_pcm/) return;\r
	170	\r
	171	pos=dac_info[raster], len=pos&0xf;\r
	172	if (!len) return;\r
	173	\r
	174	pos>>=4;\r
	175	\r
	176	if (do_dac) {\r
	177	short d = PsndOut + pos2;\r
	178	int dout = *ym2612_dacout;\r
	179	if(PicoOpt&8) {\r
	180	// some manual loop unrolling here :)\r
	181	d[0] = dout;\r
	182	if (len > 1) {\r
	183	d[2] = dout;\r
	184	if (len > 2) {\r
	185	d[4] = dout;\r
	186	if (len > 3)\r
	187	d[6] = dout;\r
	188	}\r
	189	}\r
cc68a136	190	} else {\r
4f265db7	191	short *d = PsndOut + pos;\r
	192	d[0] = dout;\r
	193	if (len > 1) {\r
	194	d[1] = dout;\r
	195	if (len > 2) {\r
	196	d[2] = dout;\r
	197	if (len > 3)\r
	198	d[3] = dout;\r
	199	}\r
	200	}\r
cc68a136	201	}\r
	202	}\r
	203	\r
4f265db7	204	#if 0\r
	205	if (do_pcm) {\r
	206	int *d = PsndBuffer;\r
	207	d += (PicoOpt&8) ? pos*2 : pos;\r
	208	pcm_update(d, len, 1);\r
	209	}\r
	210	#endif\r
	211	}\r
cc68a136	212	\r
cc68a136	213	\r
4f265db7	214	void sound_clear(void)\r
	215	{\r
	216	if (PicoOpt & 8) memset32((int *) PsndOut, 0, PsndLen);\r
	217	else memset(PsndOut, 0, PsndLen<<1);\r
	218	// memset(PsndBuffer, 0, (PicoOpt & 8) ? (PsndLen<<3) : (PsndLen<<2));\r
cc68a136	219	}\r
	220	\r
	221	\r
	222	int sound_render(int offset, int length)\r
	223	{\r
4f265db7	224	int *buf32 = PsndBuffer+offset;\r
cc68a136	225	int stereo = (PicoOpt & 8) >> 3;\r
4f265db7	226	// emulating CD && PCM option enabled && PCM chip on && have enabled channels\r
4f265db7	227	int do_pcm = (PicoMCD&1) && (PicoOpt&0x400) && (Pico_mcd->pcm.control & 0x80) && Pico_mcd->pcm.enabled;\r
cc68a136	228	offset <<= stereo;\r
	229	\r
	230	// PSG\r
4f265db7	231	if (PicoOpt & 2)\r
cc68a136	232	SN76496Update(PsndOut+offset, length, stereo);\r
	233	\r
	234	// Add in the stereo FM buffer\r
4f265db7	235	if (PicoOpt & 1)\r
	236	YM2612UpdateOne(buf32, length, stereo, 1);\r
	237	\r
	238	if (do_pcm)\r
	239	pcm_update(buf32, length, stereo);\r
	240	\r
	241	// CDDA audio\r
	242	// if ((PicoMCD & 1) && (PicoOpt & 0x800))\r
	243	// mp3_update(PsndBuffer+offset, length, stereo);\r
	244	\r
	245	// convert + limit to normal 16bit output\r
	246	if (stereo)\r
	247	mix_32_to_16l_stereo(PsndOut+offset, buf32, length);\r
	248	else mix_32_to_16_mono (PsndOut+offset, buf32, length);\r
cc68a136	249	\r
	250	return 0;\r
	251	}\r
	252	\r
	253	\r
	254	\r
	255	#if defined(_USE_MZ80)\r
	256	\r
	257	// memhandlers for mz80 core\r
	258	unsigned char mz80_read(UINT32 a, struct MemoryReadByte *w) { return z80_read(a); }\r
	259	void mz80_write(UINT32 a, UINT8 d, struct MemoryWriteByte *w) { z80_write(d, a); }\r
	260	\r
	261	// structures for mz80 core\r
	262	static struct MemoryReadByte mz80_mem_read[]=\r
	263	{\r
	264	{0x0000,0xffff,mz80_read},\r
	265	{(UINT32) -1,(UINT32) -1,NULL}\r
	266	};\r
	267	static struct MemoryWriteByte mz80_mem_write[]=\r
	268	{\r
	269	{0x0000,0xffff,mz80_write},\r
	270	{(UINT32) -1,(UINT32) -1,NULL}\r
	271	};\r
	272	static struct z80PortRead mz80_io_read[] ={\r
	273	{(UINT16) -1,(UINT16) -1,NULL}\r
	274	};\r
	275	static struct z80PortWrite mz80_io_write[]={\r
	276	{(UINT16) -1,(UINT16) -1,NULL}\r
	277	};\r
	278	\r
	279	#elif defined(_USE_DRZ80)\r
	280	\r
	281	static struct DrZ80 drZ80;\r
	282	\r
	283	static unsigned int DrZ80_rebasePC(unsigned short a)\r
	284	{\r
	285	drZ80.Z80PC_BASE = (unsigned int) Pico.zram;\r
	286	return drZ80.Z80PC_BASE + a;\r
	287	}\r
	288	\r
	289	static unsigned int DrZ80_rebaseSP(unsigned short a)\r
	290	{\r
	291	drZ80.Z80SP_BASE = (unsigned int) Pico.zram;\r
	292	return drZ80.Z80SP_BASE + a;\r
	293	}\r
	294	\r
	295	static unsigned char DrZ80_in(unsigned short p)\r
	296	{\r
	297	return 0xff;\r
	298	}\r
	299	\r
	300	static void DrZ80_out(unsigned short p,unsigned char d)\r
	301	{\r
	302	}\r
	303	\r
	304	static void DrZ80_irq_callback()\r
	305	{\r
	306	drZ80.Z80_IRQ = 0; // lower irq when accepted\r
	307	}\r
	308	\r
	309	#endif\r
	310	\r
	311	// z80 functionality wrappers\r
	312	void z80_init()\r
313	{\r
314	#if defined(_USE_MZ80)\r
315	struct mz80context z80;\r
316	\r
317	// z80\r
318	mz80init();\r
319	// Modify the default context\r
320	mz80GetContext(&z80);\r
4f265db7	321	\r
cc68a136	322	// point mz80 stuff\r
	323	z80.z80Base=Pico.zram;\r
	324	z80.z80MemRead=mz80_mem_read;\r
	325	z80.z80MemWrite=mz80_mem_write;\r
	326	z80.z80IoRead=mz80_io_read;\r
	327	z80.z80IoWrite=mz80_io_write;\r
4f265db7	328	\r
cc68a136	329	mz80SetContext(&z80);\r
	330	\r
	331	#elif defined(_USE_DRZ80)\r
	332	\r
	333	memset(&drZ80, 0, sizeof(struct DrZ80));\r
	334	drZ80.z80_rebasePC=DrZ80_rebasePC;\r
	335	drZ80.z80_rebaseSP=DrZ80_rebaseSP;\r
	336	drZ80.z80_read8 =z80_read;\r
	337	drZ80.z80_read16 =z80_read16;\r
	338	drZ80.z80_write8 =z80_write;\r
	339	drZ80.z80_write16 =z80_write16;\r
	340	drZ80.z80_in =DrZ80_in;\r
	341	drZ80.z80_out =DrZ80_out;\r
	342	drZ80.z80_irq_callback=DrZ80_irq_callback;\r
	343	#endif\r
	344	}\r
	345	\r
	346	void z80_reset()\r
	347	{\r
	348	#if defined(_USE_MZ80)\r
	349	mz80reset();\r
	350	#elif defined(_USE_DRZ80)\r
	351	memset(&drZ80, 0, 0x54);\r
	352	drZ80.Z80F = (1<<2); // set ZFlag\r
	353	drZ80.Z80F2 = (1<<2); // set ZFlag\r
	354	drZ80.Z80IX = 0xFFFF << 16;\r
	355	drZ80.Z80IY = 0xFFFF << 16;\r
	356	drZ80.Z80IM = 0; // 1?\r
	357	drZ80.Z80PC = drZ80.z80_rebasePC(0);\r
	358	drZ80.Z80SP = drZ80.z80_rebaseSP(0x2000); // 0xf000 ?\r
	359	#endif\r
	360	Pico.m.z80_fakeval = 0; // for faking when Z80 is disabled\r
	361	}\r
	362	\r
	363	void z80_resetCycles()\r
	364	{\r
	365	#if defined(_USE_MZ80)\r
	366	mz80GetElapsedTicks(1);\r
	367	#endif\r
	368	}\r
	369	\r
	370	void z80_int()\r
	371	{\r
	372	#if defined(_USE_MZ80)\r
	373	mz80int(0);\r
	374	#elif defined(_USE_DRZ80)\r
	375	drZ80.z80irqvector = 0xFF; // default IRQ vector RST opcode\r
	376	drZ80.Z80_IRQ = 1;\r
	377	#endif\r
	378	}\r
	379	\r
	380	// returns number of cycles actually executed\r
	381	int z80_run(int cycles)\r
	382	{\r
	383	#if defined(_USE_MZ80)\r
	384	int ticks_pre = mz80GetElapsedTicks(0);\r
	385	mz80exec(cycles);\r
	386	return mz80GetElapsedTicks(0) - ticks_pre;\r
	387	#elif defined(_USE_DRZ80)\r
	388	return cycles - DrZ80Run(&drZ80, cycles);\r
	389	#else\r
	390	return cycles;\r
	391	#endif\r
	392	}\r
393	\r
394	void z80_pack(unsigned char *data)\r
395	{\r
396	#if defined(_USE_MZ80)\r
397	struct mz80context mz80;\r
398	(int )data = 0x00005A6D; // "mZ"\r
399	mz80GetContext(&mz80);\r
400	memcpy(data+4, &mz80.z80clockticks, sizeof(mz80)-5*4); // don't save base&memhandlers\r
401	#elif defined(_USE_DRZ80)\r
402	(int )data = 0x015A7244; // "DrZ" v1\r
403	drZ80.Z80PC = drZ80.z80_rebasePC(drZ80.Z80PC-drZ80.Z80PC_BASE);\r
404	drZ80.Z80SP = drZ80.z80_rebaseSP(drZ80.Z80SP-drZ80.Z80SP_BASE);\r
405	memcpy(data+4, &drZ80, 0x54);\r
406	#endif\r
407	}\r
408	\r
409	void z80_unpack(unsigned char *data)\r
410	{\r
411	#if defined(_USE_MZ80)\r
412	if((int )data == 0x00005A6D) { // "mZ" save?\r
413	struct mz80context mz80;\r
414	mz80GetContext(&mz80);\r
415	memcpy(&mz80.z80clockticks, data+4, sizeof(mz80)-5*4);\r
416	mz80SetContext(&mz80);\r
417	} else {\r
418	z80_reset();\r
419	z80_int();\r
420	}\r
421	#elif defined(_USE_DRZ80)\r
422	if((int )data == 0x015A7244) { // "DrZ" v1 save?\r
423	memcpy(&drZ80, data+4, 0x54);\r
424	// update bases\r
425	drZ80.Z80PC = drZ80.z80_rebasePC(drZ80.Z80PC-drZ80.Z80PC_BASE);\r
426	drZ80.Z80SP = drZ80.z80_rebaseSP(drZ80.Z80SP-drZ80.Z80SP_BASE);\r
427	} else {\r
428	z80_reset();\r
429	drZ80.Z80IM = 1;\r
430	z80_int(); // try to goto int handler, maybe we won't execute trash there?\r
431	}\r
432	#endif\r
433	}\r
434	\r
435	void z80_exit()\r
436	{\r
437	#if defined(_USE_MZ80)\r
438	mz80shutdown();\r
439	#endif\r
440	}\r
441	\r
442	#if defined(__DEBUG_PRINT) \|\| defined(WIN32)\r
443	void z80_debug(char *dstr)\r
444	{\r
445	#if defined(_USE_DRZ80)\r
446	sprintf(dstr, "%sZ80 state: PC: %04x SP: %04x\n", dstr, drZ80.Z80PC-drZ80.Z80PC_BASE, drZ80.Z80SP-drZ80.Z80SP_BASE);\r
447	#endif\r
448	}\r
449	#endif\r