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