src/emu/sound/sn76496.c
| r6409 | r6410 | |
| 30 | 30 | The register, connected to a z80 port, means: |
| 31 | 31 | for bits 7 6 5 4 3 2 1 0 |
| 32 | 32 | L3 L2 L1 L0 R3 R2 R1 R0 |
| 33 | Noise is an XOR function, and audio output is negated before being output. |
| 33 | 34 | ** NCR7496 (as used on the Tandy 1000) is similar to the SN76489 but with a |
| 34 | 35 | different noise LFSR patttern: taps on bits A and E, output on E |
| 35 | 36 | It uses a 15-bit ring buffer for periodic noise/arbitrary duty cycle. |
| r6409 | r6410 | |
| 62 | 63 | Fix screeching in regulus: When summing together four equal channels, the |
| 63 | 64 | size of the max amplitude per channel should be 1/4 of the max range, not |
| 64 | 65 | 1/3. Added NCR7496. |
| 66 | |
| 67 | 18/11/2009 : Lord Nightmare |
| 68 | Modify Init functions to support negating the audio output. The gamegear |
| 69 | psg does this. Change gamegear and sega psgs to use XOR rather than XNOR |
| 70 | based on testing. Got rid of R->OldNoise and fixed taps accordingly. |
| 71 | Added stereo support for game gear. |
| 65 | 72 | |
| 66 | | TODO: * Implement a function for setting stereo regs for the game gear. |
| 67 | | Requires making the core support both mono and stereo, and have |
| 68 | | a select register which determines which channels go where. |
| 69 | | * Implement the TMS9919 which is an earlier version, possibly |
| 73 | TODO: * Implement the TMS9919 which is an earlier version, possibly |
| 70 | 74 | lacking the /8 clock divider, of the SN76489, and hence would |
| 71 | 75 | have a max clock of 500Khz and 4 clocks per sample, as opposed to |
| 72 | 76 | max of 4Mhz and 32 clocks per sample on the SN76489A. |
| r6409 | r6410 | |
| 74 | 78 | to be 'sanitized' first. Also is stereo, similar to game gear. |
| 75 | 79 | * Test the NCR7496; Smspower says the whitenoise taps are A and E, |
| 76 | 80 | but this needs verification on real hardware. |
| 77 | | * Test the SMS PSG/Gamegear PSG to see whether it uses XOR or XNOR |
| 78 | | taps. (17/11/2009: this seems to be XNOR? Need a better sample.) |
| 79 | 81 | * Factor out common code so that the SAA1099 can share some code. |
| 80 | 82 | ***************************************************************************/ |
| 81 | 83 | |
| r6409 | r6410 | |
| 101 | 103 | INT32 FeedbackMask; /* mask for feedback */ |
| 102 | 104 | INT32 WhitenoiseTaps; /* mask for white noise taps */ |
| 103 | 105 | INT32 FeedbackInvert; /* feedback invert flag (xor vs xnor) */ |
| 106 | INT32 Negate; /* output negate flag */ |
| 107 | INT32 Stereo; /* whether we're dealing with stereo or not */ |
| 108 | INT32 StereoMask; /* the stereo output mask */ |
| 104 | 109 | INT32 Period[4]; /* Length of 1/2 of waveform */ |
| 105 | 110 | INT32 Count[4]; /* Position within the waveform */ |
| 106 | | INT32 OldNoise; /* 1 bit output of the PREVIOUS noise output */ |
| 107 | 111 | INT32 Output[4]; /* 1-bit output of each channel, pre-volume */ |
| 108 | 112 | INT32 CyclestoREADY;/* number of cycles until the READY line goes active */ |
| 109 | 113 | }; |
| r6409 | r6410 | |
| 132 | 136 | return (R->CyclestoREADY? 0 : 1); |
| 133 | 137 | } |
| 134 | 138 | |
| 139 | WRITE8_DEVICE_HANDLER( sn76496_stereo_w ) |
| 140 | { |
| 141 | sn76496_state *R = get_safe_token(device); |
| 142 | stream_update(R->Channel); |
| 143 | if (R->Stereo) R->StereoMask = data; |
| 144 | else fatalerror("Call to stereo write with mono chip!\n"); |
| 145 | } |
| 146 | |
| 135 | 147 | WRITE8_DEVICE_HANDLER( sn76496_w ) |
| 136 | 148 | { |
| 137 | 149 | sn76496_state *R = get_safe_token(device); |
| r6409 | r6410 | |
| 192 | 204 | R->Period[3] = ((n&3) == 3) ? 2 * R->Period[2] : (1 << (5+(n&3))); |
| 193 | 205 | /* Reset noise shifter */ |
| 194 | 206 | R->RNG = R->FeedbackMask; |
| 195 | | R->OldNoise = 0; |
| 196 | | R->Output[3] = R->OldNoise; |
| 197 | | R->OldNoise = R->RNG & 1; |
| 207 | R->Output[3] = R->RNG & 1; |
| 198 | 208 | } |
| 199 | 209 | break; |
| 200 | 210 | } |
| r6409 | r6410 | |
| 204 | 214 | { |
| 205 | 215 | int i; |
| 206 | 216 | sn76496_state *R = (sn76496_state *)param; |
| 207 | | stream_sample_t *buffer = outputs[0]; |
| 217 | stream_sample_t *lbuffer = outputs[0]; |
| 218 | stream_sample_t *rbuffer = outputs[1]; |
| 208 | 219 | |
| 209 | | |
| 210 | 220 | while (samples > 0) |
| 211 | 221 | { |
| 212 | 222 | // clock chip once |
| 213 | | INT16 out; |
| 223 | INT16 out = 0; |
| 224 | INT16 out2 = 0; |
| 214 | 225 | |
| 215 | 226 | /* decrement Cycles to READY by one */ |
| 216 | 227 | if (R->CyclestoREADY >0) R->CyclestoREADY--; |
| r6409 | r6410 | |
| 254 | 265 | R->RNG >>= 1; |
| 255 | 266 | } |
| 256 | 267 | } |
| 257 | | R->Output[3] = R->OldNoise; |
| 258 | | R->OldNoise = R->RNG & 1; |
| 268 | R->Output[3] = R->RNG & 1; |
| 259 | 269 | R->Count[3] = R->Period[3]; |
| 260 | 270 | } |
| 261 | 271 | /* //bipolar output, doesn't seem to work right with sonic 2 on gamegear at least |
| r6409 | r6410 | |
| 264 | 274 | +(R->Output[2]?R->Volume[2]:(0-R->Volume[2])) |
| 265 | 275 | +(R->Output[3]?R->Volume[3]:(0-R->Volume[3])); |
| 266 | 276 | */ |
| 267 | | out = (R->Output[0]?R->Volume[0]:0) |
| 268 | | +(R->Output[1]?R->Volume[1]:0) |
| 269 | | +(R->Output[2]?R->Volume[2]:0) |
| 270 | | +(R->Output[3]?R->Volume[3]:0); |
| 277 | if (R->Stereo) |
| 278 | { |
| 279 | out = (((R->StereoMask&0x10)&&R->Output[0])?R->Volume[0]:0) |
| 280 | + (((R->StereoMask&0x20)&&R->Output[1])?R->Volume[1]:0) |
| 281 | + (((R->StereoMask&0x40)&&R->Output[2])?R->Volume[2]:0) |
| 282 | + (((R->StereoMask&0x80)&&R->Output[3])?R->Volume[3]:0); |
| 283 | |
| 284 | out2 = (((R->StereoMask&0x1)&&R->Output[0])?R->Volume[0]:0) |
| 285 | + (((R->StereoMask&0x2)&&R->Output[1])?R->Volume[1]:0) |
| 286 | + (((R->StereoMask&0x4)&&R->Output[2])?R->Volume[2]:0) |
| 287 | + (((R->StereoMask&0x8)&&R->Output[3])?R->Volume[3]:0); |
| 288 | } |
| 289 | else |
| 290 | { |
| 291 | out = (R->Output[0]?R->Volume[0]:0) |
| 292 | +(R->Output[1]?R->Volume[1]:0) |
| 293 | +(R->Output[2]?R->Volume[2]:0) |
| 294 | +(R->Output[3]?R->Volume[3]:0); |
| 295 | } |
| 271 | 296 | |
| 272 | | *(buffer++) = out; |
| 297 | if(R->Negate) { out = -out; out2 = -out2; } |
| 273 | 298 | |
| 299 | *(lbuffer++) = out; |
| 300 | if (R->Stereo) *(rbuffer++) = out2; |
| 274 | 301 | samples--; |
| 275 | 302 | } |
| 276 | 303 | } |
| r6409 | r6410 | |
| 294 | 321 | for (i = 0;i < 15;i++) |
| 295 | 322 | { |
| 296 | 323 | /* limit volume to avoid clipping */ |
| 297 | | if (out > MAX_OUTPUT / 3) R->VolTable[i] = MAX_OUTPUT / 3; |
| 324 | if (out > MAX_OUTPUT / 4) R->VolTable[i] = MAX_OUTPUT / 4; |
| 298 | 325 | else R->VolTable[i] = out; |
| 299 | 326 | |
| 300 | 327 | out /= 1.258925412; /* = 10 ^ (2/20) = 2dB */ |
| r6409 | r6410 | |
| 304 | 331 | |
| 305 | 332 | |
| 306 | 333 | |
| 307 | | static int SN76496_init(const device_config *device, sn76496_state *R) |
| 334 | static int SN76496_init(const device_config *device, sn76496_state *R, int stereo) |
| 308 | 335 | { |
| 309 | 336 | int sample_rate = device->clock/16; |
| 310 | 337 | int i; |
| 311 | 338 | |
| 312 | | R->Channel = stream_create(device,0,1,sample_rate,R,SN76496Update); |
| 339 | R->Channel = stream_create(device,0,(stereo?2:1),sample_rate,R,SN76496Update); |
| 313 | 340 | |
| 314 | 341 | for (i = 0;i < 4;i++) R->Volume[i] = 0; |
| 315 | 342 | |
| r6409 | r6410 | |
| 330 | 357 | R->WhitenoiseTaps = 0x03; /* mask for white noise taps */ |
| 331 | 358 | R->FeedbackInvert = 0; /* feedback invert flag */ |
| 332 | 359 | R->CyclestoREADY = 1; /* assume ready is not active immediately on init. is this correct?*/ |
| 360 | R->Negate = 0; /* channels are not negated */ |
| 361 | R->Stereo = stereo; /* depends on init */ |
| 362 | R->StereoMask = 0xFF; /* all channels enabled */ |
| 333 | 363 | |
| 334 | 364 | R->RNG = R->FeedbackMask; |
| 335 | | R->OldNoise = 0; |
| 336 | | R->Output[3] = R->OldNoise; |
| 337 | | R->OldNoise = R->RNG & 1; |
| 365 | R->Output[3] = R->RNG & 1; |
| 338 | 366 | |
| 339 | 367 | return 0; |
| 340 | 368 | } |
| 341 | 369 | |
| 342 | 370 | |
| 343 | | static void generic_start(const device_config *device, int feedbackmask, int noisetaps, int feedbackinvert) |
| 371 | static void generic_start(const device_config *device, int feedbackmask, int noisetaps, int feedbackinvert, int negate, int stereo) |
| 344 | 372 | { |
| 345 | 373 | sn76496_state *chip = get_safe_token(device); |
| 346 | 374 | |
| 347 | | if (SN76496_init(device,chip) != 0) |
| 375 | if (SN76496_init(device,chip,stereo) != 0) |
| 348 | 376 | fatalerror("Error creating SN76496 chip"); |
| 349 | 377 | SN76496_set_gain(chip, 0); |
| 350 | 378 | |
| 351 | 379 | chip->FeedbackMask = feedbackmask; |
| 352 | 380 | chip->WhitenoiseTaps = noisetaps; |
| 353 | 381 | chip->FeedbackInvert = feedbackinvert; |
| 382 | chip->Negate = negate; |
| 383 | chip->Stereo = stereo; |
| 354 | 384 | |
| 355 | 385 | state_save_register_device_item_array(device, 0, chip->VolTable); |
| 356 | 386 | state_save_register_device_item_array(device, 0, chip->Register); |
| r6409 | r6410 | |
| 360 | 390 | state_save_register_device_item(device, 0, chip->FeedbackMask); |
| 361 | 391 | state_save_register_device_item(device, 0, chip->WhitenoiseTaps); |
| 362 | 392 | state_save_register_device_item(device, 0, chip->FeedbackInvert); |
| 393 | state_save_register_device_item(device, 0, chip->Negate); |
| 394 | state_save_register_device_item(device, 0, chip->Stereo); |
| 395 | state_save_register_device_item(device, 0, chip->StereoMask); |
| 363 | 396 | state_save_register_device_item_array(device, 0, chip->Period); |
| 364 | 397 | state_save_register_device_item_array(device, 0, chip->Count); |
| 365 | | state_save_register_device_item(device, 0, chip->OldNoise); |
| 366 | 398 | state_save_register_device_item_array(device, 0, chip->Output); |
| 367 | 399 | state_save_register_device_item(device, 0, chip->CyclestoREADY); |
| 368 | 400 | } |
| 369 | 401 | |
| 402 | // function parameters: device, feedback destination tap, feedback source taps, xor(false)/xnor(true), normal(false)/invert(true), mono(false)/stereo(true) |
| 370 | 403 | |
| 371 | 404 | static DEVICE_START( sn76489 ) |
| 372 | 405 | { |
| 373 | | generic_start(device, 0x4000, 0x03, FALSE); // todo: verify; assumed to be the same as sn94624 |
| 406 | generic_start(device, 0x8000, 0x06, FALSE, FALSE, FALSE); // todo: verify; assumed to be the same as sn94624 |
| 374 | 407 | } |
| 375 | 408 | |
| 376 | 409 | static DEVICE_START( sn76489a ) |
| 377 | 410 | { |
| 378 | | generic_start(device, 0x8000, 0x06, TRUE); // verified by plgdavid |
| 411 | generic_start(device, 0x10000, 0x0C, TRUE, FALSE, FALSE); // verified by plgdavid |
| 379 | 412 | } |
| 380 | 413 | |
| 381 | 414 | static DEVICE_START( sn76494 ) |
| 382 | 415 | { |
| 383 | | generic_start(device, 0x8000, 0x06, TRUE); // todo: verify; assumed to be the same as sn76489a |
| 416 | generic_start(device, 0x10000, 0x0C, TRUE, FALSE, FALSE); // todo: verify; assumed to be the same as sn76489a |
| 384 | 417 | } |
| 385 | 418 | |
| 386 | 419 | static DEVICE_START( sn76496 ) |
| 387 | 420 | { |
| 388 | | generic_start(device, 0x8000, 0x06, TRUE); // todo: verify; assumed to be the same as sn76489a |
| 421 | generic_start(device, 0x10000, 0x0C, TRUE, FALSE, FALSE); // todo: verify; assumed to be the same as sn76489a |
| 389 | 422 | } |
| 390 | 423 | |
| 391 | 424 | static DEVICE_START( sn94624 ) |
| 392 | 425 | { |
| 393 | | generic_start(device, 0x4000, 0x03, FALSE); // verified by plgdavid |
| 426 | generic_start(device, 0x10000, 0x0C, FALSE, FALSE, FALSE); // verified by plgdavid |
| 394 | 427 | } |
| 395 | 428 | |
| 396 | 429 | static DEVICE_START( ncr7496 ) |
| 397 | 430 | { |
| 398 | | generic_start(device, 0x4000, 0x11, FALSE); // todo: verify; from smspower wiki |
| 431 | generic_start(device, 0x8000, 0x22, FALSE, FALSE, FALSE); // todo: verify; from smspower wiki |
| 399 | 432 | } |
| 400 | 433 | |
| 401 | 434 | static DEVICE_START( gamegear ) |
| 402 | 435 | { |
| 403 | | generic_start(device, 0x8000, 0x09, TRUE); // semi-verified by Lord Nightmare, need better sample |
| 436 | generic_start(device, 0x8000, 0x09, FALSE, TRUE, TRUE); // Verified by Justin Kerk |
| 404 | 437 | } |
| 405 | 438 | |
| 406 | 439 | static DEVICE_START( smsiii ) |
| 407 | 440 | { |
| 408 | | generic_start(device, 0x8000, 0x09, TRUE); // todo: verify; from smspower wiki, assumed to have same invert as gamegear |
| 441 | generic_start(device, 0x8000, 0x09, FALSE, TRUE, FALSE); // todo: verify; from smspower wiki, assumed to have same invert as gamegear |
| 409 | 442 | } |
| 410 | 443 | |
| 411 | 444 | |