mirror of
https://github.com/scummvm/scummvm.git
synced 2025-04-02 10:52:32 -04:00
220 lines
7.5 KiB
C++
220 lines
7.5 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "audio/mixer.h"
|
|
|
|
#include "agi/agi.h"
|
|
#include "agi/sound_a2.h"
|
|
|
|
namespace Agi {
|
|
|
|
// SoundGenA2 plays Apple II sounds.
|
|
//
|
|
// Apple II AGI sounds are a series of monotonic notes. They sound similar to
|
|
// PC speaker versions, but they use a different resource format, and sound
|
|
// playback is a blocking operation.
|
|
//
|
|
// The sound resource's values are based on the number of 6502 CPU cycles
|
|
// consumed by AGI's play-note routine and the speed of the CPU. Playback was
|
|
// driven by the engine's own inner loops instead of a timer, so games are
|
|
// blocked until a sound is completed or interrupted by a key press.
|
|
//
|
|
// Common::PCSpeaker is used for sound generation. It produces significantly
|
|
// louder volumes than the other AGI sound generators, so I've lowered the
|
|
// mixer volume for consistency.
|
|
|
|
#define A2_MIXER_VOLUME 20
|
|
|
|
static void calculateNote(uint16 clickCount, uint16 delayCount, float &freq, uint32 &duration_usec);
|
|
static uint32 calculateDelayCycles(uint16 delayCount);
|
|
static uint32 calculateTotalCycles(uint32 delayCycles, uint16 delayCount, uint16 clickCount);
|
|
|
|
SoundGenA2::SoundGenA2(AgiBase *vm, Audio::Mixer *pMixer) :
|
|
_isPlaying(false),
|
|
SoundGen(vm, pMixer) {
|
|
|
|
_mixer->playStream(Audio::Mixer::kMusicSoundType, _soundHandle, this, -1, A2_MIXER_VOLUME, 0, DisposeAfterUse::NO, true);
|
|
}
|
|
|
|
SoundGenA2::~SoundGenA2() {
|
|
_mixer->stopHandle(*_soundHandle);
|
|
}
|
|
|
|
void SoundGenA2::play(int resnum) {
|
|
Common::StackLock lock(_mutex);
|
|
|
|
if (_vm->_game.sounds[resnum] == nullptr ||
|
|
_vm->_game.sounds[resnum]->type() != AGI_SOUND_APPLE2) {
|
|
error("Apple II sound %d not loaded", resnum);
|
|
}
|
|
|
|
_speaker.stop();
|
|
|
|
// parse and enqueue all notes
|
|
AgiSound *sound = _vm->_game.sounds[resnum];
|
|
byte *data = sound->getData();
|
|
uint32 dataLength = sound->getLength();
|
|
for (uint32 i = 0; i + 4 < dataLength; i += 4) {
|
|
uint16 clickCount = READ_LE_UINT16(&data[i]);
|
|
uint16 delayCount = READ_LE_UINT16(&data[i + 2]);
|
|
if (clickCount == 0xffff) {
|
|
break;
|
|
}
|
|
|
|
float freq;
|
|
uint32 duration_usec;
|
|
calculateNote(clickCount, delayCount, freq, duration_usec);
|
|
|
|
if (delayCount != 0) {
|
|
_speaker.playQueue(Audio::PCSpeaker::kWaveFormSquare, freq, duration_usec);
|
|
} else {
|
|
_speaker.playQueue(Audio::PCSpeaker::kWaveFormSilence, 0, duration_usec);
|
|
}
|
|
}
|
|
|
|
_isPlaying = true;
|
|
}
|
|
|
|
void SoundGenA2::stop() {
|
|
Common::StackLock lock(_mutex);
|
|
|
|
_speaker.stop();
|
|
_isPlaying = false;
|
|
}
|
|
|
|
int SoundGenA2::readBuffer(int16 *buffer, const int numSamples) {
|
|
Common::StackLock lock(_mutex);
|
|
|
|
// if not playing then there are no samples
|
|
if (!_isPlaying) {
|
|
return 0;
|
|
}
|
|
|
|
// fill the buffer with PCSpeaker samples
|
|
int result = _speaker.readBuffer(buffer, numSamples);
|
|
|
|
// if PCSpeaker is no longer playing then sound is finished
|
|
if (!_speaker.isPlaying()) {
|
|
_isPlaying = false;
|
|
_vm->_sound->soundIsFinished();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Apple II note calculations
|
|
//
|
|
// Each note is four bytes. Each byte controls how many iterations a loop makes
|
|
// in AGI's play-note routine. If the last two bytes are zero then the "click"
|
|
// instruction (LDA $C030) is skipped.
|
|
//
|
|
// The four bytes are conceptually two 16-bit little-endian values: the number
|
|
// of clicks to perform and the delay before each click.
|
|
//
|
|
// Calculating a note's frequency and duration requires calculating the number
|
|
// of CPU cycles spent delaying before each click and the number of CPU cycles
|
|
// spent in the play-note routine, and then applying the CPU speed.
|
|
//
|
|
// play-note routine from Black Cauldron:
|
|
//
|
|
// 6583:A5 12 LDA VALTYP+1 0012 ; a = delayCount[0]
|
|
// 6585:05 13 ORA GARFLG 0013 ; a |= delayCount[1]
|
|
// 6587:85 14 STA SUBFLG 0014 ; playNote = delayCount != 0
|
|
// ----------- begin counting cycles -----------
|
|
// 6589:A6 13 LDX GARFLG 0013 ; x = delayCount[1]
|
|
// 658B:A4 12 LDY VALTYP+1 0012 ; y = delayCount[0]
|
|
// 658D:88 DEY ; x--
|
|
// 658E:D0 FD BNE $658D 658D
|
|
// 6590:CA DEX ; y--
|
|
// 6591:10 FA BPL $658D 658D
|
|
// 6593:A5 14 LDA SUBFLG 0014 ; a = playNote
|
|
// 6595:F0 03 BEQ $659A 659A ; skip click if !playNote
|
|
// 6597:AD 30 C0 LDA SPKR C030 ; *click*
|
|
// 659A:C6 10 DEC DIMFLG 0010 ; clickCount[0]--
|
|
// 659C:D0 EB BNE $6589 6589
|
|
// 659E:C6 11 DEC VALTYP 0011 ; clickCount[1]--
|
|
// 65A0:10 E7 BPL $6589 6589
|
|
// ----------- end counting cycles -------------
|
|
// 65A2:60 RTS
|
|
|
|
static void calculateNote(uint16 clickCount, uint16 delayCount, float &freq, uint32 &duration_usec) {
|
|
// calculate CPU cycles
|
|
uint32 delayCycles = calculateDelayCycles(delayCount);
|
|
uint32 totalCycles = calculateTotalCycles(delayCycles, delayCount, clickCount);
|
|
|
|
// frequency is half the time spent delaying before a click,
|
|
// because each click only toggles the speaker's state.
|
|
// the average 6502 CPU cycle at 1.023 MHz is 0.98 microseconds.
|
|
freq = 0.5f / (delayCycles * 0.00000098f);
|
|
duration_usec = (uint32)(totalCycles * 0.98f);
|
|
}
|
|
|
|
static uint32 calculateDelayCycles(uint16 delayCount) {
|
|
bool playNote = (delayCount != 0);
|
|
uint32 delayHighByte = delayCount >> 8;
|
|
|
|
uint32 cycles = 0;
|
|
cycles += 3; // LDX
|
|
cycles += 3; // LDY
|
|
if (playNote) {
|
|
cycles += (2 * delayCount); // DEY
|
|
int bneNoBranchCount = (delayCount / 256) + 1;
|
|
cycles += (3 * (delayCount - bneNoBranchCount)) + // BNE
|
|
(2 * bneNoBranchCount);
|
|
} else {
|
|
cycles += ((2 + 3) * 256) - 1; // DEY, BNE - 1 for last 2-cycle BNE
|
|
}
|
|
cycles += 2 * (delayHighByte + 1); // DEX
|
|
cycles += (3 * delayHighByte) + 2; // BPL (3 cycles, 2 cycles on last iteration)
|
|
cycles += 3; // LDA playNote
|
|
cycles += playNote ? 2 : 3; // BEQ (playNote)
|
|
|
|
return cycles;
|
|
}
|
|
|
|
static uint32 calculateTotalCycles(uint32 delayCycles, uint16 delayCount, uint16 clickCount) {
|
|
bool playNote = (delayCount != 0);
|
|
uint32 clickHighByte = clickCount >> 8;
|
|
|
|
// click count should never be zero, but if it were, then the low byte
|
|
// would wrap around and produce 256 clicks while the high byte would
|
|
// be correctly interpreted as zero.
|
|
if (clickCount == 0) {
|
|
clickCount = 256;
|
|
}
|
|
|
|
uint32 cycles = 0;
|
|
cycles += delayCycles * clickCount; // every click incurs delayCycles
|
|
if (playNote) {
|
|
cycles += (4 * clickCount); // every click incurs LDA SPKR (the click!)
|
|
}
|
|
|
|
cycles += 5 * clickCount; // DEC
|
|
int bneNoBranchCount = (clickCount / 256) + 1;
|
|
cycles += (3 * (clickCount - bneNoBranchCount)) + // BNE
|
|
(2 * bneNoBranchCount);
|
|
cycles += 5 * (clickHighByte + 1); // DEC
|
|
cycles += (3 * clickHighByte) + 2; // BPL (3 cycles, 2 cycles on last iteration)
|
|
|
|
return cycles;
|
|
}
|
|
|
|
} // End of namespace Agi
|