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