[Sound Functions]

dword _InstallSound( )

• Author: Hyun Jeong
• Inputs: -
• Outputs: installs sound
• Returns: 1 if error; 0 otherwise
• Calls: _SB16_Init, _DMA_Lock_Mem
• installs the sound. By doing the follwing:
1. It sets the [_DMA_Mix] flag, which indicates whether to mix the sound effect to the background music.
2. Initializes the [_ISR_Called] to 0, which counts the number of times the soundISR is called.
3. The DMA buffer is allocated to the constant "SIZE", first set in the code. The size I ended up using is 4096 bytes. The smallest I was able to use was 2048 bytes. Smaller sizes made heavy pop and crack noises. Perhaps it took too many CPU cycles to correctly refill the buffers on time. There was no difference with 4096 bytes, so it was used to save CPU cycles. After allocating the memory, the selector and the address were stored into [DMASel] and [DMAAddr] respectively.

void _SoundISR( )

• Author: Hyun Jeong
• Inputs: -
• Outputs: sound played
• Returns: -
• Calls: _DMA_Refill
• This is the handler for sounds. This is called regularly after playing specified number of samples indicated in _SB16_Start function. It was set to 2048 samples, which is 2048 bytes for 8-bit sound. It is half the buffer size, so half of the buffer could be refilled each time. The SoundISR simply counts the number of time it's called and calls _DMA_Refill to refill the half of the DMA buffer.

void _DMA_Refill( )

• Author: Hyun Jeong
• Inputs: -
• Outputs: DMA Buffer Refilled, sound mixed
• Returns: -
• Calls: _SB16_Start

• Refilling the buffer - This was the key to playing long sound files with smooth transitions. Each time it is called, it refills half of the buffer with the next half-buffer-length of the sound clip to be played. [_DMA_Refill_Flag] indicates which half to refill. The flag is updated every time one half is filled, so the other half is filled the next time this function is called.

  • The actual refill was just copying the next half-buffer length of the sound clip to the DMA buffer address. The next portion to be played was stored in [BGMPos], which is incremented by SIZE/2 each time. [NextPos] is just a variable starting at 0 incremented each time by SIZE/2 also, which is used for comparing to handle the end case. When [NextPos] is greater than [BGMSize], which is the size of the background music, we know we've reached the end, and jump to the end case.

  • The end case was handled rather crudely. The code was originally written to play the remaining size of the file, switching to single cycle. But with small enough DMA buffer and having the sound file with enough blank at the end, simply not playing small remainder was good enough. Therefore, when the end is reached, the small remainder is ignored and the music starts again from the beginning.

  Mixing the sounds - Next, it checks the [_DMA_Mix] flag to see whether it needs to mix sound effects to the background music. In this program, background music was always on, so whenever we wanted to play a sound effect, it had to mixed with the background music. To mix the sounds, it loaded data from the buffer it just refilled into an MMX register. It loads the sound effect to be mixed into another MMX register and performs bytewise parallel add. The result is stored back into the buffer and it is repeated until the entire half buffer is filled.

  [MixCycle] stores how many times cycles (DMA refills) the sound must be mixed. It is initialized in _PlaySFX. It is decremented each time, and when it reaches 0, it jumps to the end case. This end case was also handled similar to the DMA refilling case. Again with small enough buffer and sound files with blanks at the end, I simply set the [_DMA_Mix] flag back to 0.

dword _PlayBGM(dword FileOff, dword filesize)

• Author: Hyun Jeong
• Inputs: FileOff - offset of the background music to play
• Outputs: sound played
• Returns: 1 if error, 0 otherwise
• Calls: _DMA_Start, _DMA_Stop, _SB16Init, _SB16_GetChannel, _SB16_SetFormat, _SB16_SetMixers, _SB16_Start
• This function starts the music playing. It sets the appropriate flags and position markers to be used in refilling. It initially fills the entire buffer with the beginning of the sound clip. Then it uses the library functions to initialize sound and to start the DMA transfer, etc.

dword _StopBGM(dword crossfade)

• Author: Hyun Jeong
• Inputs: .Crossfade (1 for crossfade and 0 otherwise)
• Outputs: Stops BGM
• Returns: 1 if error, 0 otherwise
• Calls: -
• Stops the background music This function stops the sound. The "crossfade" decreases the volume gradually then bring the music to stop. It was an attempt to reduce pop or crack noise when stopping the sound. This didn't make any noticeable change. Perhaps the CPU cycle was too fast and each instruction was executed too fast to make it noticeable to our ears. Each decrement in volume could have been made with longer intervals, perhaps using the timer or at the ISR. In theory, when we are near the end of the music (maybe about several buffer lengths from the end), or when this function is called, we can decrease the volume each time the ISR is called. However, there was neither time nor significant reason for this to be implemented.

dword _PlaySFX(dword fileOff2, dword filesize2)

• Author: Hyun Jeong
• Inputs: fileOff2 - offset of the sound effect to play, size of the sound clip
• Outputs: sound played
• Returns: 1 if error, 0 otherwise
• Calls: -
• This function does not actually do any "playing." This just sets the variables used for mixing. Sets the [_DMA_Mix] flag to 1, and sets SFX position markers to the next address to refill. [_MixCycles], the number of buffer-refill cycles is found by dividing the size of the sound effect by the size of the half-buffer. The remainder from this division is the length of the end case, stored in [RemCycle]. Since background music is always on, this does not need to start any DMA transfers.