Mercurial > vba-linux

     1 #ifdef WIN32

     2 #   include "../win32/stdafx.h"

     3 #   include "../win32/VBA.h"

     4 #endif

     5 

     6 #include <cstring>

     7 #include <cassert>

     8 

     9 #include "../common/System.h"

    10 #include "../common/Util.h"

    11 //#include "../Blip_Buffer.h"

    12 #include "gbGlobals.h"

    13 #include "gbSound.h"

    14 

    15 #ifndef countof

    16 #define countof(a)  (sizeof(a) / sizeof(a[0]))

    17 #endif

    18 

    19 extern u8	 soundBuffer[6][735];

    20 extern u16	 soundFinalWave[1470];

    21 extern u16	 soundFrameSound[735 * 30 * 2];

    22 extern int32 soundVolume;

    23 

    24 soundtick_t GB_USE_TICKS_AS = 24; // (1048576.0/44100.0); // FIXME: (4194304.0/70224.0)(fps) vs 60.0fps?

    25 

    26 #define SOUND_MAGIC   0x60000000

    27 #define SOUND_MAGIC_2 0x30000000

    28 #define NOISE_MAGIC   (2097152.0 / 44100.0)

    29 

    30 extern int32 speed;

    31 

    32 extern u8 soundWavePattern[4][32];

    33 

    34 extern u32		   soundBufferLen;

    35 extern u32		   soundBufferTotalLen;

    36 extern int32	   soundQuality;

    37 extern int32	   soundPaused;

    38 extern int32	   soundPlay;

    39 extern soundtick_t soundTicks;

    40 extern soundtick_t SOUND_CLOCK_TICKS;

    41 extern u32		   soundNextPosition;

    42 

    43 extern int32 soundLevel1;

    44 extern int32 soundLevel2;

    45 extern int32 soundBalance;

    46 extern int32 soundMasterOn;

    47 extern u32	 soundIndex;

    48 extern u32	 soundBufferIndex;

    49 extern int32 soundFrameSoundWritten;

    50 int32		 soundVIN = 0;

    51 extern int32 soundDebug;

    52 

    53 extern int32 sound1On;

    54 extern int32 sound1ATL;

    55 extern int32 sound1Skip;

    56 extern int32 sound1Index;

    57 extern int32 sound1Continue;

    58 extern int32 sound1EnvelopeVolume;

    59 extern int32 sound1EnvelopeATL;

    60 extern int32 sound1EnvelopeUpDown;

    61 extern int32 sound1EnvelopeATLReload;

    62 extern int32 sound1SweepATL;

    63 extern int32 sound1SweepATLReload;

    64 extern int32 sound1SweepSteps;

    65 extern int32 sound1SweepUpDown;

    66 extern int32 sound1SweepStep;

    67 extern u8 *	 sound1Wave;

    68 

    69 extern int32 sound2On;

    70 extern int32 sound2ATL;

    71 extern int32 sound2Skip;

    72 extern int32 sound2Index;

    73 extern int32 sound2Continue;

    74 extern int32 sound2EnvelopeVolume;

    75 extern int32 sound2EnvelopeATL;

    76 extern int32 sound2EnvelopeUpDown;

    77 extern int32 sound2EnvelopeATLReload;

    78 extern u8 *	 sound2Wave;

    79 

    80 extern int32 sound3On;

    81 extern int32 sound3ATL;

    82 extern int32 sound3Skip;

    83 extern int32 sound3Index;

    84 extern int32 sound3Continue;

    85 extern int32 sound3OutputLevel;

    86 extern int32 sound3Last;

    87 

    88 extern int32 sound4On;

    89 extern int32 sound4Clock;

    90 extern int32 sound4ATL;

    91 extern int32 sound4Skip;

    92 extern int32 sound4Index;

    93 extern int32 sound4ShiftRight;

    94 extern int32 sound4ShiftSkip;

    95 extern int32 sound4ShiftIndex;

    96 extern int32 sound4NSteps;

    97 extern int32 sound4CountDown;

    98 extern int32 sound4Continue;

    99 extern int32 sound4EnvelopeVolume;

   100 extern int32 sound4EnvelopeATL;

   101 extern int32 sound4EnvelopeUpDown;

   102 extern int32 sound4EnvelopeATLReload;

   103 

   104 extern int32 soundEnableFlag;

   105 extern int32 soundMutedFlag;

   106 

   107 extern int32 soundFreqRatio[8];

   108 extern int32 soundShiftClock[16];

   109 

   110 extern s16	 soundFilter[4000];

   111 extern s16	 soundLeft[5];

   112 extern s16	 soundRight[5];

   113 extern int32 soundEchoIndex;

   114 extern bool8 soundEcho;

   115 extern bool8 soundLowPass;

   116 extern bool8 soundReverse;

   117 extern bool8 soundOffFlag;

   118 

   119 bool8 gbDigitalSound = false;

   120 

   121 void gbSoundEvent(register u16 address, register int data)

   122 {

   123 	int freq = 0;

   124 

   125 	gbMemory[address] = data;

   126 

   127 #ifndef FINAL_VERSION

   128 	if (soundDebug)

   129 	{

   130 		// don't translate. debug only

   131 		log("Sound event: %08lx %02x\n", address, data);

   132 	}

   133 #endif

   134 	switch (address)

   135 	{

   136 	case NR10:

   137 		sound1SweepATL	  = sound1SweepATLReload = 344 * ((data >> 4) & 7);

   138 		sound1SweepSteps  = data & 7;

   139 		sound1SweepUpDown = data & 0x08;

   140 		sound1SweepStep	  = 0;

   141 		break;

   142 	case NR11:

   143 		sound1Wave = soundWavePattern[data >> 6];

   144 		sound1ATL  = 172 * (64 - (data & 0x3f));

   145 		break;

   146 	case NR12:

   147 		sound1EnvelopeVolume	= data >> 4;

   148 		sound1EnvelopeUpDown	= data & 0x08;

   149 		sound1EnvelopeATLReload = sound1EnvelopeATL = 689 * (data & 7);

   150 		break;

   151 	case NR13:

   152 		freq	  = (((int)(gbMemory[NR14] & 7)) << 8) | data;

   153 		sound1ATL = 172 * (64 - (gbMemory[NR11] & 0x3f));

   154 		freq	  = 2048 - freq;

   155 		if (freq)

   156 		{

   157 			sound1Skip = SOUND_MAGIC / freq;

   158 		}

   159 		else

   160 			sound1Skip = 0;

   161 		break;

   162 	case NR14:

   163 		freq = (((int)(data & 7) << 8) | gbMemory[NR13]);

   164 		freq = 2048 - freq;

   165 		sound1ATL	   = 172 * (64 - (gbMemory[NR11] & 0x3f));

   166 		sound1Continue = data & 0x40;

   167 		if (freq)

   168 		{

   169 			sound1Skip = SOUND_MAGIC / freq;

   170 		}

   171 		else

   172 			sound1Skip = 0;

   173 		if (data & 0x80)

   174 		{

   175 			gbMemory[NR52]		|= 1;

   176 			sound1EnvelopeVolume = gbMemory[NR12] >> 4;

   177 			sound1EnvelopeUpDown = gbMemory[NR12] & 0x08;

   178 			sound1ATL = 172 * (64 - (gbMemory[NR11] & 0x3f));

   179 			sound1EnvelopeATLReload = sound1EnvelopeATL = 689 * (gbMemory[NR12] & 7);

   180 			sound1SweepATL			= sound1SweepATLReload = 344 * ((gbMemory[NR10] >> 4) & 7);

   181 			sound1SweepSteps		= gbMemory[NR10] & 7;

   182 			sound1SweepUpDown		= gbMemory[NR10] & 0x08;

   183 			sound1SweepStep			= 0;

   184 

   185 			sound1Index = 0;

   186 			sound1On	= 1;

   187 		}

   188 		break;

   189 	case NR21:

   190 		sound2Wave = soundWavePattern[data >> 6];

   191 		sound2ATL  = 172 * (64 - (data & 0x3f));

   192 		break;

   193 	case NR22:

   194 		sound2EnvelopeVolume	= data >> 4;

   195 		sound2EnvelopeUpDown	= data & 0x08;

   196 		sound2EnvelopeATLReload = sound2EnvelopeATL = 689 * (data & 7);

   197 		break;

   198 	case NR23:

   199 		freq	  = (((int)(gbMemory[NR24] & 7)) << 8) | data;

   200 		sound2ATL = 172 * (64 - (gbMemory[NR21] & 0x3f));

   201 		freq	  = 2048 - freq;

   202 		if (freq)

   203 		{

   204 			sound2Skip = SOUND_MAGIC / freq;

   205 		}

   206 		else

   207 			sound2Skip = 0;

   208 		break;

   209 	case NR24:

   210 		freq = (((int)(data & 7) << 8) | gbMemory[NR23]);

   211 		freq = 2048 - freq;

   212 		sound2ATL	   = 172 * (64 - (gbMemory[NR21] & 0x3f));

   213 		sound2Continue = data & 0x40;

   214 		if (freq)

   215 		{

   216 			sound2Skip = SOUND_MAGIC / freq;

   217 		}

   218 		else

   219 			sound2Skip = 0;

   220 		if (data & 0x80)

   221 		{

   222 			gbMemory[NR52]		|= 2;

   223 			sound2EnvelopeVolume = gbMemory[NR22] >> 4;

   224 			sound2EnvelopeUpDown = gbMemory[NR22] & 0x08;

   225 			sound2ATL = 172 * (64 - (gbMemory[NR21] & 0x3f));

   226 			sound2EnvelopeATLReload = sound2EnvelopeATL = 689 * (gbMemory[NR22] & 7);

   227 

   228 			sound2Index = 0;

   229 			sound2On	= 1;

   230 		}

   231 		break;

   232 	case NR30:

   233 		if (!(data & 0x80))

   234 		{

   235 			gbMemory[NR52] &= 0xfb;

   236 			sound3On		= 0;

   237 		}

   238 		break;

   239 	case NR31:

   240 		sound3ATL = 172 * (256 - data);

   241 		break;

   242 	case NR32:

   243 		sound3OutputLevel = (data >> 5) & 3;

   244 		break;

   245 	case NR33:

   246 		freq = 2048 - (((int)(gbMemory[NR34] & 7) << 8) | data);

   247 		if (freq)

   248 		{

   249 			sound3Skip = SOUND_MAGIC_2 / freq;

   250 		}

   251 		else

   252 			sound3Skip = 0;

   253 		break;

   254 	case NR34:

   255 		freq = 2048 - (((data & 7) << 8) | (int)gbMemory[NR33]);

   256 		if (freq)

   257 		{

   258 			sound3Skip = SOUND_MAGIC_2 / freq;

   259 		}

   260 		else

   261 		{

   262 			sound3Skip = 0;

   263 		}

   264 		sound3Continue = data & 0x40;

   265 		if ((data & 0x80) && (gbMemory[NR30] & 0x80))

   266 		{

   267 			gbMemory[NR52] |= 4;

   268 			sound3ATL		= 172 * (256 - gbMemory[NR31]);

   269 			sound3Index		= 0;

   270 			sound3On		= 1;

   271 		}

   272 		break;

   273 	case NR41:

   274 		sound4ATL = 172 * (64 - (data & 0x3f));

   275 		break;

   276 	case NR42:

   277 		sound4EnvelopeVolume	= data >> 4;

   278 		sound4EnvelopeUpDown	= data & 0x08;

   279 		sound4EnvelopeATLReload = sound4EnvelopeATL = 689 * (data & 7);

   280 		break;

   281 	case NR43:

   282 		freq		 = soundFreqRatio[data & 7];

   283 		sound4NSteps = data & 0x08;

   284 

   285 		sound4Skip = freq * NOISE_MAGIC;

   286 

   287 		sound4Clock = data >> 4;

   288 

   289 		freq = freq / soundShiftClock[sound4Clock];

   290 

   291 		sound4ShiftSkip = freq * NOISE_MAGIC;

   292 

   293 		break;

   294 	case NR44:

   295 		sound4Continue = data & 0x40;

   296 		if (data & 0x80)

   297 		{

   298 			gbMemory[NR52]		|= 8;

   299 			sound4EnvelopeVolume = gbMemory[NR42] >> 4;

   300 			sound4EnvelopeUpDown = gbMemory[NR42] & 0x08;

   301 			sound4ATL = 172 * (64 - (gbMemory[NR41] & 0x3f));

   302 			sound4EnvelopeATLReload = sound4EnvelopeATL = 689 * (gbMemory[NR42] & 7);

   303 

   304 			sound4On = 1;

   305 

   306 			sound4Index		 = 0;

   307 			sound4ShiftIndex = 0;

   308 

   309 			freq = soundFreqRatio[gbMemory[NR43] & 7];

   310 

   311 			sound4Skip = freq * NOISE_MAGIC;

   312 

   313 			sound4NSteps = gbMemory[NR43] & 0x08;

   314 

   315 			freq = freq / soundShiftClock[gbMemory[NR43] >> 4];

   316 

   317 			sound4ShiftSkip = freq * NOISE_MAGIC;

   318 			if (sound4NSteps)

   319 				sound4ShiftRight = 0x7f;

   320 			else

   321 				sound4ShiftRight = 0x7fff;

   322 		}

   323 		break;

   324 	case NR50:

   325 		soundVIN	= data & 0x88;

   326 		soundLevel1 = data & 7;

   327 		soundLevel2 = (data >> 4) & 7;

   328 		break;

   329 	case NR51:

   330 		soundBalance	  = (data & soundEnableFlag);

   331 		gbMemory[address] = data;

   332 		break;

   333 	case NR52:

   334 		soundMasterOn = data & 0x80;

   335 		if (!(data & 0x80))

   336 		{

   337 			sound1On = 0;

   338 			sound2On = 0;

   339 			sound3On = 0;

   340 			sound4On = 0;

   341 		}

   342 		break;

   343 	}

   344 

   345 	gbDigitalSound = true;

   346 

   347 	if (sound1On && sound1EnvelopeVolume != 0)

   348 		gbDigitalSound = false;

   349 	if (sound2On && sound2EnvelopeVolume != 0)

   350 		gbDigitalSound = false;

   351 	if (sound3On && sound3OutputLevel != 0)

   352 		gbDigitalSound = false;

   353 	if (sound4On && sound4EnvelopeVolume != 0)

   354 		gbDigitalSound = false;

   355 }

   356 

   357 void gbSoundChannel1()

   358 {

   359 	int vol = sound1EnvelopeVolume;

   360 

   361 	int freq = 0;

   362 

   363 	int value = 0;

   364 

   365 	if (sound1On && (sound1ATL || !sound1Continue))

   366 	{

   367 		sound1Index += soundQuality * sound1Skip;

   368 		sound1Index &= 0x1fffffff;

   369 

   370 		value = ((s8)sound1Wave[sound1Index >> 24]) * vol;

   371 	}

   372 

   373 	soundBuffer[0][soundIndex] = value;

   374 

   375 	if (sound1On)

   376 	{

   377 		if (sound1ATL)

   378 		{

   379 			sound1ATL -= soundQuality;

   380 

   381 			if (sound1ATL <= 0 && sound1Continue)

   382 			{

   383 				gbMemory[NR52] &= 0xfe;

   384 				sound1On		= 0;

   385 			}

   386 		}

   387 

   388 		if (sound1EnvelopeATL)

   389 		{

   390 			sound1EnvelopeATL -= soundQuality;

   391 

   392 			if (sound1EnvelopeATL <= 0)

   393 			{

   394 				if (sound1EnvelopeUpDown)

   395 				{

   396 					if (sound1EnvelopeVolume < 15)

   397 						sound1EnvelopeVolume++;

   398 				}

   399 				else

   400 				{

   401 					if (sound1EnvelopeVolume)

   402 						sound1EnvelopeVolume--;

   403 				}

   404 

   405 				sound1EnvelopeATL += sound1EnvelopeATLReload;

   406 			}

   407 		}

   408 

   409 		if (sound1SweepATL)

   410 		{

   411 			sound1SweepATL -= soundQuality;

   412 

   413 			if (sound1SweepATL <= 0)

   414 			{

   415 				freq = (((int)(gbMemory[NR14] & 7) << 8) | gbMemory[NR13]);

   416 

   417 				int updown = 1;

   418 

   419 				if (sound1SweepUpDown)

   420 					updown = -1;

   421 

   422 				int newfreq = 0;

   423 				if (sound1SweepSteps)

   424 				{

   425 					newfreq = freq + updown * freq / (1 << sound1SweepSteps);

   426 					if (newfreq == freq)

   427 						newfreq = 0;

   428 				}

   429 				else

   430 					newfreq = freq;

   431 

   432 				if (newfreq < 0)

   433 				{

   434 					sound1SweepATL += sound1SweepATLReload;

   435 				}

   436 				else if (newfreq > 2047)

   437 				{

   438 					sound1SweepATL	= 0;

   439 					sound1On		= 0;

   440 					gbMemory[NR52] &= 0xfe;

   441 				}

   442 				else

   443 				{

   444 					sound1SweepATL += sound1SweepATLReload;

   445 					sound1Skip		= SOUND_MAGIC / (2048 - newfreq);

   446 

   447 					gbMemory[NR13] = newfreq & 0xff;

   448 					gbMemory[NR14] = (gbMemory[NR14] & 0xf8) | ((newfreq >> 8) & 7);

   449 				}

   450 			}

   451 		}

   452 	}

   453 }

   454 

   455 void gbSoundChannel2()

   456 {

   457 	//  int freq = 0;

   458 	int vol = sound2EnvelopeVolume;

   459 

   460 	int value = 0;

   461 

   462 	if (sound2On && (sound2ATL || !sound2Continue))

   463 	{

   464 		sound2Index += soundQuality * sound2Skip;

   465 		sound2Index &= 0x1fffffff;

   466 

   467 		value = ((s8)sound2Wave[sound2Index >> 24]) * vol;

   468 	}

   469 

   470 	soundBuffer[1][soundIndex] = value;

   471 

   472 	if (sound2On)

   473 	{

   474 		if (sound2ATL)

   475 		{

   476 			sound2ATL -= soundQuality;

   477 

   478 			if (sound2ATL <= 0 && sound2Continue)

   479 			{

   480 				gbMemory[NR52] &= 0xfd;

   481 				sound2On		= 0;

   482 			}

   483 		}

   484 

   485 		if (sound2EnvelopeATL)

   486 		{

   487 			sound2EnvelopeATL -= soundQuality;

   488 

   489 			if (sound2EnvelopeATL <= 0)

   490 			{

   491 				if (sound2EnvelopeUpDown)

   492 				{

   493 					if (sound2EnvelopeVolume < 15)

   494 						sound2EnvelopeVolume++;

   495 				}

   496 				else

   497 				{

   498 					if (sound2EnvelopeVolume)

   499 						sound2EnvelopeVolume--;

   500 				}

   501 				sound2EnvelopeATL += sound2EnvelopeATLReload;

   502 			}

   503 		}

   504 	}

   505 }

   506 

   507 void gbSoundChannel3()

   508 {

   509 	int value = sound3Last;

   510 

   511 	if (sound3On && (sound3ATL || !sound3Continue))

   512 	{

   513 		sound3Index += soundQuality * sound3Skip;

   514 		sound3Index &= 0x1fffffff;

   515 

   516 		value = gbMemory[0xff30 + (sound3Index >> 25)];

   517 

   518 		if ((sound3Index & 0x01000000))

   519 		{

   520 			value &= 0x0f;

   521 		}

   522 		else

   523 		{

   524 			value >>= 4;

   525 		}

   526 

   527 		value -= 8;

   528 		value *= 2;

   529 

   530 		switch (sound3OutputLevel)

   531 		{

   532 		case 0:

   533 			value = 0;

   534 			break;

   535 		case 1:

   536 			break;

   537 		case 2:

   538 			value = (value >> 1);

   539 			break;

   540 		case 3:

   541 			value = (value >> 2);

   542 			break;

   543 		}

   544 		//value += 1;

   545 		sound3Last = value;

   546 	}

   547 

   548 	soundBuffer[2][soundIndex] = value;

   549 

   550 	if (sound3On)

   551 	{

   552 		if (sound3ATL)

   553 		{

   554 			sound3ATL -= soundQuality;

   555 

   556 			if (sound3ATL <= 0 && sound3Continue)

   557 			{

   558 				gbMemory[NR52] &= 0xfb;

   559 				sound3On		= 0;

   560 			}

   561 		}

   562 	}

   563 }

   564 

   565 void gbSoundChannel4()

   566 {

   567 	int vol = sound4EnvelopeVolume;

   568 

   569 	int value = 0;

   570 

   571 	if (sound4Clock <= 0x0c)

   572 	{

   573 		if (sound4On && (sound4ATL || !sound4Continue))

   574 		{

   575 	  #define NOISE_ONE_SAMP_SCALE  0x200000

   576 

   577 			sound4Index		 += soundQuality * sound4Skip;

   578 			sound4ShiftIndex += soundQuality * sound4ShiftSkip;

   579 

   580 			if (sound4NSteps)

   581 			{

   582 				while (sound4ShiftIndex >= NOISE_ONE_SAMP_SCALE)

   583 				{

   584 					sound4ShiftRight = (((sound4ShiftRight << 6) ^

   585 					                     (sound4ShiftRight << 5)) & 0x40) |

   586 					                   (sound4ShiftRight >> 1);

   587 					sound4ShiftIndex -= NOISE_ONE_SAMP_SCALE;

   588 				}

   589 			}

   590 			else

   591 			{

   592 				while (sound4ShiftIndex >= NOISE_ONE_SAMP_SCALE)

   593 				{

   594 					sound4ShiftRight = (((sound4ShiftRight << 14) ^

   595 					                     (sound4ShiftRight << 13)) & 0x4000) |

   596 					                   (sound4ShiftRight >> 1);

   597 

   598 					sound4ShiftIndex -= NOISE_ONE_SAMP_SCALE;

   599 				}

   600 			}

   601 

   602 			sound4Index		 %= NOISE_ONE_SAMP_SCALE;

   603 			sound4ShiftIndex %= NOISE_ONE_SAMP_SCALE;

   604 

   605 			value = ((sound4ShiftRight & 1) * 2 - 1) * vol;

   606 		}

   607 		else

   608 		{

   609 			value = 0;

   610 		}

   611 	}

   612 

   613 	soundBuffer[3][soundIndex] = value;

   614 

   615 	if (sound4On)

   616 	{

   617 		if (sound4ATL)

   618 		{

   619 			sound4ATL -= soundQuality;

   620 

   621 			if (sound4ATL <= 0 && sound4Continue)

   622 			{

   623 				gbMemory[NR52] &= 0xfd;

   624 				sound4On		= 0;

   625 			}

   626 		}

   627 

   628 		if (sound4EnvelopeATL)

   629 		{

   630 			sound4EnvelopeATL -= soundQuality;

   631 

   632 			if (sound4EnvelopeATL <= 0)

   633 			{

   634 				if (sound4EnvelopeUpDown)

   635 				{

   636 					if (sound4EnvelopeVolume < 15)

   637 						sound4EnvelopeVolume++;

   638 				}

   639 				else

   640 				{

   641 					if (sound4EnvelopeVolume)

   642 						sound4EnvelopeVolume--;

   643 				}

   644 				sound4EnvelopeATL += sound4EnvelopeATLReload;

   645 			}

   646 		}

   647 	}

   648 }

   649 

   650 void gbSoundMix()

   651 {

   652 	int res = 0;

   653 

   654 	if (gbMemory)

   655 		soundBalance = (gbMemory[NR51] & soundEnableFlag & ~soundMutedFlag);

   656 

   657 	if (soundBalance & 16)

   658 	{

   659 		res += ((s8)soundBuffer[0][soundIndex]);

   660 	}

   661 	if (soundBalance & 32)

   662 	{

   663 		res += ((s8)soundBuffer[1][soundIndex]);

   664 	}

   665 	if (soundBalance & 64)

   666 	{

   667 		res += ((s8)soundBuffer[2][soundIndex]);

   668 	}

   669 	if (soundBalance & 128)

   670 	{

   671 		res += ((s8)soundBuffer[3][soundIndex]);

   672 	}

   673 

   674 	if (gbDigitalSound)

   675 		res = soundLevel1 * 256;

   676 	else

   677 		res *= soundLevel1 * 60;

   678 

   679 	if (soundEcho)

   680 	{

   681 		res *= 2;

   682 		res += soundFilter[soundEchoIndex];

   683 		res /= 2;

   684 		soundFilter[soundEchoIndex++] = res;

   685 	}

   686 

   687 	if (soundLowPass)

   688 	{

   689 		soundLeft[4] = soundLeft[3];

   690 		soundLeft[3] = soundLeft[2];

   691 		soundLeft[2] = soundLeft[1];

   692 		soundLeft[1] = soundLeft[0];

   693 		soundLeft[0] = res;

   694 		res = (soundLeft[4] + 2 * soundLeft[3] + 8 * soundLeft[2] + 2 * soundLeft[1] +

   695 		       soundLeft[0]) / 14;

   696 	}

   697 

   698 	bool noSpecialEffects = false;

   699 #if (defined(WIN32) && !defined(SDL))

   700 	if (theApp.soundRecording || theApp.aviRecording || theApp.nvAudioLog)

   701 		noSpecialEffects = true;

   702 #endif

   703 

   704 	if (!noSpecialEffects)

   705 	{

   706 		switch (soundVolume)

   707 		{

   708 		case 0:

   709 		case 1:

   710 		case 2:

   711 		case 3:

   712 			res *= (soundVolume + 1);

   713 			break;

   714 		case 4:

   715 			res >>= 2;

   716 			break;

   717 		case 5:

   718 			res >>= 1;

   719 			break;

   720 		}

   721 	}

   722 

   723 	if (res > 32767)

   724 		res = 32767;

   725 	if (res < -32768)

   726 		res = -32768;

   727 

   728 	if (soundReverse && !noSpecialEffects)

   729 	{

   730 		soundFinalWave[++soundBufferIndex] = res;

   731 		if ((soundFrameSoundWritten + 1) >= countof(soundFrameSound))

   732 			/*assert(false)*/;

   733 		else

   734 			soundFrameSound[++soundFrameSoundWritten] = res;

   735 	}

   736 	else

   737 	{

   738 		soundFinalWave[soundBufferIndex++] = res;

   739 		if (soundFrameSoundWritten >= countof(soundFrameSound))

   740 			/*assert(false)*/;

   741 		else

   742 			soundFrameSound[soundFrameSoundWritten++] = res;

   743 	}

   744 

   745 	res = 0;

   746 

   747 	if (soundBalance & 1)

   748 	{

   749 		res += ((s8)soundBuffer[0][soundIndex]);

   750 	}

   751 	if (soundBalance & 2)

   752 	{

   753 		res += ((s8)soundBuffer[1][soundIndex]);

   754 	}

   755 	if (soundBalance & 4)

   756 	{

   757 		res += ((s8)soundBuffer[2][soundIndex]);

   758 	}

   759 	if (soundBalance & 8)

   760 	{

   761 		res += ((s8)soundBuffer[3][soundIndex]);

   762 	}

   763 

   764 	if (gbDigitalSound)

   765 		res = soundLevel2 * 256;

   766 	else

   767 		res *= soundLevel2 * 60;

   768 

   769 	if (soundEcho)

   770 	{

   771 		res *= 2;

   772 		res += soundFilter[soundEchoIndex];

   773 		res /= 2;

   774 		soundFilter[soundEchoIndex++] = res;

   775 

   776 		if (soundEchoIndex >= 4000)

   777 			soundEchoIndex = 0;

   778 	}

   779 

   780 	if (soundLowPass)

   781 	{

   782 		soundRight[4] = soundRight[3];

   783 		soundRight[3] = soundRight[2];

   784 		soundRight[2] = soundRight[1];

   785 		soundRight[1] = soundRight[0];

   786 		soundRight[0] = res;

   787 		res = (soundRight[4] + 2 * soundRight[3] + 8 * soundRight[2] + 2 * soundRight[1] +

   788 		       soundRight[0]) / 14;

   789 	}

   790 

   791 	if (!noSpecialEffects)

   792 	{

   793 		switch (soundVolume)

   794 		{

   795 		case 0:

   796 		case 1:

   797 		case 2:

   798 		case 3:

   799 			res *= (soundVolume + 1);

   800 			break;

   801 		case 4:

   802 			res >>= 2;

   803 			break;

   804 		case 5:

   805 			res >>= 1;

   806 			break;

   807 		}

   808 	}

   809 

   810 	if (res > 32767)

   811 		res = 32767;

   812 	if (res < -32768)

   813 		res = -32768;

   814 

   815 	if (soundReverse && !noSpecialEffects)

   816 	{

   817 		soundFinalWave[-1 + soundBufferIndex++]		   = res;

   818 		if ((soundFrameSoundWritten) >= countof(soundFrameSound))

   819 			/*assert(false)*/;

   820 		else

   821 			soundFrameSound[-1 + soundFrameSoundWritten++] = res;

   822 	}

   823 	else

   824 	{

   825 		soundFinalWave[soundBufferIndex++]			  = res;

   826 		if ((soundFrameSoundWritten + 1) >= countof(soundFrameSound))

   827 			/*assert(false)*/;

   828 		else

   829 			soundFrameSound[soundFrameSoundWritten++] = res;

   830 	}

   831 }

   832 

   833 void gbSoundTick()

   834 {

   835 	if (systemSoundOn)

   836 	{

   837 		if (soundMasterOn)

   838 		{

   839 			gbSoundChannel1();

   840 			gbSoundChannel2();

   841 			gbSoundChannel3();

   842 			gbSoundChannel4();

   843 

   844 			gbSoundMix();

   845 		}

   846 		else

   847 		{

   848 			soundFinalWave[soundBufferIndex++] = 0;

   849 			soundFinalWave[soundBufferIndex++] = 0;

   850 			if ((soundFrameSoundWritten + 1) >= countof(soundFrameSound))

   851 				/*assert(false)*/;

   852 			else

   853 			{

   854 				soundFrameSound[soundFrameSoundWritten++] = 0;

   855 				soundFrameSound[soundFrameSoundWritten++] = 0;

   856 			}

   857 		}

   858 

   859 		soundIndex++;

   860 

   861 		if (2 * soundBufferIndex >= soundBufferLen)

   862 		{

   863 			if (systemSoundOn)

   864 			{

   865 				if (soundPaused)

   866 				{

   867 					extern void soundResume();

   868 					soundResume();

   869 				}

   870 

   871 				systemSoundWriteToBuffer();

   872 			}

   873 			soundIndex		 = 0;

   874 			soundBufferIndex = 0;

   875 		}

   876 	}

   877 }

   878 

   879 void gbSoundReset()

   880 {

   881 	soundPaused		  = 1;

   882 	soundPlay		  = 0;

   883 	SOUND_CLOCK_TICKS = soundQuality * GB_USE_TICKS_AS;

   884 //  soundTicks = SOUND_CLOCK_TICKS;

   885 	soundTicks		  = 0;

   886 	soundNextPosition = 0;

   887 	soundMasterOn	  = 1;

   888 	soundIndex		  = 0;

   889 	soundBufferIndex  = 0;

   890 	soundLevel1		  = 7;

   891 	soundLevel2		  = 7;

   892 	soundVIN = 0;

   893 

   894 	sound1On = 0;

   895 	sound1ATL = 0;

   896 	sound1Skip = 0;

   897 	sound1Index = 0;

   898 	sound1Continue = 0;

   899 	sound1EnvelopeVolume	= 0;

   900 	sound1EnvelopeATL		= 0;

   901 	sound1EnvelopeUpDown	= 0;

   902 	sound1EnvelopeATLReload = 0;

   903 	sound1SweepATL			= 0;

   904 	sound1SweepATLReload	= 0;

   905 	sound1SweepSteps		= 0;

   906 	sound1SweepUpDown		= 0;

   907 	sound1SweepStep			= 0;

   908 	sound1Wave				= soundWavePattern[2];

   909 

   910 	sound2On = 0;

   911 	sound2ATL = 0;

   912 	sound2Skip = 0;

   913 	sound2Index = 0;

   914 	sound2Continue = 0;

   915 	sound2EnvelopeVolume	= 0;

   916 	sound2EnvelopeATL		= 0;

   917 	sound2EnvelopeUpDown	= 0;

   918 	sound2EnvelopeATLReload = 0;

   919 	sound2Wave				= soundWavePattern[2];

   920 

   921 	sound3On = 0;

   922 	sound3ATL		  = 0;

   923 	sound3Skip		  = 0;

   924 	sound3Index		  = 0;

   925 	sound3Continue	  = 0;

   926 	sound3OutputLevel = 0;

   927 

   928 	sound4On = 0;

   929 	sound4Clock = 0;

   930 	sound4ATL = 0;

   931 	sound4Skip = 0;

   932 	sound4Index = 0;

   933 	sound4ShiftRight		= 0x7f;

   934 	sound4NSteps			= 0;

   935 	sound4CountDown			= 0;

   936 	sound4Continue			= 0;

   937 	sound4EnvelopeVolume	= 0;

   938 	sound4EnvelopeATL		= 0;

   939 	sound4EnvelopeUpDown	= 0;

   940 	sound4EnvelopeATLReload = 0;

   941 

   942 	// don't translate

   943 	if (soundDebug)

   944 	{

   945 		log("*** Sound Init ***\n");

   946 	}

   947 

   948 	gbSoundEvent(0xff10, 0x80);

   949 	gbSoundEvent(0xff11, 0xbf);

   950 	gbSoundEvent(0xff12, 0xf3);

   951 	gbSoundEvent(0xff14, 0xbf);

   952 	gbSoundEvent(0xff16, 0x3f);

   953 	gbSoundEvent(0xff17, 0x00);

   954 	gbSoundEvent(0xff19, 0xbf);

   955 

   956 	gbSoundEvent(0xff1a, 0x7f);

   957 	gbSoundEvent(0xff1b, 0xff);

   958 	gbSoundEvent(0xff1c, 0xbf);

   959 	gbSoundEvent(0xff1e, 0xbf);

   960 

   961 	gbSoundEvent(0xff20, 0xff);

   962 	gbSoundEvent(0xff21, 0x00);

   963 	gbSoundEvent(0xff22, 0x00);

   964 	gbSoundEvent(0xff23, 0xbf);

   965 	gbSoundEvent(0xff24, 0x77);

   966 	gbSoundEvent(0xff25, 0xf3);

   967 

   968 	gbSoundEvent(0xff26, 0xf0);

   969 

   970 	// don't translate

   971 	if (soundDebug)

   972 	{

   973 		log("*** Sound Init Complete ***\n");

   974 	}

   975 

   976 	sound1On = 0;

   977 	sound2On = 0;

   978 	sound3On = 0;

   979 	sound4On = 0;

   980 

   981 	int addr = 0xff30;

   982 

   983 	while (addr < 0xff40)

   984 	{

   985 		gbMemory[addr++] = 0x00;

   986 		gbMemory[addr++] = 0xff;

   987 	}

   988 

   989 	memset(soundFinalWave, 0x00, soundBufferLen);

   990 

   991 	memset(soundFilter, 0, sizeof(soundFilter));

   992 	soundEchoIndex = 0;

   993 }

   994 

   995 extern bool soundInit();

   996 extern void soundShutdown();

   997 

   998 void gbSoundSetQuality(int quality)

   999 {

  1000 	if (soundQuality != quality && systemSoundCanChangeQuality())

  1001 	{

  1002 		if (!soundOffFlag)

  1003 			soundShutdown();

  1004 		soundQuality	  = quality;

  1005 		soundNextPosition = 0;

  1006 		if (!soundOffFlag)

  1007 			soundInit();

  1008 		SOUND_CLOCK_TICKS = (gbSpeed ? 2 : 1) * GB_USE_TICKS_AS * soundQuality;

  1009 		soundIndex		  = 0;

  1010 		soundBufferIndex  = 0;

  1011 	}

  1012 	else

  1013 	{

  1014 		soundNextPosition = 0;

  1015 		SOUND_CLOCK_TICKS = (gbSpeed ? 2 : 1) * GB_USE_TICKS_AS * soundQuality;

  1016 		soundIndex		  = 0;

  1017 		soundBufferIndex  = 0;

  1018 	}

  1019 }

  1020 

  1021 static int32 soundTicks_int32;

  1022 static int32 SOUND_CLOCK_TICKS_int32;

  1023 variable_desc gbSoundSaveStruct[] = {

  1024 	{ &soundPaused,				sizeof(int32)					  },

  1025 	{ &soundPlay,				sizeof(int32)					  },

  1026 	{ &soundTicks_int32,		sizeof(int32)					  },

  1027 	{ &SOUND_CLOCK_TICKS_int32, sizeof(int32)					  },

  1028 	{ &soundLevel1,				sizeof(int32)					  },

  1029 	{ &soundLevel2,				sizeof(int32)					  },

  1030 	{ &soundBalance,			sizeof(int32)					  },

  1031 	{ &soundMasterOn,			sizeof(int32)					  },

  1032 	{ &soundIndex,				sizeof(int32)					  },

  1033 	{ &soundVIN,				sizeof(int32)					  },

  1034 	{ &sound1On,				sizeof(int32)					  },

  1035 	{ &sound1ATL,				sizeof(int32)					  },

  1036 	{ &sound1Skip,				sizeof(int32)					  },

  1037 	{ &sound1Index,				sizeof(int32)					  },

  1038 	{ &sound1Continue,			sizeof(int32)					  },

  1039 	{ &sound1EnvelopeVolume,	sizeof(int32)					  },

  1040 	{ &sound1EnvelopeATL,		sizeof(int32)					  },

  1041 	{ &sound1EnvelopeATLReload, sizeof(int32)					  },

  1042 	{ &sound1EnvelopeUpDown,	sizeof(int32)					  },

  1043 	{ &sound1SweepATL,			sizeof(int32)					  },

  1044 	{ &sound1SweepATLReload,	sizeof(int32)					  },

  1045 	{ &sound1SweepSteps,		sizeof(int32)					  },

  1046 	{ &sound1SweepUpDown,		sizeof(int32)					  },

  1047 	{ &sound1SweepStep,			sizeof(int32)					  },

  1048 	{ &sound2On,				sizeof(int32)					  },

  1049 	{ &sound2ATL,				sizeof(int32)					  },

  1050 	{ &sound2Skip,				sizeof(int32)					  },

  1051 	{ &sound2Index,				sizeof(int32)					  },

  1052 	{ &sound2Continue,			sizeof(int32)					  },

  1053 	{ &sound2EnvelopeVolume,	sizeof(int32)					  },

  1054 	{ &sound2EnvelopeATL,		sizeof(int32)					  },

  1055 	{ &sound2EnvelopeATLReload, sizeof(int32)					  },

  1056 	{ &sound2EnvelopeUpDown,	sizeof(int32)					  },

  1057 	{ &sound3On,				sizeof(int32)					  },

  1058 	{ &sound3ATL,				sizeof(int32)					  },

  1059 	{ &sound3Skip,				sizeof(int32)					  },

  1060 	{ &sound3Index,				sizeof(int32)					  },

  1061 	{ &sound3Continue,			sizeof(int32)					  },

  1062 	{ &sound3OutputLevel,		sizeof(int32)					  },

  1063 	{ &sound4On,				sizeof(int32)					  },

  1064 	{ &sound4ATL,				sizeof(int32)					  },

  1065 	{ &sound4Skip,				sizeof(int32)					  },

  1066 	{ &sound4Index,				sizeof(int32)					  },

  1067 	{ &sound4Clock,				sizeof(int32)					  },

  1068 	{ &sound4ShiftRight,		sizeof(int32)					  },

  1069 	{ &sound4ShiftSkip,			sizeof(int32)					  },

  1070 	{ &sound4ShiftIndex,		sizeof(int32)					  },

  1071 	{ &sound4NSteps,			sizeof(int32)					  },

  1072 	{ &sound4CountDown,			sizeof(int32)					  },

  1073 	{ &sound4Continue,			sizeof(int32)					  },

  1074 	{ &sound4EnvelopeVolume,	sizeof(int32)					  },

  1075 	{ &sound4EnvelopeATL,		sizeof(int32)					  },

  1076 	{ &sound4EnvelopeATLReload, sizeof(int32)					  },

  1077 	{ &sound4EnvelopeUpDown,	sizeof(int32)					  },

  1078 	{ &soundEnableFlag,			sizeof(int32)					  },

  1079 	{ NULL,						0								  }

  1080 };

  1081 

  1082 //variable_desc gbSoundSaveStructV2[] = {

  1083 //  { &soundTicks, sizeof(soundtick_t) },

  1084 //  { &SOUND_CLOCK_TICKS, sizeof(soundtick_t) },

  1085 //  { &GB_USE_TICKS_AS, sizeof(soundtick_t) },

  1086 //  { NULL, 0 }

  1087 //};

  1088 

  1089 void gbSoundSaveGame(gzFile gzFile)

  1090 {

  1091 	soundTicks_int32		= (int32) soundTicks;

  1092 	SOUND_CLOCK_TICKS_int32 = (int32) SOUND_CLOCK_TICKS;

  1093 

  1094 	utilWriteData(gzFile, gbSoundSaveStruct);

  1095 

  1096 	utilGzWrite(gzFile, soundBuffer, 4 * 735);

  1097 	utilGzWrite(gzFile, soundFinalWave, 2 * 735);

  1098 	utilGzWrite(gzFile, &soundQuality, sizeof(int32));

  1099 

  1100 	//utilWriteData(gzFile, gbSoundSaveStructV2);

  1101 }

  1102 

  1103 void gbSoundReadGame(int version, gzFile gzFile)

  1104 {

  1105 	int32 oldSoundPaused = soundPaused;

  1106 	int32 oldSoundEnableFlag = soundEnableFlag;

  1107 	utilReadData(gzFile, gbSoundSaveStruct);

  1108 	soundPaused = oldSoundPaused;

  1109 	soundEnableFlag = oldSoundEnableFlag;

  1110 

  1111 	soundBufferIndex = soundIndex * 2;

  1112 

  1113 	utilGzRead(gzFile, soundBuffer, 4 * 735);

  1114 	utilGzRead(gzFile, soundFinalWave, 2 * 735);

  1115 

  1116 	if (version >= 7)

  1117 	{

  1118 		int quality = 1;

  1119 		utilGzRead(gzFile, &quality, sizeof(int32));

  1120 		gbSoundSetQuality(quality);

  1121 	}

  1122 	else

  1123 	{

  1124 		soundQuality = -1;

  1125 		gbSoundSetQuality(1);

  1126 	}

  1127 

  1128 	sound1Wave = soundWavePattern[gbMemory[NR11] >> 6];

  1129 	sound2Wave = soundWavePattern[gbMemory[NR21] >> 6];

  1130 

  1131 	//if(version >= 14) {

  1132 	//  utilReadData(gzFile, gbSoundSaveStructV2);

  1133 	//}

  1134 	//else {

  1135 	soundTicks		  = (soundtick_t) soundTicks_int32;

  1136 	SOUND_CLOCK_TICKS = (soundtick_t) SOUND_CLOCK_TICKS_int32;

  1137 	//}

  1138 }

  1139
author	Robert McIntyre <rlm@mit.edu>
date	Sun, 04 Mar 2012 22:32:01 -0600
parents	f9f4f1b99eed
children