?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add gigabeat F/S volume limits to the manual, and a few minor formatting changes.
[kugel-rb.git] / apps / codecs / nsf.c
blob6beb8fe3e652b6f97b5f3151018fc8d45f93cc56
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 *
9 * Copyright (C) 2006 Adam Gashlin (hcs)
10 * Copyright (C) 2004 Disch
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21
22 /*
23 * This is a perversion of Disch's excellent NotSoFatso.
24 */
25
26 #include "codeclib.h"
27 #include "inttypes.h"
28 #include "system.h"
29
30 CODEC_HEADER
31
32 /* arm doesn't benefit from IRAM? */
33 #ifdef CPU_ARM
34 #undef ICODE_ATTR
35 #define ICODE_ATTR
36 #undef IDATA_ATTR
37 #define IDATA_ATTR
38 #else
39 #define ICODE_INSTEAD_OF_INLINE
40 #endif
41
42 /* Maximum number of bytes to process in one iteration */
43 #define WAV_CHUNK_SIZE (1024*2)
44
45 static int16_t samples[WAV_CHUNK_SIZE] IBSS_ATTR;
46
47 #define ZEROMEMORY(addr,size) memset(addr,0,size)
48
49 /* simple profiling with USEC_TIMER
50
51 #define NSF_PROFILE
52
53 */
54
55 #ifdef NSF_PROFILE
56
57 #define CREATE_TIMER(name) uint32_t nsf_timer_##name##_start,\
58 nsf_timer_##name##_total
59 #define ENTER_TIMER(name) nsf_timer_##name##_start=USEC_TIMER
60 #define EXIT_TIMER(name) nsf_timer_##name##_total+=\
61 (USEC_TIMER-nsf_timer_##name##_start)
62 #define READ_TIMER(name) (nsf_timer_##name##_total)
63 #define RESET_TIMER(name) nsf_timer_##name##_total=0
64
65 #define PRINT_TIMER_PCT(bname,tname,nstr) ci->fdprintf(
66 logfd,"%10ld ",READ_TIMER(bname));\
67 ci->fdprintf(logfd,"(%3d%%) " nstr "\t",\
68 ((uint64_t)READ_TIMER(bname))*100/READ_TIMER(tname))
69
70 CREATE_TIMER(total);
71 CREATE_TIMER(cpu);
72 CREATE_TIMER(apu);
73 CREATE_TIMER(squares);
74 CREATE_TIMER(tnd);
75 CREATE_TIMER(tnd_enter);
76 CREATE_TIMER(tnd_tri);
77 CREATE_TIMER(tnd_noise);
78 CREATE_TIMER(tnd_dmc);
79 CREATE_TIMER(fds);
80 CREATE_TIMER(frame);
81 CREATE_TIMER(mix);
82
83 void reset_profile_timers(void) {
84 RESET_TIMER(total);
85 RESET_TIMER(cpu);
86 RESET_TIMER(apu);
87 RESET_TIMER(squares);
88 RESET_TIMER(tnd);
89 RESET_TIMER(tnd_enter);
90 RESET_TIMER(tnd_tri);
91 RESET_TIMER(tnd_noise);
92 RESET_TIMER(tnd_dmc);
93 RESET_TIMER(fds);
94 RESET_TIMER(frame);
95 RESET_TIMER(mix);
96 }
97
98 int logfd=-1;
99
100 void print_timers(char * path, int track) {
101 logfd = ci->open("/nsflog.txt",O_WRONLY|O_CREAT|O_APPEND);
102 ci->fdprintf(logfd,"%s[%d]:\t",path,track);
103 ci->fdprintf(logfd,"%10ld total\t",READ_TIMER(total));
104 PRINT_TIMER_PCT(cpu,total,"CPU");
105 PRINT_TIMER_PCT(apu,total,"APU");
106 ci->fdprintf(logfd,"\n\t");
107 PRINT_TIMER_PCT(squares,apu,"squares");
108 PRINT_TIMER_PCT(frame,apu,"frame");
109 PRINT_TIMER_PCT(mix,apu,"mix");
110 PRINT_TIMER_PCT(fds,apu,"FDS");
111 PRINT_TIMER_PCT(tnd,apu,"tnd");
112 ci->fdprintf(logfd,"\n\t\t");
113 PRINT_TIMER_PCT(tnd_enter,tnd,"enter");
114 PRINT_TIMER_PCT(tnd_tri,tnd,"triangle");
115 PRINT_TIMER_PCT(tnd_noise,tnd,"noise");
116 PRINT_TIMER_PCT(tnd_dmc,tnd,"DMC");
117 ci->fdprintf(logfd,"\n");
118
119 ci->close(logfd);
120 logfd=-1;
121 }
122
123 #else
124
125 #define CREATE_TIMER(name)
126 #define ENTER_TIMER(name)
127 #define EXIT_TIMER(name)
128 #define READ_TIMER(name)
129 #define RESET_TIMER(name)
130 #define print_timers(path,track)
131 #define reset_profile_timers()
132
133 #endif
134
135 /* proper handling of multibyte values */
136 #ifdef ROCKBOX_LITTLE_ENDIAN
137 union TWIN
138 {
139 uint16_t W;
140 struct{ uint8_t l; uint8_t h; } B;
141 };
142
143 union QUAD
144 {
145 uint32_t D;
146 struct{ uint8_t l; uint8_t h; uint16_t w; } B;
147 };
148 #else
149
150 union TWIN
151 {
152 uint16_t W;
153 struct{ uint8_t h; uint8_t l; } B;
154 };
155
156 union QUAD
157 {
158 uint32_t D;
159 struct{uint16_t w; uint8_t h; uint8_t l; } B;
160 };
161
162 #endif
163
164 #define NTSC_FREQUENCY 1789772.727273f
165 #define PAL_FREQUENCY 1652097.692308f
166 #define NTSC_NMIRATE 60.098814f
167 #define PAL_NMIRATE 50.006982f
168
169 #define NES_FREQUENCY 21477270
170 #define NTSC_FRAME_COUNTER_FREQ (NTSC_FREQUENCY / (NES_FREQUENCY / 89490.0f))
171 #define PAL_FRAME_COUNTER_FREQ (PAL_FREQUENCY / (NES_FREQUENCY / 89490.0f))
172
173 /****************** tables */
174 static const int32_t ModulationTable[8] ICONST_ATTR = {0,1,2,4,0,-4,-2,-1};
175 const uint16_t DMC_FREQ_TABLE[2][0x10] = {
176 /* NTSC */
177 {0x1AC,0x17C,0x154,0x140,0x11E,0x0FE,0x0E2,0x0D6,0x0BE,0x0A0,0x08E,0x080,
178 0x06A,0x054,0x048,0x036},
179 /* PAL */
180 {0x18C,0x160,0x13A,0x128,0x108,0x0EA,0x0D0,0x0C6,0x0B0,0x094,0x082,0x076,
181 0x062,0x04E,0x042,0x032}
182 };
183
184 const uint8_t DUTY_CYCLE_TABLE[4] = {2,4,8,12};
185
186 const uint8_t LENGTH_COUNTER_TABLE[0x20] = {
187 0x0A,0xFE,0x14,0x02,0x28,0x04,0x50,0x06,0xA0,0x08,0x3C,0x0A,0x0E,0x0C,0x1A,
188 0x0E,0x0C,0x10,0x18,0x12,0x30,0x14,0x60,0x16,0xC0,0x18,0x48,0x1A,0x10,0x1C,
189 0x20,0x1E
190 };
191
192 const uint16_t NOISE_FREQ_TABLE[0x10] = {
193 0x004,0x008,0x010,0x020,0x040,0x060,0x080,0x0A0,0x0CA,0x0FE,0x17C,0x1FC,
194 0x2FA,0x3F8,0x7F2,0xFE4
195 };
196
197 /****************** NSF loading ******************/
198
199 /* file format structs (both are little endian) */
200
201 struct NESM_HEADER
202 {
203 uint32_t nHeader;
204 uint8_t nHeaderExtra;
205 uint8_t nVersion;
206 uint8_t nTrackCount;
207 uint8_t nInitialTrack;
208 uint16_t nLoadAddress;
209 uint16_t nInitAddress;
210 uint16_t nPlayAddress;
211 uint8_t szGameTitle[32];
212 uint8_t szArtist[32];
213 uint8_t szCopyright[32];
214 uint16_t nSpeedNTSC;
215 uint8_t nBankSwitch[8];
216 uint16_t nSpeedPAL;
217 uint8_t nNTSC_PAL;
218 uint8_t nExtraChip;
219 uint8_t nExpansion[4];
220 };
221
222 struct NSFE_INFOCHUNK
223 {
224 uint16_t nLoadAddress;
225 uint16_t nInitAddress;
226 uint16_t nPlayAddress;
227 uint8_t nIsPal;
228 uint8_t nExt;
229 uint8_t nTrackCount;
230 uint8_t nStartingTrack;
231 };
232
233 int32_t LoadFile(uint8_t *,size_t);
234
235 int32_t LoadFile_NESM(uint8_t *,size_t);
236 int32_t LoadFile_NSFE(uint8_t *,size_t);
237
238 /* NSF file info */
239
240 /* basic NSF info */
241 int32_t bIsExtended=0; /* 0 = NSF, 1 = NSFE */
242 uint8_t nIsPal=0; /* 0 = NTSC, 1 = PAL,
243 2,3 = mixed NTSC/PAL (interpretted as NTSC) */
244 int32_t nfileLoadAddress=0; /* The address to which the NSF code is
245 loaded */
246 int32_t nfileInitAddress=0; /* The address of the Init routine
247 (called at track change) */
248 int32_t nfilePlayAddress=0; /* The address of the Play routine
249 (called several times a second) */
250 uint8_t nChipExtensions=0; /* Bitwise representation of the external chips
251 used by this NSF. */
252
253 /* old NESM speed stuff (blarg) */
254 int32_t nNTSC_PlaySpeed=0;
255 int32_t nPAL_PlaySpeed=0;
256
257 /* track info */
258 /* The number of tracks in the NSF (1 = 1 track, 5 = 5 tracks, etc) */
259 int32_t nTrackCount=0;
260 /* The initial track (ZERO BASED: 0 = 1st track, 4 = 5th track, etc) */
261 int32_t nInitialTrack=0;
262
263 /* nsf data */
264 uint8_t* pDataBuffer=0; /* the buffer containing NSF code. */
265 int32_t nDataBufferSize=0; /* the size of the above buffer. */
266
267 /* playlist */
268 uint8_t nPlaylist[256]; /* Each entry is the zero based index of the
269 song to play */
270 int32_t nPlaylistSize=0; /* the number of tracks in the playlist */
271
272 /* track time / fade */
273 int32_t nTrackTime[256]; /* track times -1 if no track times specified */
274 int32_t nTrackFade[256]; /* track fade times -1 if none are specified */
275
276 /* string info */
277 uint8_t szGameTitle[0x101];
278 uint8_t szArtist[0x101];
279 uint8_t szCopyright[0x101];
280 uint8_t szRipper[0x101];
281
282 /* bankswitching info */
283 uint8_t nBankswitch[8]={0}; /* The initial bankswitching registers needed
284 * for some NSFs. If the NSF does not use
285 * bankswitching, these values will all be zero
286 */
287
288 int32_t LoadFile(uint8_t * inbuffer, size_t size)
289 {
290 if(!inbuffer) return -1;
291
292 int32_t ret = -1;
293
294 if(!memcmp(inbuffer,"NESM",4)) ret = LoadFile_NESM(inbuffer,size);
295 if(!memcmp(inbuffer,"NSFE",4)) ret = LoadFile_NSFE(inbuffer,size);
296
297 /*
298 * Snake's revenge puts '00' for the initial track,
299 * which (after subtracting 1) makes it 256 or -1 (bad!)
300 * This prevents that crap
301 */
302 if(nInitialTrack >= nTrackCount)
303 nInitialTrack = 0;
304 if(nInitialTrack < 0)
305 nInitialTrack = 0;
306
307 /* if there's no tracks... this is a crap NSF */
308 if(nTrackCount < 1)
309 {
310 return -1;
311 }
312
313 return ret;
314 }
315
316 int32_t LoadFile_NESM(uint8_t* inbuffer, size_t size)
317 {
318 uint8_t ignoreversion=1;
319 uint8_t needdata=1;
320
321 /* read the info */
322 struct NESM_HEADER hdr;
323
324 memcpy(&hdr,inbuffer,sizeof(hdr));
325
326 /* confirm the header */
327 if(memcmp("NESM",&(hdr.nHeader),4)) return -1;
328 if(hdr.nHeaderExtra != 0x1A) return -1;
329 /* stupid NSFs claim to be above version 1 >_> */
330 if((!ignoreversion) && (hdr.nVersion != 1)) return -1;
331
332 /*
333 * NESM is generally easier to work with (but limited!)
334 * just move the data over from NESM_HEADER over to our member data
335 */
336
337 bIsExtended = 0;
338 nIsPal = hdr.nNTSC_PAL & 0x03;
339 nPAL_PlaySpeed = letoh16(hdr.nSpeedPAL);
340 nNTSC_PlaySpeed = letoh16(hdr.nSpeedNTSC);
341 nfileLoadAddress = letoh16(hdr.nLoadAddress);
342 nfileInitAddress = letoh16(hdr.nInitAddress);
343 nfilePlayAddress = letoh16(hdr.nPlayAddress);
344 nChipExtensions = hdr.nExtraChip;
345
346
347 nTrackCount = hdr.nTrackCount;
348 nInitialTrack = hdr.nInitialTrack - 1;
349
350 memcpy(nBankswitch,hdr.nBankSwitch,8);
351
352 memcpy(szGameTitle,hdr.szGameTitle,32);
353 memcpy(szArtist ,hdr.szArtist ,32);
354 memcpy(szCopyright,hdr.szCopyright,32);
355
356 /* read the NSF data */
357 if(needdata)
358 {
359 pDataBuffer=inbuffer+0x80;
360 nDataBufferSize=size-0x80;
361 }
362
363 /* if we got this far... it was a successful read */
364 return 0;
365 }
366
367 int32_t LoadFile_NSFE(uint8_t* inbuffer, size_t size)
368 {
369 /* the vars we'll be using */
370 uint32_t nChunkType;
371 int32_t nChunkSize;
372 int32_t nChunkUsed;
373 int32_t i;
374 uint8_t * nDataPos = 0;
375 uint8_t bInfoFound = 0;
376 uint8_t bEndFound = 0;
377 uint8_t bBankFound = 0;
378 nPlaylistSize=-1;
379
380 struct NSFE_INFOCHUNK info;
381 ZEROMEMORY(&info,sizeof(struct NSFE_INFOCHUNK));
382 ZEROMEMORY(nBankswitch,8);
383 info.nTrackCount = 1; /* default values */
384
385 if (size < 8) return -1; /* must have at least NSFE,NEND */
386
387 /* confirm the header! */
388 memcpy(&nChunkType,inbuffer,4);
389 inbuffer+=4;
390 if(memcmp(&nChunkType,"NSFE",4)) return -1;
391
392 for (i=0;i<256;i++) {
393 nTrackTime[i]=-1;
394 nTrackFade[i]=-1;
395 }
396
397 /* begin reading chunks */
398 while(!bEndFound)
399 {
400 memcpy(&nChunkSize,inbuffer,4);
401 nChunkSize=letoh32(nChunkSize);
402 inbuffer+=4;
403 memcpy(&nChunkType,inbuffer,4);
404 inbuffer+=4;
405
406 if(!memcmp(&nChunkType,"INFO",4)) {
407 /* only one info chunk permitted */
408 if(bInfoFound) return -1;
409 if(nChunkSize < 8) return -1; /* minimum size */
410
411 bInfoFound = 1;
412 nChunkUsed = MIN((int32_t)sizeof(struct NSFE_INFOCHUNK),
413 nChunkSize);
414
415 memcpy(&info,inbuffer,nChunkUsed);
416 inbuffer+=nChunkSize;
417
418 bIsExtended = 1;
419 nIsPal = info.nIsPal & 3;
420 nfileLoadAddress = letoh16(info.nLoadAddress);
421 nfileInitAddress = letoh16(info.nInitAddress);
422 nfilePlayAddress = letoh16(info.nPlayAddress);
423 nChipExtensions = info.nExt;
424 nTrackCount = info.nTrackCount;
425 nInitialTrack = info.nStartingTrack;
426
427 nPAL_PlaySpeed = (uint16_t)(1000000 / PAL_NMIRATE);
428 nNTSC_PlaySpeed = (uint16_t)(1000000 / NTSC_NMIRATE);
429 } else if (!memcmp(&nChunkType,"DATA",4)) {
430 if(!bInfoFound) return -1;
431 if(nDataPos) return -1;
432 if(nChunkSize < 1) return -1;
433
434 nDataBufferSize = nChunkSize;
435 nDataPos = inbuffer;
436
437 inbuffer+=nChunkSize;
438 } else if (!memcmp(&nChunkType,"NEND",4)) {
439 bEndFound = 1;
440 } else if (!memcmp(&nChunkType,"time",4)) {
441 if(!bInfoFound) return -1;
442 for (nChunkUsed=0; nChunkUsed < MIN(nChunkSize / 4,nTrackCount);
443 nChunkUsed++,inbuffer+=4) {
444 nTrackTime[nChunkUsed]=
445 ((uint32_t)inbuffer[0])|
446 ((uint32_t)inbuffer[1]<<8)|
447 ((uint32_t)inbuffer[2]<<16)|
448 ((uint32_t)inbuffer[3]<<24);
449 }
450
451 inbuffer+=nChunkSize-(nChunkUsed*4);
452
453 /* negative signals to use default time */
454 for(; nChunkUsed < nTrackCount; nChunkUsed++)
455 nTrackTime[nChunkUsed] = -1;
456 } else if (!memcmp(&nChunkType,"fade",4)) {
457 if(!bInfoFound) return -1;
458 for (nChunkUsed=0; nChunkUsed < MIN(nChunkSize / 4,nTrackCount);
459 nChunkUsed++,inbuffer+=4) {
460 nTrackFade[nChunkUsed]=
461 ((uint32_t)inbuffer[0])|
462 ((uint32_t)inbuffer[1]<<8)|
463 ((uint32_t)inbuffer[2]<<16)|
464 ((uint32_t)inbuffer[3]<<24);
465 }
466
467 inbuffer+=nChunkSize-(nChunkUsed*4);
468
469 /* negative signals to use default time */
470 for(; nChunkUsed < nTrackCount; nChunkUsed++)
471 nTrackFade[nChunkUsed] = -1;
472 } else if (!memcmp(&nChunkType,"BANK",4)) {
473 if(bBankFound) return -1;
474
475 bBankFound = 1;
476 nChunkUsed = MIN(8,nChunkSize);
477 memcpy(nBankswitch,inbuffer,nChunkUsed);
478
479 inbuffer+=nChunkSize;
480 } else if (!memcmp(&nChunkType,"plst",4)) {
481
482 nPlaylistSize = nChunkSize;
483 if(nPlaylistSize >= 1) {
484
485 memcpy(nPlaylist,inbuffer,nChunkSize);
486 inbuffer+=nChunkSize;
487 }
488 } else if (!memcmp(&nChunkType,"auth",4)) {
489 uint8_t* ptr;
490
491 ptr = inbuffer;
492
493 uint8_t* ar[4] = {szGameTitle,szArtist,szCopyright,szRipper};
494 int32_t i;
495 for(i = 0; (ptr-inbuffer)<nChunkSize && i < 4; i++)
496 {
497 nChunkUsed = strlen(ptr) + 1;
498 memcpy(ar[i],ptr,nChunkUsed);
499 ptr += nChunkUsed;
500 }
501 inbuffer+=nChunkSize;
502 } else if (!memcmp(&nChunkType,"tlbl",4)) {
503 /* we unfortunately can't use these anyway */
504 inbuffer+=nChunkSize;
505 } else { /* unknown chunk */
506 nChunkType = letoh32(nChunkType)>>24; /* check the first byte */
507 /* chunk is vital... don't continue */
508 if((nChunkType >= 'A') && (nChunkType <= 'Z'))
509 return -1;
510 /* otherwise, just skip it */
511 inbuffer+=nChunkSize;
512 } /* end if series */
513 } /* end while */
514
515 /*
516 * if we exited the while loop without a 'return', we must have hit an NEND
517 * chunk if this is the case, the file was layed out as it was expected.
518 * now.. make sure we found both an info chunk, AND a data chunk... since
519 * these are minimum requirements for a valid NSFE file
520 */
521
522 if(!bInfoFound) return -1;
523 if(!nDataPos) return -1;
524
525 /* if both those chunks existed, this file is valid.
526 Load the data if it's needed */
527
528 pDataBuffer=nDataPos;
529
530 /* return success! */
531 return 0;
532 }
533
534
535 /****************** Audio Device Structures ******************/
536
537 struct FDSWave
538 {
539 /* Envelope Unit */
540 uint8_t bEnvelopeEnable;
541 uint8_t nEnvelopeSpeed;
542
543 /* Volume Envelope */
544 uint8_t nVolEnv_Mode;
545 uint8_t nVolEnv_Decay;
546 uint8_t nVolEnv_Gain;
547 int32_t nVolEnv_Timer;
548 int32_t nVolEnv_Count;
549 uint8_t nVolume;
550 uint8_t bVolEnv_On;
551
552 /* Sweep Envenlope */
553 uint8_t nSweep_Mode;
554 uint8_t nSweep_Decay;
555 int32_t nSweep_Timer;
556 int32_t nSweep_Count;
557 uint8_t nSweep_Gain;
558 uint8_t bSweepEnv_On;
559
560 /* Effector / LFO / Modulation Unit */
561 int32_t nSweepBias;
562 uint8_t bLFO_Enabled;
563 union TWIN nLFO_Freq;
564 /*float fLFO_Timer;*/
565 /*float fLFO_Count;*/
566 int32_t nLFO_Timer; /* -17.14*/
567 int32_t nLFO_Count; /* -17.14*/
568 uint8_t nLFO_Addr;
569 uint8_t nLFO_Table[0x40];
570 uint8_t bLFO_On;
571
572 /* Main Output */
573 uint8_t nMainVolume;
574 uint8_t bEnabled;
575 union TWIN nFreq;
576 /*float fFreqCount;*/
577 int32_t nFreqCount; /* -17.14 */
578 uint8_t nMainAddr;
579 uint8_t nWaveTable[0x40];
580 uint8_t bWaveWrite;
581 uint8_t bMain_On;
582
583 /* Output and Downsampling */
584 int32_t nMixL;
585
586 /* Pop Reducer */
587 uint8_t bPopReducer;
588 uint8_t nPopOutput;
589 int32_t nPopCount;
590
591 };
592 int16_t FDS_nOutputTable_L[4][0x21][0x40];
593
594 struct FME07Wave
595 {
596 /* Frequency Control */
597 union TWIN nFreqTimer;
598 int32_t nFreqCount;
599
600 /* Channel Disabling */
601 uint8_t bChannelEnabled;
602
603 /* Volume */
604 uint8_t nVolume;
605
606 /* Duty Cycle */
607 uint8_t nDutyCount;
608
609 /* Output and Downsampling */
610 int32_t nMixL;
611 };
612
613 int16_t FME07_nOutputTable_L[0x10] IDATA_ATTR;
614
615 struct N106Wave
616 {
617 /* All Channel Stuff */
618
619 uint8_t nActiveChannels;
620 uint8_t bAutoIncrement;
621 uint8_t nCurrentAddress;
622 uint8_t nRAM[0x100]; /* internal memory for registers/wave data */
623 int32_t nFrequencyLookupTable[8]; /* lookup tbl for freq conversions */
624
625 /*
626 * Individual channel stuff
627 */
628 /* Wavelength / Frequency */
629 union QUAD nFreqReg[8];
630 int32_t nFreqTimer[8];
631 int32_t nFreqCount[8];
632
633 /* Wave data length / remaining */
634 uint8_t nWaveSize[8];
635 uint8_t nWaveRemaining[8];
636
637 /* Wave data position */
638 uint8_t nWavePosStart[8];
639 uint8_t nWavePos[8];
640 uint8_t nOutput[8];
641
642 /* Volume */
643 uint8_t nVolume[8];
644
645 /* Pop Reducer */
646 uint8_t nPreVolume[8];
647 uint8_t nPopCheck[8];
648
649 /* Mixing */
650 int32_t nMixL[8];
651 };
652
653 int16_t N106_nOutputTable_L[0x10][0x10];
654
655 struct VRC6PulseWave
656 {
657
658 /* Frequency Control */
659 union TWIN nFreqTimer;
660 int32_t nFreqCount;
661
662 /* Flags */
663 uint8_t bChannelEnabled;
664 uint8_t bDigitized;
665
666 /* Volume */
667 uint8_t nVolume;
668
669 /* Duty Cycle */
670 uint8_t nDutyCycle;
671 uint8_t nDutyCount;
672
673 /* Output and Downsampling */
674 int32_t nMixL;
675
676 };
677
678 int16_t VRC6Pulse_nOutputTable_L[0x10] IDATA_ATTR;
679
680 struct VRC6SawWave
681 {
682
683 /* Frequency Control */
684 union TWIN nFreqTimer;
685 int32_t nFreqCount;
686
687 /* Flags */
688 uint8_t bChannelEnabled;
689
690 /* Phase Accumulator */
691 uint8_t nAccumRate;
692 uint8_t nAccum;
693 uint8_t nAccumStep;
694
695 /* Output and Downsampling */
696 int32_t nMixL;
697
698 };
699
700 int16_t VRC6Saw_nOutputTable_L[0x20] IDATA_ATTR;
701
702 struct Wave_Squares
703 {
704
705 /* Programmable Timer */
706 union TWIN nFreqTimer[2];
707 int32_t nFreqCount[2];
708
709 /* Length Counter */
710 uint8_t nLengthCount[2];
711 uint8_t bLengthEnabled[2];
712 uint8_t bChannelEnabled[2];
713
714 /* Volume / Decay */
715 uint8_t nVolume[2];
716 uint8_t nDecayVolume[2];
717 uint8_t bDecayEnable[2];
718 uint8_t bDecayLoop[2];
719 uint8_t nDecayTimer[2];
720 uint8_t nDecayCount[2];
721
722 /* Sweep Unit */
723 uint8_t bSweepEnable[2];
724 uint8_t bSweepMode[2];
725 uint8_t bSweepForceSilence[2];
726 uint8_t nSweepTimer[2];
727 uint8_t nSweepCount[2];
728 uint8_t nSweepShift[2];
729
730 /* Duty Cycle */
731 uint8_t nDutyCount[2];
732 uint8_t nDutyCycle[2];
733
734 /* Output and Downsampling */
735 int32_t nMixL;
736 };
737
738 int16_t Squares_nOutputTable_L[0x10][0x10] IDATA_ATTR;
739
740 struct Wave_TND
741 {
742
743 /*
744 * Triangle
745 */
746
747 /* Programmable Timer */
748 union TWIN nTriFreqTimer;
749 int32_t nTriFreqCount;
750
751 /* Length Counter */
752 uint8_t nTriLengthCount;
753 uint8_t bTriLengthEnabled;
754 uint8_t bTriChannelEnabled;
755
756 /* Linear Counter */
757 uint8_t nTriLinearCount;
758 uint8_t nTriLinearLoad;
759 uint8_t bTriLinearHalt;
760 uint8_t bTriLinearControl;
761
762 /* Tri-Step Generator / Output */
763 uint8_t nTriStep;
764 uint8_t nTriOutput;
765
766 /*
767 * Noise
768 */
769
770 /* Programmable Timer */
771 uint16_t nNoiseFreqTimer;
772 int32_t nNoiseFreqCount;
773
774 /* Length Counter */
775 uint8_t nNoiseLengthCount;
776 uint8_t bNoiseLengthEnabled;
777 uint8_t bNoiseChannelEnabled;
778
779 /* Volume / Decay */
780 uint8_t nNoiseVolume;
781 uint8_t nNoiseDecayVolume;
782 uint8_t bNoiseDecayEnable;
783 uint8_t bNoiseDecayLoop;
784 uint8_t nNoiseDecayTimer;
785 uint8_t nNoiseDecayCount;
786
787 /* Random Number Generator */
788 uint16_t nNoiseRandomShift;
789 uint8_t bNoiseRandomMode; /* 1 = 32k, 6 = 93-bit */
790 uint8_t bNoiseRandomOut;
791
792 /*
793 * DMC
794 */
795
796 /* Play Mode */
797 uint8_t bDMCLoop;
798 uint8_t bDMCIRQEnabled;
799 uint8_t bDMCIRQPending;
800
801 /* Address / DMA */
802 uint8_t nDMCDMABank_Load;
803 uint16_t nDMCDMAAddr_Load;
804 uint8_t nDMCDMABank;
805 uint16_t nDMCDMAAddr;
806 uint8_t* pDMCDMAPtr[8];
807
808 /* Length / Input */
809 uint16_t nDMCLength;
810 uint16_t nDMCBytesRemaining;
811 uint8_t nDMCDelta;
812 uint8_t nDMCDeltaBit;
813 uint8_t bDMCDeltaSilent;
814 uint8_t nDMCSampleBuffer;
815 uint8_t bDMCSampleBufferEmpty;
816
817 /* Frequency */
818 uint16_t nDMCFreqTimer;
819 int32_t nDMCFreqCount;
820
821 /* Output */
822 uint8_t bDMCActive;
823 uint8_t nDMCOutput;
824
825 int32_t nMixL;
826 };
827
828 /* channels */
829 struct Wave_Squares mWave_Squares IDATA_ATTR; /* Square channels 1 and 2 */
830 struct Wave_TND mWave_TND IDATA_ATTR; /* Triangle/Noise/DMC channels */
831 struct VRC6PulseWave mWave_VRC6Pulse[2] IDATA_ATTR;
832 struct VRC6SawWave mWave_VRC6Saw IDATA_ATTR;
833 struct N106Wave mWave_N106 IDATA_ATTR;
834 struct FDSWave mWave_FDS IDATA_ATTR;
835 struct FME07Wave mWave_FME07[3] IDATA_ATTR; /* FME-07's 3 pulse channels */
836
837
838 /****************** MMC5 ******************/
839 /* will include MMC5 sound channels some day,
840 currently only multiply is supported */
841
842 /****************** N106 (Disch loves this chip) ******************/
843
844 #ifdef ICODE_INSTEAD_OF_INLINE
845 void Wave_N106_DoTicks(const int32_t ticks) ICODE_ATTR;
846 void Wave_N106_DoTicks(const int32_t ticks)
847 #else
848 inline void Wave_N106_DoTicks(const int32_t ticks);
849 inline void Wave_N106_DoTicks(const int32_t ticks)
850 #endif
851 {
852 register int32_t i;
853
854 for(i = (7 - mWave_N106.nActiveChannels); i < 8; i++)
855 {
856 if(!mWave_N106.nFreqReg[i].D)
857 {
858 /* written frequency of zero will cause divide by zero error
859 makes me wonder if the formula was supposed to be Reg+1 */
860 mWave_N106.nVolume[i] = mWave_N106.nPreVolume[i];
861 continue;
862 }
863
864 {
865 mWave_N106.nMixL[i] =
866 N106_nOutputTable_L[mWave_N106.nVolume[i]]
867 [mWave_N106.nOutput[i]];
868
869 if(mWave_N106.nFreqTimer[i] < 0)
870 mWave_N106.nFreqTimer[i] =
871 (mWave_N106.nFrequencyLookupTable[mWave_N106.nActiveChannels] /
872 mWave_N106.nFreqReg[i].D);
873 if(mWave_N106.nFreqCount[i] > mWave_N106.nFreqTimer[i])
874 mWave_N106.nFreqCount[i] = mWave_N106.nFreqTimer[i];
875
876 mWave_N106.nFreqCount[i] -= ticks << 8;
877 while(mWave_N106.nFreqCount[i] <= 0)
878 {
879 mWave_N106.nFreqCount[i] += mWave_N106.nFreqTimer[i];
880 if(mWave_N106.nWaveRemaining[i])
881 {
882 mWave_N106.nWaveRemaining[i]--;
883 mWave_N106.nWavePos[i]++;
884 }
885 if(!mWave_N106.nWaveRemaining[i])
886 {
887 mWave_N106.nWaveRemaining[i] = mWave_N106.nWaveSize[i];
888 mWave_N106.nWavePos[i] = mWave_N106.nWavePosStart[i];
889 if(mWave_N106.nVolume[i] != mWave_N106.nPreVolume[i])
890 {
891 if(++mWave_N106.nPopCheck[i] >= 2)
892 {
893 mWave_N106.nPopCheck[i] = 0;
894 mWave_N106.nVolume[i] = mWave_N106.nPreVolume[i];
895 }
896 }
897 }
898
899 mWave_N106.nOutput[i] =
900 mWave_N106.nRAM[mWave_N106.nWavePos[i]];
901
902 if(!mWave_N106.nOutput[i])
903 {
904 mWave_N106.nPopCheck[i] = 0;
905 mWave_N106.nVolume[i] = mWave_N106.nPreVolume[i];
906 }
907
908 }
909 }
910 }
911 }
912 /****************** VRC6 ******************/
913
914 #ifdef ICODE_INSTEAD_OF_INLINE
915 void Wave_VRC6_DoTicks(const int32_t ticks) ICODE_ATTR;
916 void Wave_VRC6_DoTicks(const int32_t ticks)
917 #else
918 inline void Wave_VRC6_DoTicks(const int32_t ticks);
919 inline void Wave_VRC6_DoTicks(const int32_t ticks)
920 #endif
921 {
922 register int32_t i;
923
924 for(i = 0; i < 2; i++) {
925
926 if(mWave_VRC6Pulse[i].bChannelEnabled) {
927
928 mWave_VRC6Pulse[i].nFreqCount -= ticks;
929
930 if(mWave_VRC6Pulse[i].nDutyCount <=
931 mWave_VRC6Pulse[i].nDutyCycle)
932 {
933 mWave_VRC6Pulse[i].nMixL =
934 VRC6Pulse_nOutputTable_L[mWave_VRC6Pulse[i].nVolume];
935 }
936 else
937 mWave_VRC6Pulse[i].nMixL = 0;
938
939 while(mWave_VRC6Pulse[i].nFreqCount <= 0) {
940 mWave_VRC6Pulse[i].nFreqCount +=
941 mWave_VRC6Pulse[i].nFreqTimer.W + 1;
942
943 if(!mWave_VRC6Pulse[i].bDigitized)
944 mWave_VRC6Pulse[i].nDutyCount =
945 (mWave_VRC6Pulse[i].nDutyCount + 1) & 0x0F;
946 }
947 }
948 }
949
950 if(mWave_VRC6Saw.bChannelEnabled) {
951
952 mWave_VRC6Saw.nFreqCount -= ticks;
953
954 mWave_VRC6Saw.nMixL =
955 VRC6Saw_nOutputTable_L[mWave_VRC6Saw.nAccum >> 3];
956
957 while(mWave_VRC6Saw.nFreqCount <= 0) {
958
959 mWave_VRC6Saw.nFreqCount += mWave_VRC6Saw.nFreqTimer.W + 1;
960
961 mWave_VRC6Saw.nAccumStep++;
962 if(mWave_VRC6Saw.nAccumStep == 14)
963 {
964 mWave_VRC6Saw.nAccumStep = 0;
965 mWave_VRC6Saw.nAccum = 0;
966 }
967 else if(!(mWave_VRC6Saw.nAccumStep & 1))
968 mWave_VRC6Saw.nAccum += mWave_VRC6Saw.nAccumRate;
969 }
970 }
971 }
972
973 /****************** Square waves ******************/
974
975 /* decay */
976 #ifdef ICODE_INSTEAD_OF_INLINE
977 void Wave_Squares_ClockMajor(void) ICODE_ATTR;
978 void Wave_Squares_ClockMajor()
979 #else
980 inline void Wave_Squares_ClockMajor(void);
981 inline void Wave_Squares_ClockMajor()
982 #endif
983 {
984 if(mWave_Squares.nDecayCount[0])
985 mWave_Squares.nDecayCount[0]--;
986 else
987 {
988 mWave_Squares.nDecayCount[0] = mWave_Squares.nDecayTimer[0];
989 if(mWave_Squares.nDecayVolume[0])
990 mWave_Squares.nDecayVolume[0]--;
991 else
992 {
993 if(mWave_Squares.bDecayLoop[0])
994 mWave_Squares.nDecayVolume[0] = 0x0F;
995 }
996
997 if(mWave_Squares.bDecayEnable[0])
998 mWave_Squares.nVolume[0] = mWave_Squares.nDecayVolume[0];
999 }
1000
1001 if(mWave_Squares.nDecayCount[1])
1002 mWave_Squares.nDecayCount[1]--;
1003 else
1004 {
1005 mWave_Squares.nDecayCount[1] = mWave_Squares.nDecayTimer[1];
1006 if(mWave_Squares.nDecayVolume[1])
1007 mWave_Squares.nDecayVolume[1]--;
1008 else
1009 {
1010 if(mWave_Squares.bDecayLoop[1])
1011 mWave_Squares.nDecayVolume[1] = 0x0F;
1012 }
1013
1014 if(mWave_Squares.bDecayEnable[1])
1015 mWave_Squares.nVolume[1] = mWave_Squares.nDecayVolume[1];
1016 }
1017
1018 }
1019
1020
1021 #ifdef ICODE_INSTEAD_OF_INLINE
1022 void Wave_Squares_CheckSweepForcedSilence(const int32_t i) ICODE_ATTR;
1023 void Wave_Squares_CheckSweepForcedSilence(const int32_t i)
1024 #else
1025 inline void Wave_Squares_CheckSweepForcedSilence(const int32_t i);
1026 inline void Wave_Squares_CheckSweepForcedSilence(const int32_t i)
1027 #endif
1028 {
1029 if(mWave_Squares.nFreqTimer[i].W < 8) {
1030 mWave_Squares.bSweepForceSilence[i] = 1; return;
1031 }
1032 if(!mWave_Squares.bSweepMode[i] &&
1033 (( mWave_Squares.nFreqTimer[i].W +
1034 (mWave_Squares.nFreqTimer[i].W >> mWave_Squares.nSweepShift[i]))
1035 >= 0x0800)) { mWave_Squares.bSweepForceSilence[i] = 1; return; }
1036
1037 mWave_Squares.bSweepForceSilence[i] = 0;
1038 }
1039
1040 /* sweep / length */
1041 #ifdef ICODE_INSTEAD_OF_INLINE
1042 void Wave_Squares_ClockMinor(void) ICODE_ATTR;
1043 void Wave_Squares_ClockMinor()
1044 #else
1045 inline void Wave_Squares_ClockMinor(void);
1046 inline void Wave_Squares_ClockMinor()
1047 #endif
1048 {
1049 /* unrolled a little loop
1050 static int i = 0;
1051 for(i = 0; i < 2; i++)
1052 {
1053 */
1054 if(mWave_Squares.bLengthEnabled[0] && mWave_Squares.nLengthCount[0])
1055 mWave_Squares.nLengthCount[0]--;
1056
1057 if(!mWave_Squares.bSweepEnable[0] || !mWave_Squares.nLengthCount[0] ||
1058 mWave_Squares.bSweepForceSilence[0] || !mWave_Squares.nSweepShift[0])
1059 goto other_square;
1060
1061 if(mWave_Squares.nSweepCount[0])
1062 mWave_Squares.nSweepCount[0]--;
1063 else
1064 {
1065 mWave_Squares.nSweepCount[0] = mWave_Squares.nSweepTimer[0];
1066 if(mWave_Squares.bSweepMode[0]) mWave_Squares.nFreqTimer[0].W -=
1067 (mWave_Squares.nFreqTimer[0].W >> mWave_Squares.nSweepShift[0])+1;
1068 else mWave_Squares.nFreqTimer[0].W +=
1069 (mWave_Squares.nFreqTimer[0].W >> mWave_Squares.nSweepShift[0]);
1070
1071 Wave_Squares_CheckSweepForcedSilence(0);
1072 }
1073
1074 /* */
1075 other_square:
1076 if(mWave_Squares.bLengthEnabled[1] && mWave_Squares.nLengthCount[1])
1077 mWave_Squares.nLengthCount[1]--;
1078
1079 if(!mWave_Squares.bSweepEnable[1] || !mWave_Squares.nLengthCount[1] ||
1080 mWave_Squares.bSweepForceSilence[1] || !mWave_Squares.nSweepShift[1])
1081 return;
1082
1083 if(mWave_Squares.nSweepCount[1])
1084 mWave_Squares.nSweepCount[1]--;
1085 else
1086 {
1087 mWave_Squares.nSweepCount[1] = mWave_Squares.nSweepTimer[1];
1088 if(mWave_Squares.bSweepMode[1]) mWave_Squares.nFreqTimer[1].W -=
1089 (mWave_Squares.nFreqTimer[1].W >> mWave_Squares.nSweepShift[1]);
1090 else mWave_Squares.nFreqTimer[1].W +=
1091 (mWave_Squares.nFreqTimer[1].W >> mWave_Squares.nSweepShift[1]);
1092
1093 Wave_Squares_CheckSweepForcedSilence(1);
1094 }
1095 }
1096
1097 /****************** Triangle/noise/DMC ******************/
1098
1099 /* decay (noise), linear (tri) */
1100
1101 #ifdef ICODE_INSTEAD_OF_INLINE
1102 void Wave_TND_ClockMajor(void) ICODE_ATTR;
1103 void Wave_TND_ClockMajor()
1104 #else
1105 inline void Wave_TND_ClockMajor(void);
1106 inline void Wave_TND_ClockMajor()
1107 #endif
1108 {
1109 /* noise's decay */
1110 if(mWave_TND.nNoiseDecayCount)
1111 mWave_TND.nNoiseDecayCount--;
1112 else
1113 {
1114 mWave_TND.nNoiseDecayCount = mWave_TND.nNoiseDecayTimer;
1115 if(mWave_TND.nNoiseDecayVolume)
1116 mWave_TND.nNoiseDecayVolume--;
1117 else
1118 {
1119 if(mWave_TND.bNoiseDecayLoop)
1120 mWave_TND.nNoiseDecayVolume = 0x0F;
1121 }
1122
1123 if(mWave_TND.bNoiseDecayEnable)
1124 mWave_TND.nNoiseVolume = mWave_TND.nNoiseDecayVolume;
1125 }
1126
1127 /* triangle's linear */
1128 if(mWave_TND.bTriLinearHalt)
1129 mWave_TND.nTriLinearCount = mWave_TND.nTriLinearLoad;
1130 else if(mWave_TND.nTriLinearCount)
1131 mWave_TND.nTriLinearCount--;
1132
1133 if(!mWave_TND.bTriLinearControl)
1134 mWave_TND.bTriLinearHalt = 0;
1135 }
1136
1137 /* length */
1138
1139 #ifdef ICODE_INSTEAD_OF_INLINE
1140 void Wave_TND_ClockMinor(void) ICODE_ATTR;
1141 void Wave_TND_ClockMinor()
1142 #else
1143 inline void Wave_TND_ClockMinor(void);
1144 inline void Wave_TND_ClockMinor()
1145 #endif
1146 {
1147 if(mWave_TND.bNoiseLengthEnabled && mWave_TND.nNoiseLengthCount)
1148 mWave_TND.nNoiseLengthCount--;
1149
1150 if(mWave_TND.bTriLengthEnabled && mWave_TND.nTriLengthCount)
1151 mWave_TND.nTriLengthCount--;
1152 }
1153
1154 /*#undef this*/
1155
1156 /****************** NSF Core ******************/
1157
1158 /* start globals */
1159
1160 /*
1161 * Memory
1162 */
1163 /* RAM: 0x0000 - 0x07FF */
1164 uint8_t pRAM[0x800] IDATA_ATTR;
1165 /* SRAM: 0x6000 - 0x7FFF (non-FDS only) */
1166 uint8_t pSRAM[0x2000];
1167 /* ExRAM: 0x5C00 - 0x5FF5 (MMC5 only)
1168 * Also holds NSF player code (at 0x5000 - 0x500F) */
1169 uint8_t pExRAM[0x1000];
1170 /* Full ROM buffer */
1171 uint8_t* pROM_Full IDATA_ATTR;
1172
1173 uint16_t main_nOutputTable_L[0x8000];
1174
1175 uint8_t* pROM[10] IDATA_ATTR;/* ROM banks (point to areas in pROM_Full) */
1176 /* 0x8000 - 0xFFFF */
1177 /* also includes 0x6000 - 0x7FFF (FDS only) */
1178 uint8_t* pStack; /* the stack (points to areas in pRAM) */
1179 /* 0x0100 - 0x01FF */
1180
1181 int32_t nROMSize; /* size of this ROM file in bytes */
1182 int32_t nROMBankCount; /* max number of 4k banks */
1183 int32_t nROMMaxSize; /* size of allocated pROM_Full buffer */
1184
1185 /*
1186 * Memory Proc Pointers
1187 */
1188
1189 typedef uint8_t ( *ReadProc)(uint16_t);
1190 typedef void ( *WriteProc)(uint16_t,uint8_t);
1191 ReadProc ReadMemory[0x10] IDATA_ATTR;
1192 WriteProc WriteMemory[0x10] IDATA_ATTR;
1193
1194 /*
1195 * 6502 Registers / Mode
1196 */
1197
1198 uint8_t regA IDATA_ATTR; /* Accumulator */
1199 uint8_t regX IDATA_ATTR; /* X-Index */
1200 uint8_t regY IDATA_ATTR; /* Y-Index */
1201 uint8_t regP IDATA_ATTR; /* Processor Status */
1202 uint8_t regSP IDATA_ATTR; /* Stack Pointer */
1203 uint16_t regPC IDATA_ATTR; /* Program Counter */
1204
1205 uint8_t bPALMode IDATA_ATTR;/* 1 if in PAL emulation mode, 0 if in NTSC */
1206 uint8_t bCPUJammed IDATA_ATTR; /* 0 = not jammed. 1 = really jammed.
1207 * 2 = 'fake' jammed */
1208 /* fake jam caused by the NSF code to signal
1209 * the end of the play/init routine */
1210
1211 /* Multiplication Register, for MMC5 chip only (5205+5206) */
1212 uint8_t nMultIn_Low;
1213 uint8_t nMultIn_High;
1214
1215 /*
1216 * NSF Preparation Information
1217 */
1218
1219 uint8_t nBankswitchInitValues[10]; /* banks to swap to on tune init */
1220 uint16_t nPlayAddress; /* Play routine address */
1221 uint16_t nInitAddress; /* Init routine address */
1222
1223 uint8_t nExternalSound; /* external sound chips */
1224 uint8_t nCurTrack;
1225
1226 float fNSFPlaybackSpeed;
1227
1228 /*
1229 * pAPU
1230 */
1231
1232 uint8_t nFrameCounter; /* Frame Sequence Counter */
1233 uint8_t nFrameCounterMax; /* Frame Sequence Counter Size
1234 (3 or 4 depending on $4017.7) */
1235 uint8_t bFrameIRQEnabled; /* TRUE if frame IRQs are enabled */
1236 uint8_t bFrameIRQPending; /* TRUE if the frame sequencer is holding down
1237 an IRQ */
1238
1239 uint8_t nFME07_Address;
1240
1241 /*
1242 * Timing and Counters
1243 */
1244 /* fixed point -15.16 */
1245
1246 int32_t nTicksUntilNextFrame;
1247 int32_t nTicksPerPlay;
1248 int32_t nTicksUntilNextPlay;
1249 int32_t nTicksPerSample;
1250 int32_t nTicksUntilNextSample;
1251
1252 uint32_t nCPUCycle IDATA_ATTR;
1253 uint32_t nAPUCycle IDATA_ATTR;
1254
1255
1256 uint32_t nTotalPlays; /* number of times the play subroutine has been called
1257 (for tracking output time) */
1258 /*
1259 * Silence Tracker
1260 */
1261 int32_t nSilentSamples;
1262 int32_t nSilentSampleMax;
1263 int32_t nSilenceTrackMS;
1264 uint8_t bNoSilenceIfTime;
1265 uint8_t bTimeNotDefault;
1266
1267 /*
1268 * Sound output options
1269 */
1270 const int32_t nSampleRate=44100;
1271
1272 /*
1273 * Volume/fading/filter tracking
1274 */
1275
1276 uint32_t nStartFade; /* play call to start fading out */
1277 uint32_t nEndFade; /* play call to stop fading out (song is over) */
1278 uint8_t bFade; /* are we fading? */
1279 float fFadeVolume;
1280 float fFadeChange;
1281
1282 /*
1283 * Designated Output Buffer
1284 */
1285 uint8_t* pOutput IDATA_ATTR;
1286
1287 const uint8_t bDMCPopReducer=1;
1288 uint8_t nDMCPop_Prev IDATA_ATTR = 0;
1289 uint8_t bDMCPop_Skip IDATA_ATTR = 0;
1290 uint8_t bDMCPop_SamePlay IDATA_ATTR = 0;
1291
1292 const uint8_t nForce4017Write=0;
1293 const uint8_t bN106PopReducer=0;
1294 const uint8_t bIgnore4011Writes=0;
1295
1296 const uint8_t bIgnoreBRK=0;
1297 const uint8_t bIgnoreIllegalOps=0;
1298 const uint8_t bNoWaitForReturn=0;
1299 const uint8_t bPALPreference=0;
1300 const uint8_t bCleanAXY=0;
1301 const uint8_t bResetDuty=0;
1302
1303 /*
1304 * Sound Filter
1305 */
1306
1307 int64_t nFilterAccL IDATA_ATTR;
1308 int64_t nHighPass IDATA_ATTR;
1309
1310 int32_t nHighPassBase IDATA_ATTR;
1311
1312 uint8_t bHighPassEnabled IDATA_ATTR;
1313
1314 /* end globals */
1315
1316 #define CLOCK_MAJOR() { Wave_Squares_ClockMajor(); Wave_TND_ClockMajor(); }
1317 #define CLOCK_MINOR() { Wave_Squares_ClockMinor(); Wave_TND_ClockMinor(); }
1318
1319 #define EXTSOUND_VRC6 0x01
1320 #define EXTSOUND_VRC7 0x02
1321 #define EXTSOUND_FDS 0x04
1322 #define EXTSOUND_MMC5 0x08
1323 #define EXTSOUND_N106 0x10
1324 #define EXTSOUND_FME07 0x20
1325
1326 #define SILENCE_THRESHOLD 3
1327
1328 /*
1329 * prototypes
1330 */
1331
1332 uint32_t Emulate6502(uint32_t runto) ICODE_ATTR;
1333 void EmulateAPU(uint8_t bBurnCPUCycles) ICODE_ATTR;
1334
1335 int NSFCore_Initialize(void); /* 1 = initialized ok,
1336 0 = couldn't initialize (memory allocation error) */
1337
1338 /*
1339 * Song Loading
1340 */
1341 int LoadNSF(int32_t); /* grab data from an existing file
1342 1 = loaded ok, 0 = error loading */
1343
1344 /*
1345 * Track Control
1346 */
1347 void SetTrack(uint8_t track); /* Change tracks */
1348
1349 /*
1350 * Getting Samples
1351 */
1352 /* fill a buffer with samples */
1353 int32_t GetSamples(uint8_t* buffer, int32_t buffersize);
1354
1355 /*
1356 * Playback options
1357 */
1358 /* Set desired playback options (0 = bad options couldn't be set) */
1359 int SetPlaybackOptions(int32_t samplerate);
1360 /* Speed throttling (0 = uses NSF specified speed) */
1361 void SetPlaybackSpeed(float playspersec);
1362
1363 float GetPlaybackSpeed(void);
1364 float GetMasterVolume(void);
1365
1366 /*
1367 * Seeking
1368 */
1369 /* gets the number of 'play' routine calls executed */
1370 float GetPlayCalls(void);
1371
1372 /* gets the output time (based on the given play rate,
1373 if basedplayspersec is zero, current playback speed is used */
1374 uint32_t GetWrittenTime(float basedplayspersec);
1375 /* sets the number of 'plays' routines executed (for precise seeking) */
1376 void SetPlayCalls(float plays);
1377 /* sets the written time (approx. seeking) */
1378 void SetWrittenTime(uint32_t ms,float basedplays);
1379
1380 /*
1381 * Fading
1382 */
1383
1384 void StopFade(void); /* stops all fading (plays indefinitely) */
1385 uint8_t SongCompleted(void); /* song has faded out (samples have stopped
1386 being generated) */
1387 /* parameters are play calls */
1388 void SetFade(int32_t fadestart,int32_t fadestop,uint8_t bNotDefault);
1389 void SetFadeTime(uint32_t fadestart,uint32_t fadestop,float basedplays,
1390 uint8_t bNotDefault); /* parameters are in milliseconds */
1391
1392 /*
1393 * Internal Functions
1394 */
1395 void RebuildOutputTables(void);
1396 void RecalculateFade(void); /* called when fade status is changed. */
1397 void RecalcFilter(void);
1398 void RecalcSilenceTracker(void);
1399
1400 void WriteMemory_VRC6(uint16_t a,uint8_t v) ICODE_ATTR;
1401 void WriteMemory_MMC5(uint16_t a,uint8_t v) ICODE_ATTR;
1402 void WriteMemory_N106(uint16_t a,uint8_t v) ICODE_ATTR;
1403 void WriteMemory_FME07(uint16_t a,uint8_t v) ICODE_ATTR;
1404
1405 /*
1406 * Memory Read/Write routines
1407 */
1408
1409 uint8_t ReadMemory_RAM(uint16_t a) ICODE_ATTR;
1410 uint8_t ReadMemory_ExRAM(uint16_t a) ICODE_ATTR;
1411 uint8_t ReadMemory_SRAM(uint16_t a) ICODE_ATTR;
1412 uint8_t ReadMemory_pAPU(uint16_t a) ICODE_ATTR;
1413 uint8_t ReadMemory_ROM(uint16_t a) ICODE_ATTR;
1414 uint8_t ReadMemory_Default(uint16_t a) ICODE_ATTR;
1415
1416 uint8_t ReadMemory_N106(uint16_t a) ICODE_ATTR;
1417
1418 void WriteMemory_RAM(uint16_t a,uint8_t v) ICODE_ATTR;
1419 void WriteMemory_ExRAM(uint16_t a,uint8_t v) ICODE_ATTR;
1420 void WriteMemory_SRAM(uint16_t a,uint8_t v) ICODE_ATTR;
1421 void WriteMemory_pAPU(uint16_t a,uint8_t v) ICODE_ATTR;
1422 void WriteMemory_FDSRAM(uint16_t a,uint8_t v) ICODE_ATTR;
1423 void WriteMemory_Default(uint16_t a,uint8_t v) ICODE_ATTR;
1424
1425 uint8_t ReadMemory_RAM(uint16_t a) { return pRAM[a & 0x07FF]; }
1426 uint8_t ReadMemory_ExRAM(uint16_t a) { return pExRAM[a & 0x0FFF]; }
1427 uint8_t ReadMemory_SRAM(uint16_t a) { return pSRAM[a & 0x1FFF]; }
1428 uint8_t ReadMemory_ROM(uint16_t a)
1429 { return pROM[(a >> 12) - 6][a & 0x0FFF]; }
1430 uint8_t ReadMemory_Default(uint16_t a) { return (a >> 8); }
1431
1432 void WriteMemory_RAM(uint16_t a,uint8_t v)
1433 { pRAM[a & 0x07FF] = v; }
1434 void WriteMemory_ExRAM(uint16_t a,uint8_t v);
1435 void WriteMemory_SRAM(uint16_t a,uint8_t v)
1436 { pSRAM[a & 0x1FFF] = v; }
1437 void WriteMemory_FDSRAM(uint16_t a,uint8_t v)
1438 { pROM[(a >> 12) - 6][a & 0x0FFF] = v; }
1439 void WriteMemory_Default(uint16_t a,uint8_t v) { (void)a; (void)v; }
1440
1441
1442 /* Read Memory Procs */
1443
1444 uint8_t ReadMemory_pAPU(uint16_t a)
1445 {
1446 EmulateAPU(1);
1447
1448 if(a == 0x4015)
1449 {
1450 uint8_t ret = 0;
1451 if(mWave_Squares.nLengthCount[0]) ret |= 0x01;
1452 if(mWave_Squares.nLengthCount[1]) ret |= 0x02;
1453 if(mWave_TND.nTriLengthCount) ret |= 0x04;
1454 if(mWave_TND.nNoiseLengthCount) ret |= 0x08;
1455 if(mWave_TND.nDMCBytesRemaining) ret |= 0x10;
1456
1457 if(bFrameIRQPending) ret |= 0x40;
1458 if(mWave_TND.bDMCIRQPending) ret |= 0x80;
1459
1460 bFrameIRQPending = 0;
1461 return ret;
1462 }
1463
1464 if(!(nExternalSound & EXTSOUND_FDS)) return 0x40;
1465 if(bPALMode) return 0x40;
1466
1467 if((a >= 0x4040) && (a <= 0x407F))
1468 return mWave_FDS.nWaveTable[a & 0x3F] | 0x40;
1469 if(a == 0x4090)
1470 return (mWave_FDS.nVolEnv_Gain & 0x3F) | 0x40;
1471 if(a == 0x4092)
1472 return (mWave_FDS.nSweep_Gain & 0x3F) | 0x40;
1473
1474 return 0x40;
1475 }
1476
1477 uint8_t ReadMemory_N106(uint16_t a)
1478 {
1479 if(a != 0x4800)
1480 return ReadMemory_pAPU(a);
1481
1482 uint8_t ret = mWave_N106.nRAM[(mWave_N106.nCurrentAddress << 1)] |
1483 (mWave_N106.nRAM[(mWave_N106.nCurrentAddress << 1) + 1] << 4);
1484 if(mWave_N106.bAutoIncrement)
1485 mWave_N106.nCurrentAddress = (mWave_N106.nCurrentAddress + 1) & 0x7F;
1486
1487 return ret;
1488 }
1489
1490
1491 /* Write Memory Procs */
1492
1493 void WriteMemory_ExRAM(uint16_t a,uint8_t v)
1494 {
1495 if(a < 0x5FF6) /* Invalid */
1496 return;
1497
1498 a -= 0x5FF6;
1499
1500 /* Swap out banks */
1501
1502 EmulateAPU(1);
1503 /* stop it from swapping to a bank that doesn't exist */
1504 if(v >= nROMBankCount)
1505 v = 0;
1506
1507 pROM[a] = pROM_Full + (v << 12);
1508
1509 /* Update the DMC's DMA pointer, as well */
1510 if(a >= 2)
1511 mWave_TND.pDMCDMAPtr[a - 2] = pROM[a];
1512 }
1513
1514 void WriteMemory_pAPU(uint16_t a,uint8_t v)
1515 {
1516 EmulateAPU(1);
1517 switch(a)
1518 {
1519 /* Square 1 */
1520 case 0x4000:
1521 mWave_Squares.nDutyCycle[0] = DUTY_CYCLE_TABLE[v >> 6];
1522 mWave_Squares.bLengthEnabled[0] =
1523 !(mWave_Squares.bDecayLoop[0] = (v & 0x20));
1524 mWave_Squares.bDecayEnable[0] = !(v & 0x10);
1525 mWave_Squares.nDecayTimer[0] = (v & 0x0F);
1526
1527 if(!mWave_Squares.bDecayEnable[0])
1528 mWave_Squares.nVolume[0] = mWave_Squares.nDecayTimer[0];
1529 break;
1530
1531 case 0x4001:
1532 mWave_Squares.bSweepEnable[0] = (v & 0x80);
1533 mWave_Squares.nSweepTimer[0] = (v & 0x70) >> 4;
1534 mWave_Squares.bSweepMode[0] = v & 0x08;
1535 mWave_Squares.nSweepShift[0] = v & 0x07;
1536 Wave_Squares_CheckSweepForcedSilence(0);
1537 break;
1538
1539 case 0x4002:
1540 mWave_Squares.nFreqTimer[0].B.l = v;
1541 Wave_Squares_CheckSweepForcedSilence(0);
1542 break;
1543
1544 case 0x4003:
1545 mWave_Squares.nFreqTimer[0].B.h = v & 0x07;
1546 Wave_Squares_CheckSweepForcedSilence(0);
1547
1548 mWave_Squares.nDecayVolume[0] = 0x0F;
1549
1550 if(mWave_Squares.bChannelEnabled[0])
1551 mWave_Squares.nLengthCount[0] = LENGTH_COUNTER_TABLE[v >> 3];
1552
1553 if(bResetDuty)
1554 mWave_Squares.nDutyCount[0] = 0;
1555 break;
1556
1557
1558 /* Square 2 */
1559 case 0x4004:
1560 mWave_Squares.nDutyCycle[1] = DUTY_CYCLE_TABLE[v >> 6];
1561 mWave_Squares.bLengthEnabled[1] =
1562 !(mWave_Squares.bDecayLoop[1] = (v & 0x20));
1563 mWave_Squares.bDecayEnable[1] = !(v & 0x10);
1564 mWave_Squares.nDecayTimer[1] = (v & 0x0F);
1565
1566 if(!mWave_Squares.bDecayEnable[1])
1567 mWave_Squares.nVolume[1] = mWave_Squares.nDecayTimer[1];
1568 break;
1569
1570 case 0x4005:
1571 mWave_Squares.bSweepEnable[1] = (v & 0x80);
1572 mWave_Squares.nSweepTimer[1] = (v & 0x70) >> 4;
1573 mWave_Squares.bSweepMode[1] = v & 0x08;
1574 mWave_Squares.nSweepShift[1] = v & 0x07;
1575 Wave_Squares_CheckSweepForcedSilence(1);
1576 break;
1577
1578 case 0x4006:
1579 mWave_Squares.nFreqTimer[1].B.l = v;
1580 Wave_Squares_CheckSweepForcedSilence(1);
1581 break;
1582
1583 case 0x4007:
1584 mWave_Squares.nFreqTimer[1].B.h = v & 0x07;
1585 Wave_Squares_CheckSweepForcedSilence(1);
1586
1587 mWave_Squares.nDecayVolume[1] = 0x0F;
1588
1589 if(mWave_Squares.bChannelEnabled[1])
1590 mWave_Squares.nLengthCount[1] = LENGTH_COUNTER_TABLE[v >> 3];
1591
1592 if(bResetDuty)
1593 mWave_Squares.nDutyCount[1] = 0;
1594 break;
1595
1596
1597 /* Triangle */
1598 case 0x4008:
1599 mWave_TND.nTriLinearLoad = v & 0x7F;
1600 mWave_TND.bTriLinearControl = v & 0x80;
1601 mWave_TND.bTriLengthEnabled = !(v & 0x80);
1602 break;
1603
1604 case 0x400A:
1605 mWave_TND.nTriFreqTimer.B.l = v;
1606 break;
1607
1608 case 0x400B:
1609 mWave_TND.nTriFreqTimer.B.h = v & 0x07;
1610 mWave_TND.bTriLinearHalt = 1;
1611
1612 if(mWave_TND.bTriChannelEnabled)
1613 mWave_TND.nTriLengthCount = LENGTH_COUNTER_TABLE[v >> 3];
1614 break;
1615
1616 /* Noise */
1617 case 0x400C:
1618 mWave_TND.bNoiseLengthEnabled =
1619 !(mWave_TND.bNoiseDecayLoop = (v & 0x20));
1620 mWave_TND.bNoiseDecayEnable = !(v & 0x10);
1621 mWave_TND.nNoiseDecayTimer = (v & 0x0F);
1622
1623 if(mWave_TND.bNoiseDecayEnable)
1624 mWave_TND.nNoiseVolume = mWave_TND.nNoiseDecayVolume;
1625 else
1626 mWave_TND.nNoiseVolume = mWave_TND.nNoiseDecayTimer;
1627 break;
1628
1629 case 0x400E:
1630 mWave_TND.nNoiseFreqTimer = NOISE_FREQ_TABLE[v & 0x0F];
1631 mWave_TND.bNoiseRandomMode = (v & 0x80) ? 6 : 1;
1632 break;
1633
1634 case 0x400F:
1635 if(mWave_TND.bNoiseChannelEnabled)
1636 mWave_TND.nNoiseLengthCount = LENGTH_COUNTER_TABLE[v >> 3];
1637
1638 mWave_TND.nNoiseDecayVolume = 0x0F;
1639 if(mWave_TND.bNoiseDecayEnable)
1640 mWave_TND.nNoiseVolume = 0x0F;
1641 break;
1642
1643 /* DMC */
1644 case 0x4010:
1645 mWave_TND.bDMCLoop = v & 0x40;
1646 mWave_TND.bDMCIRQEnabled = v & 0x80;
1647 /* IRQ can't be pending if disabled */
1648 if(!mWave_TND.bDMCIRQEnabled)
1649 mWave_TND.bDMCIRQPending = 0;
1650
1651 mWave_TND.nDMCFreqTimer = DMC_FREQ_TABLE[bPALMode][v & 0x0F];
1652 break;
1653
1654 case 0x4011:
1655 if(bIgnore4011Writes)
1656 break;
1657 v &= 0x7F;
1658 if(bDMCPopReducer)
1659 {
1660 if(bDMCPop_SamePlay)
1661 mWave_TND.nDMCOutput = v;
1662 else
1663 {
1664 if(bDMCPop_Skip)
1665 {
1666 bDMCPop_Skip = 0;
1667 break;
1668 }
1669 if(nDMCPop_Prev == v) break;
1670 if(mWave_TND.nDMCOutput == v) break;
1671 mWave_TND.nDMCOutput = nDMCPop_Prev;
1672 nDMCPop_Prev = v;
1673 bDMCPop_SamePlay = 1;
1674 }
1675 }
1676 else
1677 mWave_TND.nDMCOutput = v;
1678 break;
1679
1680 case 0x4012:
1681 mWave_TND.nDMCDMABank_Load = (v >> 6) | 0x04;
1682 mWave_TND.nDMCDMAAddr_Load = (v << 6) & 0x0FFF;
1683 break;
1684
1685 case 0x4013:
1686 mWave_TND.nDMCLength = (v << 4) + 1;
1687 break;
1688
1689 /* All / General Purpose */
1690 case 0x4015:
1691 mWave_TND.bDMCIRQPending = 0;
1692
1693 if(v & 0x01){ mWave_Squares.bChannelEnabled[0] = 1; }
1694 else { mWave_Squares.bChannelEnabled[0] =
1695 mWave_Squares.nLengthCount[0] = 0; }
1696 if(v & 0x02){ mWave_Squares.bChannelEnabled[1] = 1; }
1697 else { mWave_Squares.bChannelEnabled[1] =
1698 mWave_Squares.nLengthCount[1] = 0; }
1699 if(v & 0x04){ mWave_TND.bTriChannelEnabled = 1; }
1700 else { mWave_TND.bTriChannelEnabled =
1701 mWave_TND.nTriLengthCount = 0; }
1702 if(v & 0x08){ mWave_TND.bNoiseChannelEnabled = 1; }
1703 else { mWave_TND.bNoiseChannelEnabled =
1704 mWave_TND.nNoiseLengthCount = 0; }
1705
1706 if(v & 0x10)
1707 {
1708 if(!mWave_TND.nDMCBytesRemaining)
1709 {
1710 bDMCPop_Skip = 1;
1711 mWave_TND.nDMCDMAAddr = mWave_TND.nDMCDMAAddr_Load;
1712 mWave_TND.nDMCDMABank = mWave_TND.nDMCDMABank_Load;
1713 mWave_TND.nDMCBytesRemaining = mWave_TND.nDMCLength;
1714 mWave_TND.bDMCActive = 1;
1715 }
1716 }
1717 else
1718 mWave_TND.nDMCBytesRemaining = 0;
1719 break;
1720
1721 case 0x4017:
1722 bFrameIRQEnabled = !(v & 0x40);
1723 bFrameIRQPending = 0;
1724 nFrameCounter = 0;
1725 nFrameCounterMax = (v & 0x80) ? 4 : 3;
1726 nTicksUntilNextFrame =
1727 (bPALMode ? PAL_FRAME_COUNTER_FREQ : NTSC_FRAME_COUNTER_FREQ)
1728 * 0x10000;
1729
1730 CLOCK_MAJOR();
1731 if(v & 0x80) CLOCK_MINOR();
1732 break;
1733 }
1734
1735 if(!(nExternalSound & EXTSOUND_FDS)) return;
1736 if(bPALMode) return;
1737
1738 /* FDS Sound registers */
1739
1740 if(a < 0x4040) return;
1741
1742 /* wave table */
1743 if(a <= 0x407F)
1744 {
1745 if(mWave_FDS.bWaveWrite)
1746 mWave_FDS.nWaveTable[a - 0x4040] = v;
1747 }
1748 else
1749 {
1750 switch(a)
1751 {
1752 case 0x4080:
1753 mWave_FDS.nVolEnv_Mode = (v >> 6);
1754 if(v & 0x80)
1755 {
1756 mWave_FDS.nVolEnv_Gain = v & 0x3F;
1757 if(!mWave_FDS.nMainAddr)
1758 {
1759 if(mWave_FDS.nVolEnv_Gain < 0x20)
1760 mWave_FDS.nVolume = mWave_FDS.nVolEnv_Gain;
1761 else mWave_FDS.nVolume = 0x20;
1762 }
1763 }
1764 mWave_FDS.nVolEnv_Decay = v & 0x3F;
1765 mWave_FDS.nVolEnv_Timer =
1766 ((mWave_FDS.nVolEnv_Decay + 1) * mWave_FDS.nEnvelopeSpeed * 8);
1767
1768 mWave_FDS.bVolEnv_On = mWave_FDS.bEnvelopeEnable &&
1769 mWave_FDS.nEnvelopeSpeed && !(v & 0x80);
1770 break;
1771
1772 case 0x4082:
1773 mWave_FDS.nFreq.B.l = v;
1774 mWave_FDS.bMain_On = mWave_FDS.nFreq.W && mWave_FDS.bEnabled &&
1775 !mWave_FDS.bWaveWrite;
1776 break;
1777
1778 case 0x4083:
1779 mWave_FDS.bEnabled = !(v & 0x80);
1780 mWave_FDS.bEnvelopeEnable = !(v & 0x40);
1781 if(v & 0x80)
1782 {
1783 if(mWave_FDS.nVolEnv_Gain < 0x20)
1784 mWave_FDS.nVolume = mWave_FDS.nVolEnv_Gain;
1785 else mWave_FDS.nVolume = 0x20;
1786 }
1787 mWave_FDS.nFreq.B.h = v & 0x0F;
1788 mWave_FDS.bMain_On = mWave_FDS.nFreq.W && mWave_FDS.bEnabled &&
1789 !mWave_FDS.bWaveWrite;
1790
1791 mWave_FDS.bVolEnv_On = mWave_FDS.bEnvelopeEnable &&
1792 mWave_FDS.nEnvelopeSpeed && !(mWave_FDS.nVolEnv_Mode & 2);
1793 mWave_FDS.bSweepEnv_On = mWave_FDS.bEnvelopeEnable &&
1794 mWave_FDS.nEnvelopeSpeed && !(mWave_FDS.nSweep_Mode & 2);
1795 break;
1796
1797
1798 case 0x4084:
1799 mWave_FDS.nSweep_Mode = v >> 6;
1800 if(v & 0x80)
1801 mWave_FDS.nSweep_Gain = v & 0x3F;
1802 mWave_FDS.nSweep_Decay = v & 0x3F;
1803 mWave_FDS.nSweep_Timer =
1804 ((mWave_FDS.nSweep_Decay + 1) * mWave_FDS.nEnvelopeSpeed * 8);
1805 mWave_FDS.bSweepEnv_On =
1806 mWave_FDS.bEnvelopeEnable && mWave_FDS.nEnvelopeSpeed &&
1807 !(v & 0x80);
1808 break;
1809
1810
1811 case 0x4085:
1812 if(v & 0x40) mWave_FDS.nSweepBias = (v & 0x3F) - 0x40;
1813 else mWave_FDS.nSweepBias = v & 0x3F;
1814 mWave_FDS.nLFO_Addr = 0;
1815 break;
1816
1817
1818 case 0x4086:
1819 mWave_FDS.nLFO_Freq.B.l = v;
1820 mWave_FDS.bLFO_On =
1821 mWave_FDS.bLFO_Enabled && mWave_FDS.nLFO_Freq.W;
1822 if(mWave_FDS.nLFO_Freq.W)
1823 mWave_FDS.nLFO_Timer = (0x10000<<14) / mWave_FDS.nLFO_Freq.W;
1824 break;
1825
1826 case 0x4087:
1827 mWave_FDS.bLFO_Enabled = !(v & 0x80);
1828 mWave_FDS.nLFO_Freq.B.h = v & 0x0F;
1829 mWave_FDS.bLFO_On =
1830 mWave_FDS.bLFO_Enabled && mWave_FDS.nLFO_Freq.W;
1831 if(mWave_FDS.nLFO_Freq.W)
1832 mWave_FDS.nLFO_Timer = (0x10000<<14) / mWave_FDS.nLFO_Freq.W;
1833 break;
1834
1835 case 0x4088:
1836 if(mWave_FDS.bLFO_Enabled) break;
1837 register int32_t i;
1838 for(i = 0; i < 62; i++)
1839 mWave_FDS.nLFO_Table[i] = mWave_FDS.nLFO_Table[i + 2];
1840 mWave_FDS.nLFO_Table[62] = mWave_FDS.nLFO_Table[63] = v & 7;
1841 break;
1842
1843 case 0x4089:
1844 mWave_FDS.nMainVolume = v & 3;
1845 mWave_FDS.bWaveWrite = v & 0x80;
1846 mWave_FDS.bMain_On = mWave_FDS.nFreq.W && mWave_FDS.bEnabled &&
1847 !mWave_FDS.bWaveWrite;
1848 break;
1849
1850 case 0x408A:
1851 mWave_FDS.nEnvelopeSpeed = v;
1852 mWave_FDS.bVolEnv_On =
1853 mWave_FDS.bEnvelopeEnable &&
1854 mWave_FDS.nEnvelopeSpeed && !(mWave_FDS.nVolEnv_Mode & 2);
1855 mWave_FDS.bSweepEnv_On =
1856 mWave_FDS.bEnvelopeEnable &&
1857 mWave_FDS.nEnvelopeSpeed && !(mWave_FDS.nSweep_Mode & 2);
1858 break;
1859 }
1860 }
1861 }
1862
1863 void WriteMemory_VRC6(uint16_t a,uint8_t v)
1864 {
1865 EmulateAPU(1);
1866
1867 if((a < 0xA000) && (nExternalSound & EXTSOUND_VRC7)) return;
1868 else if(nExternalSound & EXTSOUND_FDS)
1869 WriteMemory_FDSRAM(a,v);
1870
1871 switch(a)
1872 {
1873 /* Pulse 1 */
1874 case 0x9000:
1875 mWave_VRC6Pulse[0].nVolume = v & 0x0F;
1876 mWave_VRC6Pulse[0].nDutyCycle = (v >> 4) & 0x07;
1877 mWave_VRC6Pulse[0].bDigitized = v & 0x80;
1878 if(mWave_VRC6Pulse[0].bDigitized)
1879 mWave_VRC6Pulse[0].nDutyCount = 0;
1880 break;
1881
1882 case 0x9001:
1883 mWave_VRC6Pulse[0].nFreqTimer.B.l = v;
1884 break;
1885
1886 case 0x9002:
1887 mWave_VRC6Pulse[0].nFreqTimer.B.h = v & 0x0F;
1888 mWave_VRC6Pulse[0].bChannelEnabled = v & 0x80;
1889 break;
1890
1891
1892 /* Pulse 2 */
1893 case 0xA000:
1894 mWave_VRC6Pulse[1].nVolume = v & 0x0F;
1895 mWave_VRC6Pulse[1].nDutyCycle = (v >> 4) & 0x07;
1896 mWave_VRC6Pulse[1].bDigitized = v & 0x80;
1897 if(mWave_VRC6Pulse[1].bDigitized)
1898 mWave_VRC6Pulse[1].nDutyCount = 0;
1899 break;
1900
1901 case 0xA001:
1902 mWave_VRC6Pulse[1].nFreqTimer.B.l = v;
1903 break;
1904
1905 case 0xA002:
1906 mWave_VRC6Pulse[1].nFreqTimer.B.h = v & 0x0F;
1907 mWave_VRC6Pulse[1].bChannelEnabled = v & 0x80;
1908 break;
1909
1910 /* Sawtooth */
1911 case 0xB000:
1912 mWave_VRC6Saw.nAccumRate = (v & 0x3F);
1913 break;
1914
1915 case 0xB001:
1916 mWave_VRC6Saw.nFreqTimer.B.l = v;
1917 break;
1918
1919 case 0xB002:
1920 mWave_VRC6Saw.nFreqTimer.B.h = v & 0x0F;
1921 mWave_VRC6Saw.bChannelEnabled = v & 0x80;
1922 break;
1923 }
1924 }
1925
1926 void WriteMemory_MMC5(uint16_t a,uint8_t v)
1927 {
1928 if((a <= 0x5015) && !bPALMode)
1929 {
1930 /* no audio emulation */
1931 return;
1932 }
1933
1934 if(a == 0x5205)
1935 {
1936 nMultIn_Low = v;
1937 goto multiply;
1938 }
1939 if(a == 0x5206)
1940 {
1941 nMultIn_High = v;
1942 multiply:
1943 a = nMultIn_Low * nMultIn_High;
1944 pExRAM[0x205] = a & 0xFF;
1945 pExRAM[0x206] = a >> 8;
1946 return;
1947 }
1948
1949 if(a < 0x5C00) return;
1950
1951 pExRAM[a & 0x0FFF] = v;
1952 if(a >= 0x5FF6)
1953 WriteMemory_ExRAM(a,v);
1954 }
1955
1956 void WriteMemory_N106(uint16_t a,uint8_t v)
1957 {
1958 if(a < 0x4800)
1959 {
1960 WriteMemory_pAPU(a,v);
1961 return;
1962 }
1963
1964 if(a == 0xF800)
1965 {
1966 mWave_N106.nCurrentAddress = v & 0x7F;
1967 mWave_N106.bAutoIncrement = (v & 0x80);
1968 return;
1969 }
1970
1971 if(a == 0x4800)
1972 {
1973 EmulateAPU(1);
1974 mWave_N106.nRAM[mWave_N106.nCurrentAddress << 1] = v & 0x0F;
1975 mWave_N106.nRAM[(mWave_N106.nCurrentAddress << 1) + 1] = v >> 4;
1976 a = mWave_N106.nCurrentAddress;
1977 if(mWave_N106.bAutoIncrement)
1978 mWave_N106.nCurrentAddress =
1979 (mWave_N106.nCurrentAddress + 1) & 0x7F;
1980
1981 #define N106REGWRITE(ch,r0,r1,r2,r3,r4) \
1982 case r0: if(mWave_N106.nFreqReg[ch].B.l == v) break; \
1983 mWave_N106.nFreqReg[ch].B.l = v; \
1984 mWave_N106.nFreqTimer[ch] = -1; \
1985 break; \
1986 case r1: if(mWave_N106.nFreqReg[ch].B.h == v) break; \
1987 mWave_N106.nFreqReg[ch].B.h = v; \
1988 mWave_N106.nFreqTimer[ch] = -1; \
1989 break; \
1990 case r2: if(mWave_N106.nFreqReg[ch].B.w != (v & 3)){ \
1991 mWave_N106.nFreqReg[ch].B.w = v & 0x03; \
1992 mWave_N106.nFreqTimer[ch] = -1;} \
1993 mWave_N106.nWaveSize[ch] = 0x20 - (v & 0x1C); \
1994 break; \
1995 case r3: mWave_N106.nWavePosStart[ch] = v; \
1996 break; \
1997 case r4: mWave_N106.nPreVolume[ch] = v & 0x0F; \
1998 if(!bN106PopReducer) \
1999 mWave_N106.nVolume[ch] = v & 0x0F
2000
2001 switch(a)
2002 {
2003 N106REGWRITE(0,0x40,0x42,0x44,0x46,0x47); break;
2004 N106REGWRITE(1,0x48,0x4A,0x4C,0x4E,0x4F); break;
2005 N106REGWRITE(2,0x50,0x52,0x54,0x56,0x57); break;
2006 N106REGWRITE(3,0x58,0x5A,0x5C,0x5E,0x5F); break;
2007 N106REGWRITE(4,0x60,0x62,0x64,0x66,0x67); break;
2008 N106REGWRITE(5,0x68,0x6A,0x6C,0x6E,0x6F); break;
2009 N106REGWRITE(6,0x70,0x72,0x74,0x76,0x77); break;
2010 N106REGWRITE(7,0x78,0x7A,0x7C,0x7E,0x7F);
2011 v = (v >> 4) & 7;
2012 if(mWave_N106.nActiveChannels == v) break;
2013 mWave_N106.nActiveChannels = v;
2014 mWave_N106.nFreqTimer[0] = -1;
2015 mWave_N106.nFreqTimer[1] = -1;
2016 mWave_N106.nFreqTimer[2] = -1;
2017 mWave_N106.nFreqTimer[3] = -1;
2018 mWave_N106.nFreqTimer[4] = -1;
2019 mWave_N106.nFreqTimer[5] = -1;
2020 mWave_N106.nFreqTimer[6] = -1;
2021 mWave_N106.nFreqTimer[7] = -1;
2022 break;
2023 }
2024 #undef N106REGWRITE
2025 }
2026 }
2027
2028 void WriteMemory_FME07(uint16_t a,uint8_t v)
2029 {
2030 if((a < 0xD000) && (nExternalSound & EXTSOUND_FDS))
2031 WriteMemory_FDSRAM(a,v);
2032
2033 if(a == 0xC000)
2034 nFME07_Address = v;
2035 if(a == 0xE000)
2036 {
2037 switch(nFME07_Address)
2038 {
2039 case 0x00: mWave_FME07[0].nFreqTimer.B.l = v; break;
2040 case 0x01: mWave_FME07[0].nFreqTimer.B.h = v & 0x0F; break;
2041 case 0x02: mWave_FME07[1].nFreqTimer.B.l = v; break;
2042 case 0x03: mWave_FME07[1].nFreqTimer.B.h = v & 0x0F; break;
2043 case 0x04: mWave_FME07[2].nFreqTimer.B.l = v; break;
2044 case 0x05: mWave_FME07[2].nFreqTimer.B.h = v & 0x0F; break;
2045 case 0x07:
2046 mWave_FME07[0].bChannelEnabled = !(v & 0x01);
2047 mWave_FME07[1].bChannelEnabled = !(v & 0x02);
2048 mWave_FME07[2].bChannelEnabled = !(v & 0x03);
2049 break;
2050 case 0x08: mWave_FME07[0].nVolume = v & 0x0F; break;
2051 case 0x09: mWave_FME07[1].nVolume = v & 0x0F; break;
2052 case 0x0A: mWave_FME07[2].nVolume = v & 0x0F; break;
2053 }
2054 }
2055 }
2056
2057 /*
2058 * Emulate APU
2059 */
2060
2061 int32_t fulltick;
2062 void EmulateAPU(uint8_t bBurnCPUCycles)
2063 {
2064 int32_t tick;
2065 int64_t diff;
2066
2067 int32_t tnd_out;
2068 int square_out1;
2069 int square_out2;
2070
2071 ENTER_TIMER(apu);
2072
2073 fulltick += (signed)(nCPUCycle - nAPUCycle);
2074
2075 int32_t burned;
2076 int32_t mixL;
2077
2078 if(bFade && nSilentSampleMax && (nSilentSamples >= nSilentSampleMax))
2079 fulltick = 0;
2080
2081 while(fulltick>0)
2082 {
2083 tick = (nTicksUntilNextSample+0xffff)>>16;
2084
2085 fulltick -= tick;
2086
2087 /*
2088 * Sample Generation
2089 */
2090
2091 ENTER_TIMER(squares);
2092 /* Square generation */
2093
2094 mWave_Squares.nFreqCount[0] -= tick;
2095 mWave_Squares.nFreqCount[1] -= tick;
2096
2097 if((mWave_Squares.nDutyCount[0] < mWave_Squares.nDutyCycle[0]) &&
2098 mWave_Squares.nLengthCount[0] &&
2099 !mWave_Squares.bSweepForceSilence[0])
2100 square_out1 = mWave_Squares.nVolume[0];
2101 else
2102 square_out1 = 0;
2103
2104 if((mWave_Squares.nDutyCount[1] < mWave_Squares.nDutyCycle[1]) &&
2105 mWave_Squares.nLengthCount[1] &&
2106 !mWave_Squares.bSweepForceSilence[1])
2107 square_out2 = mWave_Squares.nVolume[1];
2108 else
2109 square_out2 = 0;
2110
2111 mWave_Squares.nMixL = Squares_nOutputTable_L[square_out1][square_out2];
2112
2113 if(mWave_Squares.nFreqCount[0]<=0)
2114 {
2115 int cycles =
2116 (-mWave_Squares.nFreqCount[0])/
2117 (mWave_Squares.nFreqTimer[0].W + 1) + 1;
2118 mWave_Squares.nFreqCount[0] =
2119 (mWave_Squares.nFreqTimer[0].W + 1)-
2120 (-mWave_Squares.nFreqCount[0])%
2121 (mWave_Squares.nFreqTimer[0].W + 1);
2122 mWave_Squares.nDutyCount[0] =
2123 (mWave_Squares.nDutyCount[0]+cycles)%0x10;
2124 }
2125 if(mWave_Squares.nFreqCount[1]<=0)
2126 {
2127 int cycles =
2128 (-mWave_Squares.nFreqCount[1])/
2129 (mWave_Squares.nFreqTimer[1].W + 1) + 1;
2130 mWave_Squares.nFreqCount[1] =
2131 (mWave_Squares.nFreqTimer[1].W + 1)-
2132 (-mWave_Squares.nFreqCount[1])%
2133 (mWave_Squares.nFreqTimer[1].W + 1);
2134 mWave_Squares.nDutyCount[1] = (mWave_Squares.nDutyCount[1]+cycles)%
2135 0x10;
2136 }
2137 /* end of Square generation */
2138 EXIT_TIMER(squares);
2139 ENTER_TIMER(tnd);
2140
2141 ENTER_TIMER(tnd_enter);
2142
2143 burned=0;
2144
2145 /* TND generation */
2146
2147 if(mWave_TND.nNoiseFreqTimer) mWave_TND.nNoiseFreqCount -= tick;
2148
2149 if(mWave_TND.nTriFreqTimer.W > 8)
2150 mWave_TND.nTriFreqCount -= tick;
2151
2152 tnd_out = mWave_TND.nTriOutput << 11;
2153
2154 if(mWave_TND.bNoiseRandomOut && mWave_TND.nNoiseLengthCount)
2155 tnd_out |= mWave_TND.nNoiseVolume << 7;
2156
2157 tnd_out |= mWave_TND.nDMCOutput;
2158
2159 mWave_TND.nMixL = main_nOutputTable_L[tnd_out];
2160
2161 EXIT_TIMER(tnd_enter);
2162
2163 ENTER_TIMER(tnd_tri);
2164
2165 /* Tri */
2166
2167 if(mWave_TND.nTriFreqCount<=0)
2168 {
2169 if(mWave_TND.nTriLengthCount && mWave_TND.nTriLinearCount)
2170 {
2171 do mWave_TND.nTriStep++;
2172 while ((mWave_TND.nTriFreqCount +=
2173 mWave_TND.nTriFreqTimer.W + 1) <= 0);
2174 mWave_TND.nTriStep &= 0x1F;
2175
2176 if(mWave_TND.nTriStep & 0x10)
2177 mWave_TND.nTriOutput = mWave_TND.nTriStep ^ 0x1F;
2178 else mWave_TND.nTriOutput = mWave_TND.nTriStep;
2179 } else mWave_TND.nTriFreqCount=mWave_TND.nTriFreqTimer.W+1;
2180 }
2181
2182 EXIT_TIMER(tnd_tri);
2183
2184 ENTER_TIMER(tnd_noise);
2185
2186 /* Noise */
2187
2188 if(mWave_TND.nNoiseFreqTimer &&
2189 mWave_TND.nNoiseVolume && mWave_TND.nNoiseFreqCount<=0)
2190 {
2191 mWave_TND.nNoiseFreqCount = mWave_TND.nNoiseFreqTimer;
2192 mWave_TND.nNoiseRandomShift <<= 1;
2193 mWave_TND.bNoiseRandomOut = (((mWave_TND.nNoiseRandomShift <<
2194 mWave_TND.bNoiseRandomMode) ^
2195 mWave_TND.nNoiseRandomShift) & 0x8000 ) ? 1 : 0;
2196 if(mWave_TND.bNoiseRandomOut)
2197 mWave_TND.nNoiseRandomShift |= 0x01;
2198 }
2199
2200 EXIT_TIMER(tnd_noise);
2201
2202 ENTER_TIMER(tnd_dmc);
2203
2204 /* DMC */
2205 if(mWave_TND.bDMCActive)
2206 {
2207 mWave_TND.nDMCFreqCount -= tick;
2208 while (mWave_TND.nDMCFreqCount <= 0) {
2209 if (!mWave_TND.bDMCActive) {
2210 mWave_TND.nDMCFreqCount = mWave_TND.nDMCFreqTimer;
2211 break;
2212 }
2213
2214 mWave_TND.nDMCFreqCount += mWave_TND.nDMCFreqTimer;
2215
2216 if(mWave_TND.bDMCSampleBufferEmpty &&
2217 mWave_TND.nDMCBytesRemaining)
2218 {
2219 burned += 4; /* 4 cycle burn! */
2220 mWave_TND.nDMCSampleBuffer =
2221 mWave_TND.pDMCDMAPtr[mWave_TND.nDMCDMABank]
2222 [mWave_TND.nDMCDMAAddr];
2223 mWave_TND.nDMCDMAAddr++;
2224 if(mWave_TND.nDMCDMAAddr & 0x1000)
2225 {
2226 mWave_TND.nDMCDMAAddr &= 0x0FFF;
2227 mWave_TND.nDMCDMABank =
2228 (mWave_TND.nDMCDMABank + 1) & 0x07;
2229 }
2230
2231 mWave_TND.bDMCSampleBufferEmpty = 0;
2232 mWave_TND.nDMCBytesRemaining--;
2233 if(!mWave_TND.nDMCBytesRemaining)
2234 {
2235 if(mWave_TND.bDMCLoop)
2236 {
2237 mWave_TND.nDMCDMABank = mWave_TND.nDMCDMABank_Load;
2238 mWave_TND.nDMCDMAAddr = mWave_TND.nDMCDMAAddr_Load;
2239 mWave_TND.nDMCBytesRemaining =mWave_TND.nDMCLength;
2240 }
2241 else if(mWave_TND.bDMCIRQEnabled)
2242 mWave_TND.bDMCIRQPending = 1;
2243 }
2244 }
2245
2246 if(!mWave_TND.nDMCDeltaBit)
2247 {
2248 mWave_TND.nDMCDeltaBit = 8;
2249 mWave_TND.bDMCDeltaSilent =mWave_TND.bDMCSampleBufferEmpty;
2250 mWave_TND.nDMCDelta = mWave_TND.nDMCSampleBuffer;
2251 mWave_TND.bDMCSampleBufferEmpty = 1;
2252 }
2253
2254 if(mWave_TND.nDMCDeltaBit) {
2255 mWave_TND.nDMCDeltaBit--;
2256 if(!mWave_TND.bDMCDeltaSilent)
2257 {
2258 if(mWave_TND.nDMCDelta & 0x01)
2259 {
2260 if(mWave_TND.nDMCOutput < 0x7E)
2261 mWave_TND.nDMCOutput += 2;
2262 }
2263 else if(mWave_TND.nDMCOutput > 1)
2264 mWave_TND.nDMCOutput -= 2;
2265 }
2266 mWave_TND.nDMCDelta >>= 1;
2267 }
2268
2269 if(!mWave_TND.nDMCBytesRemaining &&
2270 mWave_TND.bDMCSampleBufferEmpty &&
2271 mWave_TND.bDMCDeltaSilent)
2272 mWave_TND.bDMCActive = mWave_TND.nDMCDeltaBit = 0;
2273 }
2274 }
2275
2276 EXIT_TIMER(tnd_dmc);
2277
2278 /* end of TND generation */
2279 EXIT_TIMER(tnd);
2280
2281 if(nExternalSound && !bPALMode)
2282 {
2283 if(nExternalSound & EXTSOUND_VRC6)
2284 Wave_VRC6_DoTicks(tick);
2285 if(nExternalSound & EXTSOUND_N106)
2286 Wave_N106_DoTicks(tick);
2287 if(nExternalSound & EXTSOUND_FME07)
2288 {
2289 if (mWave_FME07[0].bChannelEnabled &&
2290 mWave_FME07[0].nFreqTimer.W) {
2291 mWave_FME07[0].nFreqCount -= tick;
2292
2293 if(mWave_FME07[0].nDutyCount < 16)
2294 {
2295 mWave_FME07[0].nMixL =
2296 FME07_nOutputTable_L[mWave_FME07[0].nVolume];
2297 } else mWave_FME07[0].nMixL = 0;
2298 while(mWave_FME07[0].nFreqCount <= 0) {
2299 mWave_FME07[0].nFreqCount +=
2300 mWave_FME07[0].nFreqTimer.W;
2301
2302 mWave_FME07[0].nDutyCount=
2303 (mWave_FME07[0].nDutyCount+1)&0x1f;
2304 }
2305 }
2306
2307 if (mWave_FME07[1].bChannelEnabled &&
2308 mWave_FME07[1].nFreqTimer.W) {
2309 mWave_FME07[1].nFreqCount -= tick;
2310
2311 if(mWave_FME07[1].nDutyCount < 16)
2312 {
2313 mWave_FME07[1].nMixL =
2314 FME07_nOutputTable_L[mWave_FME07[1].nVolume];
2315 } else mWave_FME07[1].nMixL = 0;
2316 while(mWave_FME07[1].nFreqCount <= 0) {
2317 mWave_FME07[1].nFreqCount +=
2318 mWave_FME07[1].nFreqTimer.W;
2319
2320 mWave_FME07[1].nDutyCount=
2321 (mWave_FME07[1].nDutyCount+1)&0x1f;
2322 }
2323 }
2324
2325 if (mWave_FME07[2].bChannelEnabled &&
2326 mWave_FME07[2].nFreqTimer.W) {
2327 mWave_FME07[2].nFreqCount -= tick;
2328
2329 if(mWave_FME07[2].nDutyCount < 16)
2330 {
2331 mWave_FME07[2].nMixL =
2332 FME07_nOutputTable_L[mWave_FME07[2].nVolume];
2333 } else mWave_FME07[2].nMixL = 0;
2334 while(mWave_FME07[2].nFreqCount <= 0) {
2335 mWave_FME07[2].nFreqCount +=
2336 mWave_FME07[2].nFreqTimer.W;
2337
2338 mWave_FME07[2].nDutyCount=
2339 (mWave_FME07[2].nDutyCount+1)&0x1f;
2340 }
2341 }
2342
2343 } /* end FME07 */
2344 ENTER_TIMER(fds);
2345 if(nExternalSound & EXTSOUND_FDS) {
2346
2347 /* Volume Envelope Unit */
2348 if(mWave_FDS.bVolEnv_On)
2349 {
2350 mWave_FDS.nVolEnv_Count -= tick;
2351 while(mWave_FDS.nVolEnv_Count <= 0)
2352 {
2353 mWave_FDS.nVolEnv_Count += mWave_FDS.nVolEnv_Timer;
2354 if(mWave_FDS.nVolEnv_Mode) {
2355 if(mWave_FDS.nVolEnv_Gain < 0x20)
2356 mWave_FDS.nVolEnv_Gain++;
2357 }
2358 else {
2359 if(mWave_FDS.nVolEnv_Gain)
2360 mWave_FDS.nVolEnv_Gain--;
2361 }
2362 }
2363 }
2364
2365 /* Sweep Envelope Unit */
2366 if(mWave_FDS.bSweepEnv_On)
2367 {
2368 mWave_FDS.nSweep_Count -= tick;
2369 while(mWave_FDS.nSweep_Count <= 0)
2370 {
2371 mWave_FDS.nSweep_Count += mWave_FDS.nSweep_Timer;
2372 if(mWave_FDS.nSweep_Mode) {
2373 if(mWave_FDS.nSweep_Gain < 0x20)
2374 mWave_FDS.nSweep_Gain++;
2375 } else {
2376 if(mWave_FDS.nSweep_Gain) mWave_FDS.nSweep_Gain--;
2377 }
2378 }
2379 }
2380
2381 /* Effector / LFO */
2382 int32_t subfreq = 0;
2383 if(mWave_FDS.bLFO_On)
2384 {
2385 mWave_FDS.nLFO_Count -= tick<<14;
2386 while(mWave_FDS.nLFO_Count <= 0)
2387 {
2388 mWave_FDS.nLFO_Count += mWave_FDS.nLFO_Timer;
2389 if(mWave_FDS.nLFO_Table[mWave_FDS.nLFO_Addr] == 4)
2390 mWave_FDS.nSweepBias = 0;
2391 else
2392 mWave_FDS.nSweepBias +=
2393 ModulationTable[
2394 mWave_FDS.nLFO_Table[mWave_FDS.nLFO_Addr]
2395 ];
2396 mWave_FDS.nLFO_Addr = (mWave_FDS.nLFO_Addr + 1) & 0x3F;
2397 }
2398
2399 while(mWave_FDS.nSweepBias > 63)
2400 mWave_FDS.nSweepBias -= 128;
2401 while(mWave_FDS.nSweepBias < -64)
2402 mWave_FDS.nSweepBias += 128;
2403
2404 register int32_t temp =
2405 mWave_FDS.nSweepBias * mWave_FDS.nSweep_Gain;
2406 if(temp & 0x0F)
2407 {
2408 temp /= 16;
2409 if(mWave_FDS.nSweepBias < 0) temp--;
2410 else temp += 2;
2411 }
2412 else
2413 temp /= 16;
2414
2415 if(temp > 193) temp -= 258;
2416 if(temp < -64) temp += 256;
2417
2418 subfreq = mWave_FDS.nFreq.W * temp / 64;
2419 }
2420
2421 /* Main Unit */
2422 if(mWave_FDS.bMain_On)
2423 {
2424 mWave_FDS.nMixL =
2425 FDS_nOutputTable_L[mWave_FDS.nMainVolume]
2426 [mWave_FDS.nVolume]
2427 [mWave_FDS.nWaveTable[mWave_FDS.nMainAddr] ];
2428
2429 if((subfreq + mWave_FDS.nFreq.W) > 0)
2430 {
2431 int32_t freq = (0x10000<<14) / (subfreq + mWave_FDS.nFreq.W);
2432
2433 mWave_FDS.nFreqCount -= tick<<14;
2434 while(mWave_FDS.nFreqCount <= 0)
2435 {
2436 mWave_FDS.nFreqCount += freq;
2437
2438 mWave_FDS.nMainAddr =
2439 (mWave_FDS.nMainAddr + 1) & 0x3F;
2440 mWave_FDS.nPopOutput =
2441 mWave_FDS.nWaveTable[mWave_FDS.nMainAddr];
2442 if(!mWave_FDS.nMainAddr)
2443 {
2444 if(mWave_FDS.nVolEnv_Gain < 0x20)
2445 mWave_FDS.nVolume = mWave_FDS.nVolEnv_Gain;
2446 else mWave_FDS.nVolume = 0x20;
2447 }
2448 }
2449 }
2450 else
2451 mWave_FDS.nFreqCount = mWave_FDS.nLFO_Count;
2452 }
2453 else if(mWave_FDS.bPopReducer && mWave_FDS.nPopOutput)
2454 {
2455 mWave_FDS.nMixL = FDS_nOutputTable_L[mWave_FDS.nMainVolume]
2456 [mWave_FDS.nVolume]
2457 [mWave_FDS.nPopOutput];
2458
2459 mWave_FDS.nPopCount -= tick;
2460 while(mWave_FDS.nPopCount <= 0)
2461 {
2462 mWave_FDS.nPopCount += 500;
2463 mWave_FDS.nPopOutput--;
2464 if(!mWave_FDS.nPopOutput)
2465 mWave_FDS.nMainAddr = 0;
2466 }
2467 } /* end FDS */
2468 }
2469 EXIT_TIMER(fds);
2470 } /* end while fulltick */
2471
2472 if(bBurnCPUCycles)
2473 {
2474 nCPUCycle += burned;
2475 fulltick += burned;
2476 }
2477
2478 /* Frame Sequencer */
2479
2480 ENTER_TIMER(frame);
2481 nTicksUntilNextFrame -= tick<<16;
2482 while(nTicksUntilNextFrame <= 0)
2483 {
2484 nTicksUntilNextFrame +=
2485 (bPALMode ? PAL_FRAME_COUNTER_FREQ : NTSC_FRAME_COUNTER_FREQ) *
2486 0x10000;
2487 nFrameCounter++;
2488 if(nFrameCounter > nFrameCounterMax)
2489 nFrameCounter = 0;
2490
2491 if(nFrameCounterMax == 4)
2492 {
2493 if(nFrameCounter < 4)
2494 {
2495 CLOCK_MAJOR();
2496 if(!(nFrameCounter & 1))
2497 CLOCK_MINOR();
2498 }
2499 }
2500 else
2501 {
2502 CLOCK_MAJOR();
2503 if(nFrameCounter & 1)
2504 CLOCK_MINOR();
2505
2506 if((nFrameCounter == 3) && bFrameIRQEnabled)
2507 bFrameIRQPending = 1;
2508 }
2509 }
2510 EXIT_TIMER(frame);
2511
2512 ENTER_TIMER(mix);
2513 nTicksUntilNextSample -= tick<<16;
2514 if(nTicksUntilNextSample <= 0)
2515 {
2516 nTicksUntilNextSample += nTicksPerSample;
2517
2518 mixL = mWave_Squares.nMixL;
2519 mixL += mWave_TND.nMixL;
2520
2521 if(nExternalSound && !bPALMode)
2522 {
2523 if(nExternalSound & EXTSOUND_VRC6)
2524 {
2525 mixL += (mWave_VRC6Pulse[0].nMixL);
2526 mixL += (mWave_VRC6Pulse[1].nMixL);
2527 mixL += (mWave_VRC6Saw.nMixL);
2528 }
2529 if(nExternalSound & EXTSOUND_N106) {
2530 mixL += (mWave_N106.nMixL[0]);
2531 mixL += (mWave_N106.nMixL[1]);
2532 mixL += (mWave_N106.nMixL[2]);
2533 mixL += (mWave_N106.nMixL[3]);
2534 mixL += (mWave_N106.nMixL[4]);
2535 mixL += (mWave_N106.nMixL[5]);
2536 mixL += (mWave_N106.nMixL[6]);
2537 mixL += (mWave_N106.nMixL[7]);
2538 }
2539 if(nExternalSound & EXTSOUND_FME07)
2540 {
2541 mixL += (mWave_FME07[0].nMixL);
2542 mixL += (mWave_FME07[1].nMixL);
2543 mixL += (mWave_FME07[2].nMixL);
2544 }
2545 if(nExternalSound & EXTSOUND_FDS)
2546 mixL += mWave_FDS.nMixL;
2547 }
2548
2549 /* Filter */
2550 diff = ((int64_t)mixL << 25) - nFilterAccL;
2551 nFilterAccL += (diff * nHighPass) >> 16;
2552 mixL = (int32_t)(diff >> 23);
2553 /* End Filter */
2554
2555 if(bFade && (fFadeVolume < 1))
2556 mixL = (int32_t)(mixL * fFadeVolume);
2557
2558 if(mixL < -32768) mixL = -32768;
2559 if(mixL > 32767) mixL = 32767;
2560
2561 *((uint16_t*)pOutput) = (uint16_t)mixL;
2562 pOutput += 2;
2563 }
2564
2565 }
2566 EXIT_TIMER(mix);
2567
2568 nAPUCycle = nCPUCycle;
2569
2570 EXIT_TIMER(apu);
2571 }
2572
2573
2574 /*
2575 * Initialize
2576 *
2577 * Initializes Memory
2578 */
2579
2580 int NSFCore_Initialize()
2581 {
2582 int32_t i;
2583 /* clear globals */
2584 /* why, yes, this was easier when they were in a struct */
2585
2586 /*
2587 * Memory
2588 */
2589
2590 ZEROMEMORY(pRAM,0x800);
2591 ZEROMEMORY(pSRAM,0x2000);
2592 ZEROMEMORY(pExRAM,0x1000);
2593 pROM_Full=0;
2594
2595 ZEROMEMORY(pROM,10);
2596 pStack=0;
2597
2598 nROMSize=0;
2599 nROMBankCount=0;
2600 nROMMaxSize=0;
2601
2602 /*
2603 * Memory Proc Pointers
2604 */
2605
2606 ZEROMEMORY(ReadMemory,sizeof(ReadProc)*0x10);
2607 ZEROMEMORY(WriteMemory,sizeof(WriteProc)*0x10);
2608
2609 /*
2610 * 6502 Registers / Mode
2611 */
2612
2613 regA=0;
2614 regX=0;
2615 regY=0;
2616 regP=0;
2617 regSP=0;
2618 regPC=0;
2619
2620 bPALMode=0;
2621 bCPUJammed=0;
2622
2623 nMultIn_Low=0;
2624 nMultIn_High=0;
2625
2626 /*
2627 * NSF Preparation Information
2628 */
2629
2630 ZEROMEMORY(nBankswitchInitValues,10);
2631 nPlayAddress=0;
2632 nInitAddress=0;
2633
2634 nExternalSound=0;
2635 nCurTrack=0;
2636
2637 fNSFPlaybackSpeed=0;
2638
2639 /*
2640 * pAPU
2641 */
2642
2643 nFrameCounter=0;
2644 nFrameCounterMax=0;
2645 bFrameIRQEnabled=0;
2646 bFrameIRQPending=0;
2647
2648 /*
2649 * Timing and Counters
2650 */
2651 nTicksUntilNextFrame=0;
2652
2653 nTicksPerPlay=0;
2654 nTicksUntilNextPlay=0;
2655
2656 nTicksPerSample=0;
2657 nTicksUntilNextSample=0;
2658
2659 nCPUCycle=0;
2660 nAPUCycle=0;
2661 nTotalPlays=0;
2662
2663 /*
2664 * Silence Tracker
2665 */
2666 nSilentSamples=0;
2667 nSilentSampleMax=0;
2668 nSilenceTrackMS=0;
2669 bNoSilenceIfTime=0;
2670 bTimeNotDefault=0;
2671
2672 /*
2673 * Volume/fading/filter tracking
2674 */
2675
2676 nStartFade=0;
2677 nEndFade=0;
2678 bFade=0;
2679 fFadeVolume=0;
2680 fFadeChange=0;
2681
2682 pOutput=0;
2683
2684 nDMCPop_Prev=0;
2685 bDMCPop_Skip=0;
2686 bDMCPop_SamePlay=0;
2687
2688 /*
2689 * Sound Filter
2690 */
2691
2692 nFilterAccL=0;
2693 nHighPass=0;
2694
2695 nHighPassBase=0;
2696
2697 bHighPassEnabled=0;
2698
2699 /* channels */
2700
2701 ZEROMEMORY(&mWave_Squares,sizeof(struct Wave_Squares));
2702 ZEROMEMORY(&mWave_TND,sizeof(struct Wave_TND));
2703 ZEROMEMORY(mWave_VRC6Pulse,sizeof(struct VRC6PulseWave)*2);
2704 ZEROMEMORY(&mWave_VRC6Saw,sizeof(struct VRC6SawWave));
2705 ZEROMEMORY(&mWave_N106,sizeof(struct N106Wave));
2706 ZEROMEMORY(mWave_FME07,sizeof(struct FME07Wave)*3);
2707 ZEROMEMORY(&mWave_FDS,sizeof(struct FDSWave));
2708
2709 /* end clear globals */
2710
2711 // Default filter bases
2712 nHighPassBase = 150;
2713
2714 bHighPassEnabled = 1;
2715
2716 mWave_TND.nNoiseRandomShift = 1;
2717 for(i = 0; i < 8; i++)
2718 mWave_TND.pDMCDMAPtr[i] = pROM[i + 2];
2719
2720
2721 SetPlaybackOptions(nSampleRate);
2722
2723 for(i = 0; i < 8; i++)
2724 mWave_N106.nFrequencyLookupTable[i] =
2725 ((((i + 1) * 45 * 0x40000) / (float)NES_FREQUENCY) *
2726 (float)NTSC_FREQUENCY) * 256.0;
2727
2728 ZEROMEMORY(pRAM,0x800);
2729 ZEROMEMORY(pSRAM,0x2000);
2730 ZEROMEMORY(pExRAM,0x1000);
2731 pStack = pRAM + 0x100;
2732 return 1;
2733 }
2734
2735 /*
2736 * LoadNSF
2737 */
2738
2739 int LoadNSF(int32_t datasize)
2740 {
2741 if(!pDataBuffer) return 0;
2742
2743 int32_t i;
2744
2745 nExternalSound = nChipExtensions;
2746 if(nIsPal & 2)
2747 bPALMode = bPALPreference;
2748 else
2749 bPALMode = nIsPal & 1;
2750
2751 SetPlaybackOptions(nSampleRate);
2752
2753 int32_t neededsize = datasize + (nfileLoadAddress & 0x0FFF);
2754 if(neededsize & 0x0FFF) neededsize += 0x1000 - (neededsize & 0x0FFF);
2755 if(neededsize < 0x1000) neededsize = 0x1000;
2756
2757 uint8_t specialload = 0;
2758
2759 for(i = 0; (i < 8) && (!nBankswitch[i]); i++);
2760 if(i < 8) /* uses bankswitching */
2761 {
2762 memcpy(&nBankswitchInitValues[2],nBankswitch,8);
2763 nBankswitchInitValues[0] = nBankswitch[6];
2764 nBankswitchInitValues[1] = nBankswitch[7];
2765 if(nExternalSound & EXTSOUND_FDS)
2766 {
2767 if(!(nBankswitchInitValues[0] || nBankswitchInitValues[1]))
2768 {
2769 /*
2770 * FDS sound with '00' specified for both $6000 and $7000 banks.
2771 * point this to an area of fresh RAM (sort of hackish solution
2772 * for those FDS tunes that don't quite follow the nsf specs.
2773 */
2774 nBankswitchInitValues[0] = (uint8_t)(neededsize >> 12);
2775 nBankswitchInitValues[1] = (uint8_t)(neededsize >> 12) + 1;
2776 neededsize += 0x2000;
2777 }
2778 }
2779 }
2780 else /* doesn't use bankswitching */
2781 {
2782 if(nExternalSound & EXTSOUND_FDS)
2783 {
2784 /* bad load address */
2785 if(nfileLoadAddress < 0x6000) return 0;
2786
2787 if(neededsize < 0xA000)
2788 neededsize = 0xA000;
2789 specialload = 1;
2790 for(i = 0; i < 10; i++)
2791 nBankswitchInitValues[i] = (uint8_t)i;
2792 }
2793 else
2794 {
2795 /* bad load address */
2796 if(nfileLoadAddress < 0x8000) return 0;
2797
2798 int32_t j = (nfileLoadAddress >> 12) - 6;
2799 for(i = 0; i < j; i++)
2800 nBankswitchInitValues[i] = 0;
2801 for(j = 0; i < 10; i++, j++)
2802 nBankswitchInitValues[i] = (uint8_t)j;
2803 }
2804 }
2805
2806 nROMSize = neededsize;
2807 nROMBankCount = neededsize >> 12;
2808
2809 if(specialload)
2810 pROM_Full = pDataBuffer-(nfileLoadAddress-0x6000);
2811 else
2812 pROM_Full = pDataBuffer-(nfileLoadAddress&0x0FFF);
2813
2814 ZEROMEMORY(pRAM,0x0800);
2815 ZEROMEMORY(pExRAM,0x1000);
2816 ZEROMEMORY(pSRAM,0x2000);
2817
2818 nExternalSound = nChipExtensions;
2819 fNSFPlaybackSpeed = (bPALMode ? PAL_NMIRATE : NTSC_NMIRATE);
2820
2821 SetPlaybackSpeed(0);
2822
2823 nPlayAddress = nfilePlayAddress;
2824 nInitAddress = nfileInitAddress;
2825
2826 pExRAM[0x00] = 0x20; /* JSR */
2827 pExRAM[0x01] = nInitAddress&0xff; /* Init Address */
2828 pExRAM[0x02] = (nInitAddress>>8)&0xff;
2829 pExRAM[0x03] = 0xF2; /* JAM */
2830 pExRAM[0x04] = 0x20; /* JSR */
2831 pExRAM[0x05] = nPlayAddress&0xff; /* Play Address */
2832 pExRAM[0x06] = (nPlayAddress>>8)&0xff;
2833 pExRAM[0x07] = 0x4C; /* JMP */
2834 pExRAM[0x08] = 0x03;/* $5003 (JAM right before the JSR to play address) */
2835 pExRAM[0x09] = 0x50;
2836
2837 regA = regX = regY = 0;
2838 regP = 0x04; /* I_FLAG */
2839 regSP = 0xFF;
2840
2841 nFilterAccL = 0;
2842
2843 /* Reset Read/Write Procs */
2844
2845 ReadMemory[0] = ReadMemory[1] = ReadMemory_RAM;
2846 ReadMemory[2] = ReadMemory[3] = ReadMemory_Default;
2847 ReadMemory[4] = ReadMemory_pAPU;
2848 ReadMemory[5] = ReadMemory_ExRAM;
2849 ReadMemory[6] = ReadMemory[7] = ReadMemory_SRAM;
2850
2851 WriteMemory[0] = WriteMemory[1] = WriteMemory_RAM;
2852 WriteMemory[2] = WriteMemory[3] = WriteMemory_Default;
2853 WriteMemory[4] = WriteMemory_pAPU;
2854 WriteMemory[5] = WriteMemory_ExRAM;
2855 WriteMemory[6] = WriteMemory[7] = WriteMemory_SRAM;
2856
2857 for(i = 8; i < 16; i++)
2858 {
2859 ReadMemory[i] = ReadMemory_ROM;
2860 WriteMemory[i] = WriteMemory_Default;
2861 }
2862
2863 if(nExternalSound & EXTSOUND_FDS)
2864 {
2865 WriteMemory[0x06] = WriteMemory_FDSRAM;
2866 WriteMemory[0x07] = WriteMemory_FDSRAM;
2867 WriteMemory[0x08] = WriteMemory_FDSRAM;
2868 WriteMemory[0x09] = WriteMemory_FDSRAM;
2869 WriteMemory[0x0A] = WriteMemory_FDSRAM;
2870 WriteMemory[0x0B] = WriteMemory_FDSRAM;
2871 WriteMemory[0x0C] = WriteMemory_FDSRAM;
2872 WriteMemory[0x0D] = WriteMemory_FDSRAM;
2873 ReadMemory[0x06] = ReadMemory_ROM;
2874 ReadMemory[0x07] = ReadMemory_ROM;
2875 }
2876
2877 if(!bPALMode) /* no expansion sound available on a PAL system */
2878 {
2879 if(nExternalSound & EXTSOUND_VRC6)
2880 {
2881 /* if both VRC6+VRC7... it MUST go to WriteMemory_VRC6
2882 * or register writes will be lost (WriteMemory_VRC6 calls
2883 * WriteMemory_VRC7 if needed) */
2884 WriteMemory[0x09] = WriteMemory_VRC6;
2885 WriteMemory[0x0A] = WriteMemory_VRC6;
2886 WriteMemory[0x0B] = WriteMemory_VRC6;
2887 }
2888 if(nExternalSound & EXTSOUND_N106)
2889 {
2890 WriteMemory[0x04] = WriteMemory_N106;
2891 ReadMemory[0x04] = ReadMemory_N106;
2892 WriteMemory[0x0F] = WriteMemory_N106;
2893 }
2894 if(nExternalSound & EXTSOUND_FME07)
2895 {
2896 WriteMemory[0x0C] = WriteMemory_FME07;
2897 WriteMemory[0x0E] = WriteMemory_FME07;
2898 }
2899 }
2900
2901 /* MMC5 still has a multiplication reg that needs to be available on
2902 PAL tunes */
2903 if(nExternalSound & EXTSOUND_MMC5)
2904 WriteMemory[0x05] = WriteMemory_MMC5;
2905
2906 return 1;
2907 }
2908
2909 /*
2910 * SetTrack
2911 */
2912
2913 void SetTrack(uint8_t track)
2914 {
2915 int32_t i;
2916
2917 nCurTrack = track;
2918
2919 regPC = 0x5000;
2920 regA = track;
2921 regX = bPALMode;
2922 regY = bCleanAXY ? 0 : 0xCD;
2923 regSP = 0xFF;
2924 if(bCleanAXY)
2925 regP = 0x04;
2926 bCPUJammed = 0;
2927
2928 nCPUCycle = nAPUCycle = 0;
2929 nDMCPop_Prev = 0;
2930 bDMCPop_Skip = 0;
2931
2932 for(i = 0x4000; i < 0x400F; i++)
2933 WriteMemory_pAPU(i,0);
2934 WriteMemory_pAPU(0x4010,0);
2935 WriteMemory_pAPU(0x4012,0);
2936 WriteMemory_pAPU(0x4013,0);
2937 WriteMemory_pAPU(0x4014,0);
2938 WriteMemory_pAPU(0x4015,0);
2939 WriteMemory_pAPU(0x4015,0x0F);
2940 WriteMemory_pAPU(0x4017,0);
2941
2942 for(i = 0; i < 10; i++)
2943 WriteMemory_ExRAM(0x5FF6 + i,nBankswitchInitValues[i]);
2944
2945 ZEROMEMORY(pRAM,0x0800);
2946 ZEROMEMORY(pSRAM,0x2000);
2947 ZEROMEMORY(&pExRAM[0x10],0x0FF0);
2948 bFade = 0;
2949
2950
2951 nTicksUntilNextSample = nTicksPerSample;
2952 nTicksUntilNextFrame =
2953 (bPALMode ? PAL_FRAME_COUNTER_FREQ : NTSC_FRAME_COUNTER_FREQ)*0x10000;
2954 nTicksUntilNextPlay = nTicksPerPlay;
2955 nTotalPlays = 0;
2956
2957 /* Clear mixing vals */
2958 mWave_Squares.nMixL = 0;
2959 mWave_TND.nMixL = 0;
2960 mWave_VRC6Pulse[0].nMixL = 0;
2961 mWave_VRC6Pulse[1].nMixL = 0;
2962 mWave_VRC6Saw.nMixL = 0;
2963
2964 /* Reset Tri/Noise/DMC */
2965 mWave_TND.nTriStep = mWave_TND.nTriOutput = 0;
2966 mWave_TND.nDMCOutput = 0;
2967 mWave_TND.bNoiseRandomOut = 0;
2968 mWave_Squares.nDutyCount[0] = mWave_Squares.nDutyCount[1] = 0;
2969 mWave_TND.bDMCActive = 0;
2970 mWave_TND.nDMCBytesRemaining = 0;
2971 mWave_TND.bDMCSampleBufferEmpty = 1;
2972 mWave_TND.bDMCDeltaSilent = 1;
2973
2974 /* Reset VRC6 */
2975 mWave_VRC6Pulse[0].nVolume = 0;
2976 mWave_VRC6Pulse[1].nVolume = 0;
2977 mWave_VRC6Saw.nAccumRate = 0;
2978
2979 /* Reset N106 */
2980 ZEROMEMORY(mWave_N106.nRAM,0x100);
2981 ZEROMEMORY(mWave_N106.nVolume,8);
2982 ZEROMEMORY(mWave_N106.nOutput,8);
2983 ZEROMEMORY(mWave_N106.nMixL,32);
2984
2985 /* Reset FME-07 */
2986 mWave_FME07[0].nVolume = 0;
2987 mWave_FME07[1].nVolume = 0;
2988 mWave_FME07[2].nVolume = 0;
2989
2990 /* Clear FDS crap */
2991
2992 mWave_FDS.bEnvelopeEnable = 0;
2993 mWave_FDS.nEnvelopeSpeed = 0xFF;
2994 mWave_FDS.nVolEnv_Mode = 2;
2995 mWave_FDS.nVolEnv_Decay = 0;
2996 mWave_FDS.nVolEnv_Gain = 0;
2997 mWave_FDS.nVolume = 0;
2998 mWave_FDS.bVolEnv_On = 0;
2999 mWave_FDS.nSweep_Mode = 2;
3000 mWave_FDS.nSweep_Decay = 0;
3001 mWave_FDS.nSweep_Gain = 0;
3002 mWave_FDS.bSweepEnv_On = 0;
3003 mWave_FDS.nSweepBias = 0;
3004 mWave_FDS.bLFO_Enabled = 0;
3005 mWave_FDS.nLFO_Freq.W = 0;
3006 /* mWave_FDS.fLFO_Timer = 0;
3007 mWave_FDS.fLFO_Count = 0;*/
3008 mWave_FDS.nLFO_Timer = 0;
3009 mWave_FDS.nLFO_Count = 0;
3010 mWave_FDS.nLFO_Addr = 0;
3011 mWave_FDS.bLFO_On = 0;
3012 mWave_FDS.nMainVolume = 0;
3013 mWave_FDS.bEnabled = 0;
3014 mWave_FDS.nFreq.W = 0;
3015 /* mWave_FDS.fFreqCount = 0;*/
3016 mWave_FDS.nFreqCount = 0;
3017 mWave_FDS.nMainAddr = 0;
3018 mWave_FDS.bWaveWrite = 0;
3019 mWave_FDS.bMain_On = 0;
3020 mWave_FDS.nMixL = 0;
3021 ZEROMEMORY(mWave_FDS.nWaveTable,0x40);
3022 ZEROMEMORY(mWave_FDS.nLFO_Table,0x40);
3023
3024 mWave_FDS.nSweep_Count = mWave_FDS.nSweep_Timer =
3025 ((mWave_FDS.nSweep_Decay + 1) * mWave_FDS.nEnvelopeSpeed * 8);
3026 mWave_FDS.nVolEnv_Count = mWave_FDS.nVolEnv_Timer =
3027 ((mWave_FDS.nVolEnv_Decay + 1) * mWave_FDS.nEnvelopeSpeed * 8);
3028
3029 nSilentSamples = 0;
3030
3031 nFilterAccL = 0;
3032
3033 nSilentSamples = 0;
3034
3035 fulltick=0;
3036 }
3037
3038 /*
3039 * SetPlaybackOptions
3040 */
3041
3042 int SetPlaybackOptions(int32_t samplerate)
3043 {
3044 if(samplerate < 2000) return 0;
3045 if(samplerate > 96000) return 0;
3046
3047 nTicksPerSample =
3048 (bPALMode ? PAL_FREQUENCY : NTSC_FREQUENCY) / samplerate * 0x10000;
3049 nTicksUntilNextSample = nTicksPerSample;
3050
3051 RecalcFilter();
3052 RecalcSilenceTracker();
3053
3054 return 1;
3055 }
3056
3057 /*
3058 * SetPlaybackSpeed
3059 */
3060
3061 void SetPlaybackSpeed(float playspersec)
3062 {
3063 if(playspersec < 1)
3064 {
3065 playspersec = fNSFPlaybackSpeed;
3066 }
3067
3068 nTicksPerPlay = nTicksUntilNextPlay =
3069 (bPALMode ? PAL_FREQUENCY : NTSC_FREQUENCY) / playspersec * 0x10000;
3070 }
3071
3072 /*
3073 * GetPlaybackSpeed
3074 */
3075
3076 float GetPlaybackSpeed()
3077 {
3078 if(nTicksPerPlay <= 0) return 0;
3079 return ((bPALMode ? PAL_FREQUENCY : NTSC_FREQUENCY) / (nTicksPerPlay>>16));
3080 }
3081
3082 /*
3083 * RecalcFilter
3084 */
3085
3086 void RecalcFilter()
3087 {
3088 if(!nSampleRate) return;
3089
3090 nHighPass = ((int64_t)nHighPassBase << 16) / nSampleRate;
3091
3092 if(nHighPass > (1<<16)) nHighPass = 1<<16;
3093 }
3094
3095 /*
3096 * RecalcSilenceTracker
3097 */
3098
3099 void RecalcSilenceTracker()
3100 {
3101 if(nSilenceTrackMS <= 0 || !nSampleRate ||
3102 (bNoSilenceIfTime && bTimeNotDefault))
3103 {
3104 nSilentSampleMax = 0;
3105 return;
3106 }
3107
3108 nSilentSampleMax = nSilenceTrackMS * nSampleRate / 500;
3109 nSilentSampleMax /= 2;
3110 }
3111
3112 void RebuildOutputTables(void) {
3113 int32_t i,j;
3114 float l[3];
3115 int32_t temp;
3116 float ftemp;
3117
3118 /* tnd */
3119 for(i = 0; i < 3; i++)
3120 {
3121 l[i] = 255;
3122 }
3123
3124 for(i = 0; i < 0x8000; i++)
3125 {
3126 ftemp = (l[0] * (i >> 11)) / 2097885;
3127 ftemp += (l[1] * ((i >> 7) & 0x0F)) / 3121455;
3128 ftemp += (l[2] * (i & 0x7F)) / 5772690;
3129
3130 if(!ftemp)
3131 main_nOutputTable_L[i] = 0;
3132 else
3133 main_nOutputTable_L[i] =
3134 (int16_t)(2396850 / ((1.0f / ftemp) + 100));
3135 }
3136
3137 /* squares */
3138 for(i = 0; i < 2; i++)
3139 {
3140 l[i] = 255;
3141 }
3142
3143 for(j = 0; j < 0x10; j++)
3144 {
3145 for(i = 0; i < 0x10; i++)
3146 {
3147 temp = (int32_t)(l[0] * j);
3148 temp += (int32_t)(l[1] * i);
3149
3150 if(!temp)
3151 Squares_nOutputTable_L[j][i] = 0;
3152 else
3153 Squares_nOutputTable_L[j][i] = 1438200 / ((2072640 / temp) + 100);
3154 }
3155 }
3156
3157 /* VRC6 Pulse 1,2 */
3158 for(i = 0; i < 0x10; i++)
3159 {
3160 VRC6Pulse_nOutputTable_L[i] =
3161 1875 * i / 0x0F;
3162 }
3163 /* VRC6 Saw */
3164 for(i = 0; i < 0x20; i++)
3165 {
3166 VRC6Saw_nOutputTable_L[i] = 3750 * i / 0x1F;
3167 }
3168
3169 /* N106 channels */
3170 /* this amplitude is just a guess */
3171
3172 for(i = 0; i < 0x10; i++)
3173 {
3174 for(j = 0; j < 0x10; j++)
3175 {
3176 N106_nOutputTable_L[i][j] = (3000 * i * j) / 0xE1;
3177 }
3178 }
3179
3180 /* FME-07 Square A,B,C */
3181 FME07_nOutputTable_L[15] = 3000;
3182 FME07_nOutputTable_L[0] = 0;
3183 for(i = 14; i > 0; i--)
3184 {
3185 FME07_nOutputTable_L[i] = FME07_nOutputTable_L[i + 1] * 80 / 100;
3186 }
3187
3188 /*
3189 * FDS
3190 */
3191 /* this base volume (4000) is just a guess to what sounds right.
3192 * Given the number of steps available in an FDS wave... it seems like
3193 * it should be much much more... but then it's TOO loud.
3194 */
3195 for(i = 0; i < 0x21; i++)
3196 {
3197 for(j = 0; j < 0x40; j++)
3198 {
3199 FDS_nOutputTable_L[0][i][j] =
3200 (4000 * i * j * 30) / (0x21 * 0x40 * 30);
3201 FDS_nOutputTable_L[1][i][j] =
3202 (4000 * i * j * 20) / (0x21 * 0x40 * 30);
3203 FDS_nOutputTable_L[2][i][j] =
3204 (4000 * i * j * 15) / (0x21 * 0x40 * 30);
3205 FDS_nOutputTable_L[3][i][j] =
3206 (4000 * i * j * 12) / (0x21 * 0x40 * 30);
3207 }
3208 }
3209 }
3210
3211 /*
3212 * GetPlayCalls
3213 */
3214
3215 float GetPlayCalls()
3216 {
3217 if(!nTicksPerPlay) return 0;
3218
3219 return ((float)nTotalPlays) +
3220 (1.0f - (nTicksUntilNextPlay*1.0f / nTicksPerPlay));
3221 }
3222
3223 /*
3224 * GetWrittenTime
3225 */
3226 uint32_t GetWrittenTime(float basedplayspersec /* = 0 */)
3227 {
3228 if(basedplayspersec <= 0)
3229 basedplayspersec = GetPlaybackSpeed();
3230
3231 if(basedplayspersec <= 0)
3232 return 0;
3233
3234 return (uint32_t)((GetPlayCalls() * 1000) / basedplayspersec);
3235 }
3236
3237 /*
3238 * StopFade
3239 */
3240 void StopFade()
3241 {
3242 bFade = 0;
3243 fFadeVolume = 1;
3244 }
3245
3246 /*
3247 * SongCompleted
3248 */
3249
3250 uint8_t SongCompleted()
3251 {
3252 if(!bFade) return 0;
3253 if(nTotalPlays >= nEndFade) return 1;
3254 if(nSilentSampleMax) return (nSilentSamples >= nSilentSampleMax);
3255
3256 return 0;
3257 }
3258
3259 /*
3260 * SetFade
3261 */
3262
3263 void SetFade(int32_t fadestart,int32_t fadestop,
3264 uint8_t bNotDefault) /* play routine calls */
3265 {
3266 if(fadestart < 0) fadestart = 0;
3267 if(fadestop < fadestart) fadestop = fadestart;
3268
3269 nStartFade = (uint32_t)fadestart;
3270 nEndFade = (uint32_t)fadestop;
3271 bFade = 1;
3272 bTimeNotDefault = bNotDefault;
3273
3274 RecalcSilenceTracker();
3275 RecalculateFade();
3276 }
3277
3278 /*
3279 * SetFadeTime
3280 */
3281
3282 void SetFadeTime(uint32_t fadestart,uint32_t fadestop,float basedplays,
3283 uint8_t bNotDefault) /* time in MS */
3284 {
3285 if(basedplays <= 0)
3286 basedplays = GetPlaybackSpeed();
3287 if(basedplays <= 0)
3288 return;
3289
3290 SetFade((int32_t)(fadestart * basedplays / 1000),
3291 (int32_t)(fadestop * basedplays / 1000),bNotDefault);
3292 }
3293
3294 /*
3295 * RecalculateFade
3296 */
3297
3298 void RecalculateFade()
3299 {
3300 if(!bFade) return;
3301
3302 /* make it hit silence a little before the song ends...
3303 otherwise we're not really fading OUT, we're just fading umm...
3304 quieter =P */
3305 int32_t temp = (int32_t)(GetPlaybackSpeed() / 4);
3306
3307 if(nEndFade <= nStartFade)
3308 {
3309 nEndFade = nStartFade;
3310 fFadeChange = 1.0f;
3311 }
3312 else if((nEndFade - temp) <= nStartFade)
3313 fFadeChange = 1.0f;
3314 else
3315 fFadeChange = 1.0f / (nEndFade - nStartFade - temp);
3316
3317 if(nTotalPlays < nStartFade)
3318 fFadeVolume = 1.0f;
3319 else if(nTotalPlays >= nEndFade)
3320 fFadeVolume = 0.0f;
3321 else
3322 {
3323 fFadeVolume = 1.0f - ( (nTotalPlays - nStartFade + 1) * fFadeChange );
3324 if(fFadeVolume < 0)
3325 fFadeVolume = 0;
3326 }
3327
3328 }
3329
3330 int32_t GetSamples(uint8_t* buffer,int32_t buffersize)
3331 {
3332 if(!buffer) return 0;
3333 if(buffersize < 16) return 0;
3334 if(bFade && (nTotalPlays >= nEndFade)) return 0;
3335
3336 pOutput = buffer;
3337 uint32_t runtocycle =
3338 (uint32_t)((buffersize / 2) * nTicksPerSample / 0x10000);
3339 nCPUCycle = nAPUCycle = 0;
3340 uint32_t tick;
3341
3342 while(1)
3343 {
3344 /*tick = (uint32_t)ceil(fTicksUntilNextPlay);*/
3345 tick = (nTicksUntilNextPlay+0xffff)>>16;
3346 if((tick + nCPUCycle) > runtocycle)
3347 tick = runtocycle - nCPUCycle;
3348
3349 if(bCPUJammed)
3350 {
3351 nCPUCycle += tick;
3352 EmulateAPU(0);
3353 }
3354 else
3355 {
3356 tick = Emulate6502(tick + nCPUCycle);
3357 EmulateAPU(1);
3358 }
3359
3360 nTicksUntilNextPlay -= tick<<16;
3361 if(nTicksUntilNextPlay <= 0)
3362 {
3363 nTicksUntilNextPlay += nTicksPerPlay;
3364 if((bCPUJammed == 2) || bNoWaitForReturn)
3365 {
3366 regX = regY = regA = (bCleanAXY ? 0 : 0xCD);
3367 regPC = 0x5004;
3368 nTotalPlays++;
3369 bDMCPop_SamePlay = 0;
3370 bCPUJammed = 0;
3371 if(nForce4017Write == 1) WriteMemory_pAPU(0x4017,0x00);
3372 if(nForce4017Write == 2) WriteMemory_pAPU(0x4017,0x80);
3373 }
3374
3375 if(bFade && (nTotalPlays >= nStartFade))
3376 {
3377 fFadeVolume -= fFadeChange;
3378 if(fFadeVolume < 0)
3379 fFadeVolume = 0;
3380 if(nTotalPlays >= nEndFade)
3381 break;
3382 }
3383 }
3384
3385 if(nCPUCycle >= runtocycle)
3386 break;
3387 }
3388
3389 nCPUCycle = nAPUCycle = 0;
3390
3391 if(nSilentSampleMax && bFade)
3392 {
3393 int16_t* tempbuf = (int16_t*)buffer;
3394 while( ((uint8_t*)tempbuf) < pOutput)
3395 {
3396 if( (*tempbuf < -SILENCE_THRESHOLD) ||
3397 (*tempbuf > SILENCE_THRESHOLD) )
3398 nSilentSamples = 0;
3399 else
3400 {
3401 if(++nSilentSamples >= nSilentSampleMax)
3402 return (int32_t)( ((uint8_t*)tempbuf) - buffer);
3403 }
3404 tempbuf++;
3405 }
3406 }
3407
3408 return (int32_t)(pOutput - buffer);
3409 }
3410
3411 /****************** 6502 emulation ******************/
3412
3413 /* Memory reading/writing and other defines */
3414
3415 /* reads zero page memory */
3416 #define Zp(a) pRAM[a]
3417 /* reads zero page memory in word form */
3418 #define ZpWord(a) (Zp(a) | (Zp((uint8_t)(a + 1)) << 8))
3419 /* reads memory */
3420 #define Rd(a) ((ReadMemory[((uint16_t)(a)) >> 12])(a))
3421 /* reads memory in word form */
3422 #define RdWord(a) (Rd(a) | (Rd(a + 1) << 8))
3423 /* writes memory */
3424 #define Wr(a,v) (WriteMemory[((uint16_t)(a)) >> 12])(a,v)
3425 /* writes zero paged memory */
3426 #define WrZ(a,v) pRAM[a] = v
3427 /* pushes a value onto the stack */
3428 #define PUSH(v) pStack[SP--] = v
3429 /* pulls a value from the stack */
3430 #define PULL(v) v = pStack[++SP]
3431
3432 /* Addressing Modes */
3433
3434 /* first set - gets the value that's being addressed */
3435 /*Immediate*/
3436 #define Ad_VlIm() val = Rd(PC.W); PC.W++
3437 /*Zero Page*/
3438 #define Ad_VlZp() final.W = Rd(PC.W); val = Zp(final.W); PC.W++
3439 /*Zero Page, X*/
3440 #define Ad_VlZx() front.W = final.W = Rd(PC.W); final.B.l += X; \
3441 val = Zp(final.B.l); PC.W++
3442 /*Zero Page, Y*/
3443 #define Ad_VlZy() front.W = final.W = Rd(PC.W); final.B.l += Y; \
3444 val = Zp(final.B.l); PC.W++
3445 /*Absolute*/
3446 #define Ad_VlAb() final.W = RdWord(PC.W); val = Rd(final.W); PC.W += 2
3447 /*Absolute, X [uses extra cycle if crossed page]*/
3448 #define Ad_VlAx() front.W = final.W = RdWord(PC.W); final.W += X; PC.W += 2;\
3449 if(front.B.h != final.B.h) nCPUCycle++; val = Rd(final.W)
3450 /*Absolute, X [uses extra cycle if crossed page]*/
3451 #define Ad_VlAy() front.W = final.W = RdWord(PC.W); final.W += Y; PC.W += 2;\
3452 if(front.B.h != final.B.h) nCPUCycle++; val = Rd(final.W)
3453 /*(Indirect, X)*/
3454 #define Ad_VlIx() front.W = final.W = Rd(PC.W); final.B.l += X; PC.W++; \
3455 final.W = ZpWord(final.B.l); val = Rd(final.W)
3456 /*(Indirect), Y [uses extra cycle if crossed page]*/
3457 #define Ad_VlIy() val = Rd(PC.W); front.W = final.W = ZpWord(val); PC.W++;\
3458 final.W += Y; if(final.B.h != front.B.h) nCPUCycle++; \
3459 front.W = val; val = Rd(final.W)
3460
3461 /* second set - gets the ADDRESS that the mode is referring to (for operators
3462 * that write to memory) note that AbsoluteX, AbsoluteY, and
3463 * IndirectY modes do NOT check for page boundary crossing here
3464 * since that extra cycle isn't added for operators that write to
3465 * memory (it only applies to ones that only read from memory.. in
3466 * which case the 1st set should be used)
3467 */
3468 /*Zero Page*/
3469 #define Ad_AdZp() final.W = Rd(PC.W); PC.W++
3470 /*Zero Page, X*/
3471 #define Ad_AdZx() final.W = front.W = Rd(PC.W); final.B.l += X; PC.W++
3472 /*Zero Page, Y*/
3473 #define Ad_AdZy() final.W = front.W = Rd(PC.W); final.B.l += Y; PC.W++
3474 /*Absolute*/
3475 #define Ad_AdAb() final.W = RdWord(PC.W); PC.W += 2
3476 /*Absolute, X*/
3477 #define Ad_AdAx() front.W = final.W = RdWord(PC.W); PC.W += 2; \
3478 final.W += X
3479 /*Absolute, Y*/
3480 #define Ad_AdAy() front.W = final.W = RdWord(PC.W); PC.W += 2; \
3481 final.W += Y
3482 /*(Indirect, X)*/
3483 #define Ad_AdIx() front.W = final.W = Rd(PC.W); PC.W++; final.B.l += X; \
3484 final.W = ZpWord(final.B.l)
3485 /*(Indirect), Y*/
3486 #define Ad_AdIy() front.W = Rd(PC.W); final.W = ZpWord(front.W) + Y; \
3487 PC.W++
3488
3489 /* third set - reads memory, performs the desired operation on the value, then
3490 * writes back to memory
3491 * used for operators that directly change memory (ASL, INC, DEC, etc)
3492 */
3493 /*Zero Page*/
3494 #define MRW_Zp(cmd) Ad_AdZp(); val = Zp(final.W); cmd(val); WrZ(final.W,val)
3495 /*Zero Page, X*/
3496 #define MRW_Zx(cmd) Ad_AdZx(); val = Zp(final.W); cmd(val); WrZ(final.W,val)
3497 /*Zero Page, Y*/
3498 #define MRW_Zy(cmd) Ad_AdZy(); val = Zp(final.W); cmd(val); WrZ(final.W,val)
3499 /*Absolute*/
3500 #define MRW_Ab(cmd) Ad_AdAb(); val = Rd(final.W); cmd(val); Wr(final.W,val)
3501 /*Absolute, X*/
3502 #define MRW_Ax(cmd) Ad_AdAx(); val = Rd(final.W); cmd(val); Wr(final.W,val)
3503 /*Absolute, Y*/
3504 #define MRW_Ay(cmd) Ad_AdAy(); val = Rd(final.W); cmd(val); Wr(final.W,val)
3505 /*(Indirect, X)*/
3506 #define MRW_Ix(cmd) Ad_AdIx(); val = Rd(final.W); cmd(val); Wr(final.W,val)
3507 /*(Indirect), Y*/
3508 #define MRW_Iy(cmd) Ad_AdIy(); val = Rd(final.W); cmd(val); Wr(final.W,val)
3509
3510 /* Relative modes are special in that they're only used by branch commands
3511 * this macro handles the jump, and should only be called if the branch
3512 * condition was true if the branch condition was false, the PC must be
3513 * incremented
3514 */
3515
3516 #define RelJmp(cond) val = Rd(PC.W); PC.W++; final.W = PC.W + (int8_t)(val);\
3517 if(cond) {\
3518 nCPUCycle += ((final.B.h != PC.B.h) ? 2 : 1);\
3519 PC.W = final.W; }
3520
3521 /* Status Flags */
3522
3523 #define C_FLAG 0x01 /* carry flag */
3524 #define Z_FLAG 0x02 /* zero flag */
3525 #define I_FLAG 0x04 /* mask interrupt flag */
3526 #define D_FLAG 0x08 /* decimal flag (decimal mode is unsupported on
3527 NES) */
3528 #define B_FLAG 0x10 /* break flag (not really in the status register
3529 It's value in ST is never used. When ST is
3530 put in memory (by an interrupt or PHP), this
3531 flag is set only if BRK was called)
3532 ** also when PHP is called due to a bug */
3533 #define R_FLAG 0x20 /* reserved flag (not really in the register.
3534 It's value is never used.
3535 Whenever ST is put in memory,
3536 this flag is always set) */
3537 #define V_FLAG 0x40 /* overflow flag */
3538 #define N_FLAG 0x80 /* sign flag */
3539
3540
3541 /* Lookup Tables */
3542
3543 /* the number of CPU cycles used for each instruction */
3544 static const uint8_t CPU_Cycles[0x100] = {
3545 7,6,0,8,3,3,5,5,3,2,2,2,4,4,6,6,
3546 2,5,0,8,4,4,6,6,2,4,2,7,4,4,7,7,
3547 6,6,0,8,3,3,5,5,4,2,2,2,4,4,6,6,
3548 2,5,0,8,4,4,6,6,2,4,2,7,4,4,7,7,
3549 6,6,0,8,3,3,5,5,3,2,2,2,3,4,6,6,
3550 2,5,0,8,4,4,6,6,2,4,2,7,4,4,7,7,
3551 6,6,0,8,3,3,5,5,4,2,2,2,5,4,6,6,
3552 2,5,0,8,4,4,6,6,2,4,2,7,4,4,7,7,
3553 2,6,2,6,3,3,3,3,2,2,2,2,4,4,4,4,
3554 2,6,0,6,4,4,4,4,2,5,2,5,5,5,5,5,
3555 2,6,2,6,3,3,3,3,2,2,2,2,4,4,4,4,
3556 2,5,0,5,4,4,4,4,2,4,2,4,4,4,4,4,
3557 2,6,2,8,3,3,5,5,2,2,2,2,4,4,6,6,
3558 2,5,0,8,4,4,6,6,2,4,2,7,4,4,7,7,
3559 2,6,2,8,3,3,5,5,2,2,2,2,4,4,6,6,
3560 2,5,0,8,4,4,6,6,2,4,2,7,4,4,7,7 };
3561
3562 /* the status of the NZ flags for the given value */
3563 static const uint8_t NZTable[0x100] = {
3564 Z_FLAG,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3565 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3566 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3567 0,0,0,0,0,0,0,0,0,0,0,
3568 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3569 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3570 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3571 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3572 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3573 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3574 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3575 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3576 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3577 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3578 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,
3579 N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG,N_FLAG };
3580
3581 /* A quick macro for working with the above table */
3582 #define UpdateNZ(v) ST = (ST & ~(N_FLAG|Z_FLAG)) | NZTable[v]
3583
3584
3585 /*
3586 * Opcodes
3587 *
3588 * These opcodes perform the action with the given value (changing that
3589 * value if necessary). Registers and flags associated with the operation
3590 * are changed accordingly. There are a few exceptions which will be noted
3591 * when they arise
3592 */
3593
3594
3595 /* ADC
3596 Adds the value to the accumulator with carry
3597 Changes: A, NVZC
3598 - Decimal mode not supported on the NES
3599 - Due to a bug, NVZ flags are not altered if the Decimal flag is on
3600 --(taken out)-- */
3601 #define ADC() \
3602 tw.W = A + val + (ST & C_FLAG); \
3603 ST = (ST & (I_FLAG|D_FLAG)) | tw.B.h | NZTable[tw.B.l] | \
3604 ( (0x80 & ~(A ^ val) & (A ^ tw.B.l)) ? V_FLAG : 0 ); \
3605 A = tw.B.l
3606
3607 /* AND
3608 Combines the value with the accumulator using a bitwise AND operation
3609 Changes: A, NZ */
3610 #define AND() \
3611 A &= val; \
3612 UpdateNZ(A)
3613
3614 /* ASL
3615 Left shifts the value 1 bit. The bit that gets shifted out goes to
3616 the carry flag.
3617 Changes: value, NZC */
3618 #define ASL(value) \
3619 tw.W = value << 1; \
3620 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | tw.B.h | NZTable[tw.B.l]; \
3621 value = tw.B.l
3622
3623 /* BIT
3624 Compares memory with the accumulator with an AND operation, but changes
3625 neither.
3626 The two high bits of memory get transferred to the status reg
3627 Z is set if the AND operation yielded zero, otherwise it's cleared
3628 Changes: NVZ */
3629 #define BIT() \
3630 ST = (ST & ~(N_FLAG|V_FLAG|Z_FLAG)) | (val & (N_FLAG|V_FLAG)) | \
3631 ((A & val) ? 0 : Z_FLAG)
3632
3633 /* CMP, CPX, CPY
3634 Compares memory with the given register with a subtraction operation.
3635 Flags are set accordingly depending on the result:
3636 Reg < Memory: Z=0, C=0
3637 Reg = Memory: Z=1, C=1
3638 Reg > Memory: Z=0, C=1
3639 N is set according to the result of the subtraction operation
3640 Changes: NZC
3641
3642 NOTE -- CMP, CPX, CPY all share this same routine, so the desired
3643 register (A, X, or Y respectively) must be given when calling
3644 this macro... as well as the memory to compare it with. */
3645 #define CMP(reg) \
3646 tw.W = reg - val; \
3647 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | (tw.B.h ? 0 : C_FLAG) | \
3648 NZTable[tw.B.l]
3649
3650 /* DEC, DEX, DEY
3651 Decriments a value by one.
3652 Changes: value, NZ */
3653 #define DEC(value) \
3654 value--; \
3655 UpdateNZ(value)
3656
3657 /* EOR
3658 Combines a value with the accumulator using a bitwise exclusive-OR
3659 operation
3660 Changes: A, NZ */
3661 #define EOR() \
3662 A ^= val; \
3663 UpdateNZ(A)
3664
3665 /* INC, INX, INY
3666 Incriments a value by one.
3667 Changes: value, NZ */
3668 #define INC(value) \
3669 value++; \
3670 UpdateNZ(value)
3671
3672 /* LSR
3673 Shifts value one bit to the right. Bit that gets shifted out goes to
3674 the Carry flag.
3675 Changes: value, NZC */
3676 #define LSR(value) \
3677 tw.W = value >> 1; \
3678 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | NZTable[tw.B.l] | \
3679 (value & 0x01); \
3680 value = tw.B.l
3681
3682 /* ORA
3683 Combines a value with the accumulator using a bitwise inclusive-OR
3684 operation
3685 Changes: A, NZ */
3686 #define ORA() \
3687 A |= val; \
3688 UpdateNZ(A)
3689
3690 /* ROL
3691 Rotates a value one bit to the left:
3692 C <- 7<-6<-5<-4<-3<-2<-1<-0 <- C
3693 Changes: value, NZC */
3694 #define ROL(value) \
3695 tw.W = (value << 1) | (ST & 0x01); \
3696 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | NZTable[tw.B.l] | tw.B.h; \
3697 value = tw.B.l
3698
3699 /* ROR
3700 Rotates a value one bit to the right:
3701 C -> 7->6->5->4->3->2->1->0 -> C
3702 Changes: value, NZC */
3703 #define ROR(value) \
3704 tw.W = (value >> 1) | (ST << 7); \
3705 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | NZTable[tw.B.l] | \
3706 (value & 0x01); \
3707 value = tw.B.l
3708
3709 /* SBC
3710 Subtracts a value from the accumulator with borrow (inverted carry)
3711 Changes: A, NVZC
3712 - Decimal mode not supported on the NES
3713 - Due to a bug, NVZ flags are not altered if the Decimal flag is on
3714 --(taken out)-- */
3715 #define SBC() \
3716 tw.W = A - val - ((ST & C_FLAG) ? 0 : 1); \
3717 ST = (ST & (I_FLAG|D_FLAG)) | (tw.B.h ? 0 : C_FLAG) | NZTable[tw.B.l] | \
3718 (((A ^ val) & (A ^ tw.B.l) & 0x80) ? V_FLAG : 0); \
3719 A = tw.B.l
3720
3721 /* Undocumented Opcodes
3722 *
3723 * These opcodes are not included in the official specifications. However,
3724 * some of the unused opcode values perform operations which have since been
3725 * documented.
3726 */
3727
3728
3729 /* ASO
3730 Left shifts a value, then ORs the result with the accumulator
3731 Changes: value, A, NZC */
3732 #define ASO(value) \
3733 tw.W = value << 1; \
3734 A |= tw.B.l; \
3735 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | NZTable[A] | tw.B.h; \
3736 value = tw.B.l
3737
3738 /* RLA
3739 Roll memory left 1 bit, then AND the result with the accumulator
3740 Changes: value, A, NZC */
3741 #define RLA(value) \
3742 tw.W = (value << 1) | (ST & 0x01); \
3743 A &= tw.B.l; \
3744 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | NZTable[A] | tw.B.h; \
3745 value = tw.B.l
3746
3747 /* LSE
3748 Right shifts a value one bit, then EORs the result with the accumulator
3749 Changes: value, A, NZC */
3750 #define LSE(value) \
3751 tw.W = value >> 1; \
3752 A ^= tw.B.l; \
3753 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | NZTable[A] | (value & 0x01); \
3754 value = tw.B.l
3755
3756 /* RRA
3757 Roll memory right one bit, then ADC the result
3758 Changes: value, A, NVZC */
3759 #define RRA(value) \
3760 tw.W = (value >> 1) | (ST << 7); \
3761 ST = (ST & ~C_FLAG) | (value & 0x01); \
3762 value = tw.B.l; \
3763 ADC()
3764
3765 /* AXS
3766 ANDs the contents of the X and A registers and stores the result
3767 int memory.
3768 Changes: value [DOES NOT CHANGE X, A, or any flags] */
3769 #define AXS(value) \
3770 value = A & X
3771
3772 /* DCM
3773 Decriments a value and compares it with the A register.
3774 Changes: value, NZC */
3775 #define DCM(value) \
3776 value--; \
3777 CMP(A)
3778
3779 /* INS
3780 Incriments a value then SBCs it
3781 Changes: value, A, NVZC */
3782 #define INS(value) \
3783 value++; \
3784 SBC()
3785
3786 /* AXA */
3787 #define AXA(value) \
3788 value = A & X & (Rd(PC.W - 1) + 1)
3789
3790
3791 /* The 6502 emulation function! */
3792
3793 union TWIN front;
3794 union TWIN final;
3795 uint8_t val;
3796 uint8_t op;
3797
3798 uint32_t Emulate6502(uint32_t runto)
3799 {
3800 /* If the CPU is jammed... don't bother */
3801 if(bCPUJammed == 1)
3802 return 0;
3803
3804 register union TWIN tw; /* used in calculations */
3805 register uint8_t ST = regP;
3806 register union TWIN PC;
3807 uint8_t SP = regSP;
3808 register uint8_t A = regA;
3809 register uint8_t X = regX;
3810 register uint8_t Y = regY;
3811 union TWIN front;
3812 union TWIN final;
3813 PC.W = regPC;
3814
3815 uint32_t ret = nCPUCycle;
3816
3817 ENTER_TIMER(cpu);
3818
3819 /* Start the loop */
3820
3821 while(nCPUCycle < runto)
3822 {
3823 op = Rd(PC.W);
3824 PC.W++;
3825
3826 nCPUCycle += CPU_Cycles[op];
3827 switch(op)
3828 {
3829 /* Documented Opcodes first */
3830
3831 /* Flag setting/clearing */
3832 case 0x18: ST &= ~C_FLAG; break; /* CLC */
3833 case 0x38: ST |= C_FLAG; break; /* SEC */
3834 case 0x58: ST &= ~I_FLAG; break; /* CLI */
3835 case 0x78: ST |= I_FLAG; break; /* SEI */
3836 case 0xB8: ST &= ~V_FLAG; break; /* CLV */
3837 case 0xD8: ST &= ~D_FLAG; break; /* CLD */
3838 case 0xF8: ST |= D_FLAG; break; /* SED */
3839
3840 /* Branch commands */
3841 case 0x10: RelJmp(!(ST & N_FLAG)); break; /* BPL */
3842 case 0x30: RelJmp( (ST & N_FLAG)); break; /* BMI */
3843 case 0x50: RelJmp(!(ST & V_FLAG)); break; /* BVC */
3844 case 0x70: RelJmp( (ST & V_FLAG)); break; /* BVS */
3845 case 0x90: RelJmp(!(ST & C_FLAG)); break; /* BCC */
3846 case 0xB0: RelJmp( (ST & C_FLAG)); break; /* BCS */
3847 case 0xD0: RelJmp(!(ST & Z_FLAG)); break; /* BNE */
3848 case 0xF0: RelJmp( (ST & Z_FLAG)); break; /* BEQ */
3849
3850 /* Direct stack alteration commands (push/pull commands) */
3851 case 0x08: PUSH(ST | R_FLAG | B_FLAG); break; /* PHP */
3852 case 0x28: PULL(ST); break; /* PLP */
3853 case 0x48: PUSH(A); break; /* PHA */
3854 case 0x68: PULL(A); UpdateNZ(A); break; /* PLA */
3855
3856 /* Register Transfers */
3857 case 0x8A: A = X; UpdateNZ(A); break; /* TXA */
3858 case 0x98: A = Y; UpdateNZ(A); break; /* TYA */
3859 case 0x9A: SP = X; break; /* TXS */
3860 case 0xA8: Y = A; UpdateNZ(A); break; /* TAY */
3861 case 0xAA: X = A; UpdateNZ(A); break; /* TAX */
3862 case 0xBA: X = SP; UpdateNZ(X); break; /* TSX */
3863
3864 /* Other commands */
3865
3866 /* ADC */
3867 case 0x61: Ad_VlIx(); ADC(); break;
3868 case 0x65: Ad_VlZp(); ADC(); break;
3869 case 0x69: Ad_VlIm(); ADC(); break;
3870 case 0x6D: Ad_VlAb(); ADC(); break;
3871 case 0x71: Ad_VlIy(); ADC(); break;
3872 case 0x75: Ad_VlZx(); ADC(); break;
3873 case 0x79: Ad_VlAy(); ADC(); break;
3874 case 0x7D: Ad_VlAx(); ADC(); break;
3875
3876 /* AND */
3877 case 0x21: Ad_VlIx(); AND(); break;
3878 case 0x25: Ad_VlZp(); AND(); break;
3879 case 0x29: Ad_VlIm(); AND(); break;
3880 case 0x2D: Ad_VlAb(); AND(); break;
3881 case 0x31: Ad_VlIy(); AND(); break;
3882 case 0x35: Ad_VlZx(); AND(); break;
3883 case 0x39: Ad_VlAy(); AND(); break;
3884 case 0x3D: Ad_VlAx(); AND(); break;
3885
3886 /* ASL */
3887 case 0x0A: ASL(A); break;
3888 case 0x06: MRW_Zp(ASL); break;
3889 case 0x0E: MRW_Ab(ASL); break;
3890 case 0x16: MRW_Zx(ASL); break;
3891 case 0x1E: MRW_Ax(ASL); break;
3892
3893 /* BIT */
3894 case 0x24: Ad_VlZp(); BIT(); break;
3895 case 0x2C: Ad_VlAb(); BIT(); break;
3896
3897 /* BRK */
3898 case 0x00:
3899 if(bIgnoreBRK)
3900 break;
3901 PC.W++; /*BRK has a padding byte*/
3902 PUSH(PC.B.h); /*push high byte of the return address*/
3903 PUSH(PC.B.l); /*push low byte of return address*/
3904 PUSH(ST | R_FLAG | B_FLAG); /*push processor status with R|B flags*/
3905 ST |= I_FLAG; /*mask interrupts*/
3906 PC.W = RdWord(0xFFFE); /*read the IRQ vector and jump to it*/
3907
3908 /* extra check to make sure we didn't hit an infinite BRK loop */
3909 if(!Rd(PC.W)) /* next command will be BRK */
3910 {
3911 /* the CPU will endlessly loop...
3912 just jam it to ease processing power */
3913 bCPUJammed = 1;
3914 goto jammed;
3915 }
3916 break;
3917
3918 /* CMP */
3919 case 0xC1: Ad_VlIx(); CMP(A); break;
3920 case 0xC5: Ad_VlZp(); CMP(A); break;
3921 case 0xC9: Ad_VlIm(); CMP(A); break;
3922 case 0xCD: Ad_VlAb(); CMP(A); break;
3923 case 0xD1: Ad_VlIy(); CMP(A); break;
3924 case 0xD5: Ad_VlZx(); CMP(A); break;
3925 case 0xD9: Ad_VlAy(); CMP(A); break;
3926 case 0xDD: Ad_VlAx(); CMP(A); break;
3927
3928 /* CPX */
3929 case 0xE0: Ad_VlIm(); CMP(X); break;
3930 case 0xE4: Ad_VlZp(); CMP(X); break;
3931 case 0xEC: Ad_VlAb(); CMP(X); break;
3932
3933 /* CPY */
3934 case 0xC0: Ad_VlIm(); CMP(Y); break;
3935 case 0xC4: Ad_VlZp(); CMP(Y); break;
3936 case 0xCC: Ad_VlAb(); CMP(Y); break;
3937
3938 /* DEC */
3939 case 0xCA: DEC(X); break; /* DEX */
3940 case 0x88: DEC(Y); break; /* DEY */
3941 case 0xC6: MRW_Zp(DEC); break;
3942 case 0xCE: MRW_Ab(DEC); break;
3943 case 0xD6: MRW_Zx(DEC); break;
3944 case 0xDE: MRW_Ax(DEC); break;
3945
3946 /* EOR */
3947 case 0x41: Ad_VlIx(); EOR(); break;
3948 case 0x45: Ad_VlZp(); EOR(); break;
3949 case 0x49: Ad_VlIm(); EOR(); break;
3950 case 0x4D: Ad_VlAb(); EOR(); break;
3951 case 0x51: Ad_VlIy(); EOR(); break;
3952 case 0x55: Ad_VlZx(); EOR(); break;
3953 case 0x59: Ad_VlAy(); EOR(); break;
3954 case 0x5D: Ad_VlAx(); EOR(); break;
3955
3956 /* INC */
3957 case 0xE8: INC(X); break; /* INX */
3958 case 0xC8: INC(Y); break; /* INY */
3959 case 0xE6: MRW_Zp(INC); break;
3960 case 0xEE: MRW_Ab(INC); break;
3961 case 0xF6: MRW_Zx(INC); break;
3962 case 0xFE: MRW_Ax(INC); break;
3963
3964 /* JMP */
3965 /* Absolute JMP */
3966 case 0x4C: final.W = RdWord(PC.W); PC.W = final.W; val = 0; break;
3967 /* Indirect JMP -- must take caution:
3968 Indirection at 01FF will read from 01FF and 0100 (not 0200) */
3969 case 0x6C: front.W = final.W = RdWord(PC.W);
3970 PC.B.l = Rd(final.W); final.B.l++;
3971 PC.B.h = Rd(final.W); final.W = PC.W;
3972 break;
3973 /* JSR */
3974 case 0x20:
3975 val = 0;
3976 final.W = RdWord(PC.W);
3977 PC.W++; /* JSR only increments the return address by one.
3978 It's incremented again upon RTS */
3979 PUSH(PC.B.h); /* push high byte of return address */
3980 PUSH(PC.B.l); /* push low byte of return address */
3981 PC.W = final.W;
3982 break;
3983
3984 /* LDA */
3985 case 0xA1: Ad_VlIx(); A = val; UpdateNZ(A); break;
3986 case 0xA5: Ad_VlZp(); A = val; UpdateNZ(A); break;
3987 case 0xA9: Ad_VlIm(); A = val; UpdateNZ(A); break;
3988 case 0xAD: Ad_VlAb(); A = val; UpdateNZ(A); break;
3989 case 0xB1: Ad_VlIy(); A = val; UpdateNZ(A); break;
3990 case 0xB5: Ad_VlZx(); A = val; UpdateNZ(A); break;
3991 case 0xB9: Ad_VlAy(); A = val; UpdateNZ(A); break;
3992 case 0xBD: Ad_VlAx(); A = val; UpdateNZ(A); break;
3993
3994 /* LDX */
3995 case 0xA2: Ad_VlIm(); X = val; UpdateNZ(X); break;
3996 case 0xA6: Ad_VlZp(); X = val; UpdateNZ(X); break;
3997 case 0xAE: Ad_VlAb(); X = val; UpdateNZ(X); break;
3998 case 0xB6: Ad_VlZy(); X = val; UpdateNZ(X); break;
3999 case 0xBE: Ad_VlAy(); X = val; UpdateNZ(X); break;
4000
4001 /* LDY */
4002 case 0xA0: Ad_VlIm(); Y = val; UpdateNZ(Y); break;
4003 case 0xA4: Ad_VlZp(); Y = val; UpdateNZ(Y); break;
4004 case 0xAC: Ad_VlAb(); Y = val; UpdateNZ(Y); break;
4005 case 0xB4: Ad_VlZx(); Y = val; UpdateNZ(Y); break;
4006 case 0xBC: Ad_VlAx(); Y = val; UpdateNZ(Y); break;
4007
4008 /* LSR */
4009 case 0x4A: LSR(A); break;
4010 case 0x46: MRW_Zp(LSR); break;
4011 case 0x4E: MRW_Ab(LSR); break;
4012 case 0x56: MRW_Zx(LSR); break;
4013 case 0x5E: MRW_Ax(LSR); break;
4014
4015 /* NOP */
4016 case 0xEA:
4017
4018 /* --- Undocumented ---
4019 These opcodes perform the same action as NOP */
4020 case 0x1A: case 0x3A: case 0x5A:
4021 case 0x7A: case 0xDA: case 0xFA: break;
4022
4023 /* ORA */
4024 case 0x01: Ad_VlIx(); ORA(); break;
4025 case 0x05: Ad_VlZp(); ORA(); break;
4026 case 0x09: Ad_VlIm(); ORA(); break;
4027 case 0x0D: Ad_VlAb(); ORA(); break;
4028 case 0x11: Ad_VlIy(); ORA(); break;
4029 case 0x15: Ad_VlZx(); ORA(); break;
4030 case 0x19: Ad_VlAy(); ORA(); break;
4031 case 0x1D: Ad_VlAx(); ORA(); break;
4032
4033 /* ROL */
4034 case 0x2A: ROL(A); break;
4035 case 0x26: MRW_Zp(ROL); break;
4036 case 0x2E: MRW_Ab(ROL); break;
4037 case 0x36: MRW_Zx(ROL); break;
4038 case 0x3E: MRW_Ax(ROL); break;
4039
4040 /* ROR */
4041 case 0x6A: ROR(A); break;
4042 case 0x66: MRW_Zp(ROR); break;
4043 case 0x6E: MRW_Ab(ROR); break;
4044 case 0x76: MRW_Zx(ROR); break;
4045 case 0x7E: MRW_Ax(ROR); break;
4046
4047 /* RTI */
4048 case 0x40:
4049 PULL(ST); /*pull processor status*/
4050 PULL(PC.B.l); /*pull low byte of return address*/
4051 PULL(PC.B.h); /*pull high byte of return address*/
4052 break;
4053
4054 /* RTS */
4055 case 0x60:
4056 PULL(PC.B.l);
4057 PULL(PC.B.h);
4058 PC.W++; /* the return address is one less of what it needs */
4059 break;
4060
4061 /* SBC */
4062 case 0xE1: Ad_VlIx(); SBC(); break;
4063 case 0xE5: Ad_VlZp(); SBC(); break;
4064 /* - Undocumented - EB performs the same operation as SBC immediate */
4065 case 0xEB:
4066 case 0xE9: Ad_VlIm(); SBC(); break;
4067 case 0xED: Ad_VlAb(); SBC(); break;
4068 case 0xF1: Ad_VlIy(); SBC(); break;
4069 case 0xF5: Ad_VlZx(); SBC(); break;
4070 case 0xF9: Ad_VlAy(); SBC(); break;
4071 case 0xFD: Ad_VlAx(); SBC(); break;
4072
4073 /* STA */
4074 case 0x81: Ad_AdIx(); val = A; Wr(final.W,A); break;
4075 case 0x85: Ad_AdZp(); val = A; WrZ(final.W,A); break;
4076 case 0x8D: Ad_AdAb(); val = A; Wr(final.W,A); break;
4077 case 0x91: Ad_AdIy(); val = A; Wr(final.W,A); break;
4078 case 0x95: Ad_AdZx(); val = A; WrZ(final.W,A); break;
4079 case 0x99: Ad_AdAy(); val = A; Wr(final.W,A); break;
4080 case 0x9D: Ad_AdAx(); val = A; Wr(final.W,A); break;
4081
4082 /* STX */
4083 case 0x86: Ad_AdZp(); val = X; WrZ(final.W,X); break;
4084 case 0x8E: Ad_AdAb(); val = X; Wr(final.W,X); break;
4085 case 0x96: Ad_AdZy(); val = X; WrZ(final.W,X); break;
4086
4087 /* STY */
4088 case 0x84: Ad_AdZp(); val = Y; WrZ(final.W,Y); break;
4089 case 0x8C: Ad_AdAb(); val = Y; Wr(final.W,Y); break;
4090 case 0x94: Ad_AdZx(); val = Y; WrZ(final.W,Y); break;
4091
4092 /* Undocumented Opcodes */
4093 /* ASO */
4094 case 0x03: if(bIgnoreIllegalOps) break; MRW_Ix(ASO); break;
4095 case 0x07: if(bIgnoreIllegalOps) break; MRW_Zp(ASO); break;
4096 case 0x0F: if(bIgnoreIllegalOps) break; MRW_Ab(ASO); break;
4097 case 0x13: if(bIgnoreIllegalOps) break; MRW_Iy(ASO); break;
4098 case 0x17: if(bIgnoreIllegalOps) break; MRW_Zx(ASO); break;
4099 case 0x1B: if(bIgnoreIllegalOps) break; MRW_Ay(ASO); break;
4100 case 0x1F: if(bIgnoreIllegalOps) break; MRW_Ax(ASO); break;
4101
4102 /* RLA */
4103 case 0x23: if(bIgnoreIllegalOps) break; MRW_Ix(RLA); break;
4104 case 0x27: if(bIgnoreIllegalOps) break; MRW_Zp(RLA); break;
4105 case 0x2F: if(bIgnoreIllegalOps) break; MRW_Ab(RLA); break;
4106 case 0x33: if(bIgnoreIllegalOps) break; MRW_Iy(RLA); break;
4107 case 0x37: if(bIgnoreIllegalOps) break; MRW_Zx(RLA); break;
4108 case 0x3B: if(bIgnoreIllegalOps) break; MRW_Ay(RLA); break;
4109 case 0x3F: if(bIgnoreIllegalOps) break; MRW_Ax(RLA); break;
4110
4111 /* LSE */
4112 case 0x43: if(bIgnoreIllegalOps) break; MRW_Ix(LSE); break;
4113 case 0x47: if(bIgnoreIllegalOps) break; MRW_Zp(LSE); break;
4114 case 0x4F: if(bIgnoreIllegalOps) break; MRW_Ab(LSE); break;
4115 case 0x53: if(bIgnoreIllegalOps) break; MRW_Iy(LSE); break;
4116 case 0x57: if(bIgnoreIllegalOps) break; MRW_Zx(LSE); break;
4117 case 0x5B: if(bIgnoreIllegalOps) break; MRW_Ay(LSE); break;
4118 case 0x5F: if(bIgnoreIllegalOps) break; MRW_Ax(LSE); break;
4119
4120 /* RRA */
4121 case 0x63: if(bIgnoreIllegalOps) break; MRW_Ix(RRA); break;
4122 case 0x67: if(bIgnoreIllegalOps) break; MRW_Zp(RRA); break;
4123 case 0x6F: if(bIgnoreIllegalOps) break; MRW_Ab(RRA); break;
4124 case 0x73: if(bIgnoreIllegalOps) break; MRW_Iy(RRA); break;
4125 case 0x77: if(bIgnoreIllegalOps) break; MRW_Zx(RRA); break;
4126 case 0x7B: if(bIgnoreIllegalOps) break; MRW_Ay(RRA); break;
4127 case 0x7F: if(bIgnoreIllegalOps) break; MRW_Ax(RRA); break;
4128
4129 /* AXS */
4130 case 0x83: if(bIgnoreIllegalOps) break; MRW_Ix(AXS); break;
4131 case 0x87: if(bIgnoreIllegalOps) break; MRW_Zp(AXS); break;
4132 case 0x8F: if(bIgnoreIllegalOps) break; MRW_Ab(AXS); break;
4133 case 0x97: if(bIgnoreIllegalOps) break; MRW_Zy(AXS); break;
4134
4135 /* LAX */
4136 case 0xA3: if(bIgnoreIllegalOps) break;
4137 Ad_VlIx(); X = A = val; UpdateNZ(A); break;
4138 case 0xA7: if(bIgnoreIllegalOps) break;
4139 Ad_VlZp(); X = A = val; UpdateNZ(A); break;
4140 case 0xAF: if(bIgnoreIllegalOps) break;
4141 Ad_VlAb(); X = A = val; UpdateNZ(A); break;
4142 case 0xB3: if(bIgnoreIllegalOps) break;
4143 Ad_VlIy(); X = A = val; UpdateNZ(A); break;
4144 case 0xB7: if(bIgnoreIllegalOps) break;
4145 Ad_VlZy(); X = A = val; UpdateNZ(A); break;
4146 case 0xBF: if(bIgnoreIllegalOps) break;
4147 Ad_VlAy(); X = A = val; UpdateNZ(A); break;
4148
4149 /* DCM */
4150 case 0xC3: if(bIgnoreIllegalOps) break; MRW_Ix(DCM); break;
4151 case 0xC7: if(bIgnoreIllegalOps) break; MRW_Zp(DCM); break;
4152 case 0xCF: if(bIgnoreIllegalOps) break; MRW_Ab(DCM); break;
4153 case 0xD3: if(bIgnoreIllegalOps) break; MRW_Iy(DCM); break;
4154 case 0xD7: if(bIgnoreIllegalOps) break; MRW_Zx(DCM); break;
4155 case 0xDB: if(bIgnoreIllegalOps) break; MRW_Ay(DCM); break;
4156 case 0xDF: if(bIgnoreIllegalOps) break; MRW_Ax(DCM); break;
4157
4158 /* INS */
4159 case 0xE3: if(bIgnoreIllegalOps) break; MRW_Ix(INS); break;
4160 case 0xE7: if(bIgnoreIllegalOps) break; MRW_Zp(INS); break;
4161 case 0xEF: if(bIgnoreIllegalOps) break; MRW_Ab(INS); break;
4162 case 0xF3: if(bIgnoreIllegalOps) break; MRW_Iy(INS); break;
4163 case 0xF7: if(bIgnoreIllegalOps) break; MRW_Zx(INS); break;
4164 case 0xFB: if(bIgnoreIllegalOps) break; MRW_Ay(INS); break;
4165 case 0xFF: if(bIgnoreIllegalOps) break; MRW_Ax(INS); break;
4166
4167 /* ALR
4168 AND Accumulator with memory and LSR the result */
4169 case 0x4B: if(bIgnoreIllegalOps) break;
4170 Ad_VlIm(); A &= val; LSR(A); break;
4171
4172 /* ARR
4173 ANDs memory with the Accumulator and RORs the result */
4174 case 0x6B: if(bIgnoreIllegalOps) break;
4175 Ad_VlIm(); A &= val; ROR(A); break;
4176
4177 /* XAA
4178 Transfers X -> A, then ANDs A with memory */
4179 case 0x8B: if(bIgnoreIllegalOps) break;
4180 Ad_VlIm(); A = X & val; UpdateNZ(A); break;
4181
4182 /* OAL
4183 OR the Accumulator with #EE, AND Accumulator with Memory,
4184 Transfer A -> X */
4185 case 0xAB: if(bIgnoreIllegalOps) break;
4186 Ad_VlIm(); X = (A &= (val | 0xEE));
4187 UpdateNZ(A); break;
4188
4189 /* SAX
4190 ANDs A and X registers (does not change A), subtracts memory
4191 from result (CMP style, not SBC style) result is stored in X */
4192 case 0xCB: if(bIgnoreIllegalOps) break;
4193 Ad_VlIm(); tw.W = (X & A) - val; X = tw.B.l;
4194 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) | NZTable[X] |
4195 (tw.B.h ? C_FLAG : 0); break;
4196 /* SKB
4197 Skip Byte... or DOP - Double No-Op
4198 These bytes do nothing, but take a parameter (which can be
4199 ignored) */
4200 case 0x04: case 0x14: case 0x34: case 0x44: case 0x54: case 0x64:
4201 case 0x80: case 0x82: case 0x89: case 0xC2: case 0xD4: case 0xE2:
4202 case 0xF4:
4203 if(bIgnoreIllegalOps) break;
4204 PC.W++; /* skip unused byte */
4205 break;
4206
4207 /* SKW
4208 Swip Word... or TOP - Tripple No-Op
4209 These bytes are the same as SKB, only they take a 2 byte parameter.
4210 This can be ignored in some cases, but the read needs to be
4211 performed in a some cases because an extra clock cycle may be used
4212 in the process */
4213 /* Absolute address... no need for operator */
4214 case 0x0C:
4215 if(bIgnoreIllegalOps) break;
4216 PC.W += 2; break;
4217 /* Absolute X address... may cross page, have to perform the read */
4218 case 0x1C: case 0x3C: case 0x5C: case 0x7C: case 0xDC: case 0xFC:
4219 if(bIgnoreIllegalOps) break;
4220 Ad_VlAx(); break;
4221
4222 /* HLT / JAM
4223 Jams up CPU operation */
4224 case 0x02: case 0x12: case 0x22: case 0x32: case 0x42: case 0x52:
4225 case 0x62: case 0x72: case 0x92: case 0xB2: case 0xD2: case 0xF2:
4226 /*it's not -really- jammed... only the NSF code has ended*/
4227 if(PC.W == 0x5004) bCPUJammed = 2;
4228 else
4229 {
4230 if(bIgnoreIllegalOps) break;
4231 bCPUJammed = 1;
4232 }
4233 goto jammed;
4234
4235 /* TAS */
4236 case 0x9B:
4237 if(bIgnoreIllegalOps) break;
4238 Ad_AdAy();
4239 SP = A & X & (Rd(PC.W - 1) + 1);
4240 Wr(final.W,SP);
4241 break;
4242
4243 /* SAY */
4244 case 0x9C:
4245 if(bIgnoreIllegalOps) break;
4246 Ad_AdAx();
4247 Y &= (Rd(PC.W - 1) + 1);
4248 Wr(final.W,Y);
4249 break;
4250
4251 /* XAS */
4252 case 0x9E:
4253 if(bIgnoreIllegalOps) break;
4254 Ad_AdAy();
4255 X &= (Rd(PC.W - 1) + 1);
4256 Wr(final.W,X);
4257 break;
4258
4259 /* AXA */
4260 case 0x93: if(bIgnoreIllegalOps) break; MRW_Iy(AXA); break;
4261 case 0x9F: if(bIgnoreIllegalOps) break; MRW_Ay(AXA); break;
4262
4263 /* ANC */
4264 case 0x0B: case 0x2B:
4265 if(bIgnoreIllegalOps) break;
4266 Ad_VlIm();
4267 A &= val;
4268 ST = (ST & ~(N_FLAG|Z_FLAG|C_FLAG)) |
4269 NZTable[A] | ((A & 0x80) ? C_FLAG : 0);
4270 break;
4271
4272 /* LAS */
4273 case 0xBB:
4274 if(bIgnoreIllegalOps) break;
4275 Ad_VlAy();
4276 X = A = (SP &= val);
4277 UpdateNZ(A);
4278 break;
4279 }
4280 }
4281
4282 jammed:
4283 regPC = PC.W;
4284 regA = A;
4285 regX = X;
4286 regY = Y;
4287 regSP = SP;
4288 regP = ST;
4289
4290 EXIT_TIMER(cpu);
4291
4292 return (nCPUCycle - ret);
4293 }
4294
4295 /****************** rockbox interface ******************/
4296
4297 static void set_codec_track(int t, int d) {
4298 int track,fade,def=0;
4299 SetTrack(t);
4300
4301 /* for REPEAT_ONE we disable track limits */
4302 if (ci->global_settings->repeat_mode!=REPEAT_ONE) {
4303 if (!bIsExtended || nTrackTime[t]==-1) {track=60*2*1000; def=1;}
4304 else track=nTrackTime[t];
4305 if (!bIsExtended || nTrackFade[t]==-1) fade=5*1000;
4306 else fade=nTrackFade[t];
4307 nSilenceTrackMS=5000;
4308 SetFadeTime(track,track+fade, fNSFPlaybackSpeed,def);
4309 }
4310 ci->id3->elapsed=d*1000; /* d is track no to display */
4311 }
4312
4313 /* this is the codec entry point */
4314 enum codec_status codec_main(void)
4315 {
4316 int written;
4317 uint8_t *buf;
4318 size_t n;
4319 int endofstream; /* end of stream flag */
4320 int track;
4321 int dontresettrack;
4322 char last_path[MAX_PATH];
4323 int usingplaylist;
4324
4325 /* we only render 16 bits */
4326 ci->configure(DSP_SET_SAMPLE_DEPTH, 16);
4327
4328 ci->configure(DSP_SET_FREQUENCY, 44100);
4329 ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
4330
4331 RebuildOutputTables();
4332
4333 dontresettrack=0;
4334 last_path[0]='\0';
4335 track=0;
4336
4337 next_track:
4338 usingplaylist=0;
4339 DEBUGF("NSF: next_track\n");
4340 if (codec_init()) {
4341 return CODEC_ERROR;
4342 }
4343 DEBUGF("NSF: after init\n");
4344
4345
4346 /* wait for track info to load */
4347 while (!*ci->taginfo_ready && !ci->stop_codec)
4348 ci->sleep(1);
4349
4350 codec_set_replaygain(ci->id3);
4351
4352 /* Read the entire file */
4353 DEBUGF("NSF: request file\n");
4354 ci->seek_buffer(0);
4355 buf = ci->request_buffer(&n, ci->filesize);
4356 if (!buf || n < (size_t)ci->filesize) {
4357 DEBUGF("NSF: file load failed\n");
4358 return CODEC_ERROR;
4359 }
4360
4361 init_nsf:
4362 if(!NSFCore_Initialize()) {
4363 DEBUGF("NSF: NSFCore_Initialize failed\n"); return CODEC_ERROR;}
4364
4365 if(LoadFile(buf,ci->filesize)) {
4366 DEBUGF("NSF: LoadFile failed\n"); return CODEC_ERROR;}
4367 if(!SetPlaybackOptions(44100)) {
4368 DEBUGF("NSF: SetPlaybackOptions failed\n"); return CODEC_ERROR;}
4369 if(!LoadNSF(nDataBufferSize)) {
4370 DEBUGF("NSF: LoadNSF failed\n"); return CODEC_ERROR;}
4371
4372 ci->id3->title=szGameTitle;
4373 ci->id3->artist=szArtist;
4374 ci->id3->album=szCopyright;
4375 if (usingplaylist) {
4376 ci->id3->length=nPlaylistSize*1000;
4377 } else {
4378 ci->id3->length=nTrackCount*1000;
4379 }
4380
4381 if (!dontresettrack||strcmp(ci->id3->path,last_path)) {
4382 /* if this is the first time we're seeing this file, or if we haven't
4383 been asked to preserve the track number, default to the proper
4384 initial track */
4385 if (bIsExtended &&
4386 ci->global_settings->repeat_mode!=REPEAT_ONE && nPlaylistSize>0) {
4387 /* decide to use the playlist */
4388 usingplaylist=1;
4389 track=0;
4390 set_codec_track(nPlaylist[0],0);
4391 } else {
4392 /* simply use the initial track */
4393 track=nInitialTrack;
4394 set_codec_track(track,track);
4395 }
4396 } else {
4397 /* if we've already been running this file assume track is set
4398 already */
4399 if (usingplaylist) set_codec_track(nPlaylist[track],track);
4400 else set_codec_track(track,track);
4401 }
4402 strcpy(last_path,ci->id3->path);
4403
4404 /* The main decoder loop */
4405
4406 endofstream = 0;
4407
4408 reset_profile_timers();
4409
4410 while (!endofstream) {
4411
4412 ci->yield();
4413 if (ci->stop_codec || ci->new_track) {
4414 break;
4415 }
4416
4417 if (ci->seek_time >0) {
4418 track=ci->seek_time/1000;
4419 if (usingplaylist) {
4420 if (track>=nPlaylistSize) break;
4421 } else {
4422 if (track>=nTrackCount) break;
4423 }
4424 ci->seek_complete();
4425 dontresettrack=1;
4426 goto init_nsf;
4427 }
4428
4429 ENTER_TIMER(total);
4430 written=GetSamples((uint8_t*)samples,WAV_CHUNK_SIZE/2);
4431 EXIT_TIMER(total);
4432
4433 if (!written || SongCompleted()) {
4434 print_timers(last_path,track);
4435 reset_profile_timers();
4436
4437 track++;
4438 if (usingplaylist) {
4439 if (track>=nPlaylistSize) break;
4440 } else {
4441 if (track>=nTrackCount) break;
4442 }
4443 dontresettrack=1;
4444 goto init_nsf;
4445 }
4446
4447 ci->pcmbuf_insert(samples, NULL, written >> 1);
4448 }
4449
4450 print_timers(last_path,track);
4451
4452 if (ci->request_next_track()) {
4453 if (ci->global_settings->repeat_mode==REPEAT_ONE) {
4454 /* in repeat one mode just advance to the next track */
4455 track++;
4456 if (track>=nTrackCount) track=0;
4457 dontresettrack=1;
4458 /* at this point we can't tell if another file has been selected */
4459 goto next_track;
4460 } else {
4461 /* otherwise do a proper load of the next file */
4462 dontresettrack=0;
4463 last_path[0]='\0';
4464 }
4465 goto next_track; /* when we fall through here we'll reload the file */
4466 }
4467
4468 return CODEC_OK;
4469 }
My public Rockbox git repo