ShuriZma
/
quickerNES
mirror of https://github.com/SergioMartin86/quickerNES.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2 from SergioMartin86/lightStates 

refactoring
This commit is contained in:
Sergio Martin 2024-01-20 13:08:14 +01:00 committed by GitHub
parent a06335ebba b7788f946b
commit 0883f5f4da
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
167 changed files with 13616 additions and 12462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
.clang-format Normal file
View File

@ -0,0 +1,121 @@
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortLambdasOnASingleLine: None
AllowShortBlocksOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: false
BinPackParameters: false
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Allman
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: false
ColumnLimit: 0
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 2
ContinuationIndentWidth: 2
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
- Regex: '.*'
Priority: 1
IncludeIsMainRegex: '(Test)?$'
IndentCaseLabels: false
IndentPPDirectives: BeforeHash
IndentWidth: 2
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 2
UseTab: Never
...

2
.github/workflows/make.yml vendored
View File

@ -1,8 +1,6 @@
name: Build and Run Tests
on:
push:
branches: [ "main" ]
pull_request:
branches: [ "main" ]

2
.gitignore vendored
View File

@ -1,3 +1,5 @@
run-clang-format
# Things
.vscode

59
.run-clang-format.sh Executable file
View File

@ -0,0 +1,59 @@
#!/usr/bin/env bash
if [[ $# -ne 1 ]]; then
echo "Usage: $0 <check|fix>"
exit 1
fi
task="${1}"; shift
function check()
{
if [ ! $? -eq 0 ]; then
echo "Error fixing style."
exit -1
fi
}
function check_syntax()
{
# If run-clang-format is not installed, clone it
if [ ! -f run-clang-format/run-clang-format.py ]; then
git clone https://github.com/Sarcasm/run-clang-format.git
if [ ! $? -eq 0 ]; then
echo "Error installing run-clang-format."
exit 1
fi
fi
python3 run-clang-format/run-clang-format.py --recursive source --extensions "cpp,hpp"
if [ ! $? -eq 0 ]; then
echo "Error: C++ Code formatting in source is not normalized."
echo "Solution: Please run this program with the 'fix' argument"
exit -1
fi
}
function fix_syntax()
{
src_files=`find source -type f -name "*.cpp" -o -name "*.hpp"`
echo $src_files | xargs -n6 -P2 clang-format -style=file -i "$@"
check
}
##############################################
### Testing/fixing C++ Code Style
##############################################
command -v clang-format >/dev/null
if [ ! $? -eq 0 ]; then
echo "Error: please install clang-format on your system."
exit -1
fi
if [[ "${task}" == 'check' ]]; then
check_syntax
else
fix_syntax
fi
exit 0

6
extern/hqn/hqn.cpp vendored
View File

@ -10,7 +10,7 @@ namespace hqn
int32_t *_initF_VideoPalette()
{
static int32_t VideoPalette[512];
const Nes_Emu::rgb_t *palette = Nes_Emu::nes_colors;
const emulator_t::rgb_t *palette = emulator_t::nes_colors;
for (int i = 0; i < 512; i++)
{
VideoPalette[i] = palette[i].red << 16 | palette[i].green << 8
@ -25,7 +25,7 @@ const int32_t *HQNState::NES_VIDEO_PALETTE = _initF_VideoPalette();
// Constructor
HQNState::HQNState()
{
m_emu = new Nes_Emu();
m_emu = new emulator_t();
joypad[0] = 0x00;
joypad[1] = 0x00;
@ -50,7 +50,7 @@ error_t HQNState::setSampleRate(int rate)
{
const char *ret = m_emu->set_sample_rate(rate);
if (!ret)
m_emu->set_equalizer(Nes_Emu::nes_eq);
m_emu->set_equalizer(emulator_t::nes_eq);
return ret;
}

28
extern/hqn/hqn.h vendored
View File

@ -1,12 +1,22 @@
#ifndef __HQN_H__
#define __HQN_H__
#include <Nes_Emu.h>
#include <cstdint>
#include <stdio.h>
#define BLIT_SIZE 65536
// Creating emulator instance
#ifdef _USE_QUICKNES
#include <Nes_Emu.hpp>
typedef Nes_Emu emulator_t;
#endif
#ifdef _USE_QUICKERNES
#include <emu.hpp>
typedef quickerNES::Emu emulator_t;
#endif
namespace hqn
{
@ -36,7 +46,7 @@ class HQNState
public:
/* A reference to the emulator instance. */
Nes_Emu *m_emu;
emulator_t *m_emu;
static const int32_t *NES_VIDEO_PALETTE;
@ -46,7 +56,7 @@ public:
HQNState();
~HQNState();
void setEmulatorPointer(void* const emuPtr) { m_emu = (Nes_Emu*)emuPtr; }
void setEmulatorPointer(void* const emuPtr) { m_emu = (emulator_t*)emuPtr; }
/*
The joypad data for the two joypads available to an NES.
@ -55,7 +65,7 @@ public:
uint32_t joypad[2];
/* Get the emulator this state uses. */
inline Nes_Emu *emu() const
inline emulator_t *emu() const
{ return m_emu; }
@ -146,7 +156,7 @@ inline void saveBlit(const void *ePtr, int32_t *dest, const int32_t *colors, int
{
// what is the point of the 256 color bitmap and the dynamic color allocation to it?
// why not just render directly to a 512 color bitmap with static palette positions?
// Nes_Emu *e = m_emu; // e was a parameter but since this is now part of a class, it's just in here
// emulator_t *e = m_emu; // e was a parameter but since this is now part of a class, it's just in here
// const int srcpitch = e->frame().pitch;
// const unsigned char *src = e->frame().pixels;
// const unsigned char *const srcend = src + (e->image_height - cropbottom) * srcpitch;
@ -166,16 +176,16 @@ inline void saveBlit(const void *ePtr, int32_t *dest, const int32_t *colors, int
// }
// }
const Nes_Emu *e = (Nes_Emu*) ePtr;
const emulator_t *e = (emulator_t*) ePtr;
const unsigned char *in_pixels = e->frame().pixels;
if (in_pixels == NULL) return;
int32_t *out_pixels = dest;
for (unsigned h = 0; h < Nes_Emu::image_height; h++, in_pixels += e->frame().pitch, out_pixels += Nes_Emu::image_width)
for (unsigned w = 0; w < Nes_Emu::image_width; w++)
for (unsigned h = 0; h < emulator_t::image_height; h++, in_pixels += e->frame().pitch, out_pixels += emulator_t::image_width)
for (unsigned w = 0; w < emulator_t::image_width; w++)
{
unsigned col = e->frame().palette[in_pixels[w]];
const Nes_Emu::rgb_t& rgb = e->nes_colors[col];
const emulator_t::rgb_t& rgb = e->nes_colors[col];
unsigned r = rgb.red;
unsigned g = rgb.green;
unsigned b = rgb.blue;

293
source/emuInstance.hpp
View File

@ -1,183 +1,204 @@
#pragma once
#include <utils.hpp>
#include "sha1/sha1.hpp"
#include <utils.hpp>
#define _LOW_MEM_SIZE 0x800
#define _HIGH_MEM_SIZE 0x2000
#define _NAMETABLES_MEM_SIZE 0x1000
// Size of image generated in graphics buffer
static const uint16_t image_width = 256;
static const uint16_t image_height = 240;
static const uint16_t image_width = 256;
static const uint16_t image_height = 240;
class EmuInstance
{
public:
public:
typedef uint8_t inputType;
typedef uint8_t inputType;
// Deleting default constructors
virtual ~EmuInstance() = default;
// Deleting default constructors
virtual ~EmuInstance() = default;
// Controller input bits
// 0 - A / 1
// 1 - B / 2
// 2 - Select / 4
// 3 - Start / 8
// 4 - Up / 16
// 5 - Down / 32
// 6 - Left / 64
// 7 - Right / 128
// Controller input bits
// 0 - A / 1
// 1 - B / 2
// 2 - Select / 4
// 3 - Start / 8
// 4 - Up / 16
// 5 - Down / 32
// 6 - Left / 64
// 7 - Right / 128
// Move Format:
// RLDUTSBA
// ........
// Move Format:
// RLDUTSBA
// ........
static inline inputType moveStringToCode(const std::string& move)
{
inputType moveCode = 0;
for (size_t i = 0; i < move.size(); i++) switch(move[i])
static inline inputType moveStringToCode(const std::string &move)
{
case 'U': moveCode |= 0b00010000; break;
case 'D': moveCode |= 0b00100000; break;
case 'L': moveCode |= 0b01000000; break;
case 'R': moveCode |= 0b10000000; break;
case 'S': moveCode |= 0b00001000; break;
case 's': moveCode |= 0b00000100; break;
case 'B': moveCode |= 0b00000010; break;
case 'A': moveCode |= 0b00000001; break;
case 'r': break;
case '.': break;
case '|': break;
default: EXIT_WITH_ERROR("Move provided cannot be parsed: '%s', unrecognized character: '%c'\n", move.c_str(), move[i]);
inputType moveCode = 0;
for (size_t i = 0; i < move.size(); i++) switch (move[i])
{
case 'U': moveCode |= 0b00010000; break;
case 'D': moveCode |= 0b00100000; break;
case 'L': moveCode |= 0b01000000; break;
case 'R': moveCode |= 0b10000000; break;
case 'S': moveCode |= 0b00001000; break;
case 's': moveCode |= 0b00000100; break;
case 'B': moveCode |= 0b00000010; break;
case 'A': moveCode |= 0b00000001; break;
case 'r': break;
case '.': break;
case '|': break;
default: EXIT_WITH_ERROR("Move provided cannot be parsed: '%s', unrecognized character: '%c'\n", move.c_str(), move[i]);
}
return moveCode;
}
return moveCode;
}
static inline std::string moveCodeToString(const inputType move)
{
static inline std::string moveCodeToString(const inputType move)
{
#ifndef _NES_PLAYER_2
std::string moveString = "|..|";
std::string moveString = "|..|";
#else
std::string moveString = "|..|........|";
std::string moveString = "|..|........|";
#endif
if (move & 0b00010000) moveString += 'U'; else moveString += '.';
if (move & 0b00100000) moveString += 'D'; else moveString += '.';
if (move & 0b01000000) moveString += 'L'; else moveString += '.';
if (move & 0b10000000) moveString += 'R'; else moveString += '.';
if (move & 0b00001000) moveString += 'S'; else moveString += '.';
if (move & 0b00000100) moveString += 's'; else moveString += '.';
if (move & 0b00000010) moveString += 'B'; else moveString += '.';
if (move & 0b00000001) moveString += 'A'; else moveString += '.';
if (move & 0b00010000)
moveString += 'U';
else
moveString += '.';
if (move & 0b00100000)
moveString += 'D';
else
moveString += '.';
if (move & 0b01000000)
moveString += 'L';
else
moveString += '.';
if (move & 0b10000000)
moveString += 'R';
else
moveString += '.';
if (move & 0b00001000)
moveString += 'S';
else
moveString += '.';
if (move & 0b00000100)
moveString += 's';
else
moveString += '.';
if (move & 0b00000010)
moveString += 'B';
else
moveString += '.';
if (move & 0b00000001)
moveString += 'A';
else
moveString += '.';
moveString += "|";
return moveString;
}
inline void advanceState(const std::string& move)
{
if (move.find("r") != std::string::npos) doSoftReset();
moveString += "|";
return moveString;
}
advanceStateImpl(moveStringToCode(move), 0);
}
inline void advanceState(const std::string &move)
{
if (move.find("r") != std::string::npos) doSoftReset();
inline size_t getStateSize() const { return _stateSize; }
inline size_t getLiteStateSize() const { return _liteStateSize; }
inline std::string getRomSHA1() const { return _romSHA1String; }
advanceStateImpl(moveStringToCode(move), 0);
}
inline hash_t getStateHash() const
{
MetroHash128 hash;
inline size_t getStateSize() const { return _stateSize; }
inline size_t getLiteStateSize() const { return _liteStateSize; }
inline std::string getRomSHA1() const { return _romSHA1String; }
hash.Update(getLowMem(), _LOW_MEM_SIZE);
hash.Update(getHighMem(), _HIGH_MEM_SIZE);
hash.Update(getNametableMem(), _NAMETABLES_MEM_SIZE);
hash.Update(getChrMem(), getChrMemSize());
inline hash_t getStateHash() const
{
MetroHash128 hash;
hash_t result;
hash.Finalize(reinterpret_cast<uint8_t *>(&result));
return result;
}
hash.Update(getLowMem(), _LOW_MEM_SIZE);
hash.Update(getHighMem(), _HIGH_MEM_SIZE);
hash.Update(getNametableMem(), _NAMETABLES_MEM_SIZE);
hash.Update(getChrMem(), getChrMemSize());
inline void enableRendering() { _doRendering = true; };
inline void disableRendering() { _doRendering = false; };
hash_t result;
hash.Finalize(reinterpret_cast<uint8_t *>(&result));
return result;
}
inline void loadStateFile(const std::string& stateFilePath)
{
std::string stateData;
bool status = loadStringFromFile(stateData, stateFilePath);
if (status == false) EXIT_WITH_ERROR("Could not find/read state file: %s\n", stateFilePath.c_str());
deserializeState((uint8_t*)stateData.data());
}
inline void enableRendering() { _doRendering = true; };
inline void disableRendering() { _doRendering = false; };
inline void saveStateFile(const std::string& stateFilePath) const
{
std::string stateData;
stateData.resize(_stateSize);
serializeState((uint8_t*)stateData.data());
saveStringToFile(stateData, stateFilePath.c_str());
}
inline void loadStateFile(const std::string &stateFilePath)
{
std::string stateData;
bool status = loadStringFromFile(stateData, stateFilePath);
if (status == false) EXIT_WITH_ERROR("Could not find/read state file: %s\n", stateFilePath.c_str());
deserializeState((uint8_t *)stateData.data());
}
inline void loadROMFile(const std::string& romFilePath)
{
// Loading ROM data
bool status = loadStringFromFile(_romData, romFilePath);
if (status == false) EXIT_WITH_ERROR("Could not find/read ROM file: %s\n", romFilePath.c_str());
inline void saveStateFile(const std::string &stateFilePath) const
{
std::string stateData;
stateData.resize(_stateSize);
serializeState((uint8_t *)stateData.data());
saveStringToFile(stateData, stateFilePath.c_str());
}
// Calculating ROM hash value
_romSHA1String = SHA1::GetHash((uint8_t*)_romData.data(), _romData.size());
inline void loadROMFile(const std::string &romFilePath)
{
// Loading ROM data
bool status = loadStringFromFile(_romData, romFilePath);
if (status == false) EXIT_WITH_ERROR("Could not find/read ROM file: %s\n", romFilePath.c_str());
// Actually loading rom file
status = loadROMFileImpl(_romData);
if (status == false) EXIT_WITH_ERROR("Could not process ROM file: %s\n", romFilePath.c_str());
// Calculating ROM hash value
_romSHA1String = SHA1::GetHash((uint8_t *)_romData.data(), _romData.size());
// Detecting full state size
_stateSize = getStateSizeImpl();
// Actually loading rom file
status = loadROMFileImpl(_romData);
if (status == false) EXIT_WITH_ERROR("Could not process ROM file: %s\n", romFilePath.c_str());
// Detecting lite state size
_liteStateSize = getLiteStateSizeImpl();
}
// Detecting full state size
_stateSize = getStateSizeImpl();
// Virtual functions
// Detecting lite state size
_liteStateSize = getLiteStateSizeImpl();
}
virtual bool loadROMFileImpl(const std::string& romFilePath) = 0;
virtual void advanceStateImpl(const inputType controller1, const inputType controller2) = 0;
virtual uint8_t* getLowMem() const = 0;
virtual uint8_t* getNametableMem() const = 0;
virtual uint8_t* getHighMem() const = 0;
virtual const uint8_t* getChrMem() const = 0;
virtual size_t getChrMemSize() const = 0;
virtual void serializeState(uint8_t* state) const = 0;
virtual void deserializeState(const uint8_t* state) = 0;
virtual size_t getStateSizeImpl() const = 0;
virtual size_t getLiteStateSizeImpl() const { return getStateSizeImpl(); };
virtual void doSoftReset() = 0;
virtual void doHardReset() = 0;
virtual std::string getCoreName() const = 0;
virtual void* getInternalEmulatorPointer() const = 0;
// Virtual functions
protected:
virtual bool loadROMFileImpl(const std::string &romFilePath) = 0;
virtual void advanceStateImpl(const inputType controller1, const inputType controller2) = 0;
virtual uint8_t *getLowMem() const = 0;
virtual uint8_t *getNametableMem() const = 0;
virtual uint8_t *getHighMem() const = 0;
virtual const uint8_t *getChrMem() const = 0;
virtual size_t getChrMemSize() const = 0;
virtual void serializeState(uint8_t *state) const = 0;
virtual void deserializeState(const uint8_t *state) = 0;
virtual size_t getStateSizeImpl() const = 0;
virtual size_t getLiteStateSizeImpl() const { return getStateSizeImpl(); };
virtual void doSoftReset() = 0;
virtual void doHardReset() = 0;
virtual std::string getCoreName() const = 0;
virtual void *getInternalEmulatorPointer() const = 0;
EmuInstance() = default;
protected:
EmuInstance() = default;
// Storage for the light state size
size_t _liteStateSize;
// Storage for the light state size
size_t _liteStateSize;
// Storage for the full state size
size_t _stateSize;
// Storage for the full state size
size_t _stateSize;
// Flag to determine whether to enable/disable rendering
bool _doRendering = true;
private:
// Flag to determine whether to enable/disable rendering
bool _doRendering = true;
// Storage for the ROM data
std::string _romData;
private:
// Storage for the ROM data
std::string _romData;
// SHA1 rom hash
std::string _romSHA1String;
// SHA1 rom hash
std::string _romSHA1String;
};

388
source/playbackInstance.hpp
View File

@ -1,34 +1,40 @@
#pragma once
#include <string>
#include <unistd.h>
#include "emuInstance.hpp"
#include <SDL.h>
#include <SDL_image.h>
#include <utils.hpp>
#include <hqn/hqn.h>
#include <hqn/hqn.h>
#include <hqn/hqn_gui_controller.h>
#include "emuInstance.hpp"
#include <string>
#include <unistd.h>
#include <utils.hpp>
#define _INVERSE_FRAME_RATE 16667
class Nes_Emu;
// Creating emulator instance
#ifdef _USE_QUICKNES
typedef Nes_Emu emulator_t;
#endif
#ifdef _USE_QUICKERNES
typedef quickerNES::Emu emulator_t;
#endif
struct stepData_t
{
std::string input;
uint8_t* stateData;
uint8_t *stateData;
hash_t hash;
};
class PlaybackInstance
{
public:
void addStep(const std::string& input)
public:
void addStep(const std::string &input)
{
stepData_t step;
step.input = input;
step.stateData = (uint8_t*) malloc(_emu->getStateSize());
step.stateData = (uint8_t *)malloc(_emu->getStateSize());
_emu->serializeState(step.stateData);
step.hash = _emu->getStateHash();
@ -37,219 +43,217 @@ class PlaybackInstance
}
// Initializes the playback module instance
PlaybackInstance(EmuInstance* emu, const std::vector<std::string>& sequence, const std::string& overlayPath = "") : _emu(emu)
{
// Enabling emulation rendering
_emu->enableRendering();
// Loading Emulator instance HQN
_hqnState.setEmulatorPointer(_emu->getInternalEmulatorPointer());
static uint8_t video_buffer[Nes_Emu::image_width * Nes_Emu::image_height];
_hqnState.m_emu->set_pixels(video_buffer, Nes_Emu::image_width+8);
// Building sequence information
for (const auto& input : sequence)
PlaybackInstance(EmuInstance *emu, const std::vector<std::string> &sequence, const std::string &overlayPath = "") : _emu(emu)
{
// Adding new step
addStep(input);
// Enabling emulation rendering
_emu->enableRendering();
// Advance state based on the input received
_emu->advanceState(input);
// Loading Emulator instance HQN
_hqnState.setEmulatorPointer(_emu->getInternalEmulatorPointer());
static uint8_t video_buffer[emulator_t::image_width * emulator_t::image_height];
_hqnState.m_emu->set_pixels(video_buffer, emulator_t::image_width + 8);
// Building sequence information
for (const auto &input : sequence)
{
// Adding new step
addStep(input);
// Advance state based on the input received
_emu->advanceState(input);
}
// Adding last step with no input
addStep("<End Of Sequence>");
// Loading overlay, if provided
if (overlayPath != "")
{
// Using overlay
_useOverlay = true;
// Loading overlay images
std::string imagePath;
imagePath = _overlayPath + std::string("/base.png");
_overlayBaseSurface = IMG_Load(imagePath.c_str());
if (_overlayBaseSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_a.png");
_overlayButtonASurface = IMG_Load(imagePath.c_str());
if (_overlayButtonASurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_b.png");
_overlayButtonBSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonBSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_select.png");
_overlayButtonSelectSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonSelectSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_start.png");
_overlayButtonStartSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonStartSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_left.png");
_overlayButtonLeftSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonLeftSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_right.png");
_overlayButtonRightSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonRightSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_up.png");
_overlayButtonUpSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonUpSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_down.png");
_overlayButtonDownSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonDownSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
}
// Opening rendering window
SDL_SetMainReady();
// We can only call SDL_InitSubSystem once
if (!SDL_WasInit(SDL_INIT_VIDEO))
if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0)
EXIT_WITH_ERROR("Failed to initialize video: %s", SDL_GetError());
// Creating HQN GUI
_hqnGUI = hqn::GUIController::create(_hqnState);
_hqnGUI->setScale(1);
}
// Adding last step with no input
addStep("<End Of Sequence>");
// Loading overlay, if provided
if (overlayPath != "")
// Function to render frame
void renderFrame(const size_t stepId)
{
// Using overlay
_useOverlay = true;
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Loading overlay images
std::string imagePath;
// Getting step information
const auto &step = _stepSequence[stepId];
imagePath = _overlayPath + std::string("/base.png");
_overlayBaseSurface = IMG_Load(imagePath.c_str());
if (_overlayBaseSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
// Pointer to overlay images (NULL if unused)
SDL_Surface *overlayButtonASurface = NULL;
SDL_Surface *overlayButtonBSurface = NULL;
SDL_Surface *overlayButtonSelectSurface = NULL;
SDL_Surface *overlayButtonStartSurface = NULL;
SDL_Surface *overlayButtonLeftSurface = NULL;
SDL_Surface *overlayButtonRightSurface = NULL;
SDL_Surface *overlayButtonUpSurface = NULL;
SDL_Surface *overlayButtonDownSurface = NULL;
imagePath = _overlayPath + std::string("/button_a.png");
_overlayButtonASurface = IMG_Load(imagePath.c_str());
if (_overlayButtonASurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
// Load correct overlay images, if using overlay
if (_useOverlay == true)
{
if (step.input.find("A") != std::string::npos) overlayButtonASurface = _overlayButtonASurface;
if (step.input.find("B") != std::string::npos) overlayButtonBSurface = _overlayButtonBSurface;
if (step.input.find("S") != std::string::npos) overlayButtonSelectSurface = _overlayButtonSelectSurface;
if (step.input.find("T") != std::string::npos) overlayButtonStartSurface = _overlayButtonStartSurface;
if (step.input.find("L") != std::string::npos) overlayButtonLeftSurface = _overlayButtonLeftSurface;
if (step.input.find("R") != std::string::npos) overlayButtonRightSurface = _overlayButtonRightSurface;
if (step.input.find("U") != std::string::npos) overlayButtonUpSurface = _overlayButtonUpSurface;
if (step.input.find("D") != std::string::npos) overlayButtonDownSurface = _overlayButtonDownSurface;
}
imagePath = _overlayPath + std::string("/button_b.png");
_overlayButtonBSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonBSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
// Since we do not store the blit information (too much memory), we need to load the previous frame and re-run the input
imagePath = _overlayPath + std::string("/button_select.png");
_overlayButtonSelectSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonSelectSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
// If its the first step, then simply reset
if (stepId == 0) _emu->doHardReset();
imagePath = _overlayPath + std::string("/button_start.png");
_overlayButtonStartSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonStartSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
// Else we load the previous frame
if (stepId > 0)
{
const auto stateData = getStateData(stepId - 1);
_emu->deserializeState(stateData);
_emu->advanceState(getStateInput(stepId - 1));
}
imagePath = _overlayPath + std::string("/button_left.png");
_overlayButtonLeftSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonLeftSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_right.png");
_overlayButtonRightSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonRightSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_up.png");
_overlayButtonUpSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonUpSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
imagePath = _overlayPath + std::string("/button_down.png");
_overlayButtonDownSurface = IMG_Load(imagePath.c_str());
if (_overlayButtonDownSurface == NULL) EXIT_WITH_ERROR("[Error] Could not load image: %s, Reason: %s\n", imagePath.c_str(), SDL_GetError());
// Updating image
int32_t curBlit[BLIT_SIZE];
saveBlit(_emu->getInternalEmulatorPointer(), curBlit, hqn::HQNState::NES_VIDEO_PALETTE, 0, 0, 0, 0);
_hqnGUI->update_blit(curBlit, _overlayBaseSurface, overlayButtonASurface, overlayButtonBSurface, overlayButtonSelectSurface, overlayButtonStartSurface, overlayButtonLeftSurface, overlayButtonRightSurface, overlayButtonUpSurface, overlayButtonDownSurface);
}
// Opening rendering window
SDL_SetMainReady();
// We can only call SDL_InitSubSystem once
if (!SDL_WasInit(SDL_INIT_VIDEO))
if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0)
EXIT_WITH_ERROR("Failed to initialize video: %s", SDL_GetError());
// Creating HQN GUI
_hqnGUI = hqn::GUIController::create(_hqnState);
_hqnGUI->setScale(1);
}
// Function to render frame
void renderFrame(const size_t stepId)
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Getting step information
const auto& step = _stepSequence[stepId];
// Pointer to overlay images (NULL if unused)
SDL_Surface* overlayButtonASurface = NULL;
SDL_Surface* overlayButtonBSurface = NULL;
SDL_Surface* overlayButtonSelectSurface = NULL;
SDL_Surface* overlayButtonStartSurface = NULL;
SDL_Surface* overlayButtonLeftSurface = NULL;
SDL_Surface* overlayButtonRightSurface = NULL;
SDL_Surface* overlayButtonUpSurface = NULL;
SDL_Surface* overlayButtonDownSurface = NULL;
// Load correct overlay images, if using overlay
if (_useOverlay == true)
size_t getSequenceLength() const
{
if (step.input.find("A") != std::string::npos) overlayButtonASurface = _overlayButtonASurface;
if (step.input.find("B") != std::string::npos) overlayButtonBSurface = _overlayButtonBSurface;
if (step.input.find("S") != std::string::npos) overlayButtonSelectSurface = _overlayButtonSelectSurface;
if (step.input.find("T") != std::string::npos) overlayButtonStartSurface = _overlayButtonStartSurface;
if (step.input.find("L") != std::string::npos) overlayButtonLeftSurface = _overlayButtonLeftSurface;
if (step.input.find("R") != std::string::npos) overlayButtonRightSurface = _overlayButtonRightSurface;
if (step.input.find("U") != std::string::npos) overlayButtonUpSurface = _overlayButtonUpSurface;
if (step.input.find("D") != std::string::npos) overlayButtonDownSurface = _overlayButtonDownSurface;
return _stepSequence.size();
}
// Since we do not store the blit information (too much memory), we need to load the previous frame and re-run the input
// If its the first step, then simply reset
if (stepId == 0) _emu->doHardReset();
// Else we load the previous frame
if (stepId > 0)
const std::string getInput(const size_t stepId) const
{
const auto stateData = getStateData(stepId-1);
_emu->deserializeState(stateData);
_emu->advanceState(getStateInput(stepId-1));
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Getting step information
const auto &step = _stepSequence[stepId];
// Returning step input
return step.input;
}
// Updating image
int32_t curBlit[BLIT_SIZE];
saveBlit(_emu->getInternalEmulatorPointer(), curBlit, hqn::HQNState::NES_VIDEO_PALETTE, 0, 0, 0, 0);
_hqnGUI->update_blit(curBlit, _overlayBaseSurface, overlayButtonASurface, overlayButtonBSurface, overlayButtonSelectSurface, overlayButtonStartSurface, overlayButtonLeftSurface, overlayButtonRightSurface, overlayButtonUpSurface, overlayButtonDownSurface);
}
size_t getSequenceLength() const
{
return _stepSequence.size();
}
const uint8_t *getStateData(const size_t stepId) const
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
const std::string getInput(const size_t stepId) const
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Getting step information
const auto& step = _stepSequence[stepId];
// Getting step information
const auto &step = _stepSequence[stepId];
// Returning step input
return step.input;
}
// Returning step input
return step.stateData;
}
const uint8_t* getStateData(const size_t stepId) const
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Getting step information
const auto& step = _stepSequence[stepId];
const hash_t getStateHash(const size_t stepId) const
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Returning step input
return step.stateData;
}
// Getting step information
const auto &step = _stepSequence[stepId];
const hash_t getStateHash(const size_t stepId) const
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Getting step information
const auto& step = _stepSequence[stepId];
// Returning step input
return step.hash;
}
// Returning step input
return step.hash;
}
const std::string getStateInput(const size_t stepId) const
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
const std::string getStateInput(const size_t stepId) const
{
// Checking the required step id does not exceed contents of the sequence
if (stepId > _stepSequence.size()) EXIT_WITH_ERROR("[Error] Attempting to render a step larger than the step sequence");
// Getting step information
const auto& step = _stepSequence[stepId];
// Getting step information
const auto &step = _stepSequence[stepId];
// Returning step input
return step.input;
}
// Returning step input
return step.input;
}
private:
// Internal sequence information
std::vector<stepData_t> _stepSequence;
private:
// Storage for the HQN state
hqn::HQNState _hqnState;
// Internal sequence information
std::vector<stepData_t> _stepSequence;
// Storage for the HQN GUI controller
hqn::GUIController *_hqnGUI;
// Storage for the HQN state
hqn::HQNState _hqnState;
// Pointer to the contained emulator instance
EmuInstance *const _emu;
// Storage for the HQN GUI controller
hqn::GUIController* _hqnGUI;
// Flag to store whether to use the button overlay
bool _useOverlay = false;
// Pointer to the contained emulator instance
EmuInstance* const _emu;
// Flag to store whether to use the button overlay
bool _useOverlay = false;
// Overlay info
std::string _overlayPath;
SDL_Surface* _overlayBaseSurface = NULL;
SDL_Surface* _overlayButtonASurface;
SDL_Surface* _overlayButtonBSurface;
SDL_Surface* _overlayButtonSelectSurface;
SDL_Surface* _overlayButtonStartSurface;
SDL_Surface* _overlayButtonLeftSurface;
SDL_Surface* _overlayButtonRightSurface;
SDL_Surface* _overlayButtonUpSurface;
SDL_Surface* _overlayButtonDownSurface;
// Overlay info
std::string _overlayPath;
SDL_Surface *_overlayBaseSurface = NULL;
SDL_Surface *_overlayButtonASurface;
SDL_Surface *_overlayButtonBSurface;
SDL_Surface *_overlayButtonSelectSurface;
SDL_Surface *_overlayButtonStartSurface;
SDL_Surface *_overlayButtonLeftSurface;
SDL_Surface *_overlayButtonRightSurface;
SDL_Surface *_overlayButtonUpSurface;
SDL_Surface *_overlayButtonDownSurface;
};

43
source/player.cpp
View File

@ -1,15 +1,15 @@
#include <cstdlib>
#include "argparse/argparse.hpp"
#include "utils.hpp"
#include "emuInstance.hpp"
#include "playbackInstance.hpp"
#include "utils.hpp"
#include <cstdlib>
#ifdef _USE_QUICKNES
#include "quickNESInstance.hpp"
#include "quickNESInstance.hpp"
#endif
#ifdef _USE_QUICKERNES
#include "quickerNESInstance.hpp"
#include "quickerNESInstance.hpp"
#endif
int main(int argc, char *argv[])
@ -26,8 +26,8 @@ int main(int argc, char *argv[])
.required();
program.add_argument("stateFile")
.help("(Optional) Path to the initial state file to load.")
.default_value(std::string(""));
.help("(Optional) Path to the initial state file to load.")
.default_value(std::string(""));
program.add_argument("--reproduce")
.help("Plays the entire sequence without interruptions and exit at the end.")
@ -40,8 +40,14 @@ int main(int argc, char *argv[])
.implicit_value(true);
// Try to parse arguments
try { program.parse_args(argc, argv); }
catch (const std::runtime_error &err) { EXIT_WITH_ERROR("%s\n%s", err.what(), program.help().str().c_str()); }
try
{
program.parse_args(argc, argv);
}
catch (const std::runtime_error &err)
{
EXIT_WITH_ERROR("%s\n%s", err.what(), program.help().str().c_str());
}
// Getting ROM file path
std::string romFilePath = program.get<std::string>("romFile");
@ -78,14 +84,14 @@ int main(int argc, char *argv[])
refreshTerminal();
// Creating emulator instance
#ifdef _USE_QUICKNES
// Creating emulator instance
#ifdef _USE_QUICKNES
auto e = QuickNESInstance();
#endif
#endif
#ifdef _USE_QUICKERNES
auto e = QuickerNESInstance();
#endif
#ifdef _USE_QUICKERNES
auto e = quickerNES::QuickerNESInstance();
#endif
// Loading ROM File
e.loadROMFile(romFilePath);
@ -110,13 +116,13 @@ int main(int argc, char *argv[])
bool showFrameInfo = true;
// Interactive section
while(continueRunning)
while (continueRunning)
{
// Updating display
if (disableRender == false) p.renderFrame(currentStep);
// Getting input
const auto& input = p.getStateInput(currentStep);
const auto &input = p.getStateInput(currentStep);
// Getting state hash
const auto hash = p.getStateHash(currentStep);
@ -158,12 +164,12 @@ int main(int argc, char *argv[])
// Correct current step if requested more than possible
if (currentStep < 0) currentStep = 0;
if (currentStep >= sequenceLength) currentStep = sequenceLength-1;
if (currentStep >= sequenceLength) currentStep = sequenceLength - 1;
// Quicksave creation command
if (command == 's')
{
// Storing state file
// Storing state file
std::string saveFileName = "quicksave.state";
std::string saveData;
@ -186,4 +192,3 @@ int main(int argc, char *argv[])
// Ending ncurses window
finalizeTerminal();
}

83
source/quickNES/Mapper_70.cpp
View File

@ -23,58 +23,59 @@
#include "Nes_Mapper.h"
template < bool _is152 >
class Mapper_74x161x162x32 : public Nes_Mapper {
public:
Mapper_74x161x162x32()
{
register_state( &bank, 1 );
}
template <bool _is152>
class Mapper_74x161x162x32 : public Nes_Mapper
{
public:
Mapper_74x161x162x32()
{
register_state(&bank, 1);
}
virtual void reset_state()
{
if ( _is152 == 0 )
bank = ~0;
}
virtual void reset_state()
{
if (_is152 == 0)
bank = ~0;
}
virtual void apply_mapping()
{
if ( _is152 )
write( 0, 0, bank );
else
{
intercept_writes( 0x6000, 1 );
write_intercepted( 0, 0x6000, bank );
}
}
virtual void apply_mapping()
{
if (_is152)
write(0, 0, bank);
else
{
intercept_writes(0x6000, 1);
write_intercepted(0, 0x6000, bank);
}
}
virtual bool write_intercepted( nes_time_t, nes_addr_t addr, int data )
{
if ( ( addr != 0x6000 ) || _is152 )
return false;
virtual bool write_intercepted(nes_time_t, nes_addr_t addr, int data)
{
if ((addr != 0x6000) || _is152)
return false;
bank = data;
set_prg_bank( 0x8000, bank_32k, ( bank >> 4 ) & 0x03 );
set_chr_bank( 0x0000, bank_8k, ( ( bank >> 4 ) & 0x04 ) | ( bank & 0x03 ) );
bank = data;
set_prg_bank(0x8000, bank_32k, (bank >> 4) & 0x03);
set_chr_bank(0x0000, bank_8k, ((bank >> 4) & 0x04) | (bank & 0x03));
return true;
}
return true;
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
if ( _is152 == 0) return;
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
if (_is152 == 0) return;
bank = handle_bus_conflict (addr, data );
set_prg_bank( 0x8000, bank_16k, ( bank >> 4 ) & 0x07 );
set_chr_bank( 0x0000, bank_8k, bank & 0x0F );
mirror_single( ( bank >> 7) & 0x01 );
}
bank = handle_bus_conflict(addr, data);
set_prg_bank(0x8000, bank_16k, (bank >> 4) & 0x07);
set_chr_bank(0x0000, bank_8k, bank & 0x0F);
mirror_single((bank >> 7) & 0x01);
}
uint8_t bank;
uint8_t bank;
};
void register_mapper_70();
void register_mapper_70()
{
register_mapper< Mapper_74x161x162x32 <true> > ( 70 );
register_mapper<Mapper_74x161x162x32<true>>(70);
}

126
source/quickNES/quickNESInstance.hpp
View File

@ -12,81 +12,79 @@ extern void register_mapper_70();
class QuickNESInstance : public EmuInstance
{
public:
public:
QuickNESInstance() : EmuInstance()
{
// Creating new emulator
_nes = new Nes_Emu;
QuickNESInstance() : EmuInstance()
{
// Creating new emulator
_nes = new Nes_Emu;
// Allocating video buffer
video_buffer = (uint8_t *)malloc(image_width * image_height);
// Allocating video buffer
video_buffer = (uint8_t*) malloc(image_width * image_height);
// Setting video buffer
_nes->set_pixels(video_buffer, image_width + 8);
// Setting video buffer
_nes->set_pixels(video_buffer, image_width+8);
// If running the original QuickNES, register extra mappers now
register_misc_mappers();
register_extra_mappers();
register_mapper_70();
}
// If running the original QuickNES, register extra mappers now
register_misc_mappers();
register_extra_mappers();
register_mapper_70();
}
virtual bool loadROMFileImpl(const std::string &romData) override
{
// Loading rom data
Mem_File_Reader romReader(romData.data(), (int)romData.size());
Auto_File_Reader romFile(romReader);
auto result = _nes->load_ines(romFile);
return result == 0;
}
virtual bool loadROMFileImpl(const std::string& romData) override
{
// Loading rom data
Mem_File_Reader romReader(romData.data(), (int)romData.size());
Auto_File_Reader romFile(romReader);
auto result = _nes->load_ines(romFile);
return result == 0;
}
uint8_t *getLowMem() const override { return _nes->low_mem(); };
uint8_t *getNametableMem() const override { return _nes->nametable_mem(); };
uint8_t *getHighMem() const override { return _nes->high_mem(); };
const uint8_t *getChrMem() const override { return _nes->chr_mem(); };
size_t getChrMemSize() const override { return _nes->chr_size(); };
uint8_t* getLowMem() const override { return _nes->low_mem(); };
uint8_t* getNametableMem() const override { return _nes->nametable_mem(); };
uint8_t* getHighMem() const override { return _nes->high_mem();};
const uint8_t* getChrMem() const override { return _nes->chr_mem();};
size_t getChrMemSize() const override { return _nes->chr_size();};
void serializeState(uint8_t *state) const override
{
Mem_Writer w(state, _stateSize, 0);
Auto_File_Writer a(w);
_nes->save_state(a);
}
void serializeState(uint8_t* state) const override
{
Mem_Writer w(state, _stateSize, 0);
Auto_File_Writer a(w);
_nes->save_state(a);
}
void deserializeState(const uint8_t *state) override
{
Mem_File_Reader r(state, _stateSize);
Auto_File_Reader a(r);
_nes->load_state(a);
}
void deserializeState(const uint8_t* state) override
{
Mem_File_Reader r(state, _stateSize);
Auto_File_Reader a(r);
_nes->load_state(a);
}
void advanceStateImpl(const inputType controller1, const inputType controller2) override
{
if (_doRendering == true) _nes->emulate_frame(controller1, controller2);
if (_doRendering == false) _nes->emulate_skip_frame(controller1, controller2);
}
void advanceStateImpl(const inputType controller1, const inputType controller2) override
{
if (_doRendering == true) _nes->emulate_frame(controller1, controller2);
if (_doRendering == false) _nes->emulate_skip_frame(controller1, controller2);
}
std::string getCoreName() const override { return "QuickNES"; }
void doSoftReset() override { _nes->reset(false); }
void doHardReset() override { _nes->reset(true); }
std::string getCoreName() const override { return "QuickNES"; }
void doSoftReset() override { _nes->reset(false); }
void doHardReset() override { _nes->reset(true); }
void *getInternalEmulatorPointer() const override { return _nes; }
void* getInternalEmulatorPointer() const override { return _nes; }
private:
inline size_t getStateSizeImpl() const override
{
uint8_t *data = (uint8_t *)malloc(_DUMMY_SIZE);
Mem_Writer w(data, _DUMMY_SIZE);
Auto_File_Writer a(w);
_nes->save_state(a);
free(data);
return w.size();
}
private:
// Video buffer
uint8_t *video_buffer;
inline size_t getStateSizeImpl() const override
{
uint8_t* data = (uint8_t*) malloc (_DUMMY_SIZE);
Mem_Writer w(data, _DUMMY_SIZE);
Auto_File_Writer a(w);
_nes->save_state(a);
free(data);
return w.size();
}
// Video buffer
uint8_t* video_buffer;
// Emulator instance
Nes_Emu* _nes;
// Emulator instance
Nes_Emu *_nes;
};

100
source/quickerNES/Nes_Cart.h
View File

@ -1,100 +0,0 @@
#pragma once
// NES cartridge data (PRG, CHR, mapper)
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
#include <cstring>
#include <cstdint>
#include <cstdlib>
class Nes_Cart {
public:
Nes_Cart() = default;
struct ines_header_t {
uint8_t signature [4];
uint8_t prg_count; // number of 16K PRG banks
uint8_t chr_count; // number of 8K CHR banks
uint8_t flags; // MMMM FTBV Mapper low, Four-screen, Trainer, Battery, V mirror
uint8_t flags2; // MMMM --XX Mapper high 4 bits
uint8_t zero [8]; // if zero [7] is non-zero, treat flags2 as zero
};
static_assert( sizeof (ines_header_t) == 16 );
// Load iNES file
void load_ines( const uint8_t* buffer )
{
ines_header_t h;
size_t bufferPos = 0;
{ size_t copySize = sizeof(ines_header_t); memcpy(&h, &buffer[bufferPos], copySize); bufferPos += copySize; }
if ( h.zero [7] ) h.flags2 = 0;
set_mapper( h.flags, h.flags2 );
// skip trainer
if ( h.flags & 0x04 ) bufferPos += 512;
// Allocating memory for prg and chr
prg_size_ = h.prg_count * 16 * 1024L;
chr_size_ = h.chr_count * 8 * 1024L;
auto p = malloc(prg_size_ + chr_size_);
prg_ = (uint8_t*)p;
chr_ = &prg_[prg_size_];
{ size_t copySize = prg_size(); memcpy(prg(), &buffer[bufferPos], copySize); bufferPos += copySize; }
{ size_t copySize = chr_size(); memcpy(chr(), &buffer[bufferPos], copySize); bufferPos += copySize; }
}
inline bool has_battery_ram() const { return mapper & 0x02; }
// Set mapper and information bytes. LSB and MSB are the standard iNES header
// bytes at offsets 6 and 7.
inline void set_mapper( int mapper_lsb, int mapper_msb )
{
mapper = mapper_msb * 0x100 + mapper_lsb;
}
inline int mapper_code() const { return ((mapper >> 8) & 0xf0) | ((mapper >> 4) & 0x0f); }
// Size of PRG data
long prg_size() const { return prg_size_; }
// Size of CHR data
long chr_size() const { return chr_size_; }
unsigned mapper_data() const { return mapper; }
// Initial mirroring setup
int mirroring() const { return mapper & 0x09; }
// Pointer to beginning of PRG data
inline uint8_t * prg() { return prg_; }
inline uint8_t const* prg() const { return prg_; }
// Pointer to beginning of CHR data
inline uint8_t * chr() { return chr_; }
inline uint8_t const* chr() const { return chr_; }
// End of public interface
private:
uint8_t *prg_;
uint8_t *chr_;
long prg_size_;
long chr_size_;
unsigned mapper;
};

986
source/quickerNES/Nes_Core.h
View File

@ -1,986 +0,0 @@
#pragma once
// Internal NES emulator
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Nes_Emu 0.7.0
#include <cstdio>
#include <string>
#include "apu/apu.h"
#include "Nes_Cpu.h"
#include "ppu/Nes_Ppu.h"
#include "mappers/mapper.h"
class Nes_Cart;
#undef NES_EMU_CPU_HOOK
#ifndef NES_EMU_CPU_HOOK
#define NES_EMU_CPU_HOOK( cpu, end_time ) cpu::run( end_time )
#endif
bool const wait_states_enabled = true;
bool const single_instruction_mode = false; // for debugging irq/nmi timing issues
const int unmapped_fill = Nes_Cpu::page_wrap_opcode;
unsigned const low_ram_size = 0x800;
unsigned const low_ram_end = 0x2000;
unsigned const sram_end = 0x8000;
const int irq_inhibit_mask = 0x04;
struct nes_state_t
{
uint16_t timestamp; // CPU clocks * 15 (for NTSC)
uint8_t pal;
uint8_t unused [1];
uint32_t frame_count; // number of frames emulated since power-up
};
struct joypad_state_t
{
uint32_t joypad_latches [2]; // joypad 1 & 2 shift registers
uint8_t w4016; // strobe
uint8_t unused [3];
};
static_assert( sizeof (joypad_state_t) == 12 );
struct cpu_state_t
{
uint16_t pc;
uint8_t s;
uint8_t p;
uint8_t a;
uint8_t x;
uint8_t y;
uint8_t unused [1];
};
static_assert( sizeof (cpu_state_t) == 8 );
class Nes_Core : private Nes_Cpu {
typedef Nes_Cpu cpu;
public:
Nes_Core() : ppu( this )
{
cart = NULL;
impl = NULL;
mapper = NULL;
memset( &nes, 0, sizeof nes );
memset( &joypad, 0, sizeof joypad );
}
~Nes_Core()
{
close();
delete impl;
}
const char * init()
{
if ( !impl )
{
impl = new impl_t;
impl->apu.dmc_reader( read_dmc, this );
impl->apu.irq_notifier( apu_irq_changed, this );
}
return 0;
}
void open( Nes_Cart const* new_cart )
{
close();
init();
// Getting cartdrige mapper code
auto mapperCode = new_cart->mapper_code();
// Getting mapper corresponding to that code
mapper = Nes_Mapper::getMapperFromCode(mapperCode);
// If no mapper was found, return null (error) now
if (mapper == nullptr)
{
fprintf(stderr, "Could not find mapper for code: %u\n", mapperCode);
exit(-1);
}
// Assigning backwards pointers to cartdrige and emulator now
mapper->cart_ = new_cart;
mapper->emu_ = this;
ppu.open_chr( new_cart->chr(), new_cart->chr_size() );
cart = new_cart;
memset( impl->unmapped_page, unmapped_fill, sizeof impl->unmapped_page );
reset( true, true );
}
size_t getLiteStateSize() const
{
size_t size = 0;
size += sizeof(nes_state_t);
size += sizeof(registers_t);
size += sizeof(ppu_state_t);
size += sizeof(Nes_Apu::apu_state_t);
size += sizeof(joypad_state_t);
size += mapper->state_size;
size += low_ram_size;
size += Nes_Ppu::spr_ram_size;
size_t nametable_size = 0x800;
if (ppu.nt_banks [3] >= &ppu.impl->nt_ram [0xC00] ) nametable_size = 0x1000;
size += nametable_size;
if ( ppu.chr_is_writable ) size += ppu.chr_size;
if ( sram_present ) size += impl->sram_size;
return size;
}
size_t getStateSize() const
{
size_t size = 0;
size += sizeof(char[4]); // NESS Block
size += sizeof(uint32_t); // Block Size
size += sizeof(char[4]); // TIME Block
size += sizeof(uint32_t); // Block Size
size += sizeof(nes_state_t);
size += sizeof(char[4]); // CPUR Block
size += sizeof(uint32_t); // Block Size
size += sizeof(registers_t);
size += sizeof(char[4]); // PPUR Block
size += sizeof(uint32_t); // Block Size
size += sizeof(ppu_state_t);
size += sizeof(char[4]); // APUR Block
size += sizeof(uint32_t); // Block Size
size += sizeof(Nes_Apu::apu_state_t);
size += sizeof(char[4]); // CTRL Block
size += sizeof(uint32_t); // Block Size
size += sizeof(joypad_state_t);
size += sizeof(char[4]); // MAPR Block
size += sizeof(uint32_t); // Block Size
size += mapper->state_size;
size += sizeof(char[4]); // LRAM Block
size += sizeof(uint32_t); // Block Size
size += low_ram_size;
size += sizeof(char[4]); // SPRT Block
size += sizeof(uint32_t); // Block Size
size += Nes_Ppu::spr_ram_size;
size += sizeof(char[4]); // NTAB Block
size += sizeof(uint32_t); // Block Size
size_t nametable_size = 0x800;
if (ppu.nt_banks [3] >= &ppu.impl->nt_ram [0xC00] ) nametable_size = 0x1000;
size += nametable_size;
if ( ppu.chr_is_writable )
{
size += sizeof(char[4]); // CHRR Block
size += sizeof(uint32_t); // Block Size
size += ppu.chr_size;
}
if ( sram_present )
{
size += sizeof(char[4]); // SRAM Block
size += sizeof(uint32_t); // Block Size
size += impl->sram_size;
}
size += sizeof(char[4]); // gend Block
size += sizeof(uint32_t); // Block Size
return size;
}
size_t serializeState(uint8_t* buffer) const
{
size_t pos = 0;
std::string headerCode;
const uint32_t headerSize = sizeof(char) * 4;
uint32_t blockSize = 0;
void* dataSource;
headerCode = "NESS"; // NESS Block
blockSize = 0xFFFFFFFF;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
headerCode = "TIME"; // TIME Block
nes_state_t state = nes;
state.timestamp *= 5;
blockSize = sizeof(nes_state_t);
dataSource = (void*) &state;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
headerCode = "CPUR"; // CPUR Block
cpu_state_t s;
memset( &s, 0, sizeof s );
s.pc = r.pc;
s.s = r.sp;
s.a = r.a;
s.x = r.x;
s.y = r.y;
s.p = r.status;
blockSize = sizeof(cpu_state_t);
dataSource = (void*) &s;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
headerCode = "PPUR"; // PPUR Block
blockSize = sizeof(ppu_state_t);
dataSource = (void*) &ppu;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
headerCode = "APUR"; // APUR Block
Nes_Apu::apu_state_t apuState;
impl->apu.save_state(&apuState);
blockSize = sizeof(Nes_Apu::apu_state_t);
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], &apuState, blockSize); pos += blockSize;
headerCode = "CTRL"; // CTRL Block
blockSize = sizeof(joypad_state_t);
dataSource = (void*) &joypad;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
headerCode = "MAPR"; // MAPR Block
blockSize = mapper->state_size;
dataSource = (void*) mapper->state;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
headerCode = "LRAM"; // LRAM Block
blockSize = low_ram_size;
dataSource = (void*) low_mem;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
headerCode = "SPRT"; // SPRT Block
blockSize = Nes_Ppu::spr_ram_size;
dataSource = (void*) ppu.spr_ram;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
headerCode = "NTAB"; // NTAB Block
size_t nametable_size = 0x800;
if (ppu.nt_banks [3] >= &ppu.impl->nt_ram [0xC00] ) nametable_size = 0x1000;
blockSize = nametable_size;
dataSource = (void*) ppu.impl->nt_ram;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
if ( ppu.chr_is_writable )
{
headerCode = "CHRR"; // CHRR Block
blockSize = ppu.chr_size;
dataSource = (void*) ppu.impl->chr_ram;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
}
if ( sram_present )
{
headerCode = "SRAM"; // SRAM Block
blockSize = impl->sram_size;
dataSource = (void*) impl->sram;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
memcpy(&buffer[pos], dataSource, blockSize); pos += blockSize;
}
headerCode = "gend"; // gend Block
blockSize = 0;
memcpy(&buffer[pos], headerCode.data(), headerSize); pos += headerSize;
memcpy(&buffer[pos], &blockSize, headerSize); pos += headerSize;
return pos; // Bytes written
}
size_t deserializeState(const uint8_t* buffer)
{
disable_rendering();
error_count = 0;
ppu.burst_phase = 0; // avoids shimmer when seeking to same time over and over
size_t pos = 0;
const uint32_t headerSize = sizeof(char) * 4;
uint32_t blockSize = 0;
// NESS Block
pos += headerSize;
pos += headerSize;
// TIME Block
nes_state_t nesState;
pos += headerSize;
pos += headerSize;
blockSize = sizeof(nes_state_t);
memcpy(&nesState, &buffer[pos], blockSize); pos += blockSize;
nes = nesState;
nes.timestamp /= 5;
// CPUR Block
cpu_state_t s;
blockSize = sizeof(cpu_state_t);
pos += headerSize;
pos += headerSize;
memcpy((void*) &s, &buffer[pos], blockSize); pos += blockSize;
r.pc = s.pc;
r.sp = s.s;
r.a = s.a;
r.x = s.x;
r.y = s.y;
r.status = s.p;
// PPUR Block
blockSize = sizeof(ppu_state_t);
pos += headerSize;
pos += headerSize;
memcpy((void*) &ppu, &buffer[pos], blockSize); pos += blockSize;
// APUR Block
Nes_Apu::apu_state_t apuState;
blockSize = sizeof(Nes_Apu::apu_state_t);
pos += headerSize;
pos += headerSize;
memcpy(&apuState, &buffer[pos], blockSize);
pos += blockSize;
impl->apu.load_state(apuState);
impl->apu.end_frame( -(int) nes.timestamp / ppu_overclock );
// CTRL Block
blockSize = sizeof(joypad_state_t);
pos += headerSize;
pos += headerSize;
memcpy((void*) &joypad, &buffer[pos], blockSize); pos += blockSize;
// MAPR Block
mapper->default_reset_state();
blockSize = mapper->state_size;
pos += headerSize;
pos += headerSize;
memcpy((void*) mapper->state, &buffer[pos], blockSize); pos += blockSize;
mapper->apply_mapping();
// LRAM Block
blockSize = low_ram_size;
pos += headerSize;
pos += headerSize;
memcpy((void*) low_mem, &buffer[pos], blockSize); pos += blockSize;
// SPRT Block
blockSize = Nes_Ppu::spr_ram_size;
pos += headerSize;
pos += headerSize;
memcpy((void*) ppu.spr_ram, &buffer[pos], blockSize); pos += blockSize;
// NTAB Block
size_t nametable_size = 0x800;
if (ppu.nt_banks [3] >= &ppu.impl->nt_ram [0xC00] ) nametable_size = 0x1000;
blockSize = nametable_size;
pos += headerSize;
pos += headerSize;
memcpy((void*) ppu.impl->nt_ram, &buffer[pos], blockSize); pos += blockSize;
if ( ppu.chr_is_writable )
{
// CHRR Block
blockSize = ppu.chr_size;
pos += headerSize;
pos += headerSize;
memcpy((void*) ppu.impl->chr_ram, &buffer[pos], blockSize); pos += blockSize;
}
if ( sram_present )
{
// SRAM Block
blockSize = impl->sram_size;
pos += headerSize;
pos += headerSize;
memcpy((void*) impl->sram, &buffer[pos], blockSize); pos += blockSize;
enable_sram(true);
}
// headerCode = "gend"; // gend Block
pos += headerSize;
pos += headerSize;
return pos; // Bytes read
}
void reset( bool full_reset, bool erase_battery_ram )
{
if ( full_reset )
{
cpu::reset( impl->unmapped_page );
cpu_time_offset = -1;
clock_ = 0;
// Low RAM
memset( cpu::low_mem, 0xFF, low_ram_size );
cpu::low_mem [8] = 0xf7;
cpu::low_mem [9] = 0xef;
cpu::low_mem [10] = 0xdf;
cpu::low_mem [15] = 0xbf;
// SRAM
lrom_readable = 0;
sram_present = true;
enable_sram( false );
if ( !cart->has_battery_ram() || erase_battery_ram )
memset( impl->sram, 0xFF, impl->sram_size );
joypad.joypad_latches [0] = 0;
joypad.joypad_latches [1] = 0;
nes.frame_count = 0;
}
// to do: emulate partial reset
ppu.reset( full_reset );
impl->apu.reset();
mapper->reset();
cpu::r.pc = read_vector( 0xFFFC );
cpu::r.sp = 0xfd;
cpu::r.a = 0;
cpu::r.x = 0;
cpu::r.y = 0;
cpu::r.status = irq_inhibit_mask;
nes.timestamp = 0;
error_count = 0;
}
nes_time_t emulate_frame(int joypad1, int joypad2)
{
current_joypad [0] = (joypad1 |= ~0xFF);
current_joypad [1] = (joypad2 |= ~0xFF);
cpu_time_offset = ppu.begin_frame( nes.timestamp ) - 1;
ppu_2002_time = 0;
clock_ = cpu_time_offset;
// TODO: clean this fucking mess up
auto t0 = emulate_frame_();
impl->apu.run_until_( t0 );
clock_ = cpu_time_offset;
auto t1 = cpu_time();
impl->apu.run_until_( t1 );
nes_time_t ppu_frame_length = ppu.frame_length();
nes_time_t length = cpu_time();
nes.timestamp = ppu.end_frame( length );
mapper->end_frame( length );
impl->apu.end_frame( ppu_frame_length );
disable_rendering();
nes.frame_count++;
return ppu_frame_length;
}
void close()
{
cart = NULL;
delete mapper;
mapper = NULL;
ppu.close_chr();
disable_rendering();
}
void irq_changed()
{
cpu_set_irq_time( earliest_irq( cpu_time() ) );
}
void event_changed()
{
cpu_set_end_time( earliest_event( cpu_time() ) );
}
public: private: friend class Nes_Emu;
struct impl_t
{
enum { sram_size = 0x2000 };
uint8_t sram [sram_size];
Nes_Apu apu;
// extra byte allows CPU to always read operand of instruction, which
// might go past end of data
uint8_t unmapped_page [::Nes_Cpu::page_size + 1];
};
impl_t* impl; // keep large arrays separate
unsigned long error_count;
bool sram_present;
public:
unsigned long current_joypad [2];
Nes_Cart const* cart;
Nes_Mapper* mapper;
nes_state_t nes;
Nes_Ppu ppu;
private:
// noncopyable
Nes_Core( const Nes_Core& );
Nes_Core& operator = ( const Nes_Core& );
// Timing
nes_time_t ppu_2002_time;
void disable_rendering() { clock_ = 0; }
inline nes_time_t earliest_irq( nes_time_t present )
{
return std::min( impl->apu.earliest_irq( present ), mapper->next_irq( present ) );
}
inline nes_time_t ppu_frame_length( nes_time_t present )
{
nes_time_t t = ppu.frame_length();
if ( t > present )
return t;
ppu.render_bg_until( clock() ); // to do: why this call to clock() rather than using present?
return ppu.frame_length();
}
inline nes_time_t earliest_event( nes_time_t present )
{
// PPU frame
nes_time_t t = ppu_frame_length( present );
// DMC
if ( wait_states_enabled )
t = std::min( t, impl->apu.next_dmc_read_time() + 1 );
// NMI
t = std::min( t, ppu.nmi_time() );
if ( single_instruction_mode )
t = std::min( t, present + 1 );
return t;
}
// APU and Joypad
joypad_state_t joypad;
int read_io( nes_addr_t addr )
{
if ( (addr & 0xFFFE) == 0x4016 )
{
// to do: to aid with recording, doesn't emulate transparent latch,
// so a game that held strobe at 1 and read $4016 or $4017 would not get
// the current A status as occurs on a NES
unsigned long result = joypad.joypad_latches [addr & 1];
if ( !(joypad.w4016 & 1) )
joypad.joypad_latches [addr & 1] = (result >> 1) | 0x80000000;
return result & 1;
}
if ( addr == Nes_Apu::status_addr )
return impl->apu.read_status( clock() );
return addr >> 8; // simulate open bus
}
void write_io( nes_addr_t addr, int data )
{
// sprite dma
if ( addr == 0x4014 )
{
ppu.dma_sprites( clock(), cpu::get_code( data * 0x100 ) );
cpu_adjust_time( 513 );
return;
}
// joypad strobe
if ( addr == 0x4016 )
{
// if strobe goes low, latch data
if ( joypad.w4016 & 1 & ~data )
{
joypad.joypad_latches [0] = current_joypad [0];
joypad.joypad_latches [1] = current_joypad [1];
}
joypad.w4016 = data;
return;
}
// apu
if ( unsigned (addr - impl->apu.start_addr) <= impl->apu.end_addr - impl->apu.start_addr )
{
impl->apu.write_register( clock(), addr, data );
if ( wait_states_enabled )
{
if ( addr == 0x4010 || (addr == 0x4015 && (data & 0x10)) )
{
impl->apu.run_until( clock() + 1 );
event_changed();
}
}
return;
}
}
static inline int read_dmc( void* data, nes_addr_t addr )
{
Nes_Core* emu = (Nes_Core*) data;
int result = *emu->cpu::get_code( addr );
if ( wait_states_enabled )
emu->cpu_adjust_time( 4 );
return result;
}
static inline void apu_irq_changed( void* emu )
{
((Nes_Core*) emu)->irq_changed();
}
// CPU
unsigned sram_readable;
unsigned sram_writable;
unsigned lrom_readable;
nes_time_t clock_;
nes_time_t cpu_time_offset;
nes_time_t emulate_frame_()
{
Nes_Cpu::result_t last_result = cpu::result_cycles;
int extra_instructions = 0;
while ( true )
{
// Add DMC wait-states to CPU time
if ( wait_states_enabled )
{
impl->apu.run_until( cpu_time() );
clock_ = cpu_time_offset;
}
nes_time_t present = cpu_time();
if ( present >= ppu_frame_length( present ) )
{
if ( ppu.nmi_time() <= present )
{
// NMI will occur next, so delayed CLI and SEI don't need to be handled.
// If NMI will occur normally ($2000.7 and $2002.7 set), let it occur
// next frame, otherwise vector it now.
if ( !(ppu.w2000 & 0x80 & ppu.r2002) )
{
/* vectored NMI at end of frame */
vector_interrupt( 0xFFFA );
present += 7;
}
return present;
}
if ( extra_instructions > 2 )
{
return present;
}
if ( last_result != cpu::result_cli && last_result != cpu::result_sei &&
(ppu.nmi_time() >= 0x10000 || (ppu.w2000 & 0x80 & ppu.r2002)) )
return present;
/* Executing extra instructions for frame */
extra_instructions++; // execute one more instruction
}
// NMI
if ( present >= ppu.nmi_time() )
{
ppu.acknowledge_nmi();
vector_interrupt( 0xFFFA );
last_result = cpu::result_cycles; // most recent sei/cli won't be delayed now
}
// IRQ
nes_time_t irq_time = earliest_irq( present );
cpu_set_irq_time( irq_time );
if ( present >= irq_time && (!(cpu::r.status & irq_inhibit_mask) ||
last_result == cpu::result_sei) )
{
if ( last_result != cpu::result_cli )
{
/* IRQ vectored */
mapper->run_until( present );
vector_interrupt( 0xFFFE );
}
else
{
// CLI delays IRQ
cpu_set_irq_time( present + 1 );
}
}
// CPU
nes_time_t end_time = earliest_event( present );
if ( extra_instructions )
end_time = present + 1;
unsigned long cpu_error_count = cpu::error_count();
last_result = NES_EMU_CPU_HOOK( cpu, end_time - cpu_time_offset - 1 );
cpu_adjust_time( cpu::time() );
clock_ = cpu_time_offset;
error_count += cpu::error_count() - cpu_error_count;
}
}
nes_addr_t read_vector( nes_addr_t addr )
{
uint8_t const* p = cpu::get_code( addr );
return p [1] * 0x100 + p [0];
}
void vector_interrupt( nes_addr_t vector )
{
cpu::push_byte( cpu::r.pc >> 8 );
cpu::push_byte( cpu::r.pc & 0xFF );
cpu::push_byte( cpu::r.status | 0x20 ); // reserved bit is set
cpu_adjust_time( 7 );
cpu::r.status |= irq_inhibit_mask;
cpu::r.pc = read_vector( vector );
}
static void log_unmapped( nes_addr_t addr, int data = -1 );
void cpu_set_irq_time( nes_time_t t ) { cpu::set_irq_time_( t - 1 - cpu_time_offset ); }
void cpu_set_end_time( nes_time_t t ) { cpu::set_end_time_( t - 1 - cpu_time_offset ); }
nes_time_t cpu_time() const { return clock_ + 1; }
inline void cpu_adjust_time( int n )
{
ppu_2002_time -= n;
cpu_time_offset += n;
cpu::reduce_limit( n );
}
public: private: friend class Nes_Ppu;
void set_ppu_2002_time( nes_time_t t ) { ppu_2002_time = t - 1 - cpu_time_offset; }
public: private: friend class Nes_Mapper;
void enable_prg_6000()
{
sram_writable = 0;
sram_readable = 0;
lrom_readable = 0x8000;
}
void enable_sram( bool b, bool read_only = false)
{
sram_writable = 0;
if ( b )
{
if ( !sram_present )
{
sram_present = true;
memset( impl->sram, 0xFF, impl->sram_size );
}
sram_readable = sram_end;
if ( !read_only )
sram_writable = sram_end;
cpu::map_code( 0x6000, impl->sram_size, impl->sram );
}
else
{
sram_readable = 0;
for ( int i = 0; i < impl->sram_size; i += cpu::page_size )
cpu::map_code( 0x6000 + i, cpu::page_size, impl->unmapped_page );
}
}
nes_time_t clock() const { return clock_; }
void add_mapper_intercept( nes_addr_t addr, unsigned size, bool read, bool write )
{
int end = (addr + size + (page_size - 1)) >> page_bits;
for ( int page = addr >> page_bits; page < end; page++ )
{
data_reader_mapped [page] |= read;
data_writer_mapped [page] |= write;
}
}
public: private: friend class Nes_Cpu;
int cpu_read_ppu( nes_addr_t, nes_time_t );
int cpu_read( nes_addr_t, nes_time_t );
void cpu_write( nes_addr_t, int data, nes_time_t );
void cpu_write_2007( int data );
private:
unsigned char data_reader_mapped [page_count + 1]; // extra entry for overflow
unsigned char data_writer_mapped [page_count + 1];
};
inline int Nes_Core::cpu_read( nes_addr_t addr, nes_time_t time )
{
{
int result = cpu::low_mem [addr & 0x7FF];
if ( !(addr & 0xE000) )
return result;
}
{
int result = *cpu::get_code( addr );
if ( addr > 0x7FFF )
return result;
}
time += cpu_time_offset;
if ( addr < 0x4000 )
return ppu.read( addr, time );
clock_ = time;
if ( data_reader_mapped [addr >> page_bits] )
{
int result = mapper->read( time, addr );
if ( result >= 0 )
return result;
}
if ( addr < 0x6000 )
return read_io( addr );
if ( addr < sram_readable )
return impl->sram [addr & (impl_t::sram_size - 1)];
if ( addr < lrom_readable )
return *cpu::get_code( addr );
return addr >> 8; // simulate open bus
}
inline int Nes_Core::cpu_read_ppu( nes_addr_t addr, nes_time_t time )
{
//LOG_FREQ( "cpu_read_ppu", 16, addr >> 12 );
// Read of status register (0x2002) is heavily optimized since many games
// poll it hundreds of times per frame.
nes_time_t next = ppu_2002_time;
int result = ppu.r2002;
if ( addr == 0x2002 )
{
ppu.second_write = false;
if ( time >= next )
result = ppu.read_2002( time + cpu_time_offset );
}
else
{
result = cpu::low_mem [addr & 0x7FF];
if ( addr >= 0x2000 )
result = cpu_read( addr, time );
}
return result;
}
inline void Nes_Core::cpu_write_2007( int data )
{
// ppu.write_2007() is inlined
if ( ppu.write_2007( data ) & Nes_Ppu::vaddr_clock_mask )
mapper->a12_clocked();
}
inline void Nes_Core::cpu_write( nes_addr_t addr, int data, nes_time_t time )
{
//LOG_FREQ( "cpu_write", 16, addr >> 12 );
if ( !(addr & 0xE000) )
{
cpu::low_mem [addr & 0x7FF] = data;
return;
}
time += cpu_time_offset;
if ( addr < 0x4000 )
{
if ( (addr & 7) == 7 )
cpu_write_2007( data );
else
ppu.write( time, addr, data );
return;
}
clock_ = time;
if ( data_writer_mapped [addr >> page_bits] && mapper->write_intercepted( time, addr, data ) )
return;
if ( addr < 0x6000 )
{
write_io( addr, data );
return;
}
if ( addr < sram_writable )
{
impl->sram [addr & (impl_t::sram_size - 1)] = data;
return;
}
if ( addr > 0x7FFF )
{
mapper->write( clock_, addr, data );
return;
}
}
#define NES_CPU_READ_PPU( cpu, addr, time ) \
static_cast<Nes_Core&>(*cpu).cpu_read_ppu( addr, time )
#define NES_CPU_READ( cpu, addr, time ) \
static_cast<Nes_Core&>(*cpu).cpu_read( addr, time )
#define NES_CPU_WRITEX( cpu, addr, data, time ){\
static_cast<Nes_Core&>(*cpu).cpu_write( addr, data, time );\
}
#define NES_CPU_WRITE( cpu, addr, data, time ){\
if ( addr < 0x800 ) cpu->low_mem [addr] = data;\
else if ( addr == 0x2007 ) static_cast<Nes_Core&>(*cpu).cpu_write_2007( data );\
else static_cast<Nes_Core&>(*cpu).cpu_write( addr, data, time );\
}

123
source/quickerNES/Nes_Cpu.h
View File

@ -1,123 +0,0 @@
#pragma once
// NES 6502 CPU emulator
// Nes_Emu 0.7.0
#include <cstdint>
typedef long nes_time_t; // clock cycle count
typedef unsigned nes_addr_t; // 16-bit address
class Nes_Cpu {
public:
// NES 6502 registers. *Not* kept updated during a call to run().
struct registers_t {
uint16_t pc; // Should be more than 16 bits to allow overflow detection -- but I (eien86) removed it to maximize performance.
uint8_t a;
uint8_t x;
uint8_t y;
uint8_t status;
uint8_t sp;
};
// Map code memory (memory accessed via the program counter). Start and size
// must be multiple of page_size.
enum { page_bits = 11 };
enum { page_count = 0x10000 >> page_bits };
enum { page_size = 1L << page_bits };
// Clear registers, unmap memory, and map code pages to unmapped_page.
void reset( void const* unmapped_page = 0 );
inline void map_code( nes_addr_t start, unsigned size, const void* data )
{
unsigned first_page = start / page_size;
const uint8_t* newPtr = (uint8_t*) data - start;
for ( unsigned i = size / page_size; i--; ) code_map [first_page + i] = newPtr;
}
// Access memory as the emulated CPU does.
int read( nes_addr_t );
void write( nes_addr_t, int data );
// Push a byte on the stack
inline void push_byte( int data )
{
int sp = r.sp;
r.sp = (sp - 1) & 0xFF;
low_mem [0x100 + sp] = data;
}
// Reasons that run() returns
enum result_t {
result_cycles, // Requested number of cycles (or more) were executed
result_sei, // I flag just set and IRQ time would generate IRQ now
result_cli, // I flag just cleared but IRQ should occur *after* next instr
result_badop // unimplemented/illegal instruction
};
result_t run( nes_time_t end_time );
nes_time_t time() const { return clock_count; }
inline void reduce_limit( int offset )
{
clock_limit -= offset;
end_time_ -= offset;
irq_time_ -= offset;
}
inline void set_end_time_( nes_time_t t )
{
end_time_ = t;
update_clock_limit();
}
inline void set_irq_time_( nes_time_t t )
{
irq_time_ = t;
update_clock_limit();
}
unsigned long error_count() const { return error_count_; }
// If PC exceeds 0xFFFF and encounters page_wrap_opcode, it will be silently wrapped.
enum { page_wrap_opcode = 0xF2 };
// One of the many opcodes that are undefined and stop CPU emulation.
enum { bad_opcode = 0xD2 };
uint8_t const* code_map [page_count + 1];
nes_time_t clock_limit;
nes_time_t clock_count;
nes_time_t irq_time_;
nes_time_t end_time_;
unsigned long error_count_;
enum { irq_inhibit = 0x04 };
inline void update_clock_limit()
{
nes_time_t t = end_time_;
if ( t > irq_time_ && !(r.status & irq_inhibit) )
t = irq_time_;
clock_limit = t;
}
registers_t r;
bool isCorrectExecution = true;
// low_mem is a full page size so it can be mapped with code_map
uint8_t low_mem [page_size > 0x800 ? page_size : 0x800];
inline uint8_t* get_code( nes_addr_t addr )
{
return (uint8_t*) code_map [addr >> page_bits] + addr;
}
};

262
source/quickerNES/Nes_Emu.h
View File

@ -1,262 +0,0 @@
#pragma once
// NES video game console emulator with snapshot support
// Nes_Emu 0.7.0
#include "apu/Multi_Buffer.h"
#include "Nes_Cart.h"
#include "Nes_Core.h"
class Nes_State;
class Nes_Emu {
public:
Nes_Emu();
virtual ~Nes_Emu();
// Basic setup
// Load iNES file into emulator and clear recording
void load_ines( const uint8_t* buffer );
// Set sample rate for sound generation
const char * set_sample_rate( long );
// Size and depth of graphics buffer required for rendering. Note that this
// is larger than the actual image, with a temporary area around the edge
// that gets filled with junk.
static const uint16_t buffer_width = Nes_Ppu::buffer_width;
uint16_t buffer_height() const { return buffer_height_; }
static const uint8_t bits_per_pixel = 8;
// Set graphics buffer to render pixels to. Pixels points to top-left pixel and
// row_bytes is the number of bytes to get to the next line (positive or negative).
void set_pixels( void* pixels, long row_bytes );
// Size of image generated in graphics buffer
static const uint16_t image_width = 256;
static const uint16_t image_height = 240;
const uint8_t* getHostPixels () const { return emu.ppu.host_pixels; }
size_t getLiteStateSize() const { return emu.getLiteStateSize(); }
size_t getStateSize() const { return emu.getStateSize(); }
// Basic emulation
// Emulate one video frame using joypad1 and joypad2 as input. Afterwards, image
// and sound are available for output using the accessors below.
virtual const char * emulate_frame( int joypad1, int joypad2 = 0 );
// Emulate one video frame using joypad1 and joypad2 as input, but skips drawing.
// Afterwards, audio is available for output using the accessors below.
virtual const char * emulate_skip_frame( int joypad1, int joypad2 = 0 );
// Maximum size of palette that can be generated
static const uint16_t max_palette_size = 256;
// Result of current frame
struct frame_t
{
static const uint8_t left = 8;
int joypad_read_count; // number of times joypads were strobed (read)
int burst_phase; // NTSC burst phase for frame (0, 1, or 2)
int sample_count; // number of samples (always a multiple of chan_count)
int chan_count; // 1: mono, 2: stereo
int top; // top-left position of image in graphics buffer
unsigned char* pixels; // pointer to top-left pixel of image
long pitch; // number of bytes to get to next row of image
int palette_begin; // first host palette entry, as set by set_palette_range()
int palette_size; // number of entries used for current frame
short palette [max_palette_size]; // [palette_begin to palette_begin+palette_size-1]
};
frame_t const& frame() const { return *frame_; }
// Read samples for the current frame. Returns number of samples read into buffer.
// Currently all samples must be read in one call.
virtual long read_samples( short* out, long max_samples );
// Additional features
// Use already-loaded cartridge. Retains pointer, so it must be kept around until
// closed. A cartridge can be shared among multiple emulators. After opening,
// cartridge's CHR data shouldn't be modified since a copy is cached internally.
void set_cart( Nes_Cart const* );
// Pointer to current cartridge, or NULL if none is loaded
Nes_Cart const* cart() const { return emu.cart; }
// Emulate powering NES off and then back on. If full_reset is false, emulates
// pressing the reset button only, which doesn't affect memory, otherwise
// emulates powering system off then on.
virtual void reset( bool full_reset = true, bool erase_battery_ram = false );
// Number of undefined CPU instructions encountered. Cleared after reset() and
// load_state(). A non-zero value indicates that cartridge is probably
// incompatible.
unsigned long error_count() const { return emu.error_count; }
// Sound
// Set sample rate and use a custom sound buffer instead of the default
// mono buffer, i.e. Nes_Buffer, Effects_Buffer, etc..
const char * set_sample_rate( long rate, Multi_Buffer* );
// Adjust effective frame rate by changing how many samples are generated each frame.
// Allows fine tuning of frame rate to improve synchronization.
void set_frame_rate( double rate );
// Number of sound channels for current cartridge
int channel_count() const { return channel_count_; }
// Frequency equalizer parameters
struct equalizer_t {
double treble; // 5.0 = extra-crisp, -200.0 = muffled
long bass; // 0 = deep, 20000 = tinny
};
// Current frequency equalization
equalizer_t const& equalizer() const { return equalizer_; }
// Change frequency equalization
void set_equalizer( equalizer_t const& );
// Equalizer presets
static equalizer_t const nes_eq; // NES
static equalizer_t const famicom_eq; // Famicom
static equalizer_t const tv_eq; // TV speaker
static equalizer_t const flat_eq; // Flat EQ
static equalizer_t const crisp_eq; // Crisp EQ (Treble boost)
static equalizer_t const tinny_eq; // Tinny EQ (Like a handheld speaker)
// File save/load
// Save emulator state
size_t serializeState (uint8_t* buffer) const { return emu.serializeState(buffer); }
size_t deserializeState (const uint8_t* buffer) { return emu.deserializeState(buffer); }
// True if current cartridge claims it uses battery-backed memory
bool has_battery_ram() const { return cart()->has_battery_ram(); }
// Graphics
// Number of frames generated per second
enum { frame_rate = 60 };
// Size of fixed NES color table (including the 8 color emphasis modes)
enum { color_table_size = 8 * 64 };
// NES color lookup table based on standard NTSC TV decoder. Use nes_ntsc.h to
// generate a palette with custom parameters.
struct rgb_t { unsigned char red, green, blue; };
static rgb_t const nes_colors [color_table_size];
// Hide/show/enhance sprites. Sprite mode does not affect emulation accuracy.
enum sprite_mode_t {
sprites_hidden = 0,
sprites_visible = 8, // limit of 8 sprites per scanline as on NES (default)
sprites_enhanced = 64 // unlimited sprites per scanline (no flickering)
};
void set_sprite_mode( sprite_mode_t n ) { emu.ppu.sprite_limit = n; }
// Set range of host palette entries to use in graphics buffer; default uses
// all of them. Begin will be rounded up to next multiple of palette_alignment.
// Use frame().palette_begin to find the adjusted beginning entry used.
enum { palette_alignment = 64 };
void set_palette_range( int begin, int end = 256 );
// Access to emulated memory, for viewer/cheater/debugger
// CHR
uint8_t const* chr_mem();
long chr_size() const;
void write_chr( void const*, long count, long offset );
// Nametable
uint8_t* nametable_mem() { return emu.ppu.impl->nt_ram; }
long nametable_size() const { return 0x1000; }
// Built-in 2K memory
enum { low_mem_size = 0x800 };
uint8_t* low_mem() { return emu.low_mem; }
// Optional 8K memory
enum { high_mem_size = 0x2000 };
uint8_t* high_mem() { return emu.impl->sram; }
// Sprite memory
uint8_t* spr_mem() { return emu.ppu.getSpriteRAM(); }
uint16_t spr_mem_size() { return emu.ppu.getSpriteRAMSize(); }
// End of public interface
public:
const char * set_sample_rate( long rate, class Nes_Buffer* );
const char * set_sample_rate( long rate, class Nes_Effects_Buffer* );
void irq_changed() { emu.irq_changed(); }
private:
frame_t* frame_;
int buffer_height_;
bool fade_sound_in;
bool fade_sound_out;
virtual const char * init_();
virtual void loading_state( Nes_State const& ) { }
long timestamp() const { return emu.nes.frame_count; }
void set_timestamp( long t ) { emu.nes.frame_count = t; }
private:
// noncopyable
Nes_Emu( const Nes_Emu& );
Nes_Emu& operator = ( const Nes_Emu& );
// sound
Multi_Buffer* default_sound_buf;
Multi_Buffer* sound_buf;
unsigned sound_buf_changed_count;
Silent_Buffer silent_buffer;
equalizer_t equalizer_;
int channel_count_;
bool sound_enabled;
void enable_sound( bool );
void clear_sound_buf();
void fade_samples( blip_sample_t*, int size, int step );
char* host_pixels;
int host_palette_size;
frame_t single_frame;
Nes_Cart private_cart;
Nes_Core emu; // large; keep at end
bool init_called;
const char * auto_init();
bool extra_fade_sound_in;
bool extra_fade_sound_out;
unsigned extra_sound_buf_changed_count;
public:
void SaveAudioBufferState();
void RestoreAudioBufferState();
};
inline void Nes_Emu::set_pixels( void* p, long n )
{
host_pixels = (char*) p + n;
emu.ppu.host_row_bytes = n;
}
inline uint8_t const* Nes_Emu::chr_mem()
{
return cart()->chr_size() ? (uint8_t*) cart()->chr() : emu.ppu.impl->chr_ram;
}
inline long Nes_Emu::chr_size() const
{
return cart()->chr_size() ? cart()->chr_size() : emu.ppu.chr_addr_size;
}

659
source/quickerNES/apu/Blip_Buffer.cpp
View File

@ -1,12 +1,11 @@
// Blip_Buffer 0.4.0. http://www.slack.net/~ant/
#include "Blip_Buffer.h"
#include "Blip_Buffer.hpp"
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -19,405 +18,405 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#ifdef BLARGG_ENABLE_OPTIMIZER
#include BLARGG_ENABLE_OPTIMIZER
#endif
namespace quickerNES
{
int const buffer_extra = blip_widest_impulse_ + 2;
Blip_Buffer::Blip_Buffer()
{
factor_ = LONG_MAX;
offset_ = 0;
buffer_ = 0;
buffer_size_ = 0;
sample_rate_ = 0;
reader_accum = 0;
bass_shift = 0;
clock_rate_ = 0;
bass_freq_ = 16;
length_ = 0;
factor_ = LONG_MAX;
offset_ = 0;
buffer_ = 0;
buffer_size_ = 0;
sample_rate_ = 0;
reader_accum = 0;
bass_shift = 0;
clock_rate_ = 0;
bass_freq_ = 16;
length_ = 0;
extra_length = length_;
extra_offset = offset_;
extra_reader_accum = reader_accum;
memset(extra_buffer, 0, sizeof(extra_buffer));
extra_length = length_;
extra_offset = offset_;
extra_reader_accum = reader_accum;
memset(extra_buffer, 0, sizeof(extra_buffer));
}
Blip_Buffer::~Blip_Buffer()
{
if ( buffer_ )
free( buffer_ );
if (buffer_)
free(buffer_);
}
void Blip_Buffer::clear( int entire_buffer )
void Blip_Buffer::clear(int entire_buffer)
{
offset_ = 0;
reader_accum = 0;
if ( buffer_ )
{
long count = (entire_buffer ? buffer_size_ : samples_avail());
memset( buffer_, 0, (count + buffer_extra) * sizeof (buf_t_) );
}
offset_ = 0;
reader_accum = 0;
if (buffer_)
{
long count = (entire_buffer ? buffer_size_ : samples_avail());
memset(buffer_, 0, (count + buffer_extra) * sizeof(buf_t_));
}
}
const char *Blip_Buffer::set_sample_rate( long new_rate, int msec )
const char *Blip_Buffer::set_sample_rate(long new_rate, int msec)
{
// start with maximum length that resampled time can represent
long new_size = (ULONG_MAX >> BLIP_BUFFER_ACCURACY) - buffer_extra - 64;
if ( msec != blip_max_length )
{
long s = (new_rate * (msec + 1) + 999) / 1000;
if ( s < new_size )
new_size = s;
}
if ( buffer_size_ != new_size )
{
void* p = realloc( buffer_, (new_size + buffer_extra) * sizeof *buffer_ );
if ( !p )
return "Out of memory";
buffer_ = (buf_t_*) p;
}
buffer_size_ = new_size;
// update things based on the sample rate
sample_rate_ = new_rate;
length_ = new_size * 1000 / new_rate - 1;
if ( clock_rate_ )
clock_rate( clock_rate_ );
bass_freq( bass_freq_ );
clear();
return 0; // success
// start with maximum length that resampled time can represent
long new_size = (ULONG_MAX >> BLIP_BUFFER_ACCURACY) - buffer_extra - 64;
if (msec != blip_max_length)
{
long s = (new_rate * (msec + 1) + 999) / 1000;
if (s < new_size)
new_size = s;
}
if (buffer_size_ != new_size)
{
void *p = realloc(buffer_, (new_size + buffer_extra) * sizeof *buffer_);
if (!p)
return "Out of memory";
buffer_ = (buf_t_ *)p;
}
buffer_size_ = new_size;
// update things based on the sample rate
sample_rate_ = new_rate;
length_ = new_size * 1000 / new_rate - 1;
if (clock_rate_)
clock_rate(clock_rate_);
bass_freq(bass_freq_);
clear();
return 0; // success
}
blip_resampled_time_t Blip_Buffer::clock_rate_factor( long clock_rate ) const
blip_resampled_time_t Blip_Buffer::clock_rate_factor(long clock_rate) const
{
double ratio = (double) sample_rate_ / clock_rate;
long factor = (long) floor( ratio * (1L << BLIP_BUFFER_ACCURACY) + 0.5 );
return (blip_resampled_time_t) factor;
double ratio = (double)sample_rate_ / clock_rate;
long factor = (long)floor(ratio * (1L << BLIP_BUFFER_ACCURACY) + 0.5);
return (blip_resampled_time_t)factor;
}
void Blip_Buffer::bass_freq( int freq )
void Blip_Buffer::bass_freq(int freq)
{
bass_freq_ = freq;
int shift = 31;
if ( freq > 0 )
{
shift = 13;
long f = (freq << 16) / sample_rate_;
while ( (f >>= 1) && --shift ) { }
}
bass_shift = shift;
bass_freq_ = freq;
int shift = 31;
if (freq > 0)
{
shift = 13;
long f = (freq << 16) / sample_rate_;
while ((f >>= 1) && --shift) {}
}
bass_shift = shift;
}
void Blip_Buffer::end_frame( blip_time_t t )
void Blip_Buffer::end_frame(blip_time_t t)
{
offset_ += t * factor_;
offset_ += t * factor_;
}
void Blip_Buffer::remove_silence( long count )
void Blip_Buffer::remove_silence(long count)
{
offset_ -= (blip_resampled_time_t) count << BLIP_BUFFER_ACCURACY;
offset_ -= (blip_resampled_time_t)count << BLIP_BUFFER_ACCURACY;
}
long Blip_Buffer::count_samples( blip_time_t t ) const
long Blip_Buffer::count_samples(blip_time_t t) const
{
unsigned long last_sample = resampled_time( t ) >> BLIP_BUFFER_ACCURACY;
unsigned long first_sample = offset_ >> BLIP_BUFFER_ACCURACY;
return (long) (last_sample - first_sample);
unsigned long last_sample = resampled_time(t) >> BLIP_BUFFER_ACCURACY;
unsigned long first_sample = offset_ >> BLIP_BUFFER_ACCURACY;
return (long)(last_sample - first_sample);
}
blip_time_t Blip_Buffer::count_clocks( long count ) const
blip_time_t Blip_Buffer::count_clocks(long count) const
{
if ( count > buffer_size_ )
count = buffer_size_;
blip_resampled_time_t time = (blip_resampled_time_t) count << BLIP_BUFFER_ACCURACY;
return (blip_time_t) ((time - offset_ + factor_ - 1) / factor_);
if (count > buffer_size_)
count = buffer_size_;
blip_resampled_time_t time = (blip_resampled_time_t)count << BLIP_BUFFER_ACCURACY;
return (blip_time_t)((time - offset_ + factor_ - 1) / factor_);
}
void Blip_Buffer::remove_samples( long count )
void Blip_Buffer::remove_samples(long count)
{
if ( count )
{
remove_silence( count );
// copy remaining samples to beginning and clear old samples
long remain = samples_avail() + buffer_extra;
memmove( buffer_, buffer_ + count, remain * sizeof *buffer_ );
memset( buffer_ + remain, 0, count * sizeof *buffer_ );
}
if (count)
{
remove_silence(count);
// copy remaining samples to beginning and clear old samples
long remain = samples_avail() + buffer_extra;
memmove(buffer_, buffer_ + count, remain * sizeof *buffer_);
memset(buffer_ + remain, 0, count * sizeof *buffer_);
}
}
// Blip_Synth_
Blip_Synth_::Blip_Synth_( short* p, int w ) :
impulses( p ),
width( w )
Blip_Synth_::Blip_Synth_(short *p, int w) : impulses(p),
width(w)
{
volume_unit_ = 0.0;
kernel_unit = 0;
buf = 0;
last_amp = 0;
delta_factor = 0;
volume_unit_ = 0.0;
kernel_unit = 0;
buf = 0;
last_amp = 0;
delta_factor = 0;
}
// TODO: apparently this is defined elsewhere too
#define pi my_pi
static double const pi = 3.1415926535897932384626433832795029;
static void gen_sinc( float* out, int count, double oversample, double treble, double cutoff )
static void gen_sinc(float *out, int count, double oversample, double treble, double cutoff)
{
if ( cutoff >= 0.999 )
cutoff = 0.999;
if ( treble < -300.0 )
treble = -300.0;
if ( treble > 5.0 )
treble = 5.0;
double const maxh = 4096.0;
double const rolloff = pow( 10.0, 1.0 / (maxh * 20.0) * treble / (1.0 - cutoff) );
double const pow_a_n = pow( rolloff, maxh - maxh * cutoff );
double const to_angle = pi / 2 / maxh / oversample;
for ( int i = 0; i < count; i++ )
{
double angle = ((i - count) * 2 + 1) * to_angle;
double c = rolloff * cos( (maxh - 1.0) * angle ) - cos( maxh * angle );
double cos_nc_angle = cos( maxh * cutoff * angle );
double cos_nc1_angle = cos( (maxh * cutoff - 1.0) * angle );
double cos_angle = cos( angle );
c = c * pow_a_n - rolloff * cos_nc1_angle + cos_nc_angle;
double d = 1.0 + rolloff * (rolloff - cos_angle - cos_angle);
double b = 2.0 - cos_angle - cos_angle;
double a = 1.0 - cos_angle - cos_nc_angle + cos_nc1_angle;
out [i] = (float) ((a * d + c * b) / (b * d)); // a / b + c / d
}
if (cutoff >= 0.999)
cutoff = 0.999;
if (treble < -300.0)
treble = -300.0;
if (treble > 5.0)
treble = 5.0;
double const maxh = 4096.0;
double const rolloff = pow(10.0, 1.0 / (maxh * 20.0) * treble / (1.0 - cutoff));
double const pow_a_n = pow(rolloff, maxh - maxh * cutoff);
double const to_angle = pi / 2 / maxh / oversample;
for (int i = 0; i < count; i++)
{
double angle = ((i - count) * 2 + 1) * to_angle;
double c = rolloff * cos((maxh - 1.0) * angle) - cos(maxh * angle);
double cos_nc_angle = cos(maxh * cutoff * angle);
double cos_nc1_angle = cos((maxh * cutoff - 1.0) * angle);
double cos_angle = cos(angle);
c = c * pow_a_n - rolloff * cos_nc1_angle + cos_nc_angle;
double d = 1.0 + rolloff * (rolloff - cos_angle - cos_angle);
double b = 2.0 - cos_angle - cos_angle;
double a = 1.0 - cos_angle - cos_nc_angle + cos_nc1_angle;
out[i] = (float)((a * d + c * b) / (b * d)); // a / b + c / d
}
}
void blip_eq_t::generate( float* out, int count ) const
void blip_eq_t::generate(float *out, int count) const
{
// lower cutoff freq for narrow kernels with their wider transition band
// (8 points->1.49, 16 points->1.15)
double oversample = blip_res * 2.25 / count + 0.85;
double half_rate = sample_rate * 0.5;
if ( cutoff_freq )
oversample = half_rate / cutoff_freq;
double cutoff = rolloff_freq * oversample / half_rate;
gen_sinc( out, count, blip_res * oversample, treble, cutoff );
// apply (half of) hamming window
double to_fraction = pi / (count - 1);
for ( int i = count; i--; )
out [i] *= 0.54 - 0.46 * cos( i * to_fraction );
// lower cutoff freq for narrow kernels with their wider transition band
// (8 points->1.49, 16 points->1.15)
double oversample = blip_res * 2.25 / count + 0.85;
double half_rate = sample_rate * 0.5;
if (cutoff_freq)
oversample = half_rate / cutoff_freq;
double cutoff = rolloff_freq * oversample / half_rate;
gen_sinc(out, count, blip_res * oversample, treble, cutoff);
// apply (half of) hamming window
double to_fraction = pi / (count - 1);
for (int i = count; i--;)
out[i] *= 0.54 - 0.46 * cos(i * to_fraction);
}
void Blip_Synth_::adjust_impulse()
{
// sum pairs for each phase and add error correction to end of first half
int const size = impulses_size();
for ( int p = blip_res; p-- >= blip_res / 2; )
{
int p2 = blip_res - 2 - p;
long error = kernel_unit;
for ( int i = 1; i < size; i += blip_res )
{
error -= impulses [i + p ];
error -= impulses [i + p2];
}
if ( p == p2 )
error /= 2; // phase = 0.5 impulse uses same half for both sides
impulses [size - blip_res + p] += error;
//printf( "error: %ld\n", error );
}
//for ( int i = blip_res; i--; printf( "\n" ) )
// for ( int j = 0; j < width / 2; j++ )
// printf( "%5ld,", impulses [j * blip_res + i + 1] );
// sum pairs for each phase and add error correction to end of first half
int const size = impulses_size();
for (int p = blip_res; p-- >= blip_res / 2;)
{
int p2 = blip_res - 2 - p;
long error = kernel_unit;
for (int i = 1; i < size; i += blip_res)
{
error -= impulses[i + p];
error -= impulses[i + p2];
}
if (p == p2)
error /= 2; // phase = 0.5 impulse uses same half for both sides
impulses[size - blip_res + p] += error;
// printf( "error: %ld\n", error );
}
// for ( int i = blip_res; i--; printf( "\n" ) )
// for ( int j = 0; j < width / 2; j++ )
// printf( "%5ld,", impulses [j * blip_res + i + 1] );
}
void Blip_Synth_::treble_eq( blip_eq_t const& eq )
void Blip_Synth_::treble_eq(blip_eq_t const &eq)
{
float fimpulse [blip_res / 2 * (blip_widest_impulse_ - 1) + blip_res * 2];
int const half_size = blip_res / 2 * (width - 1);
eq.generate( &fimpulse [blip_res], half_size );
int i;
// need mirror slightly past center for calculation
for ( i = blip_res; i--; )
fimpulse [blip_res + half_size + i] = fimpulse [blip_res + half_size - 1 - i];
// starts at 0
for ( i = 0; i < blip_res; i++ )
fimpulse [i] = 0.0f;
// find rescale factor
double total = 0.0;
for ( i = 0; i < half_size; i++ )
total += fimpulse [blip_res + i];
//double const base_unit = 44800.0 - 128 * 18; // allows treble up to +0 dB
//double const base_unit = 37888.0; // allows treble to +5 dB
double const base_unit = 32768.0; // necessary for blip_unscaled to work
double rescale = base_unit / 2 / total;
kernel_unit = (long) base_unit;
// integrate, first difference, rescale, convert to int
double sum = 0.0;
double next = 0.0;
int const impulses_size = this->impulses_size();
for ( i = 0; i < impulses_size; i++ )
{
impulses [i] = (short) floor( (next - sum) * rescale + 0.5 );
sum += fimpulse [i];
next += fimpulse [i + blip_res];
}
adjust_impulse();
// volume might require rescaling
double vol = volume_unit_;
if ( vol )
{
volume_unit_ = 0.0;
volume_unit( vol );
}
float fimpulse[blip_res / 2 * (blip_widest_impulse_ - 1) + blip_res * 2];
int const half_size = blip_res / 2 * (width - 1);
eq.generate(&fimpulse[blip_res], half_size);
int i;
// need mirror slightly past center for calculation
for (i = blip_res; i--;)
fimpulse[blip_res + half_size + i] = fimpulse[blip_res + half_size - 1 - i];
// starts at 0
for (i = 0; i < blip_res; i++)
fimpulse[i] = 0.0f;
// find rescale factor
double total = 0.0;
for (i = 0; i < half_size; i++)
total += fimpulse[blip_res + i];
// double const base_unit = 44800.0 - 128 * 18; // allows treble up to +0 dB
// double const base_unit = 37888.0; // allows treble to +5 dB
double const base_unit = 32768.0; // necessary for blip_unscaled to work
double rescale = base_unit / 2 / total;
kernel_unit = (long)base_unit;
// integrate, first difference, rescale, convert to int
double sum = 0.0;
double next = 0.0;
int const impulses_size = this->impulses_size();
for (i = 0; i < impulses_size; i++)
{
impulses[i] = (short)floor((next - sum) * rescale + 0.5);
sum += fimpulse[i];
next += fimpulse[i + blip_res];
}
adjust_impulse();
// volume might require rescaling
double vol = volume_unit_;
if (vol)
{
volume_unit_ = 0.0;
volume_unit(vol);
}
}
void Blip_Synth_::volume_unit( double new_unit )
void Blip_Synth_::volume_unit(double new_unit)
{
if ( new_unit != volume_unit_ )
{
// use default eq if it hasn't been set yet
if ( !kernel_unit )
treble_eq( -8.0 );
volume_unit_ = new_unit;
double factor = new_unit * (1L << blip_sample_bits) / kernel_unit;
if ( factor > 0.0 )
{
int shift = 0;
// if unit is really small, might need to attenuate kernel
while ( factor < 2.0 )
{
shift++;
factor *= 2.0;
}
if ( shift )
{
kernel_unit >>= shift;
// keep values positive to avoid round-towards-zero of sign-preserving
// right shift for negative values
long offset = 0x8000 + (1 << (shift - 1));
long offset2 = 0x8000 >> shift;
for ( int i = impulses_size(); i--; )
impulses [i] = (short) (((impulses [i] + offset) >> shift) - offset2);
adjust_impulse();
}
}
delta_factor = (int) floor( factor + 0.5 );
//printf( "delta_factor: %d, kernel_unit: %d\n", delta_factor, kernel_unit );
}
if (new_unit != volume_unit_)
{
// use default eq if it hasn't been set yet
if (!kernel_unit)
treble_eq(-8.0);
volume_unit_ = new_unit;
double factor = new_unit * (1L << blip_sample_bits) / kernel_unit;
if (factor > 0.0)
{
int shift = 0;
// if unit is really small, might need to attenuate kernel
while (factor < 2.0)
{
shift++;
factor *= 2.0;
}
if (shift)
{
kernel_unit >>= shift;
// keep values positive to avoid round-towards-zero of sign-preserving
// right shift for negative values
long offset = 0x8000 + (1 << (shift - 1));
long offset2 = 0x8000 >> shift;
for (int i = impulses_size(); i--;)
impulses[i] = (short)(((impulses[i] + offset) >> shift) - offset2);
adjust_impulse();
}
}
delta_factor = (int)floor(factor + 0.5);
// printf( "delta_factor: %d, kernel_unit: %d\n", delta_factor, kernel_unit );
}
}
long Blip_Buffer::read_samples( blip_sample_t* out, long max_samples, int stereo )
long Blip_Buffer::read_samples(blip_sample_t *out, long max_samples, int stereo)
{
long count = samples_avail();
if ( count > max_samples )
count = max_samples;
if ( count )
{
int const sample_shift = blip_sample_bits - 16;
int const bass_shift = this->bass_shift;
long accum = reader_accum;
buf_t_* in = buffer_;
if (out != NULL)
{
if ( !stereo )
{
for ( long n = count; n--; )
{
long s = accum >> sample_shift;
accum -= accum >> bass_shift;
accum += *in++;
*out++ = (blip_sample_t) s;
// clamp sample
if ( (blip_sample_t) s != s )
out [-1] = (blip_sample_t) (0x7FFF - (s >> 24));
}
}
else
{
for ( long n = count; n--; )
{
long s = accum >> sample_shift;
accum -= accum >> bass_shift;
accum += *in++;
*out = (blip_sample_t) s;
out += 2;
// clamp sample
if ( (blip_sample_t) s != s )
out [-2] = (blip_sample_t) (0x7FFF - (s >> 24));
}
}
}
else
{
//only run accumulator, do not output anything
for (long n = count; n--; )
{
accum -= accum >> bass_shift;
accum += *in++;
}
}
reader_accum = accum;
remove_samples( count );
}
return count;
long count = samples_avail();
if (count > max_samples)
count = max_samples;
if (count)
{
int const sample_shift = blip_sample_bits - 16;
int const bass_shift = this->bass_shift;
long accum = reader_accum;
buf_t_ *in = buffer_;
if (out != NULL)
{
if (!stereo)
{
for (long n = count; n--;)
{
long s = accum >> sample_shift;
accum -= accum >> bass_shift;
accum += *in++;
*out++ = (blip_sample_t)s;
// clamp sample
if ((blip_sample_t)s != s)
out[-1] = (blip_sample_t)(0x7FFF - (s >> 24));
}
}
else
{
for (long n = count; n--;)
{
long s = accum >> sample_shift;
accum -= accum >> bass_shift;
accum += *in++;
*out = (blip_sample_t)s;
out += 2;
// clamp sample
if ((blip_sample_t)s != s)
out[-2] = (blip_sample_t)(0x7FFF - (s >> 24));
}
}
}
else
{
// only run accumulator, do not output anything
for (long n = count; n--;)
{
accum -= accum >> bass_shift;
accum += *in++;
}
}
reader_accum = accum;
remove_samples(count);
}
return count;
}
void Blip_Buffer::mix_samples( blip_sample_t const* in, long count )
void Blip_Buffer::mix_samples(blip_sample_t const *in, long count)
{
buf_t_* out = buffer_ + (offset_ >> BLIP_BUFFER_ACCURACY) + blip_widest_impulse_ / 2;
int const sample_shift = blip_sample_bits - 16;
int prev = 0;
while ( count-- )
{
long s = (long) *in++ << sample_shift;
*out += s - prev;
prev = s;
++out;
}
*out -= prev;
buf_t_ *out = buffer_ + (offset_ >> BLIP_BUFFER_ACCURACY) + blip_widest_impulse_ / 2;
int const sample_shift = blip_sample_bits - 16;
int prev = 0;
while (count--)
{
long s = (long)*in++ << sample_shift;
*out += s - prev;
prev = s;
++out;
}
*out -= prev;
}
void Blip_Buffer::SaveAudioBufferState()
{
extra_length = length_;
extra_offset = offset_;
extra_reader_accum = reader_accum;
memcpy(extra_buffer, buffer_, sizeof(extra_buffer));
extra_length = length_;
extra_offset = offset_;
extra_reader_accum = reader_accum;
memcpy(extra_buffer, buffer_, sizeof(extra_buffer));
}
void Blip_Buffer::RestoreAudioBufferState()
{
length_ = extra_length;
offset_ = extra_offset;
reader_accum = extra_reader_accum;
memcpy(buffer_, extra_buffer, sizeof(extra_buffer));
length_ = extra_length;
offset_ = extra_offset;
reader_accum = extra_reader_accum;
memcpy(buffer_, extra_buffer, sizeof(extra_buffer));
}
} // namespace quickNES

358
source/quickerNES/apu/Blip_Buffer.h
View File

@ -1,358 +0,0 @@
// Band-limited sound synthesis and buffering
// Blip_Buffer 0.4.0
#ifndef BLIP_BUFFER_H
#define BLIP_BUFFER_H
// Time unit at source clock rate
typedef long blip_time_t;
// Output samples are 16-bit signed, with a range of -32768 to 32767
typedef short blip_sample_t;
enum { blip_sample_max = 32767 };
class Blip_Buffer {
public:
// Set output sample rate and buffer length in milliseconds (1/1000 sec, defaults
// to 1/4 second), then clear buffer. Returns NULL on success, otherwise if there
// isn't enough memory, returns error without affecting current buffer setup.
const char *set_sample_rate( long samples_per_sec, int msec_length = 1000 / 4 );
// Set number of source time units per second
void clock_rate( long );
// End current time frame of specified duration and make its samples available
// (along with any still-unread samples) for reading with read_samples(). Begins
// a new time frame at the end of the current frame.
void end_frame( blip_time_t time );
// Read at most 'max_samples' out of buffer into 'dest', removing them from from
// the buffer. Returns number of samples actually read and removed. If stereo is
// true, increments 'dest' one extra time after writing each sample, to allow
// easy interleving of two channels into a stereo output buffer.
long read_samples( blip_sample_t* dest, long max_samples, int stereo = 0 );
// Additional optional features
// Current output sample rate
long sample_rate() const;
// Length of buffer, in milliseconds
int length() const;
// Number of source time units per second
long clock_rate() const;
// Set frequency high-pass filter frequency, where higher values reduce bass more
void bass_freq( int frequency );
// Number of samples delay from synthesis to samples read out
int output_latency() const;
// Remove all available samples and clear buffer to silence. If 'entire_buffer' is
// false, just clears out any samples waiting rather than the entire buffer.
void clear( int entire_buffer = 1 );
// Number of samples available for reading with read_samples()
long samples_avail() const;
// Remove 'count' samples from those waiting to be read
void remove_samples( long count );
// Experimental features
// Number of raw samples that can be mixed within frame of specified duration.
long count_samples( blip_time_t duration ) const;
// Mix 'count' samples from 'buf' into buffer.
void mix_samples( blip_sample_t const* buf, long count );
// Count number of clocks needed until 'count' samples will be available.
// If buffer can't even hold 'count' samples, returns number of clocks until
// buffer becomes full.
blip_time_t count_clocks( long count ) const;
// not documented yet
typedef unsigned long blip_resampled_time_t;
void remove_silence( long count );
blip_resampled_time_t resampled_duration( int t ) const { return t * factor_; }
blip_resampled_time_t resampled_time( blip_time_t t ) const { return t * factor_ + offset_; }
blip_resampled_time_t clock_rate_factor( long clock_rate ) const;
public:
Blip_Buffer();
~Blip_Buffer();
// Deprecated
typedef blip_resampled_time_t resampled_time_t;
const char *sample_rate( long r ) { return set_sample_rate( r ); }
const char *sample_rate( long r, int msec ) { return set_sample_rate( r, msec ); }
private:
// noncopyable
Blip_Buffer( const Blip_Buffer& );
Blip_Buffer& operator = ( const Blip_Buffer& );
public:
typedef long buf_t_;
unsigned long factor_;
blip_resampled_time_t offset_;
buf_t_* buffer_;
long buffer_size_;
private:
long reader_accum;
int bass_shift;
long sample_rate_;
long clock_rate_;
int bass_freq_;
int length_;
friend class Blip_Reader;
private:
//extra information necessary to load state to an exact sample
buf_t_ extra_buffer[32];
int extra_length;
long extra_reader_accum;
blip_resampled_time_t extra_offset;
public:
void SaveAudioBufferState();
void RestoreAudioBufferState();
};
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// Number of bits in resample ratio fraction. Higher values give a more accurate ratio
// but reduce maximum buffer size.
#ifndef BLIP_BUFFER_ACCURACY
#define BLIP_BUFFER_ACCURACY 16
#endif
// Number bits in phase offset. Fewer than 6 bits (64 phase offsets) results in
// noticeable broadband noise when synthesizing high frequency square waves.
// Affects size of Blip_Synth objects since they store the waveform directly.
#ifndef BLIP_PHASE_BITS
#define BLIP_PHASE_BITS 6
#endif
// Internal
typedef unsigned long blip_resampled_time_t;
int const blip_widest_impulse_ = 16;
int const blip_res = 1 << BLIP_PHASE_BITS;
class blip_eq_t;
class Blip_Synth_ {
double volume_unit_;
short* const impulses;
int const width;
long kernel_unit;
int impulses_size() const { return blip_res / 2 * width + 1; }
void adjust_impulse();
public:
Blip_Buffer* buf;
int last_amp;
int delta_factor;
Blip_Synth_( short* impulses, int width );
void treble_eq( blip_eq_t const& );
void volume_unit( double );
};
// Quality level. Start with blip_good_quality.
const int blip_med_quality = 8;
const int blip_good_quality = 12;
const int blip_high_quality = 16;
// Range specifies the greatest expected change in amplitude. Calculate it
// by finding the difference between the maximum and minimum expected
// amplitudes (max - min).
template<int quality,int range>
class Blip_Synth {
public:
// Set overall volume of waveform
void volume( double v ) { impl.volume_unit( v * (1.0 / (range < 0 ? -range : range)) ); }
// Configure low-pass filter (see notes.txt)
void treble_eq( blip_eq_t const& eq ) { impl.treble_eq( eq ); }
// Get/set Blip_Buffer used for output
Blip_Buffer* output() const { return impl.buf; }
void output( Blip_Buffer* b ) { impl.buf = b; impl.last_amp = 0; }
// Update amplitude of waveform at given time. Using this requires a separate
// Blip_Synth for each waveform.
void update( blip_time_t time, int amplitude );
// Low-level interface
// Add an amplitude transition of specified delta, optionally into specified buffer
// rather than the one set with output(). Delta can be positive or negative.
// The actual change in amplitude is delta * (volume / range)
void offset( blip_time_t, int delta, Blip_Buffer* ) const;
void offset( blip_time_t t, int delta ) const { offset( t, delta, impl.buf ); }
// Works directly in terms of fractional output samples. Contact author for more.
void offset_resampled( blip_resampled_time_t, int delta, Blip_Buffer* ) const;
// Same as offset(), except code is inlined for higher performance
void offset_inline( blip_time_t t, int delta, Blip_Buffer* buf ) const {
offset_resampled( t * buf->factor_ + buf->offset_, delta, buf );
}
void offset_inline( blip_time_t t, int delta ) const {
offset_resampled( t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf );
}
public:
Blip_Synth() : impl( impulses, quality ) { }
private:
typedef short imp_t;
imp_t impulses [blip_res * (quality / 2) + 1];
Blip_Synth_ impl;
};
// Low-pass equalization parameters
class blip_eq_t {
public:
// Logarithmic rolloff to treble dB at half sampling rate. Negative values reduce
// treble, small positive values (0 to 5.0) increase treble.
blip_eq_t( double treble_db = 0 );
// See notes.txt
blip_eq_t( double treble, long rolloff_freq, long sample_rate, long cutoff_freq = 0 );
private:
double treble;
long rolloff_freq;
long sample_rate;
long cutoff_freq;
void generate( float* out, int count ) const;
friend class Blip_Synth_;
};
int const blip_sample_bits = 30;
// Optimized inline sample reader for custom sample formats and mixing of Blip_Buffer samples
class Blip_Reader {
public:
// Begin reading samples from buffer. Returns value to pass to next() (can
// be ignored if default bass_freq is acceptable).
int begin( Blip_Buffer& );
// Current sample
long read() const { return accum >> (blip_sample_bits - 16); }
// Current raw sample in full internal resolution
long read_raw() const { return accum; }
// Advance to next sample
void next( int bass_shift = 9 ) { accum += *buf++ - (accum >> bass_shift); }
// End reading samples from buffer. The number of samples read must now be removed
// using Blip_Buffer::remove_samples().
void end( Blip_Buffer& b ) { b.reader_accum = accum; }
private:
const Blip_Buffer::buf_t_* buf;
long accum;
};
// End of public interface
// Compatibility with older version
const long blip_unscaled = 65535;
const int blip_low_quality = blip_med_quality;
const int blip_best_quality = blip_high_quality;
#define BLIP_FWD( i ) { \
long t0 = i0 * delta + buf [fwd + i]; \
long t1 = imp [blip_res * (i + 1)] * delta + buf [fwd + 1 + i]; \
i0 = imp [blip_res * (i + 2)]; \
buf [fwd + i] = t0; \
buf [fwd + 1 + i] = t1; }
#define BLIP_REV( r ) { \
long t0 = i0 * delta + buf [rev - r]; \
long t1 = imp [blip_res * r] * delta + buf [rev + 1 - r]; \
i0 = imp [blip_res * (r - 1)]; \
buf [rev - r] = t0; \
buf [rev + 1 - r] = t1; }
template<int quality,int range>
inline void Blip_Synth<quality,range>::offset_resampled( blip_resampled_time_t time,
int delta, Blip_Buffer* blip_buf ) const
{
// Fails if time is beyond end of Blip_Buffer, due to a bug in caller code or the
// need for a longer buffer as set by set_sample_rate().
delta *= impl.delta_factor;
int phase = (int) (time >> (BLIP_BUFFER_ACCURACY - BLIP_PHASE_BITS) & (blip_res - 1));
imp_t const* imp = impulses + blip_res - phase;
long* buf = blip_buf->buffer_ + (time >> BLIP_BUFFER_ACCURACY);
long i0 = *imp;
int const fwd = (blip_widest_impulse_ - quality) / 2;
int const rev = fwd + quality - 2;
BLIP_FWD( 0 )
if ( quality > 8 ) BLIP_FWD( 2 )
if ( quality > 12 ) BLIP_FWD( 4 )
{
int const mid = quality / 2 - 1;
long t0 = i0 * delta + buf [fwd + mid - 1];
long t1 = imp [blip_res * mid] * delta + buf [fwd + mid];
imp = impulses + phase;
i0 = imp [blip_res * mid];
buf [fwd + mid - 1] = t0;
buf [fwd + mid] = t1;
}
if ( quality > 12 ) BLIP_REV( 6 )
if ( quality > 8 ) BLIP_REV( 4 )
BLIP_REV( 2 )
long t0 = i0 * delta + buf [rev];
long t1 = *imp * delta + buf [rev + 1];
buf [rev] = t0;
buf [rev + 1] = t1;
}
#undef BLIP_FWD
#undef BLIP_REV
template<int quality,int range>
void Blip_Synth<quality,range>::offset( blip_time_t t, int delta, Blip_Buffer* buf ) const
{
offset_resampled( t * buf->factor_ + buf->offset_, delta, buf );
}
template<int quality,int range>
void Blip_Synth<quality,range>::update( blip_time_t t, int amp )
{
int delta = amp - impl.last_amp;
impl.last_amp = amp;
offset_resampled( t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf );
}
inline blip_eq_t::blip_eq_t( double t ) :
treble( t ), rolloff_freq( 0 ), sample_rate( 44100 ), cutoff_freq( 0 ) { }
inline blip_eq_t::blip_eq_t( double t, long rf, long sr, long cf ) :
treble( t ), rolloff_freq( rf ), sample_rate( sr ), cutoff_freq( cf ) { }
inline int Blip_Buffer::length() const { return length_; }
inline long Blip_Buffer::samples_avail() const { return (long) (offset_ >> BLIP_BUFFER_ACCURACY); }
inline long Blip_Buffer::sample_rate() const { return sample_rate_; }
inline int Blip_Buffer::output_latency() const { return blip_widest_impulse_ / 2; }
inline long Blip_Buffer::clock_rate() const { return clock_rate_; }
inline void Blip_Buffer::clock_rate( long cps ) { factor_ = clock_rate_factor( clock_rate_ = cps ); }
inline int Blip_Reader::begin( Blip_Buffer& blip_buf )
{
buf = blip_buf.buffer_;
accum = blip_buf.reader_accum;
return blip_buf.bass_shift;
}
int const blip_max_length = 0;
int const blip_default_length = 250;
#endif

380
source/quickerNES/apu/Blip_Buffer.hpp Normal file
View File

@ -0,0 +1,380 @@
#pragma once
// Band-limited sound synthesis and buffering
// Blip_Buffer 0.4.0
namespace quickerNES
{
// Time unit at source clock rate
typedef long blip_time_t;
// Output samples are 16-bit signed, with a range of -32768 to 32767
typedef short blip_sample_t;
enum
{
blip_sample_max = 32767
};
class Blip_Buffer
{
public:
// Set output sample rate and buffer length in milliseconds (1/1000 sec, defaults
// to 1/4 second), then clear buffer. Returns NULL on success, otherwise if there
// isn't enough memory, returns error without affecting current buffer setup.
const char *set_sample_rate(long samples_per_sec, int msec_length = 1000 / 4);
// Set number of source time units per second
void clock_rate(long);
// End current time frame of specified duration and make its samples available
// (along with any still-unread samples) for reading with read_samples(). Begins
// a new time frame at the end of the current frame.
void end_frame(blip_time_t time);
// Read at most 'max_samples' out of buffer into 'dest', removing them from from
// the buffer. Returns number of samples actually read and removed. If stereo is
// true, increments 'dest' one extra time after writing each sample, to allow
// easy interleving of two channels into a stereo output buffer.
long read_samples(blip_sample_t *dest, long max_samples, int stereo = 0);
// Additional optional features
// Current output sample rate
long sample_rate() const;
// Length of buffer, in milliseconds
int length() const;
// Number of source time units per second
long clock_rate() const;
// Set frequency high-pass filter frequency, where higher values reduce bass more
void bass_freq(int frequency);
// Number of samples delay from synthesis to samples read out
int output_latency() const;
// Remove all available samples and clear buffer to silence. If 'entire_buffer' is
// false, just clears out any samples waiting rather than the entire buffer.
void clear(int entire_buffer = 1);
// Number of samples available for reading with read_samples()
long samples_avail() const;
// Remove 'count' samples from those waiting to be read
void remove_samples(long count);
// Experimental features
// Number of raw samples that can be mixed within frame of specified duration.
long count_samples(blip_time_t duration) const;
// Mix 'count' samples from 'buf' into buffer.
void mix_samples(blip_sample_t const *buf, long count);
// Count number of clocks needed until 'count' samples will be available.
// If buffer can't even hold 'count' samples, returns number of clocks until
// buffer becomes full.
blip_time_t count_clocks(long count) const;
// not documented yet
typedef unsigned long blip_resampled_time_t;
void remove_silence(long count);
blip_resampled_time_t resampled_duration(int t) const { return t * factor_; }
blip_resampled_time_t resampled_time(blip_time_t t) const { return t * factor_ + offset_; }
blip_resampled_time_t clock_rate_factor(long clock_rate) const;
public:
Blip_Buffer();
~Blip_Buffer();
// Deprecated
typedef blip_resampled_time_t resampled_time_t;
const char *sample_rate(long r) { return set_sample_rate(r); }
const char *sample_rate(long r, int msec) { return set_sample_rate(r, msec); }
private:
// noncopyable
Blip_Buffer(const Blip_Buffer &);
Blip_Buffer &operator=(const Blip_Buffer &);
public:
typedef long buf_t_;
unsigned long factor_;
blip_resampled_time_t offset_;
buf_t_ *buffer_;
long buffer_size_;
private:
long reader_accum;
int bass_shift;
long sample_rate_;
long clock_rate_;
int bass_freq_;
int length_;
friend class Blip_Reader;
private:
// extra information necessary to load state to an exact sample
buf_t_ extra_buffer[32];
int extra_length;
long extra_reader_accum;
blip_resampled_time_t extra_offset;
public:
void SaveAudioBufferState();
void RestoreAudioBufferState();
};
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// Number of bits in resample ratio fraction. Higher values give a more accurate ratio
// but reduce maximum buffer size.
#ifndef BLIP_BUFFER_ACCURACY
#define BLIP_BUFFER_ACCURACY 16
#endif
// Number bits in phase offset. Fewer than 6 bits (64 phase offsets) results in
// noticeable broadband noise when synthesizing high frequency square waves.
// Affects size of Blip_Synth objects since they store the waveform directly.
#ifndef BLIP_PHASE_BITS
#define BLIP_PHASE_BITS 6
#endif
// Internal
typedef unsigned long blip_resampled_time_t;
int const blip_widest_impulse_ = 16;
int const blip_res = 1 << BLIP_PHASE_BITS;
class blip_eq_t;
class Blip_Synth_
{
double volume_unit_;
short *const impulses;
int const width;
long kernel_unit;
int impulses_size() const { return blip_res / 2 * width + 1; }
void adjust_impulse();
public:
Blip_Buffer *buf;
int last_amp;
int delta_factor;
Blip_Synth_(short *impulses, int width);
void treble_eq(blip_eq_t const &);
void volume_unit(double);
};
// Quality level. Start with blip_good_quality.
const int blip_med_quality = 8;
const int blip_good_quality = 12;
const int blip_high_quality = 16;
// Range specifies the greatest expected change in amplitude. Calculate it
// by finding the difference between the maximum and minimum expected
// amplitudes (max - min).
template <int quality, int range>
class Blip_Synth
{
public:
// Set overall volume of waveform
void volume(double v) { impl.volume_unit(v * (1.0 / (range < 0 ? -range : range))); }
// Configure low-pass filter (see notes.txt)
void treble_eq(blip_eq_t const &eq) { impl.treble_eq(eq); }
// Get/set Blip_Buffer used for output
Blip_Buffer *output() const { return impl.buf; }
void output(Blip_Buffer *b)
{
impl.buf = b;
impl.last_amp = 0;
}
// Update amplitude of waveform at given time. Using this requires a separate
// Blip_Synth for each waveform.
void update(blip_time_t time, int amplitude);
// Low-level interface
// Add an amplitude transition of specified delta, optionally into specified buffer
// rather than the one set with output(). Delta can be positive or negative.
// The actual change in amplitude is delta * (volume / range)
void offset(blip_time_t, int delta, Blip_Buffer *) const;
void offset(blip_time_t t, int delta) const { offset(t, delta, impl.buf); }
// Works directly in terms of fractional output samples. Contact author for more.
void offset_resampled(blip_resampled_time_t, int delta, Blip_Buffer *) const;
// Same as offset(), except code is inlined for higher performance
void offset_inline(blip_time_t t, int delta, Blip_Buffer *buf) const
{
offset_resampled(t * buf->factor_ + buf->offset_, delta, buf);
}
void offset_inline(blip_time_t t, int delta) const
{
offset_resampled(t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf);
}
public:
Blip_Synth() : impl(impulses, quality) {}
private:
typedef short imp_t;
imp_t impulses[blip_res * (quality / 2) + 1];
Blip_Synth_ impl;
};
// Low-pass equalization parameters
class blip_eq_t
{
public:
// Logarithmic rolloff to treble dB at half sampling rate. Negative values reduce
// treble, small positive values (0 to 5.0) increase treble.
blip_eq_t(double treble_db = 0);
// See notes.txt
blip_eq_t(double treble, long rolloff_freq, long sample_rate, long cutoff_freq = 0);
private:
double treble;
long rolloff_freq;
long sample_rate;
long cutoff_freq;
void generate(float *out, int count) const;
friend class Blip_Synth_;
};
int const blip_sample_bits = 30;
// Optimized inline sample reader for custom sample formats and mixing of Blip_Buffer samples
class Blip_Reader
{
public:
// Begin reading samples from buffer. Returns value to pass to next() (can
// be ignored if default bass_freq is acceptable).
int begin(Blip_Buffer &);
// Current sample
long read() const { return accum >> (blip_sample_bits - 16); }
// Current raw sample in full internal resolution
long read_raw() const { return accum; }
// Advance to next sample
void next(int bass_shift = 9) { accum += *buf++ - (accum >> bass_shift); }
// End reading samples from buffer. The number of samples read must now be removed
// using Blip_Buffer::remove_samples().
void end(Blip_Buffer &b) { b.reader_accum = accum; }
private:
const Blip_Buffer::buf_t_ *buf;
long accum;
};
// End of public interface
// Compatibility with older version
const long blip_unscaled = 65535;
const int blip_low_quality = blip_med_quality;
const int blip_best_quality = blip_high_quality;
#define BLIP_FWD(i) \
{ \
long t0 = i0 * delta + buf[fwd + i]; \
long t1 = imp[blip_res * (i + 1)] * delta + buf[fwd + 1 + i]; \
i0 = imp[blip_res * (i + 2)]; \
buf[fwd + i] = t0; \
buf[fwd + 1 + i] = t1; \
}
#define BLIP_REV(r) \
{ \
long t0 = i0 * delta + buf[rev - r]; \
long t1 = imp[blip_res * r] * delta + buf[rev + 1 - r]; \
i0 = imp[blip_res * (r - 1)]; \
buf[rev - r] = t0; \
buf[rev + 1 - r] = t1; \
}
template <int quality, int range>
inline void Blip_Synth<quality, range>::offset_resampled(blip_resampled_time_t time,
int delta,
Blip_Buffer *blip_buf) const
{
// Fails if time is beyond end of Blip_Buffer, due to a bug in caller code or the
// need for a longer buffer as set by set_sample_rate().
delta *= impl.delta_factor;
int phase = (int)(time >> (BLIP_BUFFER_ACCURACY - BLIP_PHASE_BITS) & (blip_res - 1));
imp_t const *imp = impulses + blip_res - phase;
long *buf = blip_buf->buffer_ + (time >> BLIP_BUFFER_ACCURACY);
long i0 = *imp;
int const fwd = (blip_widest_impulse_ - quality) / 2;
int const rev = fwd + quality - 2;
BLIP_FWD(0)
if (quality > 8) BLIP_FWD(2)
if (quality > 12) BLIP_FWD(4)
{
int const mid = quality / 2 - 1;
long t0 = i0 * delta + buf[fwd + mid - 1];
long t1 = imp[blip_res * mid] * delta + buf[fwd + mid];
imp = impulses + phase;
i0 = imp[blip_res * mid];
buf[fwd + mid - 1] = t0;
buf[fwd + mid] = t1;
}
if (quality > 12) BLIP_REV(6)
if (quality > 8) BLIP_REV(4)
BLIP_REV(2)
long t0 = i0 * delta + buf[rev];
long t1 = *imp * delta + buf[rev + 1];
buf[rev] = t0;
buf[rev + 1] = t1;
}
#undef BLIP_FWD
#undef BLIP_REV
template <int quality, int range>
void Blip_Synth<quality, range>::offset(blip_time_t t, int delta, Blip_Buffer *buf) const
{
offset_resampled(t * buf->factor_ + buf->offset_, delta, buf);
}
template <int quality, int range>
void Blip_Synth<quality, range>::update(blip_time_t t, int amp)
{
int delta = amp - impl.last_amp;
impl.last_amp = amp;
offset_resampled(t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf);
}
inline blip_eq_t::blip_eq_t(double t) : treble(t), rolloff_freq(0), sample_rate(44100), cutoff_freq(0) {}
inline blip_eq_t::blip_eq_t(double t, long rf, long sr, long cf) : treble(t), rolloff_freq(rf), sample_rate(sr), cutoff_freq(cf) {}
inline int Blip_Buffer::length() const { return length_; }
inline long Blip_Buffer::samples_avail() const { return (long)(offset_ >> BLIP_BUFFER_ACCURACY); }
inline long Blip_Buffer::sample_rate() const { return sample_rate_; }
inline int Blip_Buffer::output_latency() const { return blip_widest_impulse_ / 2; }
inline long Blip_Buffer::clock_rate() const { return clock_rate_; }
inline void Blip_Buffer::clock_rate(long cps) { factor_ = clock_rate_factor(clock_rate_ = cps); }
inline int Blip_Reader::begin(Blip_Buffer &blip_buf)
{
buf = blip_buf.buffer_;
accum = blip_buf.reader_accum;
return blip_buf.bass_shift;
}
int const blip_max_length = 0;
int const blip_default_length = 250;
} // namespace quickNES

505
source/quickerNES/apu/Effects_Buffer.cpp
View File

@ -1,505 +0,0 @@
// Game_Music_Emu 0.3.0. http://www.slack.net/~ant/
#include "Effects_Buffer.h"
#include <cstring>
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
typedef long fixed_t;
#define TO_FIXED( f ) fixed_t ((f) * (1L << 15) + 0.5)
#define FMUL( x, y ) (((x) * (y)) >> 15)
const unsigned echo_size = 4096;
const unsigned echo_mask = echo_size - 1;
static_assert( (echo_size & echo_mask) == 0 ); // must be power of 2
const unsigned reverb_size = 8192 * 2;
const unsigned reverb_mask = reverb_size - 1;
static_assert( (reverb_size & reverb_mask) == 0 ); // must be power of 2
Effects_Buffer::config_t::config_t()
{
pan_1 = -0.15f;
pan_2 = 0.15f;
reverb_delay = 88.0f;
reverb_level = 0.12f;
echo_delay = 61.0f;
echo_level = 0.10f;
delay_variance = 18.0f;
effects_enabled = false;
}
void Effects_Buffer::set_depth( double d )
{
float f = (float) d;
config_t c;
c.pan_1 = -0.6f * f;
c.pan_2 = 0.6f * f;
c.reverb_delay = 880 * 0.1f;
c.echo_delay = 610 * 0.1f;
if ( f > 0.5 )
f = 0.5; // TODO: more linear reduction of extreme reverb/echo
c.reverb_level = 0.5f * f;
c.echo_level = 0.30f * f;
c.delay_variance = 180 * 0.1f;
c.effects_enabled = (d > 0.0f);
config( c );
}
Effects_Buffer::Effects_Buffer( bool center_only ) : Multi_Buffer( 2 )
{
buf_count = center_only ? max_buf_count - 4 : max_buf_count;
echo_buf = NULL;
echo_pos = 0;
reverb_buf = NULL;
reverb_pos = 0;
stereo_remain = 0;
effect_remain = 0;
effects_enabled = false;
set_depth( 0 );
}
Effects_Buffer::~Effects_Buffer()
{
delete [] echo_buf;
delete [] reverb_buf;
}
const char *Effects_Buffer::set_sample_rate( long rate, int msec )
{
if ( !echo_buf )
{
echo_buf = new blip_sample_t [echo_size];
}
if ( !reverb_buf )
{
reverb_buf = new blip_sample_t [reverb_size];
}
for ( int i = 0; i < buf_count; i++ ) bufs [i].set_sample_rate( rate, msec );
config( config_ );
clear();
return Multi_Buffer::set_sample_rate( bufs [0].sample_rate(), bufs [0].length() );
}
void Effects_Buffer::clock_rate( long rate )
{
for ( int i = 0; i < buf_count; i++ )
bufs [i].clock_rate( rate );
}
void Effects_Buffer::bass_freq( int freq )
{
for ( int i = 0; i < buf_count; i++ )
bufs [i].bass_freq( freq );
}
void Effects_Buffer::clear()
{
stereo_remain = 0;
effect_remain = 0;
if ( echo_buf )
memset( echo_buf, 0, echo_size * sizeof *echo_buf );
if ( reverb_buf )
memset( reverb_buf, 0, reverb_size * sizeof *reverb_buf );
for ( int i = 0; i < buf_count; i++ )
bufs [i].clear();
}
inline int pin_range( int n, int max, int min = 0 )
{
if ( n < min )
return min;
if ( n > max )
return max;
return n;
}
void Effects_Buffer::config( const config_t& cfg )
{
channels_changed();
// clear echo and reverb buffers
if ( !config_.effects_enabled && cfg.effects_enabled && echo_buf )
{
memset( echo_buf, 0, echo_size * sizeof (blip_sample_t) );
memset( reverb_buf, 0, reverb_size * sizeof (blip_sample_t) );
}
config_ = cfg;
if ( config_.effects_enabled )
{
// convert to internal format
chans.pan_1_levels [0] = TO_FIXED( 1 ) - TO_FIXED( config_.pan_1 );
chans.pan_1_levels [1] = TO_FIXED( 2 ) - chans.pan_1_levels [0];
chans.pan_2_levels [0] = TO_FIXED( 1 ) - TO_FIXED( config_.pan_2 );
chans.pan_2_levels [1] = TO_FIXED( 2 ) - chans.pan_2_levels [0];
chans.reverb_level = TO_FIXED( config_.reverb_level );
chans.echo_level = TO_FIXED( config_.echo_level );
int delay_offset = int (1.0 / 2000 * config_.delay_variance * sample_rate());
int reverb_sample_delay = int (1.0 / 1000 * config_.reverb_delay * sample_rate());
chans.reverb_delay_l = pin_range( reverb_size -
(reverb_sample_delay - delay_offset) * 2, reverb_size - 2, 0 );
chans.reverb_delay_r = pin_range( reverb_size + 1 -
(reverb_sample_delay + delay_offset) * 2, reverb_size - 1, 1 );
int echo_sample_delay = int (1.0 / 1000 * config_.echo_delay * sample_rate());
chans.echo_delay_l = pin_range( echo_size - 1 - (echo_sample_delay - delay_offset),
echo_size - 1 );
chans.echo_delay_r = pin_range( echo_size - 1 - (echo_sample_delay + delay_offset),
echo_size - 1 );
// set up outputs
for ( unsigned i = 0; i < chan_count; i++ )
{
channel_t& o = channels [i];
if ( i < 2 )
{
o.center = &bufs [i];
o.left = &bufs [3];
o.right = &bufs [4];
}
else
{
o.center = &bufs [2];
o.left = &bufs [5];
o.right = &bufs [6];
}
}
}
else
{
// set up outputs
for ( unsigned i = 0; i < chan_count; i++ )
{
channel_t& o = channels [i];
o.center = &bufs [0];
o.left = &bufs [1];
o.right = &bufs [2];
}
}
if ( buf_count < max_buf_count )
{
for ( unsigned i = 0; i < chan_count; i++ )
{
channel_t& o = channels [i];
o.left = o.center;
o.right = o.center;
}
}
}
void Effects_Buffer::end_frame( blip_time_t clock_count, bool stereo )
{
for ( int i = 0; i < buf_count; i++ )
bufs [i].end_frame( clock_count );
if ( stereo && buf_count == max_buf_count )
stereo_remain = bufs [0].samples_avail() + bufs [0].output_latency();
if ( effects_enabled || config_.effects_enabled )
effect_remain = bufs [0].samples_avail() + bufs [0].output_latency();
effects_enabled = config_.effects_enabled;
}
long Effects_Buffer::samples_avail() const
{
return bufs [0].samples_avail() * 2;
}
long Effects_Buffer::read_samples( blip_sample_t* out, long total_samples )
{
long remain = bufs [0].samples_avail();
if ( remain > (total_samples >> 1) )
remain = (total_samples >> 1);
total_samples = remain;
while ( remain )
{
int active_bufs = buf_count;
long count = remain;
// optimizing mixing to skip any channels which had nothing added
if ( effect_remain )
{
if ( count > effect_remain )
count = effect_remain;
if ( stereo_remain )
{
mix_enhanced( out, count );
}
else
{
mix_mono_enhanced( out, count );
active_bufs = 3;
}
}
else if ( stereo_remain )
{
mix_stereo( out, count );
active_bufs = 3;
}
else
{
mix_mono( out, count );
active_bufs = 1;
}
out += count * 2;
remain -= count;
stereo_remain -= count;
if ( stereo_remain < 0 )
stereo_remain = 0;
effect_remain -= count;
if ( effect_remain < 0 )
effect_remain = 0;
for ( int i = 0; i < buf_count; i++ )
{
if ( i < active_bufs )
bufs [i].remove_samples( count );
else
bufs [i].remove_silence( count ); // keep time synchronized
}
}
return total_samples * 2;
}
void Effects_Buffer::mix_mono( blip_sample_t* out, long count )
{
Blip_Reader c;
int shift = c.begin( bufs [0] );
// unrolled loop
for ( long n = count >> 1; n--; )
{
long cs0 = c.read();
c.next( shift );
long cs1 = c.read();
c.next( shift );
if ( (int16_t) cs0 != cs0 )
cs0 = 0x7FFF - (cs0 >> 24);
((uint32_t*) out) [0] = ((uint16_t) cs0) | (cs0 << 16);
if ( (int16_t) cs1 != cs1 )
cs1 = 0x7FFF - (cs1 >> 24);
((uint32_t*) out) [1] = ((uint16_t) cs1) | (cs1 << 16);
out += 4;
}
if ( count & 1 )
{
int s = c.read();
c.next( shift );
out [0] = s;
out [1] = s;
if ( (int16_t) s != s )
{
s = 0x7FFF - (s >> 24);
out [0] = s;
out [1] = s;
}
}
c.end( bufs [0] );
}
void Effects_Buffer::mix_stereo( blip_sample_t* out, long count )
{
Blip_Reader l; l.begin( bufs [1] );
Blip_Reader r; r.begin( bufs [2] );
Blip_Reader c;
int shift = c.begin( bufs [0] );
while ( count-- )
{
int cs = c.read();
c.next( shift );
int left = cs + l.read();
int right = cs + r.read();
l.next( shift );
r.next( shift );
if ( (int16_t) left != left )
left = 0x7FFF - (left >> 24);
out [0] = left;
out [1] = right;
out += 2;
if ( (int16_t) right != right )
out [-1] = 0x7FFF - (right >> 24);
}
c.end( bufs [0] );
r.end( bufs [2] );
l.end( bufs [1] );
}
void Effects_Buffer::mix_mono_enhanced( blip_sample_t* out, long count )
{
Blip_Reader sq1; sq1.begin( bufs [0] );
Blip_Reader sq2; sq2.begin( bufs [1] );
Blip_Reader center;
int shift = center.begin( bufs [2] );
int echo_pos = this->echo_pos;
int reverb_pos = this->reverb_pos;
while ( count-- )
{
int sum1_s = sq1.read();
int sum2_s = sq2.read();
sq1.next( shift );
sq2.next( shift );
int new_reverb_l = FMUL( sum1_s, chans.pan_1_levels [0] ) +
FMUL( sum2_s, chans.pan_2_levels [0] ) +
reverb_buf [(reverb_pos + chans.reverb_delay_l) & reverb_mask];
int new_reverb_r = FMUL( sum1_s, chans.pan_1_levels [1] ) +
FMUL( sum2_s, chans.pan_2_levels [1] ) +
reverb_buf [(reverb_pos + chans.reverb_delay_r) & reverb_mask];
fixed_t reverb_level = chans.reverb_level;
reverb_buf [reverb_pos] = FMUL( new_reverb_l, reverb_level );
reverb_buf [reverb_pos + 1] = FMUL( new_reverb_r, reverb_level );
reverb_pos = (reverb_pos + 2) & reverb_mask;
int sum3_s = center.read();
center.next( shift );
int left = new_reverb_l + sum3_s + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_l) & echo_mask] );
int right = new_reverb_r + sum3_s + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_r) & echo_mask] );
echo_buf [echo_pos] = sum3_s;
echo_pos = (echo_pos + 1) & echo_mask;
if ( (int16_t) left != left )
left = 0x7FFF - (left >> 24);
out [0] = left;
out [1] = right;
out += 2;
if ( (int16_t) right != right )
out [-1] = 0x7FFF - (right >> 24);
}
this->reverb_pos = reverb_pos;
this->echo_pos = echo_pos;
sq1.end( bufs [0] );
sq2.end( bufs [1] );
center.end( bufs [2] );
}
void Effects_Buffer::mix_enhanced( blip_sample_t* out, long count )
{
Blip_Reader l1; l1.begin( bufs [3] );
Blip_Reader r1; r1.begin( bufs [4] );
Blip_Reader l2; l2.begin( bufs [5] );
Blip_Reader r2; r2.begin( bufs [6] );
Blip_Reader sq1; sq1.begin( bufs [0] );
Blip_Reader sq2; sq2.begin( bufs [1] );
Blip_Reader center;
int shift = center.begin( bufs [2] );
int echo_pos = this->echo_pos;
int reverb_pos = this->reverb_pos;
while ( count-- )
{
int sum1_s = sq1.read();
int sum2_s = sq2.read();
sq1.next( shift );
sq2.next( shift );
int new_reverb_l = FMUL( sum1_s, chans.pan_1_levels [0] ) +
FMUL( sum2_s, chans.pan_2_levels [0] ) + l1.read() +
reverb_buf [(reverb_pos + chans.reverb_delay_l) & reverb_mask];
int new_reverb_r = FMUL( sum1_s, chans.pan_1_levels [1] ) +
FMUL( sum2_s, chans.pan_2_levels [1] ) + r1.read() +
reverb_buf [(reverb_pos + chans.reverb_delay_r) & reverb_mask];
l1.next( shift );
r1.next( shift );
fixed_t reverb_level = chans.reverb_level;
reverb_buf [reverb_pos] = FMUL( new_reverb_l, reverb_level );
reverb_buf [reverb_pos + 1] = FMUL( new_reverb_r, reverb_level );
reverb_pos = (reverb_pos + 2) & reverb_mask;
int sum3_s = center.read();
center.next( shift );
int left = new_reverb_l + sum3_s + l2.read() + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_l) & echo_mask] );
int right = new_reverb_r + sum3_s + r2.read() + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_r) & echo_mask] );
l2.next( shift );
r2.next( shift );
echo_buf [echo_pos] = sum3_s;
echo_pos = (echo_pos + 1) & echo_mask;
if ( (int16_t) left != left )
left = 0x7FFF - (left >> 24);
out [0] = left;
out [1] = right;
out += 2;
if ( (int16_t) right != right )
out [-1] = 0x7FFF - (right >> 24);
}
this->reverb_pos = reverb_pos;
this->echo_pos = echo_pos;
sq1.end( bufs [0] );
sq2.end( bufs [1] );
center.end( bufs [2] );
l1.end( bufs [3] );
r1.end( bufs [4] );
l2.end( bufs [5] );
r2.end( bufs [6] );
}

93
source/quickerNES/apu/Effects_Buffer.h
View File

@ -1,93 +0,0 @@
// Multi-channel effects buffer with panning, echo and reverb
// Game_Music_Emu 0.3.0
#ifndef EFFECTS_BUFFER_H
#define EFFECTS_BUFFER_H
#include <stdint.h>
#include "Multi_Buffer.h"
// Effects_Buffer uses several buffers and outputs stereo sample pairs.
class Effects_Buffer : public Multi_Buffer {
public:
// If center_only is true, only center buffers are created and
// less memory is used.
Effects_Buffer( bool center_only = false );
// Channel Effect Center Pan
// ---------------------------------
// 0,5 reverb pan_1
// 1,6 reverb pan_2
// 2,7 echo -
// 3 echo -
// 4 echo -
// Channel configuration
struct config_t {
double pan_1; // -1.0 = left, 0.0 = center, 1.0 = right
double pan_2;
double echo_delay; // msec
double echo_level; // 0.0 to 1.0
double reverb_delay; // msec
double delay_variance; // difference between left/right delays (msec)
double reverb_level; // 0.0 to 1.0
bool effects_enabled; // if false, use optimized simple mixer
config_t();
};
// Set configuration of buffer
virtual void config( const config_t& );
void set_depth( double );
public:
~Effects_Buffer();
const char *set_sample_rate( long samples_per_sec, int msec = blip_default_length );
void clock_rate( long );
void bass_freq( int );
void clear();
channel_t channel( int );
void end_frame( blip_time_t, bool was_stereo = true );
long read_samples( blip_sample_t*, long );
long samples_avail() const;
private:
typedef long fixed_t;
enum { max_buf_count = 7 };
Blip_Buffer bufs [max_buf_count];
enum { chan_count = 5 };
channel_t channels [chan_count];
config_t config_;
long stereo_remain;
long effect_remain;
int buf_count;
bool effects_enabled;
blip_sample_t* reverb_buf;
blip_sample_t* echo_buf;
int reverb_pos;
int echo_pos;
struct {
fixed_t pan_1_levels [2];
fixed_t pan_2_levels [2];
int echo_delay_l;
int echo_delay_r;
fixed_t echo_level;
int reverb_delay_l;
int reverb_delay_r;
fixed_t reverb_level;
} chans;
void mix_mono( blip_sample_t*, long );
void mix_stereo( blip_sample_t*, long );
void mix_enhanced( blip_sample_t*, long );
void mix_mono_enhanced( blip_sample_t*, long );
};
inline Effects_Buffer::channel_t Effects_Buffer::channel( int i ) {
return channels [i % chan_count];
}
#endif

349
source/quickerNES/apu/Multi_Buffer.cpp
View File

@ -1,7 +1,7 @@
// Blip_Buffer 0.4.0. http://www.slack.net/~ant/
#include "Multi_Buffer.h"
#include "Multi_Buffer.hpp"
#include <cstdint>
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
@ -15,30 +15,33 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
Multi_Buffer::Multi_Buffer( int spf ) : samples_per_frame_( spf )
namespace quickerNES
{
length_ = 0;
sample_rate_ = 0;
channels_changed_count_ = 1;
channels_changed_count_save_ = 1;
Multi_Buffer::Multi_Buffer(int spf) : samples_per_frame_(spf)
{
length_ = 0;
sample_rate_ = 0;
channels_changed_count_ = 1;
channels_changed_count_save_ = 1;
}
const char * Multi_Buffer::set_channel_count( int )
const char *Multi_Buffer::set_channel_count(int)
{
return 0;
return 0;
}
void Multi_Buffer::SaveAudioBufferStatePrivate()
{
channels_changed_count_save_ = channels_changed_count_;
channels_changed_count_save_ = channels_changed_count_;
}
void Multi_Buffer::RestoreAudioBufferStatePrivate()
{
channels_changed_count_ = channels_changed_count_save_;
channels_changed_count_ = channels_changed_count_save_;
}
Mono_Buffer::Mono_Buffer() : Multi_Buffer( 1 )
Mono_Buffer::Mono_Buffer() : Multi_Buffer(1)
{
}
@ -46,235 +49,239 @@ Mono_Buffer::~Mono_Buffer()
{
}
const char * Mono_Buffer::set_sample_rate( long rate, int msec )
const char *Mono_Buffer::set_sample_rate(long rate, int msec)
{
buf.set_sample_rate( rate, msec );
return Multi_Buffer::set_sample_rate( buf.sample_rate(), buf.length() );
buf.set_sample_rate(rate, msec);
return Multi_Buffer::set_sample_rate(buf.sample_rate(), buf.length());
}
void Mono_Buffer::SaveAudioBufferState()
{
SaveAudioBufferStatePrivate();
center()->SaveAudioBufferState();
SaveAudioBufferStatePrivate();
center()->SaveAudioBufferState();
}
void Mono_Buffer::RestoreAudioBufferState()
{
RestoreAudioBufferStatePrivate();
center()->RestoreAudioBufferState();
RestoreAudioBufferStatePrivate();
center()->RestoreAudioBufferState();
}
// Silent_Buffer
Silent_Buffer::Silent_Buffer() : Multi_Buffer( 1 ) // 0 channels would probably confuse
Silent_Buffer::Silent_Buffer() : Multi_Buffer(1) // 0 channels would probably confuse
{
chan.left = 0;
chan.center = 0;
chan.right = 0;
chan.left = 0;
chan.center = 0;
chan.right = 0;
}
void Silent_Buffer::SaveAudioBufferState()
{
SaveAudioBufferStatePrivate();
SaveAudioBufferStatePrivate();
}
void Silent_Buffer::RestoreAudioBufferState()
{
RestoreAudioBufferStatePrivate();
RestoreAudioBufferStatePrivate();
}
// Mono_Buffer
Mono_Buffer::channel_t Mono_Buffer::channel( int )
Mono_Buffer::channel_t Mono_Buffer::channel(int)
{
channel_t ch;
ch.center = &buf;
ch.left = &buf;
ch.right = &buf;
return ch;
channel_t ch;
ch.center = &buf;
ch.left = &buf;
ch.right = &buf;
return ch;
}
void Mono_Buffer::end_frame( blip_time_t t, bool )
void Mono_Buffer::end_frame(blip_time_t t, bool)
{
buf.end_frame( t );
buf.end_frame(t);
}
// Stereo_Buffer
Stereo_Buffer::Stereo_Buffer() : Multi_Buffer( 2 )
Stereo_Buffer::Stereo_Buffer() : Multi_Buffer(2)
{
chan.center = &bufs [0];
chan.left = &bufs [1];
chan.right = &bufs [2];
chan.center = &bufs[0];
chan.left = &bufs[1];
chan.right = &bufs[2];
}
Stereo_Buffer::~Stereo_Buffer()
{
}
const char * Stereo_Buffer::set_sample_rate( long rate, int msec )
const char *Stereo_Buffer::set_sample_rate(long rate, int msec)
{
for ( int i = 0; i < buf_count; i++ ) bufs [i].set_sample_rate( rate, msec ) ;
return Multi_Buffer::set_sample_rate( bufs [0].sample_rate(), bufs [0].length() );
for (int i = 0; i < buf_count; i++) bufs[i].set_sample_rate(rate, msec);
return Multi_Buffer::set_sample_rate(bufs[0].sample_rate(), bufs[0].length());
}
void Stereo_Buffer::clock_rate( long rate )
void Stereo_Buffer::clock_rate(long rate)
{
for ( int i = 0; i < buf_count; i++ )
bufs [i].clock_rate( rate );
for (int i = 0; i < buf_count; i++)
bufs[i].clock_rate(rate);
}
void Stereo_Buffer::bass_freq( int bass )
void Stereo_Buffer::bass_freq(int bass)
{
for ( unsigned i = 0; i < buf_count; i++ )
bufs [i].bass_freq( bass );
for (unsigned i = 0; i < buf_count; i++)
bufs[i].bass_freq(bass);
}
void Stereo_Buffer::clear()
{
stereo_added = false;
was_stereo = false;
for ( int i = 0; i < buf_count; i++ )
bufs [i].clear();
stereo_added = false;
was_stereo = false;
for (int i = 0; i < buf_count; i++)
bufs[i].clear();
}
void Stereo_Buffer::end_frame( blip_time_t clock_count, bool stereo )
void Stereo_Buffer::end_frame(blip_time_t clock_count, bool stereo)
{
for ( unsigned i = 0; i < buf_count; i++ )
bufs [i].end_frame( clock_count );
stereo_added |= stereo;
for (unsigned i = 0; i < buf_count; i++)
bufs[i].end_frame(clock_count);
stereo_added |= stereo;
}
long Stereo_Buffer::read_samples( blip_sample_t* out, long count )
long Stereo_Buffer::read_samples(blip_sample_t *out, long count)
{
count = (unsigned) count / 2;
long avail = bufs [0].samples_avail();
if ( count > avail )
count = avail;
if ( count )
{
if ( stereo_added || was_stereo )
{
mix_stereo( out, count );
bufs [0].remove_samples( count );
bufs [1].remove_samples( count );
bufs [2].remove_samples( count );
}
else
{
mix_mono( out, count );
bufs [0].remove_samples( count );
bufs [1].remove_silence( count );
bufs [2].remove_silence( count );
}
// to do: this might miss opportunities for optimization
if ( !bufs [0].samples_avail() ) {
was_stereo = stereo_added;
stereo_added = false;
}
}
return count * 2;
count = (unsigned)count / 2;
long avail = bufs[0].samples_avail();
if (count > avail)
count = avail;
if (count)
{
if (stereo_added || was_stereo)
{
mix_stereo(out, count);
bufs[0].remove_samples(count);
bufs[1].remove_samples(count);
bufs[2].remove_samples(count);
}
else
{
mix_mono(out, count);
bufs[0].remove_samples(count);
bufs[1].remove_silence(count);
bufs[2].remove_silence(count);
}
// to do: this might miss opportunities for optimization
if (!bufs[0].samples_avail())
{
was_stereo = stereo_added;
stereo_added = false;
}
}
return count * 2;
}
void Stereo_Buffer::mix_stereo( blip_sample_t* out, long count )
void Stereo_Buffer::mix_stereo(blip_sample_t *out, long count)
{
Blip_Reader left;
Blip_Reader right;
Blip_Reader center;
left.begin( bufs [1] );
right.begin( bufs [2] );
int bass = center.begin( bufs [0] );
if (out != 0)
{
while ( count-- )
{
int c = center.read();
long l = c + left.read();
long r = c + right.read();
center.next( bass );
out [0] = l;
out [1] = r;
out += 2;
if ( (int16_t) l != l )
out [-2] = 0x7FFF - (l >> 24);
left.next( bass );
right.next( bass );
if ( (int16_t) r != r )
out [-1] = 0x7FFF - (r >> 24);
}
}
else
{
//only run accumulators, do not output any audio
while (count--)
{
center.next(bass);
left.next(bass);
right.next(bass);
}
}
center.end( bufs [0] );
right.end( bufs [2] );
left.end( bufs [1] );
Blip_Reader left;
Blip_Reader right;
Blip_Reader center;
left.begin(bufs[1]);
right.begin(bufs[2]);
int bass = center.begin(bufs[0]);
if (out != 0)
{
while (count--)
{
int c = center.read();
long l = c + left.read();
long r = c + right.read();
center.next(bass);
out[0] = l;
out[1] = r;
out += 2;
if ((int16_t)l != l)
out[-2] = 0x7FFF - (l >> 24);
left.next(bass);
right.next(bass);
if ((int16_t)r != r)
out[-1] = 0x7FFF - (r >> 24);
}
}
else
{
// only run accumulators, do not output any audio
while (count--)
{
center.next(bass);
left.next(bass);
right.next(bass);
}
}
center.end(bufs[0]);
right.end(bufs[2]);
left.end(bufs[1]);
}
void Stereo_Buffer::mix_mono( blip_sample_t* out, long count )
void Stereo_Buffer::mix_mono(blip_sample_t *out, long count)
{
Blip_Reader in;
int bass = in.begin( bufs [0] );
if (out != 0)
{
while ( count-- )
{
long s = in.read();
in.next( bass );
out [0] = s;
out [1] = s;
out += 2;
if ( (int16_t) s != s ) {
s = 0x7FFF - (s >> 24);
out [-2] = s;
out [-1] = s;
}
}
}
else
{
while (count--)
{
in.next(bass);
}
}
in.end( bufs [0] );
Blip_Reader in;
int bass = in.begin(bufs[0]);
if (out != 0)
{
while (count--)
{
long s = in.read();
in.next(bass);
out[0] = s;
out[1] = s;
out += 2;
if ((int16_t)s != s)
{
s = 0x7FFF - (s >> 24);
out[-2] = s;
out[-1] = s;
}
}
}
else
{
while (count--)
{
in.next(bass);
}
}
in.end(bufs[0]);
}
void Stereo_Buffer::SaveAudioBufferState()
{
SaveAudioBufferStatePrivate();
left()->SaveAudioBufferState();
center()->SaveAudioBufferState();
right()->SaveAudioBufferState();
SaveAudioBufferStatePrivate();
left()->SaveAudioBufferState();
center()->SaveAudioBufferState();
right()->SaveAudioBufferState();
}
void Stereo_Buffer::RestoreAudioBufferState()
{
RestoreAudioBufferStatePrivate();
left()->RestoreAudioBufferState();
center()->RestoreAudioBufferState();
right()->RestoreAudioBufferState();
RestoreAudioBufferStatePrivate();
left()->RestoreAudioBufferState();
center()->RestoreAudioBufferState();
right()->RestoreAudioBufferState();
}
} // namespace quickNES

189
source/quickerNES/apu/Multi_Buffer.h
View File

@ -1,189 +0,0 @@
// Multi-channel sound buffer interface, and basic mono and stereo buffers
// Blip_Buffer 0.4.0
#ifndef MULTI_BUFFER_H
#define MULTI_BUFFER_H
#include "Blip_Buffer.h"
// Interface to one or more Blip_Buffers mapped to one or more channels
// consisting of left, center, and right buffers.
class Multi_Buffer {
public:
Multi_Buffer( int samples_per_frame );
virtual ~Multi_Buffer() { }
// Set the number of channels available
virtual const char* set_channel_count( int );
// Get indexed channel, from 0 to channel count - 1
struct channel_t {
Blip_Buffer* center;
Blip_Buffer* left;
Blip_Buffer* right;
};
virtual channel_t channel( int index ) = 0;
// See Blip_Buffer.h
virtual const char* set_sample_rate( long rate, int msec = blip_default_length ) = 0;
virtual void clock_rate( long ) = 0;
virtual void bass_freq( int ) = 0;
virtual void clear() = 0;
long sample_rate() const;
// Length of buffer, in milliseconds
int length() const;
// See Blip_Buffer.h. For optimal operation, pass false for 'added_stereo'
// if nothing was added to the left and right buffers of any channel for
// this time frame.
virtual void end_frame( blip_time_t, bool added_stereo = true ) = 0;
// Number of samples per output frame (1 = mono, 2 = stereo)
int samples_per_frame() const;
// Count of changes to channel configuration. Incremented whenever
// a change is made to any of the Blip_Buffers for any channel.
unsigned channels_changed_count() { return channels_changed_count_; }
// See Blip_Buffer.h
virtual long read_samples( blip_sample_t*, long ) = 0;
virtual long samples_avail() const = 0;
protected:
void channels_changed() { channels_changed_count_++; }
private:
// noncopyable
Multi_Buffer( const Multi_Buffer& );
Multi_Buffer& operator = ( const Multi_Buffer& );
unsigned channels_changed_count_;
long sample_rate_;
int length_;
int const samples_per_frame_;
unsigned channels_changed_count_save_;
protected:
void SaveAudioBufferStatePrivate();
void RestoreAudioBufferStatePrivate();
public:
virtual void SaveAudioBufferState() = 0;
virtual void RestoreAudioBufferState() = 0;
};
// Uses a single buffer and outputs mono samples.
class Mono_Buffer : public Multi_Buffer {
Blip_Buffer buf;
public:
Mono_Buffer();
~Mono_Buffer();
// Buffer used for all channels
Blip_Buffer* center() { return &buf; }
// See Multi_Buffer
const char* set_sample_rate( long rate, int msec = blip_default_length );
void clock_rate( long );
void bass_freq( int );
void clear();
channel_t channel( int );
void end_frame( blip_time_t, bool unused = true );
long samples_avail() const;
long read_samples( blip_sample_t*, long );
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
// Uses three buffers (one for center) and outputs stereo sample pairs.
class Stereo_Buffer : public Multi_Buffer {
public:
Stereo_Buffer();
~Stereo_Buffer();
// Buffers used for all channels
Blip_Buffer* center() { return &bufs [0]; }
Blip_Buffer* left() { return &bufs [1]; }
Blip_Buffer* right() { return &bufs [2]; }
// See Multi_Buffer
const char* set_sample_rate( long, int msec = blip_default_length );
void clock_rate( long );
void bass_freq( int );
void clear();
channel_t channel( int index );
void end_frame( blip_time_t, bool added_stereo = true );
long samples_avail() const;
long read_samples( blip_sample_t*, long );
private:
enum { buf_count = 3 };
Blip_Buffer bufs [buf_count];
channel_t chan;
bool stereo_added;
bool was_stereo;
void mix_stereo( blip_sample_t*, long );
void mix_mono( blip_sample_t*, long );
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
// Silent_Buffer generates no samples, useful where no sound is wanted
class Silent_Buffer : public Multi_Buffer {
channel_t chan;
public:
Silent_Buffer();
const char* set_sample_rate( long rate, int msec = blip_default_length );
void clock_rate( long ) { }
void bass_freq( int ) { }
void clear() { }
channel_t channel( int ) { return chan; }
void end_frame( blip_time_t, bool unused = true ) { }
long samples_avail() const { return 0; }
long read_samples( blip_sample_t*, long ) { return 0; }
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
// End of public interface
inline const char* Multi_Buffer::set_sample_rate( long rate, int msec )
{
sample_rate_ = rate;
length_ = msec;
return 0;
}
inline const char* Silent_Buffer::set_sample_rate( long rate, int msec )
{
return Multi_Buffer::set_sample_rate( rate, msec );
}
inline int Multi_Buffer::samples_per_frame() const { return samples_per_frame_; }
inline long Stereo_Buffer::samples_avail() const { return bufs [0].samples_avail() * 2; }
inline Stereo_Buffer::channel_t Stereo_Buffer::channel( int ) { return chan; }
inline long Multi_Buffer::sample_rate() const { return sample_rate_; }
inline int Multi_Buffer::length() const { return length_; }
inline void Mono_Buffer::clock_rate( long rate ) { buf.clock_rate( rate ); }
inline void Mono_Buffer::clear() { buf.clear(); }
inline void Mono_Buffer::bass_freq( int freq ) { buf.bass_freq( freq ); }
inline long Mono_Buffer::read_samples( blip_sample_t* p, long s ) { return buf.read_samples( p, s ); }
inline long Mono_Buffer::samples_avail() const { return buf.samples_avail(); }
#endif

202
source/quickerNES/apu/Multi_Buffer.hpp Normal file
View File

@ -0,0 +1,202 @@
#pragma once
// Multi-channel sound buffer interface, and basic mono and stereo buffers
// Blip_Buffer 0.4.0
#include "Blip_Buffer.hpp"
namespace quickerNES
{
// Interface to one or more Blip_Buffers mapped to one or more channels
// consisting of left, center, and right buffers.
class Multi_Buffer
{
public:
Multi_Buffer(int samples_per_frame);
virtual ~Multi_Buffer() {}
// Set the number of channels available
virtual const char *set_channel_count(int);
// Get indexed channel, from 0 to channel count - 1
struct channel_t
{
Blip_Buffer *center;
Blip_Buffer *left;
Blip_Buffer *right;
};
virtual channel_t channel(int index) = 0;
// See Blip_Buffer.h
virtual const char *set_sample_rate(long rate, int msec = blip_default_length) = 0;
virtual void clock_rate(long) = 0;
virtual void bass_freq(int) = 0;
virtual void clear() = 0;
long sample_rate() const;
// Length of buffer, in milliseconds
int length() const;
// See Blip_Buffer.h. For optimal operation, pass false for 'added_stereo'
// if nothing was added to the left and right buffers of any channel for
// this time frame.
virtual void end_frame(blip_time_t, bool added_stereo = true) = 0;
// Number of samples per output frame (1 = mono, 2 = stereo)
int samples_per_frame() const;
// Count of changes to channel configuration. Incremented whenever
// a change is made to any of the Blip_Buffers for any channel.
unsigned channels_changed_count() { return channels_changed_count_; }
// See Blip_Buffer.h
virtual long read_samples(blip_sample_t *, long) = 0;
virtual long samples_avail() const = 0;
protected:
void channels_changed() { channels_changed_count_++; }
private:
// noncopyable
Multi_Buffer(const Multi_Buffer &);
Multi_Buffer &operator=(const Multi_Buffer &);
unsigned channels_changed_count_;
long sample_rate_;
int length_;
int const samples_per_frame_;
unsigned channels_changed_count_save_;
protected:
void SaveAudioBufferStatePrivate();
void RestoreAudioBufferStatePrivate();
public:
virtual void SaveAudioBufferState() = 0;
virtual void RestoreAudioBufferState() = 0;
};
// Uses a single buffer and outputs mono samples.
class Mono_Buffer : public Multi_Buffer
{
Blip_Buffer buf;
public:
Mono_Buffer();
~Mono_Buffer();
// Buffer used for all channels
Blip_Buffer *center() { return &buf; }
// See Multi_Buffer
const char *set_sample_rate(long rate, int msec = blip_default_length);
void clock_rate(long);
void bass_freq(int);
void clear();
channel_t channel(int);
void end_frame(blip_time_t, bool unused = true);
long samples_avail() const;
long read_samples(blip_sample_t *, long);
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
// Uses three buffers (one for center) and outputs stereo sample pairs.
class Stereo_Buffer : public Multi_Buffer
{
public:
Stereo_Buffer();
~Stereo_Buffer();
// Buffers used for all channels
Blip_Buffer *center() { return &bufs[0]; }
Blip_Buffer *left() { return &bufs[1]; }
Blip_Buffer *right() { return &bufs[2]; }
// See Multi_Buffer
const char *set_sample_rate(long, int msec = blip_default_length);
void clock_rate(long);
void bass_freq(int);
void clear();
channel_t channel(int index);
void end_frame(blip_time_t, bool added_stereo = true);
long samples_avail() const;
long read_samples(blip_sample_t *, long);
private:
enum
{
buf_count = 3
};
Blip_Buffer bufs[buf_count];
channel_t chan;
bool stereo_added;
bool was_stereo;
void mix_stereo(blip_sample_t *, long);
void mix_mono(blip_sample_t *, long);
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
// Silent_Buffer generates no samples, useful where no sound is wanted
class Silent_Buffer : public Multi_Buffer
{
channel_t chan;
public:
Silent_Buffer();
const char *set_sample_rate(long rate, int msec = blip_default_length);
void clock_rate(long) {}
void bass_freq(int) {}
void clear() {}
channel_t channel(int) { return chan; }
void end_frame(blip_time_t, bool unused = true) {}
long samples_avail() const { return 0; }
long read_samples(blip_sample_t *, long) { return 0; }
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
// End of public interface
inline const char *Multi_Buffer::set_sample_rate(long rate, int msec)
{
sample_rate_ = rate;
length_ = msec;
return 0;
}
inline const char *Silent_Buffer::set_sample_rate(long rate, int msec)
{
return Multi_Buffer::set_sample_rate(rate, msec);
}
inline int Multi_Buffer::samples_per_frame() const { return samples_per_frame_; }
inline long Stereo_Buffer::samples_avail() const { return bufs[0].samples_avail() * 2; }
inline Stereo_Buffer::channel_t Stereo_Buffer::channel(int) { return chan; }
inline long Multi_Buffer::sample_rate() const { return sample_rate_; }
inline int Multi_Buffer::length() const { return length_; }
inline void Mono_Buffer::clock_rate(long rate) { buf.clock_rate(rate); }
inline void Mono_Buffer::clear() { buf.clear(); }
inline void Mono_Buffer::bass_freq(int freq) { buf.bass_freq(freq); }
inline long Mono_Buffer::read_samples(blip_sample_t *p, long s) { return buf.read_samples(p, s); }
inline long Mono_Buffer::samples_avail() const { return buf.samples_avail(); }
} // namespace quickNES

91
source/quickerNES/apu/NESEffectsBuffer.cpp Normal file
View File

@ -0,0 +1,91 @@
// Nes_Emu 0.7.0. http://www.slack.net/~ant/libs/
#include "apu/NESEffectsBuffer.hpp"
#include "apu/apu.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
Nes_Effects_Buffer::Nes_Effects_Buffer() : Effects_Buffer(true) // nes never uses stereo channels
{
config_t c;
c.effects_enabled = false;
config(c);
}
Nes_Effects_Buffer::~Nes_Effects_Buffer() {}
Multi_Buffer *set_apu(Nes_Effects_Buffer *buf, Apu *apu)
{
buf->set_apu(apu);
return buf;
}
void Nes_Effects_Buffer::enable_nonlinearity(bool b)
{
if (b) clear();
Apu *apu = nonlin.enable(b, channel(2).center);
apu->osc_output(0, channel(0).center);
apu->osc_output(1, channel(1).center);
}
void Nes_Effects_Buffer::config(const config_t &in)
{
config_t c = in;
if (!c.effects_enabled)
{
// effects must always be enabled to keep separate buffers, so
// set parameters to be equivalent to disabled
c.pan_1 = 0;
c.pan_2 = 0;
c.echo_level = 0;
c.reverb_level = 0;
c.effects_enabled = true;
}
Effects_Buffer::config(c);
}
const char *Nes_Effects_Buffer::set_sample_rate(long rate, int msec)
{
enable_nonlinearity(nonlin.enabled); // reapply
return Effects_Buffer::set_sample_rate(rate, msec);
}
void Nes_Effects_Buffer::clear()
{
nonlin.clear();
Effects_Buffer::clear();
}
Nes_Effects_Buffer::channel_t Nes_Effects_Buffer::channel(int i)
{
return Effects_Buffer::channel((2 <= i && i <= 4) ? 2 : i & 1);
}
long Nes_Effects_Buffer::read_samples(blip_sample_t *out, long count)
{
count = 2 * nonlin.make_nonlinear(*channel(2).center, count / 2);
return Effects_Buffer::read_samples(out, count);
}
void Nes_Effects_Buffer::SaveAudioBufferState()
{
}
void Nes_Effects_Buffer::RestoreAudioBufferState()
{
}
} // namespace quickNES

41
source/quickerNES/apu/NESEffectsBuffer.hpp Normal file
View File

@ -0,0 +1,41 @@
#pragma once
// Effects_Buffer with non-linear sound
// Nes_Emu 0.7.0
#include "effectsBuffer.hpp"
#include "buffer.hpp"
namespace quickerNES
{
// Effects_Buffer uses several buffers and outputs stereo sample pairs.
class Nes_Effects_Buffer : public Effects_Buffer
{
public:
Nes_Effects_Buffer();
~Nes_Effects_Buffer();
// Setup APU for use with buffer, including setting its output to this buffer.
// If you're using Nes_Emu, this is automatically called for you.
void set_apu(Apu *apu) { nonlin.set_apu(apu); }
// Enable/disable non-linear output
void enable_nonlinearity(bool = true);
// See Effects_Buffer.h for reference
const char *set_sample_rate(long rate, int msec = blip_default_length);
void config(const config_t &);
void clear();
channel_t channel(int);
long read_samples(blip_sample_t *, long);
void SaveAudioBufferState();
void RestoreAudioBufferState();
private:
Nonlinearizer nonlin;
friend Multi_Buffer *set_apu(Nes_Effects_Buffer *, Apu *);
};
} // namespace quickNES

233
source/quickerNES/apu/Nes_Buffer.cpp
View File

@ -1,233 +0,0 @@
// Nes_Emu 0.7.0. http://www.slack.net/~ant/libs/
#include "apu/Nes_Buffer.h"
#include "apu/apu.h"
/* Library Copyright (C) 2003-2006 Shay Green. This library is free software;
you can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for more
details. You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Nes_Buffer
Nes_Buffer::Nes_Buffer() : Multi_Buffer( 1 ) { }
Nes_Buffer::~Nes_Buffer() { }
Multi_Buffer* set_apu( Nes_Buffer* buf, Nes_Apu* apu )
{
buf->set_apu( apu );
return buf;
}
void Nes_Buffer::enable_nonlinearity( bool b )
{
if ( b )
clear();
Nes_Apu* apu = nonlin.enable( b, &tnd );
apu->osc_output( 0, &buf );
apu->osc_output( 1, &buf );
}
const char * Nes_Buffer::set_sample_rate( long rate, int msec )
{
enable_nonlinearity( nonlin.enabled ); // reapply
buf.set_sample_rate( rate, msec );
tnd.set_sample_rate( rate, msec );
return Multi_Buffer::set_sample_rate( buf.sample_rate(), buf.length() );
}
void Nes_Buffer::clock_rate( long rate )
{
buf.clock_rate( rate );
tnd.clock_rate( rate );
}
void Nes_Buffer::bass_freq( int freq )
{
buf.bass_freq( freq );
tnd.bass_freq( freq );
}
void Nes_Buffer::clear()
{
nonlin.clear();
buf.clear();
tnd.clear();
}
Nes_Buffer::channel_t Nes_Buffer::channel( int i )
{
channel_t c;
c.center = &buf;
if ( 2 <= i && i <= 4 )
c.center = &tnd; // only use for triangle, noise, and dmc
c.left = c.center;
c.right = c.center;
return c;
}
void Nes_Buffer::end_frame( blip_time_t length, bool )
{
buf.end_frame( length );
tnd.end_frame( length );
}
long Nes_Buffer::samples_avail() const
{
return buf.samples_avail();
}
long Nes_Buffer::read_samples( blip_sample_t* out, long count )
{
count = nonlin.make_nonlinear( tnd, count );
if ( count )
{
Blip_Reader lin;
Blip_Reader nonlin;
int lin_bass = lin.begin( buf );
int nonlin_bass = nonlin.begin( tnd );
if (out != 0)
{
for ( int n = count; n--; )
{
int s = lin.read() + nonlin.read();
lin.next( lin_bass );
nonlin.next( nonlin_bass );
*out++ = s;
if ( (int16_t) s != s )
out [-1] = 0x7FFF - (s >> 24);
}
}
else
{
//only run accumulators, do not output audio
for (int n = count; n--; )
{
lin.next(lin_bass);
nonlin.next(nonlin_bass);
}
}
lin.end( buf );
nonlin.end( tnd );
buf.remove_samples( count );
tnd.remove_samples( count );
}
return count;
}
void Nes_Buffer::SaveAudioBufferState()
{
SaveAudioBufferStatePrivate();
nonlin.SaveAudioBufferState();
buf.SaveAudioBufferState();
tnd.SaveAudioBufferState();
}
void Nes_Buffer::RestoreAudioBufferState()
{
RestoreAudioBufferStatePrivate();
nonlin.RestoreAudioBufferState();
buf.RestoreAudioBufferState();
tnd.RestoreAudioBufferState();
}
// Nes_Nonlinearizer
Nes_Nonlinearizer::Nes_Nonlinearizer()
{
apu = nullptr;
enabled = true;
float const gain = 0x7fff * 1.3f;
// don't use entire range, so any overflow will stay within table
int const range = (int) ( (double)table_size * Nes_Apu::nonlinear_tnd_gain());
for ( int i = 0; i < table_size; i++ )
{
int const offset = table_size - range;
int j = i - offset;
float n = 202.0f / (range - 1) * j;
float d = 0;
// Prevent division by zero
if ( n )
d = gain * 163.67f / (24329.0f / n + 100.0f);
int out = (int) d;
table [j & (table_size - 1)] = out;
}
extra_accum = 0;
extra_prev = 0;
}
Nes_Apu* Nes_Nonlinearizer::enable( bool b, Blip_Buffer* buf )
{
apu->osc_output( 2, buf );
apu->osc_output( 3, buf );
apu->osc_output( 4, buf );
enabled = b;
if ( b )
apu->enable_nonlinear( 1.0 );
else
apu->volume( 1.0 );
return apu;
}
#define ENTRY( s ) table [(s) >> (blip_sample_bits - table_bits - 1) & (table_size - 1)]
long Nes_Nonlinearizer::make_nonlinear( Blip_Buffer& buf, long count )
{
long avail = buf.samples_avail();
if ( count > avail )
count = avail;
if ( count && enabled )
{
Blip_Buffer::buf_t_* p = buf.buffer_;
long accum = this->accum;
long prev = this->prev;
for ( unsigned n = count; n; --n )
{
long entry = ENTRY( accum );
accum += *p;
*p++ = (entry - prev) << (blip_sample_bits - 16);
prev = entry;
}
this->prev = prev;
this->accum = accum;
}
return count;
}
void Nes_Nonlinearizer::clear()
{
accum = 0;
prev = ENTRY( 86016000 ); // avoid thump due to APU's triangle dc bias
// TODO: still results in slight clicks and thumps
}
void Nes_Nonlinearizer::SaveAudioBufferState()
{
extra_accum = accum;
extra_prev = prev;
}
void Nes_Nonlinearizer::RestoreAudioBufferState()
{
accum = extra_accum;
prev = extra_prev;
}

72
source/quickerNES/apu/Nes_Buffer.h
View File

@ -1,72 +0,0 @@
// NES non-linear audio buffer
// Nes_Emu 0.7.0
#ifndef NES_BUFFER_H
#define NES_BUFFER_H
#include "Multi_Buffer.h"
#include <cstdint>
class Nes_Apu;
class Nes_Nonlinearizer {
private:
enum { table_bits = 11 };
enum { table_size = 1 << table_bits };
int16_t table [table_size];
Nes_Apu* apu;
long accum;
long prev;
long extra_accum;
long extra_prev;
public:
Nes_Nonlinearizer();
bool enabled;
void clear();
void set_apu( Nes_Apu* a ) { apu = a; }
Nes_Apu* enable( bool, Blip_Buffer* tnd );
long make_nonlinear( Blip_Buffer& buf, long count );
void SaveAudioBufferState();
void RestoreAudioBufferState();
};
class Nes_Buffer : public Multi_Buffer {
public:
Nes_Buffer();
~Nes_Buffer();
// Setup APU for use with buffer, including setting its output to this buffer.
// If you're using Nes_Emu, this is automatically called for you.
void set_apu( Nes_Apu* apu ) { nonlin.set_apu( apu ); }
// Enable/disable non-linear output
void enable_nonlinearity( bool = true );
// Blip_Buffer to output other sound chips to
Blip_Buffer* buffer() { return &buf; }
// See Multi_Buffer.h
const char *set_sample_rate( long rate, int msec = blip_default_length );
void clock_rate( long );
void bass_freq( int );
void clear();
channel_t channel( int );
void end_frame( blip_time_t, bool unused = true );
long samples_avail() const;
long read_samples( blip_sample_t*, long );
private:
Blip_Buffer buf;
Blip_Buffer tnd;
Nes_Nonlinearizer nonlin;
friend Multi_Buffer* set_apu( Nes_Buffer*, Nes_Apu* );
public:
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
#endif

88
source/quickerNES/apu/Nes_Effects_Buffer.cpp
View File

@ -1,88 +0,0 @@
// Nes_Emu 0.7.0. http://www.slack.net/~ant/libs/
#include "apu/Nes_Effects_Buffer.h"
#include "apu/apu.h"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
Nes_Effects_Buffer::Nes_Effects_Buffer() :
Effects_Buffer( true ) // nes never uses stereo channels
{
config_t c;
c.effects_enabled = false;
config( c );
}
Nes_Effects_Buffer::~Nes_Effects_Buffer() { }
Multi_Buffer* set_apu( Nes_Effects_Buffer* buf, Nes_Apu* apu )
{
buf->set_apu( apu );
return buf;
}
void Nes_Effects_Buffer::enable_nonlinearity( bool b )
{
if ( b )
clear();
Nes_Apu* apu = nonlin.enable( b, channel( 2 ).center );
apu->osc_output( 0, channel( 0 ).center );
apu->osc_output( 1, channel( 1 ).center );
}
void Nes_Effects_Buffer::config( const config_t& in )
{
config_t c = in;
if ( !c.effects_enabled )
{
// effects must always be enabled to keep separate buffers, so
// set parameters to be equivalent to disabled
c.pan_1 = 0;
c.pan_2 = 0;
c.echo_level = 0;
c.reverb_level = 0;
c.effects_enabled = true;
}
Effects_Buffer::config( c );
}
const char * Nes_Effects_Buffer::set_sample_rate( long rate, int msec )
{
enable_nonlinearity( nonlin.enabled ); // reapply
return Effects_Buffer::set_sample_rate( rate, msec );
}
void Nes_Effects_Buffer::clear()
{
nonlin.clear();
Effects_Buffer::clear();
}
Nes_Effects_Buffer::channel_t Nes_Effects_Buffer::channel( int i )
{
return Effects_Buffer::channel( (2 <= i && i <= 4) ? 2 : i & 1 );
}
long Nes_Effects_Buffer::read_samples( blip_sample_t* out, long count )
{
count = 2 * nonlin.make_nonlinear( *channel( 2 ).center, count / 2 );
return Effects_Buffer::read_samples( out, count );
}
void Nes_Effects_Buffer::SaveAudioBufferState()
{
}
void Nes_Effects_Buffer::RestoreAudioBufferState()
{
}

40
source/quickerNES/apu/Nes_Effects_Buffer.h
View File

@ -1,40 +0,0 @@
// Effects_Buffer with non-linear sound
// Nes_Emu 0.7.0
#ifndef NES_EFFECTS_BUFFER_H
#define NES_EFFECTS_BUFFER_H
#include "Nes_Buffer.h"
#include "Effects_Buffer.h"
// Effects_Buffer uses several buffers and outputs stereo sample pairs.
class Nes_Effects_Buffer : public Effects_Buffer {
public:
Nes_Effects_Buffer();
~Nes_Effects_Buffer();
// Setup APU for use with buffer, including setting its output to this buffer.
// If you're using Nes_Emu, this is automatically called for you.
void set_apu( Nes_Apu* apu ) { nonlin.set_apu( apu ); }
// Enable/disable non-linear output
void enable_nonlinearity( bool = true );
// See Effects_Buffer.h for reference
const char *set_sample_rate( long rate, int msec = blip_default_length );
void config( const config_t& );
void clear();
channel_t channel( int );
long read_samples( blip_sample_t*, long );
void SaveAudioBufferState();
void RestoreAudioBufferState();
private:
Nes_Nonlinearizer nonlin;
friend Multi_Buffer* set_apu( Nes_Effects_Buffer*, Nes_Apu* );
};
#endif

533
source/quickerNES/apu/Nes_Oscs.cpp
View File

@ -1,533 +0,0 @@
// Nes_Snd_Emu 0.1.7. http://www.slack.net/~ant/
#include "apu.h"
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Nes_Osc
void Nes_Osc::clock_length( int halt_mask )
{
if ( length_counter && !(regs [0] & halt_mask) )
length_counter--;
}
void Nes_Envelope::clock_envelope()
{
int period = regs [0] & 15;
if ( reg_written [3] ) {
reg_written [3] = false;
env_delay = period;
envelope = 15;
}
else if ( --env_delay < 0 ) {
env_delay = period;
if ( envelope | (regs [0] & 0x20) )
envelope = (envelope - 1) & 15;
}
}
int Nes_Envelope::volume() const
{
return length_counter == 0 ? 0 : (regs [0] & 0x10) ? (regs [0] & 15) : envelope;
}
// Nes_Square
void Nes_Square::clock_sweep( int negative_adjust )
{
int sweep = regs [1];
if ( --sweep_delay < 0 )
{
reg_written [1] = true;
int period = this->period();
int shift = sweep & shift_mask;
if ( shift && (sweep & 0x80) && period >= 8 )
{
int offset = period >> shift;
if ( sweep & negate_flag )
offset = negative_adjust - offset;
if ( period + offset < 0x800 )
{
period += offset;
// rewrite period
regs [2] = period & 0xff;
regs [3] = (regs [3] & ~7) | ((period >> 8) & 7);
}
}
}
if ( reg_written [1] ) {
reg_written [1] = false;
sweep_delay = (sweep >> 4) & 7;
}
}
// TODO: clean up
inline nes_time_t Nes_Square::maintain_phase( nes_time_t time, nes_time_t end_time,
nes_time_t timer_period )
{
long remain = end_time - time;
if ( remain > 0 )
{
int count = (remain + timer_period - 1) / timer_period;
phase = (phase + count) & (phase_range - 1);
time += (long) count * timer_period;
}
return time;
}
void Nes_Square::run( nes_time_t time, nes_time_t end_time )
{
const int period = this->period();
const int timer_period = (period + 1) * 2;
if ( !output )
{
delay = maintain_phase( time + delay, end_time, timer_period ) - end_time;
return;
}
int offset = period >> (regs [1] & shift_mask);
if ( regs [1] & negate_flag )
offset = 0;
const int volume = this->volume();
if ( volume == 0 || period < 8 || (period + offset) >= 0x800 )
{
if ( last_amp ) {
synth.offset( time, -last_amp, output );
last_amp = 0;
}
time += delay;
time = maintain_phase( time, end_time, timer_period );
}
else
{
// handle duty select
int duty_select = (regs [0] >> 6) & 3;
int duty = 1 << duty_select; // 1, 2, 4, 2
int amp = 0;
if ( duty_select == 3 ) {
duty = 2; // negated 25%
amp = volume;
}
if ( phase < duty )
amp ^= volume;
int delta = update_amp( amp );
if ( delta )
synth.offset( time, delta, output );
time += delay;
if ( time < end_time )
{
Blip_Buffer* const output = this->output;
const Synth& synth = this->synth;
int delta = amp * 2 - volume;
int phase = this->phase;
do {
phase = (phase + 1) & (phase_range - 1);
if ( phase == 0 || phase == duty ) {
delta = -delta;
synth.offset_inline( time, delta, output );
}
time += timer_period;
}
while ( time < end_time );
last_amp = (delta + volume) >> 1;
this->phase = phase;
}
}
delay = time - end_time;
}
// Nes_Triangle
void Nes_Triangle::clock_linear_counter()
{
if ( reg_written [3] )
linear_counter = regs [0] & 0x7f;
else if ( linear_counter )
linear_counter--;
if ( !(regs [0] & 0x80) )
reg_written [3] = false;
}
inline int Nes_Triangle::calc_amp() const
{
int amp = phase_range - phase;
if ( amp < 0 )
amp = phase - (phase_range + 1);
return amp;
}
// TODO: clean up
inline nes_time_t Nes_Triangle::maintain_phase( nes_time_t time, nes_time_t end_time,
nes_time_t timer_period )
{
long remain = end_time - time;
if ( remain > 0 )
{
int count = (remain + timer_period - 1) / timer_period;
phase = ((unsigned) phase + 1 - count) & (phase_range * 2 - 1);
phase++;
time += (long) count * timer_period;
}
return time;
}
void Nes_Triangle::run( nes_time_t time, nes_time_t end_time )
{
const int timer_period = period() + 1;
if ( !output )
{
time += delay;
delay = 0;
if ( length_counter && linear_counter && timer_period >= 3 )
delay = maintain_phase( time, end_time, timer_period ) - end_time;
return;
}
// to do: track phase when period < 3
// to do: Output 7.5 on dac when period < 2? More accurate, but results in more clicks.
int delta = update_amp( calc_amp() );
if ( delta )
synth.offset( time, delta, output );
time += delay;
if ( length_counter == 0 || linear_counter == 0 || timer_period < 3 )
{
time = end_time;
}
else if ( time < end_time )
{
Blip_Buffer* const output = this->output;
int phase = this->phase;
int volume = 1;
if ( phase > phase_range ) {
phase -= phase_range;
volume = -volume;
}
do {
if ( --phase == 0 ) {
phase = phase_range;
volume = -volume;
}
else {
synth.offset_inline( time, volume, output );
}
time += timer_period;
}
while ( time < end_time );
if ( volume < 0 )
phase += phase_range;
this->phase = phase;
last_amp = calc_amp();
}
delay = time - end_time;
}
// Nes_Dmc
void Nes_Dmc::reset()
{
address = 0;
dac = 0;
buf = 0;
bits_remain = 1;
bits = 0;
buf_full = false;
silence = true;
next_irq = Nes_Apu::no_irq;
irq_flag = false;
irq_enabled = false;
Nes_Osc::reset();
period = 0x1ac;
}
void Nes_Dmc::recalc_irq()
{
nes_time_t irq = Nes_Apu::no_irq;
if ( irq_enabled && length_counter )
irq = apu->last_dmc_time + delay +
((length_counter - 1) * 8 + bits_remain - 1) * nes_time_t (period) + 1;
if ( irq != next_irq ) {
next_irq = irq;
apu->irq_changed();
}
}
int Nes_Dmc::count_reads( nes_time_t time, nes_time_t* last_read ) const
{
if ( last_read )
*last_read = time;
if ( length_counter == 0 )
return 0; // not reading
long first_read = next_read_time();
long avail = time - first_read;
if ( avail <= 0 )
return 0;
int count = (avail - 1) / (period * 8) + 1;
if ( !(regs [0] & loop_flag) && count > length_counter )
count = length_counter;
if ( last_read )
*last_read = first_read + (count - 1) * (period * 8) + 1;
return count;
}
static const short dmc_period_table [2] [16] = {
{0x1ac, 0x17c, 0x154, 0x140, 0x11e, 0x0fe, 0x0e2, 0x0d6, // NTSC
0x0be, 0x0a0, 0x08e, 0x080, 0x06a, 0x054, 0x048, 0x036},
{0x18e, 0x161, 0x13c, 0x129, 0x10a, 0x0ec, 0x0d2, 0x0c7, // PAL (totally untested)
0x0b1, 0x095, 0x084, 0x077, 0x062, 0x04e, 0x043, 0x032} // to do: verify PAL periods
};
inline void Nes_Dmc::reload_sample()
{
address = 0x4000 + regs [2] * 0x40;
length_counter = regs [3] * 0x10 + 1;
}
static const unsigned char dac_table [128] =
{
0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9,10,11,12,13,14,
15,15,16,17,18,19,20,20,21,22,23,24,24,25,26,27,
27,28,29,30,31,31,32,33,33,34,35,36,36,37,38,38,
39,40,41,41,42,43,43,44,45,45,46,47,47,48,48,49,
50,50,51,52,52,53,53,54,55,55,56,56,57,58,58,59,
59,60,60,61,61,62,63,63,64,64,65,65,66,66,67,67,
68,68,69,70,70,71,71,72,72,73,73,74,74,75,75,75,
76,76,77,77,78,78,79,79,80,80,81,81,82,82,82,83,
};
void Nes_Dmc::write_register( int addr, int data )
{
if ( addr == 0 )
{
period = dmc_period_table [pal_mode] [data & 15];
irq_enabled = (data & 0xc0) == 0x80; // enabled only if loop disabled
irq_flag &= irq_enabled;
recalc_irq();
}
else if ( addr == 1 )
{
int old_dac = dac;
dac = data & 0x7F;
// adjust last_amp so that "pop" amplitude will be properly non-linear
// with respect to change in dac
int faked_nonlinear = dac - (dac_table [dac] - dac_table [old_dac]);
if ( !nonlinear )
last_amp = faked_nonlinear;
}
}
void Nes_Dmc::start()
{
reload_sample();
fill_buffer();
recalc_irq();
}
void Nes_Dmc::fill_buffer()
{
if ( !buf_full && length_counter )
{
buf = prg_reader( prg_reader_data, 0x8000u + address );
address = (address + 1) & 0x7FFF;
buf_full = true;
if ( --length_counter == 0 )
{
if ( regs [0] & loop_flag ) {
reload_sample();
}
else {
apu->osc_enables &= ~0x10;
irq_flag = irq_enabled;
next_irq = Nes_Apu::no_irq;
apu->irq_changed();
}
}
}
}
void Nes_Dmc::run( nes_time_t time, nes_time_t end_time )
{
int delta = update_amp( dac );
if ( !output )
silence = true;
else if ( delta )
synth.offset( time, delta, output );
time += delay;
if ( time < end_time )
{
int bits_remain = this->bits_remain;
if ( silence && !buf_full )
{
int count = (end_time - time + period - 1) / period;
bits_remain = (bits_remain - 1 + 8 - (count % 8)) % 8 + 1;
time += count * period;
}
else
{
Blip_Buffer* const output = this->output;
const int period = this->period;
int bits = this->bits;
int dac = this->dac;
do
{
if ( !silence )
{
int step = (bits & 1) * 4 - 2;
bits >>= 1;
if ( unsigned (dac + step) <= 0x7F ) {
dac += step;
synth.offset_inline( time, step, output );
}
}
time += period;
if ( --bits_remain == 0 )
{
bits_remain = 8;
if ( !buf_full ) {
silence = true;
}
else {
silence = false;
bits = buf;
buf_full = false;
if ( !output )
silence = true;
fill_buffer();
}
}
}
while ( time < end_time );
this->dac = dac;
this->last_amp = dac;
this->bits = bits;
}
this->bits_remain = bits_remain;
}
delay = time - end_time;
}
// Nes_Noise
static const short noise_period_table [16] = {
0x004, 0x008, 0x010, 0x020, 0x040, 0x060, 0x080, 0x0A0,
0x0CA, 0x0FE, 0x17C, 0x1FC, 0x2FA, 0x3F8, 0x7F2, 0xFE4
};
void Nes_Noise::run( nes_time_t time, nes_time_t end_time )
{
int period = noise_period_table [regs [2] & 15];
#if NES_APU_NOISE_LOW_CPU
if ( period < 8 )
{
period = 8;
}
#endif
if ( !output )
{
// TODO: clean up
time += delay;
delay = time + (end_time - time + period - 1) / period * period - end_time;
return;
}
const int volume = this->volume();
int amp = (noise & 1) ? volume : 0;
int delta = update_amp( amp );
if ( delta )
synth.offset( time, delta, output );
time += delay;
if ( time < end_time )
{
const int mode_flag = 0x80;
if ( !volume )
{
// round to next multiple of period
time += (end_time - time + period - 1) / period * period;
// approximate noise cycling while muted, by shuffling up noise register
// to do: precise muted noise cycling?
if ( !(regs [2] & mode_flag) ) {
int feedback = (noise << 13) ^ (noise << 14);
noise = (feedback & 0x4000) | (noise >> 1);
}
}
else
{
Blip_Buffer* const output = this->output;
// using resampled time avoids conversion in synth.offset()
blip_resampled_time_t rperiod = output->resampled_duration( period );
blip_resampled_time_t rtime = output->resampled_time( time );
int noise = this->noise;
int delta = amp * 2 - volume;
const int tap = (regs [2] & mode_flag ? 8 : 13);
do {
int feedback = (noise << tap) ^ (noise << 14);
time += period;
if ( (noise + 1) & 2 ) {
// bits 0 and 1 of noise differ
delta = -delta;
synth.offset_resampled( rtime, delta, output );
}
rtime += rperiod;
noise = (feedback & 0x4000) | (noise >> 1);
}
while ( time < end_time );
last_amp = (delta + volume) >> 1;
this->noise = noise;
}
}
delay = time - end_time;
}

151
source/quickerNES/apu/Nes_Oscs.h
View File

@ -1,151 +0,0 @@
// Private oscillators used by Nes_Apu
// Nes_Snd_Emu 0.1.7
#ifndef NES_OSCS_H
#define NES_OSCS_H
#include "Blip_Buffer.h"
class Nes_Apu;
typedef long nes_time_t; // CPU clock cycle count
typedef unsigned nes_addr_t; // 16-bit memory address
struct Nes_Osc
{
unsigned char regs [4];
bool reg_written [4];
Blip_Buffer* output;
int length_counter;// length counter (0 if unused by oscillator)
int delay; // delay until next (potential) transition
int last_amp; // last amplitude oscillator was outputting
void clock_length( int halt_mask );
int period() const {
return (regs [3] & 7) * 0x100 + (regs [2] & 0xff);
}
void reset() {
delay = 0;
last_amp = 0;
}
int update_amp( int amp ) {
int delta = amp - last_amp;
last_amp = amp;
return delta;
}
};
struct Nes_Envelope : Nes_Osc
{
int envelope;
int env_delay;
void clock_envelope();
int volume() const;
void reset() {
envelope = 0;
env_delay = 0;
Nes_Osc::reset();
}
};
// Nes_Square
struct Nes_Square : Nes_Envelope
{
enum { negate_flag = 0x08 };
enum { shift_mask = 0x07 };
enum { phase_range = 8 };
int phase;
int sweep_delay;
typedef Blip_Synth<blip_good_quality,1> Synth;
Synth const& synth; // shared between squares
Nes_Square( Synth const* s ) : synth( *s ) { }
void clock_sweep( int adjust );
void run( nes_time_t, nes_time_t );
void reset() {
sweep_delay = 0;
Nes_Envelope::reset();
}
nes_time_t maintain_phase( nes_time_t time, nes_time_t end_time,
nes_time_t timer_period );
};
// Nes_Triangle
struct Nes_Triangle : Nes_Osc
{
enum { phase_range = 16 };
int phase;
int linear_counter;
Blip_Synth<blip_med_quality,1> synth;
int calc_amp() const;
void run( nes_time_t, nes_time_t );
void clock_linear_counter();
void reset() {
linear_counter = 0;
phase = 1;
Nes_Osc::reset();
}
nes_time_t maintain_phase( nes_time_t time, nes_time_t end_time,
nes_time_t timer_period );
};
// Nes_Noise
struct Nes_Noise : Nes_Envelope
{
int noise;
Blip_Synth<blip_med_quality,1> synth;
void run( nes_time_t, nes_time_t );
void reset() {
noise = 1 << 14;
Nes_Envelope::reset();
}
};
// Nes_Dmc
struct Nes_Dmc : Nes_Osc
{
int address; // address of next byte to read
int period;
//int length_counter; // bytes remaining to play (already defined in Nes_Osc)
int buf;
int bits_remain;
int bits;
bool buf_full;
bool silence;
enum { loop_flag = 0x40 };
int dac;
nes_time_t next_irq;
bool irq_enabled;
bool irq_flag;
bool pal_mode;
bool nonlinear;
int (*prg_reader)( void*, nes_addr_t ); // needs to be initialized to prg read function
void* prg_reader_data;
Nes_Apu* apu;
Blip_Synth<blip_med_quality,1> synth;
void start();
void write_register( int, int );
void run( nes_time_t, nes_time_t );
void recalc_irq();
void fill_buffer();
void reload_sample();
void reset();
int count_reads( nes_time_t, nes_time_t* ) const;
nes_time_t next_read_time() const;
};
#endif

619
source/quickerNES/apu/apu.cpp
View File

@ -1,7 +1,6 @@
// Snd_Emu 0.1.7. http://www.slack.net/~ant/
// Nes_Snd_Emu 0.1.7. http://www.slack.net/~ant/
#include "apu.h"
#include "apu.hpp"
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -14,353 +13,363 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
int const amp_range = 15;
Nes_Apu::Nes_Apu() :
square1( &square_synth ),
square2( &square_synth )
Apu::Apu() : square1(&square_synth),
square2(&square_synth)
{
dmc.apu = this;
dmc.prg_reader = 0;
irq_notifier_ = 0;
oscs [0] = &square1;
oscs [1] = &square2;
oscs [2] = &triangle;
oscs [3] = &noise;
oscs [4] = &dmc;
output( 0 );
volume( 1.0 );
reset( false );
dmc.apu = this;
dmc.prg_reader = 0;
irq_notifier_ = 0;
oscs[0] = &square1;
oscs[1] = &square2;
oscs[2] = &triangle;
oscs[3] = &noise;
oscs[4] = &dmc;
output(0);
volume(1.0);
reset(false);
}
Nes_Apu::~Nes_Apu()
Apu::~Apu()
{
}
void Nes_Apu::treble_eq( const blip_eq_t& eq )
void Apu::treble_eq(const blip_eq_t &eq)
{
square_synth.treble_eq( eq );
triangle.synth.treble_eq( eq );
noise.synth.treble_eq( eq );
dmc.synth.treble_eq( eq );
square_synth.treble_eq(eq);
triangle.synth.treble_eq(eq);
noise.synth.treble_eq(eq);
dmc.synth.treble_eq(eq);
}
void Nes_Apu::enable_nonlinear( double v )
void Apu::enable_nonlinear(double v)
{
dmc.nonlinear = true;
square_synth.volume( 1.3 * 0.25751258 / 0.742467605 * 0.25 / amp_range * v );
const double tnd = 0.48 / 202 * nonlinear_tnd_gain();
triangle.synth.volume( 3.0 * tnd );
noise.synth.volume( 2.0 * tnd );
dmc.synth.volume( tnd );
square1 .last_amp = 0;
square2 .last_amp = 0;
triangle.last_amp = 0;
noise .last_amp = 0;
dmc .last_amp = 0;
dmc.nonlinear = true;
square_synth.volume(1.3 * 0.25751258 / 0.742467605 * 0.25 / amp_range * v);
const double tnd = 0.48 / 202 * nonlinear_tnd_gain();
triangle.synth.volume(3.0 * tnd);
noise.synth.volume(2.0 * tnd);
dmc.synth.volume(tnd);
square1.last_amp = 0;
square2.last_amp = 0;
triangle.last_amp = 0;
noise.last_amp = 0;
dmc.last_amp = 0;
}
void Nes_Apu::volume( double v )
void Apu::volume(double v)
{
dmc.nonlinear = false;
square_synth.volume( 0.1128 / amp_range * v );
triangle.synth.volume( 0.12765 / amp_range * v );
noise.synth.volume( 0.0741 / amp_range * v );
dmc.synth.volume( 0.42545 / 127 * v );
dmc.nonlinear = false;
square_synth.volume(0.1128 / amp_range * v);
triangle.synth.volume(0.12765 / amp_range * v);
noise.synth.volume(0.0741 / amp_range * v);
dmc.synth.volume(0.42545 / 127 * v);
}
void Nes_Apu::output( Blip_Buffer* buffer )
void Apu::output(Blip_Buffer *buffer)
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, buffer );
for (int i = 0; i < osc_count; i++)
osc_output(i, buffer);
}
void Nes_Apu::reset( bool pal_mode, int initial_dmc_dac )
void Apu::reset(bool pal_mode, int initial_dmc_dac)
{
// to do: time pal frame periods exactly
frame_period = pal_mode ? 8314 : 7458;
dmc.pal_mode = pal_mode;
square1.reset();
square2.reset();
triangle.reset();
noise.reset();
dmc.reset();
last_time = 0;
last_dmc_time = 0;
osc_enables = 0;
irq_flag = false;
earliest_irq_ = no_irq;
frame_delay = 1;
write_register( 0, 0x4017, 0x00 );
write_register( 0, 0x4015, 0x00 );
for ( nes_addr_t addr = start_addr; addr <= 0x4013; addr++ )
write_register( 0, addr, (addr & 3) ? 0x00 : 0x10 );
dmc.dac = initial_dmc_dac;
if ( !dmc.nonlinear )
triangle.last_amp = 15;
//if ( !dmc.nonlinear ) // to do: remove?
// dmc.last_amp = initial_dmc_dac; // prevent output transition
// to do: time pal frame periods exactly
frame_period = pal_mode ? 8314 : 7458;
dmc.pal_mode = pal_mode;
square1.reset();
square2.reset();
triangle.reset();
noise.reset();
dmc.reset();
last_time = 0;
last_dmc_time = 0;
osc_enables = 0;
irq_flag = false;
earliest_irq_ = no_irq;
frame_delay = 1;
write_register(0, 0x4017, 0x00);
write_register(0, 0x4015, 0x00);
for (nes_addr_t addr = start_addr; addr <= 0x4013; addr++)
write_register(0, addr, (addr & 3) ? 0x00 : 0x10);
dmc.dac = initial_dmc_dac;
if (!dmc.nonlinear)
triangle.last_amp = 15;
// if ( !dmc.nonlinear ) // to do: remove?
// dmc.last_amp = initial_dmc_dac; // prevent output transition
}
void Nes_Apu::irq_changed()
void Apu::irq_changed()
{
nes_time_t new_irq = dmc.next_irq;
if ( dmc.irq_flag | irq_flag ) {
new_irq = 0;
}
else if ( new_irq > next_irq ) {
new_irq = next_irq;
}
if ( new_irq != earliest_irq_ ) {
earliest_irq_ = new_irq;
if ( irq_notifier_ )
irq_notifier_( irq_data );
}
nes_time_t new_irq = dmc.next_irq;
if (dmc.irq_flag | irq_flag)
{
new_irq = 0;
}
else if (new_irq > next_irq)
{
new_irq = next_irq;
}
if (new_irq != earliest_irq_)
{
earliest_irq_ = new_irq;
if (irq_notifier_)
irq_notifier_(irq_data);
}
}
// frames
void Nes_Apu::run_until( nes_time_t end_time )
void Apu::run_until(nes_time_t end_time)
{
if ( end_time > next_dmc_read_time() )
{
nes_time_t start = last_dmc_time;
last_dmc_time = end_time;
dmc.run( start, end_time );
}
if (end_time > next_dmc_read_time())
{
nes_time_t start = last_dmc_time;
last_dmc_time = end_time;
dmc.run(start, end_time);
}
}
void Nes_Apu::run_until_( nes_time_t end_time )
void Apu::run_until_(nes_time_t end_time)
{
if ( end_time == last_time )
return;
if ( last_dmc_time < end_time )
{
nes_time_t start = last_dmc_time;
last_dmc_time = end_time;
dmc.run( start, end_time );
}
while ( true )
{
// earlier of next frame time or end time
nes_time_t time = last_time + frame_delay;
if ( time > end_time )
time = end_time;
frame_delay -= time - last_time;
// run oscs to present
square1.run( last_time, time );
square2.run( last_time, time );
triangle.run( last_time, time );
noise.run( last_time, time );
last_time = time;
if ( time == end_time )
break; // no more frames to run
// take frame-specific actions
frame_delay = frame_period;
switch ( frame++ )
{
case 0:
if ( !(frame_mode & 0xc0) ) {
next_irq = time + frame_period * 4 + 1;
irq_flag = true;
}
// fall through
case 2:
// clock length and sweep on frames 0 and 2
square1.clock_length( 0x20 );
square2.clock_length( 0x20 );
noise.clock_length( 0x20 );
triangle.clock_length( 0x80 ); // different bit for halt flag on triangle
square1.clock_sweep( -1 );
square2.clock_sweep( 0 );
break;
case 1:
// frame 1 is slightly shorter
frame_delay -= 2;
break;
case 3:
frame = 0;
// frame 3 is almost twice as long in mode 1
if ( frame_mode & 0x80 )
frame_delay += frame_period - 6;
break;
}
// clock envelopes and linear counter every frame
triangle.clock_linear_counter();
square1.clock_envelope();
square2.clock_envelope();
noise.clock_envelope();
}
if (end_time == last_time)
return;
if (last_dmc_time < end_time)
{
nes_time_t start = last_dmc_time;
last_dmc_time = end_time;
dmc.run(start, end_time);
}
while (true)
{
// earlier of next frame time or end time
nes_time_t time = last_time + frame_delay;
if (time > end_time)
time = end_time;
frame_delay -= time - last_time;
// run oscs to present
square1.run(last_time, time);
square2.run(last_time, time);
triangle.run(last_time, time);
noise.run(last_time, time);
last_time = time;
if (time == end_time)
break; // no more frames to run
// take frame-specific actions
frame_delay = frame_period;
switch (frame++)
{
case 0:
if (!(frame_mode & 0xc0))
{
next_irq = time + frame_period * 4 + 1;
irq_flag = true;
}
// fall through
case 2:
// clock length and sweep on frames 0 and 2
square1.clock_length(0x20);
square2.clock_length(0x20);
noise.clock_length(0x20);
triangle.clock_length(0x80); // different bit for halt flag on triangle
square1.clock_sweep(-1);
square2.clock_sweep(0);
break;
case 1:
// frame 1 is slightly shorter
frame_delay -= 2;
break;
case 3:
frame = 0;
// frame 3 is almost twice as long in mode 1
if (frame_mode & 0x80)
frame_delay += frame_period - 6;
break;
}
// clock envelopes and linear counter every frame
triangle.clock_linear_counter();
square1.clock_envelope();
square2.clock_envelope();
noise.clock_envelope();
}
}
template<class T>
inline void zero_apu_osc( T* osc, nes_time_t time )
template <class T>
inline void zero_apu_osc(T *osc, nes_time_t time)
{
Blip_Buffer* output = osc->output;
int last_amp = osc->last_amp;
osc->last_amp = 0;
if ( output && last_amp )
osc->synth.offset( time, -last_amp, output );
Blip_Buffer *output = osc->output;
int last_amp = osc->last_amp;
osc->last_amp = 0;
if (output && last_amp)
osc->synth.offset(time, -last_amp, output);
}
void Nes_Apu::end_frame( nes_time_t end_time )
void Apu::end_frame(nes_time_t end_time)
{
if ( end_time > last_time )
run_until_( end_time );
if ( dmc.nonlinear )
{
zero_apu_osc( &square1, last_time );
zero_apu_osc( &square2, last_time );
zero_apu_osc( &triangle, last_time );
zero_apu_osc( &noise, last_time );
zero_apu_osc( &dmc, last_time );
}
// make times relative to new frame
last_time -= end_time;
last_dmc_time -= end_time;
if ( next_irq != no_irq ) {
next_irq -= end_time;
}
if ( dmc.next_irq != no_irq ) {
dmc.next_irq -= end_time;
}
if ( earliest_irq_ != no_irq ) {
earliest_irq_ -= end_time;
if ( earliest_irq_ < 0 )
earliest_irq_ = 0;
}
if (end_time > last_time)
run_until_(end_time);
if (dmc.nonlinear)
{
zero_apu_osc(&square1, last_time);
zero_apu_osc(&square2, last_time);
zero_apu_osc(&triangle, last_time);
zero_apu_osc(&noise, last_time);
zero_apu_osc(&dmc, last_time);
}
// make times relative to new frame
last_time -= end_time;
last_dmc_time -= end_time;
if (next_irq != no_irq)
{
next_irq -= end_time;
}
if (dmc.next_irq != no_irq)
{
dmc.next_irq -= end_time;
}
if (earliest_irq_ != no_irq)
{
earliest_irq_ -= end_time;
if (earliest_irq_ < 0)
earliest_irq_ = 0;
}
}
// registers
static const unsigned char length_table [0x20] = {
0x0A, 0xFE, 0x14, 0x02, 0x28, 0x04, 0x50, 0x06,
0xA0, 0x08, 0x3C, 0x0A, 0x0E, 0x0C, 0x1A, 0x0E,
0x0C, 0x10, 0x18, 0x12, 0x30, 0x14, 0x60, 0x16,
0xC0, 0x18, 0x48, 0x1A, 0x10, 0x1C, 0x20, 0x1E
};
static const unsigned char length_table[0x20] = {
0x0A, 0xFE, 0x14, 0x02, 0x28, 0x04, 0x50, 0x06, 0xA0, 0x08, 0x3C, 0x0A, 0x0E, 0x0C, 0x1A, 0x0E, 0x0C, 0x10, 0x18, 0x12, 0x30, 0x14, 0x60, 0x16, 0xC0, 0x18, 0x48, 0x1A, 0x10, 0x1C, 0x20, 0x1E};
void Nes_Apu::write_register( nes_time_t time, nes_addr_t addr, int data )
void Apu::write_register(nes_time_t time, nes_addr_t addr, int data)
{
// Ignore addresses outside range
if ( addr < start_addr || end_addr < addr )
return;
run_until_( time );
if ( addr < 0x4014 )
{
// Write to channel
int osc_index = (addr - start_addr) >> 2;
Nes_Osc* osc = oscs [osc_index];
int reg = addr & 3;
osc->regs [reg] = data;
osc->reg_written [reg] = true;
if ( osc_index == 4 )
{
// handle DMC specially
dmc.write_register( reg, data );
}
else if ( reg == 3 )
{
// load length counter
if ( (osc_enables >> osc_index) & 1 )
osc->length_counter = length_table [(data >> 3) & 0x1f];
// reset square phase
if ( osc_index < 2 )
((Nes_Square*) osc)->phase = Nes_Square::phase_range - 1;
}
}
else if ( addr == 0x4015 )
{
// Channel enables
for ( int i = osc_count; i--; )
if ( !((data >> i) & 1) )
oscs [i]->length_counter = 0;
bool recalc_irq = dmc.irq_flag;
dmc.irq_flag = false;
int old_enables = osc_enables;
osc_enables = data;
if ( !(data & 0x10) ) {
dmc.next_irq = no_irq;
recalc_irq = true;
}
else if ( !(old_enables & 0x10) ) {
dmc.start(); // dmc just enabled
}
if ( recalc_irq )
irq_changed();
}
else if ( addr == 0x4017 )
{
// Frame mode
frame_mode = data;
bool irq_enabled = !(data & 0x40);
irq_flag &= irq_enabled;
next_irq = no_irq;
// mode 1
frame_delay = (frame_delay & 1);
frame = 0;
if ( !(data & 0x80) )
{
// mode 0
frame = 1;
frame_delay += frame_period;
if ( irq_enabled )
next_irq = time + frame_delay + frame_period * 3;
}
irq_changed();
}
// Ignore addresses outside range
if (addr < start_addr || end_addr < addr)
return;
run_until_(time);
if (addr < 0x4014)
{
// Write to channel
int osc_index = (addr - start_addr) >> 2;
Osc *osc = oscs[osc_index];
int reg = addr & 3;
osc->regs[reg] = data;
osc->reg_written[reg] = true;
if (osc_index == 4)
{
// handle DMC specially
dmc.write_register(reg, data);
}
else if (reg == 3)
{
// load length counter
if ((osc_enables >> osc_index) & 1)
osc->length_counter = length_table[(data >> 3) & 0x1f];
// reset square phase
if (osc_index < 2)
((Square *)osc)->phase = Square::phase_range - 1;
}
}
else if (addr == 0x4015)
{
// Channel enables
for (int i = osc_count; i--;)
if (!((data >> i) & 1))
oscs[i]->length_counter = 0;
bool recalc_irq = dmc.irq_flag;
dmc.irq_flag = false;
int old_enables = osc_enables;
osc_enables = data;
if (!(data & 0x10))
{
dmc.next_irq = no_irq;
recalc_irq = true;
}
else if (!(old_enables & 0x10))
{
dmc.start(); // dmc just enabled
}
if (recalc_irq)
irq_changed();
}
else if (addr == 0x4017)
{
// Frame mode
frame_mode = data;
bool irq_enabled = !(data & 0x40);
irq_flag &= irq_enabled;
next_irq = no_irq;
// mode 1
frame_delay = (frame_delay & 1);
frame = 0;
if (!(data & 0x80))
{
// mode 0
frame = 1;
frame_delay += frame_period;
if (irq_enabled)
next_irq = time + frame_delay + frame_period * 3;
}
irq_changed();
}
}
int Nes_Apu::read_status( nes_time_t time )
int Apu::read_status(nes_time_t time)
{
run_until_( time - 1 );
int result = (dmc.irq_flag << 7) | (irq_flag << 6);
for ( int i = 0; i < osc_count; i++ )
if ( oscs [i]->length_counter )
result |= 1 << i;
run_until_( time );
if ( irq_flag ) {
irq_flag = false;
irq_changed();
}
return result;
run_until_(time - 1);
int result = (dmc.irq_flag << 7) | (irq_flag << 6);
for (int i = 0; i < osc_count; i++)
if (oscs[i]->length_counter)
result |= 1 << i;
run_until_(time);
if (irq_flag)
{
irq_flag = false;
irq_changed();
}
return result;
}
} // namespace quickNES

356
source/quickerNES/apu/apu.h
View File

@ -1,356 +0,0 @@
#pragma once
// NES 2A03 APU sound chip emulator
// Nes_Snd_Emu 0.1.7
#include <cstdint>
#include <cstdint>
#include <climits>
#include "Nes_Oscs.h"
class Nes_Apu {
public:
typedef uint8_t env_t [3];
/*struct env_t {
uint8_t delay;
uint8_t env;
uint8_t written;
};*/
struct apu_t {
uint8_t w40xx [0x14]; // $4000-$4013
uint8_t w4015; // enables
uint8_t w4017; // mode
uint16_t frame_delay;
uint8_t frame_step;
uint8_t irq_flag;
};
struct square_t {
uint16_t delay;
env_t env;
uint8_t length_counter;
uint8_t phase;
uint8_t swp_delay;
uint8_t swp_reset;
uint8_t unused2 [1];
};
struct triangle_t {
uint16_t delay;
uint8_t length_counter;
uint8_t phase;
uint8_t linear_counter;
uint8_t linear_mode;
};
struct noise_t {
uint16_t delay;
env_t env;
uint8_t length_counter;
uint16_t shift_reg;
};
struct dmc_t {
uint16_t delay;
uint16_t remain;
uint16_t addr;
uint8_t buf;
uint8_t bits_remain;
uint8_t bits;
uint8_t buf_full;
uint8_t silence;
uint8_t irq_flag;
};
struct apu_state_t
{
apu_t apu;
square_t square1;
square_t square2;
triangle_t triangle;
noise_t noise;
dmc_t dmc;
};
static_assert( sizeof (apu_state_t) == 72 );
Nes_Apu();
~Nes_Apu();
// Set buffer to generate all sound into, or disable sound if NULL
void output( Blip_Buffer* );
// Set memory reader callback used by DMC oscillator to fetch samples.
// When callback is invoked, 'user_data' is passed unchanged as the
// first parameter.
void dmc_reader( int (*callback)( void* user_data, nes_addr_t ), void* user_data = nullptr );
// All time values are the number of CPU clock cycles relative to the
// beginning of the current time frame. Before resetting the CPU clock
// count, call end_frame( last_cpu_time ).
// Write to register (0x4000-0x4017, except 0x4014 and 0x4016)
static const uint16_t start_addr = 0x4000;
static const uint16_t end_addr = 0x4017;
void write_register( nes_time_t, nes_addr_t, int data );
// Read from status register at 0x4015
static const uint16_t status_addr = 0x4015;
int read_status( nes_time_t );
// Run all oscillators up to specified time, end current time frame, then
// start a new time frame at time 0. Time frames have no effect on emulation
// and each can be whatever length is convenient.
void end_frame( nes_time_t );
// Additional optional features (can be ignored without any problem)
// Reset internal frame counter, registers, and all oscillators.
// Use PAL timing if pal_timing is true, otherwise use NTSC timing.
// Set the DMC oscillator's initial DAC value to initial_dmc_dac without
// any audible click.
void reset( bool pal_timing = false, int initial_dmc_dac = 0 );
// Save/load exact emulation state
void save_state( apu_state_t* out ) const;
void load_state( apu_state_t const& );
// Set overall volume (default is 1.0)
void volume( double );
// Set treble equalization (see notes.txt)
void treble_eq( const blip_eq_t& );
// Set sound output of specific oscillator to buffer. If buffer is NULL,
// the specified oscillator is muted and emulation accuracy is reduced.
// The oscillators are indexed as follows: 0) Square 1, 1) Square 2,
// 2) Triangle, 3) Noise, 4) DMC.
static const uint16_t osc_count = 5;
void osc_output( int index, Blip_Buffer* buffer );
// Set IRQ time callback that is invoked when the time of earliest IRQ
// may have changed, or NULL to disable. When callback is invoked,
// 'user_data' is passed unchanged as the first parameter.
void irq_notifier( void (*callback)( void* user_data ), void* user_data = nullptr );
// Get time that APU-generated IRQ will occur if no further register reads
// or writes occur. If IRQ is already pending, returns irq_waiting. If no
// IRQ will occur, returns no_irq.
static const uint64_t no_irq = LONG_MAX / 2 + 1;
static const uint16_t irq_waiting = 0;
nes_time_t earliest_irq( nes_time_t ) const;
// Count number of DMC reads that would occur if 'run_until( t )' were executed.
// If last_read is not NULL, set *last_read to the earliest time that
// 'count_dmc_reads( time )' would result in the same result.
int count_dmc_reads( nes_time_t t, nes_time_t* last_read = nullptr ) const;
// Time when next DMC memory read will occur
nes_time_t next_dmc_read_time() const;
// Run DMC until specified time, so that any DMC memory reads can be
// accounted for (i.e. inserting CPU wait states).
void run_until( nes_time_t );
// End of public interface.
private:
friend class Nes_Nonlinearizer;
void enable_nonlinear( double volume );
static double nonlinear_tnd_gain() { return 0.75; }
private:
friend struct Nes_Dmc;
// noncopyable
Nes_Apu( const Nes_Apu& );
Nes_Apu& operator = ( const Nes_Apu& );
Nes_Osc* oscs [osc_count];
Nes_Square square1;
Nes_Square square2;
Nes_Noise noise;
Nes_Triangle triangle;
Nes_Dmc dmc;
nes_time_t last_time; // has been run until this time in current frame
nes_time_t last_dmc_time;
nes_time_t earliest_irq_;
nes_time_t next_irq;
int frame_period;
int frame_delay; // cycles until frame counter runs next
int frame; // current frame (0-3)
int osc_enables;
int frame_mode;
bool irq_flag;
void (*irq_notifier_)( void* user_data );
void* irq_data;
Nes_Square::Synth square_synth; // shared by squares
void irq_changed();
void state_restored();
void run_until_( nes_time_t );
// TODO: remove
friend class Nes_Core;
};
inline void Nes_Apu::osc_output( int osc, Blip_Buffer* buf )
{
oscs [osc]->output = buf;
}
inline nes_time_t Nes_Apu::earliest_irq( nes_time_t ) const
{
return earliest_irq_;
}
inline void Nes_Apu::dmc_reader( int (*func)( void*, nes_addr_t ), void* user_data )
{
dmc.prg_reader_data = user_data;
dmc.prg_reader = func;
}
inline void Nes_Apu::irq_notifier( void (*func)( void* user_data ), void* user_data )
{
irq_notifier_ = func;
irq_data = user_data;
}
inline int Nes_Apu::count_dmc_reads( nes_time_t time, nes_time_t* last_read ) const
{
return dmc.count_reads( time, last_read );
}
inline nes_time_t Nes_Dmc::next_read_time() const
{
if ( length_counter == 0 )
return Nes_Apu::no_irq; // not reading
return apu->last_dmc_time + delay + long (bits_remain - 1) * period;
}
inline nes_time_t Nes_Apu::next_dmc_read_time() const { return dmc.next_read_time(); }
template<int mode>
struct apu_reflection
{
#define REFLECT( apu, state ) (mode ? void (apu = state) : void (state = apu))
static void reflect_env( Nes_Apu::env_t* state, Nes_Envelope& osc )
{
REFLECT( (*state) [0], osc.env_delay );
REFLECT( (*state) [1], osc.envelope );
REFLECT( (*state) [2], osc.reg_written [3] );
}
static void reflect_square( Nes_Apu::square_t& state, Nes_Square& osc )
{
reflect_env( &state.env, osc );
REFLECT( state.delay, osc.delay );
REFLECT( state.length_counter, osc.length_counter );
REFLECT( state.phase, osc.phase );
REFLECT( state.swp_delay, osc.sweep_delay );
REFLECT( state.swp_reset, osc.reg_written [1] );
}
static void reflect_triangle( Nes_Apu::triangle_t& state, Nes_Triangle& osc )
{
REFLECT( state.delay, osc.delay );
REFLECT( state.length_counter, osc.length_counter );
REFLECT( state.linear_counter, osc.linear_counter );
REFLECT( state.phase, osc.phase );
REFLECT( state.linear_mode, osc.reg_written [3] );
}
static void reflect_noise( Nes_Apu::noise_t& state, Nes_Noise& osc )
{
reflect_env( &state.env, osc );
REFLECT( state.delay, osc.delay );
REFLECT( state.length_counter, osc.length_counter );
REFLECT( state.shift_reg, osc.noise );
}
static void reflect_dmc( Nes_Apu::dmc_t& state, Nes_Dmc& osc )
{
REFLECT( state.delay, osc.delay );
REFLECT( state.remain, osc.length_counter );
REFLECT( state.buf, osc.buf );
REFLECT( state.bits_remain, osc.bits_remain );
REFLECT( state.bits, osc.bits );
REFLECT( state.buf_full, osc.buf_full );
REFLECT( state.silence, osc.silence );
REFLECT( state.irq_flag, osc.irq_flag );
if ( mode )
state.addr = osc.address | 0x8000;
else
osc.address = state.addr & 0x7fff;
}
};
inline void Nes_Apu::save_state( apu_state_t* state ) const
{
for ( int i = 0; i < osc_count * 4; i++ )
{
int index = i >> 2;
state->apu.w40xx [i] = oscs [index]->regs [i & 3];
//if ( index < 4 )
// state->length_counters [index] = oscs [index]->length_counter;
}
state->apu.w40xx [0x11] = dmc.dac;
state->apu.w4015 = osc_enables;
state->apu.w4017 = frame_mode;
state->apu.frame_delay = frame_delay;
state->apu.frame_step = frame;
state->apu.irq_flag = irq_flag;
typedef apu_reflection<1> refl;
Nes_Apu& apu = *(Nes_Apu*) this; // const_cast
refl::reflect_square ( state->square1, apu.square1 );
refl::reflect_square ( state->square2, apu.square2 );
refl::reflect_triangle( state->triangle, apu.triangle );
refl::reflect_noise ( state->noise, apu.noise );
refl::reflect_dmc ( state->dmc, apu.dmc );
}
inline void Nes_Apu::load_state( apu_state_t const& state )
{
reset();
write_register( 0, 0x4017, state.apu.w4017 );
write_register( 0, 0x4015, state.apu.w4015 );
osc_enables = state.apu.w4015; // DMC clears bit 4
for ( int i = 0; i < osc_count * 4; i++ )
{
int n = state.apu.w40xx [i];
int index = i >> 2;
oscs [index]->regs [i & 3] = n;
write_register( 0, 0x4000 + i, n );
//if ( index < 4 )
// oscs [index]->length_counter = state.length_counters [index];
}
frame_delay = state.apu.frame_delay;
frame = state.apu.frame_step;
irq_flag = state.apu.irq_flag;
typedef apu_reflection<0> refl;
apu_state_t& st = (apu_state_t&) state; // const_cast
refl::reflect_square ( st.square1, square1 );
refl::reflect_square ( st.square2, square2 );
refl::reflect_triangle( st.triangle, triangle );
refl::reflect_noise ( st.noise, noise );
refl::reflect_dmc ( st.dmc, dmc );
dmc.recalc_irq();
//force channels to have correct last_amp levels after load state
square1.run(last_time, last_time);
square2.run(last_time, last_time);
triangle.run(last_time, last_time);
noise.run(last_time, last_time);
dmc.run(last_time, last_time);
}

363
source/quickerNES/apu/apu.hpp Normal file
View File

@ -0,0 +1,363 @@
#pragma once
// NES 2A03 APU sound chip emulator
// Snd_Emu 0.1.7
#include <climits>
#include <cstdint>
#include "oscs.hpp"
namespace quickerNES
{
class Apu
{
public:
typedef uint8_t env_t[3];
/*struct env_t {
uint8_t delay;
uint8_t env;
uint8_t written;
};*/
struct apu_t
{
uint8_t w40xx[0x14]; // $4000-$4013
uint8_t w4015; // enables
uint8_t w4017; // mode
uint16_t frame_delay;
uint8_t frame_step;
uint8_t irq_flag;
};
struct square_t
{
uint16_t delay;
env_t env;
uint8_t length_counter;
uint8_t phase;
uint8_t swp_delay;
uint8_t swp_reset;
uint8_t unused2[1];
};
struct triangle_t
{
uint16_t delay;
uint8_t length_counter;
uint8_t phase;
uint8_t linear_counter;
uint8_t linear_mode;
};
struct noise_t
{
uint16_t delay;
env_t env;
uint8_t length_counter;
uint16_t shift_reg;
};
struct dmc_t
{
uint16_t delay;
uint16_t remain;
uint16_t addr;
uint8_t buf;
uint8_t bits_remain;
uint8_t bits;
uint8_t buf_full;
uint8_t silence;
uint8_t irq_flag;
};
struct apu_state_t
{
apu_t apu;
square_t square1;
square_t square2;
triangle_t triangle;
noise_t noise;
dmc_t dmc;
};
static_assert(sizeof(apu_state_t) == 72);
Apu();
~Apu();
// Set buffer to generate all sound into, or disable sound if NULL
void output(Blip_Buffer *);
// Set memory reader callback used by DMC oscillator to fetch samples.
// When callback is invoked, 'user_data' is passed unchanged as the
// first parameter.
void dmc_reader(int (*callback)(void *user_data, nes_addr_t), void *user_data = nullptr);
// All time values are the number of CPU clock cycles relative to the
// beginning of the current time frame. Before resetting the CPU clock
// count, call end_frame( last_cpu_time ).
// Write to register (0x4000-0x4017, except 0x4014 and 0x4016)
static const uint16_t start_addr = 0x4000;
static const uint16_t end_addr = 0x4017;
void write_register(nes_time_t, nes_addr_t, int data);
// Read from status register at 0x4015
static const uint16_t status_addr = 0x4015;
int read_status(nes_time_t);
// Run all oscillators up to specified time, end current time frame, then
// start a new time frame at time 0. Time frames have no effect on emulation
// and each can be whatever length is convenient.
void end_frame(nes_time_t);
// Additional optional features (can be ignored without any problem)
// Reset internal frame counter, registers, and all oscillators.
// Use PAL timing if pal_timing is true, otherwise use NTSC timing.
// Set the DMC oscillator's initial DAC value to initial_dmc_dac without
// any audible click.
void reset(bool pal_timing = false, int initial_dmc_dac = 0);
// Save/load exact emulation state
void save_state(apu_state_t *out) const;
void load_state(apu_state_t const &);
// Set overall volume (default is 1.0)
void volume(double);
// Set treble equalization (see notes.txt)
void treble_eq(const blip_eq_t &);
// Set sound output of specific oscillator to buffer. If buffer is NULL,
// the specified oscillator is muted and emulation accuracy is reduced.
// The oscillators are indexed as follows: 0) Square 1, 1) Square 2,
// 2) Triangle, 3) Noise, 4) DMC.
static const uint16_t osc_count = 5;
void osc_output(int index, Blip_Buffer *buffer);
// Set IRQ time callback that is invoked when the time of earliest IRQ
// may have changed, or NULL to disable. When callback is invoked,
// 'user_data' is passed unchanged as the first parameter.
void irq_notifier(void (*callback)(void *user_data), void *user_data = nullptr);
// Get time that APU-generated IRQ will occur if no further register reads
// or writes occur. If IRQ is already pending, returns irq_waiting. If no
// IRQ will occur, returns no_irq.
static const uint64_t no_irq = LONG_MAX / 2 + 1;
static const uint16_t irq_waiting = 0;
nes_time_t earliest_irq(nes_time_t) const;
// Count number of DMC reads that would occur if 'run_until( t )' were executed.
// If last_read is not NULL, set *last_read to the earliest time that
// 'count_dmc_reads( time )' would result in the same result.
int count_dmc_reads(nes_time_t t, nes_time_t *last_read = nullptr) const;
// Time when next DMC memory read will occur
nes_time_t next_dmc_read_time() const;
// Run DMC until specified time, so that any DMC memory reads can be
// accounted for (i.e. inserting CPU wait states).
void run_until(nes_time_t);
// End of public interface.
private:
friend class Nonlinearizer;
void enable_nonlinear(double volume);
static double nonlinear_tnd_gain() { return 0.75; }
private:
friend struct Dmc;
// noncopyable
Apu(const Apu &);
Apu &operator=(const Apu &);
Osc *oscs[osc_count];
Square square1;
Square square2;
Noise noise;
Triangle triangle;
Dmc dmc;
nes_time_t last_time; // has been run until this time in current frame
nes_time_t last_dmc_time;
nes_time_t earliest_irq_;
nes_time_t next_irq;
int frame_period;
int frame_delay; // cycles until frame counter runs next
int frame; // current frame (0-3)
int osc_enables;
int frame_mode;
bool irq_flag;
void (*irq_notifier_)(void *user_data);
void *irq_data;
Square::Synth square_synth; // shared by squares
void irq_changed();
void state_restored();
void run_until_(nes_time_t);
// TODO: remove
friend class Core;
};
inline void Apu::osc_output(int osc, Blip_Buffer *buf)
{
oscs[osc]->output = buf;
}
inline nes_time_t Apu::earliest_irq(nes_time_t) const
{
return earliest_irq_;
}
inline void Apu::dmc_reader(int (*func)(void *, nes_addr_t), void *user_data)
{
dmc.prg_reader_data = user_data;
dmc.prg_reader = func;
}
inline void Apu::irq_notifier(void (*func)(void *user_data), void *user_data)
{
irq_notifier_ = func;
irq_data = user_data;
}
inline int Apu::count_dmc_reads(nes_time_t time, nes_time_t *last_read) const
{
return dmc.count_reads(time, last_read);
}
inline nes_time_t Dmc::next_read_time() const
{
if (length_counter == 0)
return Apu::no_irq; // not reading
return apu->last_dmc_time + delay + long(bits_remain - 1) * period;
}
inline nes_time_t Apu::next_dmc_read_time() const { return dmc.next_read_time(); }
template <int mode>
struct apu_reflection
{
#define REFLECT(apu, state) (mode ? void(apu = state) : void(state = apu))
static void reflect_env(Apu::env_t *state, Envelope &osc)
{
REFLECT((*state)[0], osc.env_delay);
REFLECT((*state)[1], osc.envelope);
REFLECT((*state)[2], osc.reg_written[3]);
}
static void reflect_square(Apu::square_t &state, Square &osc)
{
reflect_env(&state.env, osc);
REFLECT(state.delay, osc.delay);
REFLECT(state.length_counter, osc.length_counter);
REFLECT(state.phase, osc.phase);
REFLECT(state.swp_delay, osc.sweep_delay);
REFLECT(state.swp_reset, osc.reg_written[1]);
}
static void reflect_triangle(Apu::triangle_t &state, Triangle &osc)
{
REFLECT(state.delay, osc.delay);
REFLECT(state.length_counter, osc.length_counter);
REFLECT(state.linear_counter, osc.linear_counter);
REFLECT(state.phase, osc.phase);
REFLECT(state.linear_mode, osc.reg_written[3]);
}
static void reflect_noise(Apu::noise_t &state, Noise &osc)
{
reflect_env(&state.env, osc);
REFLECT(state.delay, osc.delay);
REFLECT(state.length_counter, osc.length_counter);
REFLECT(state.shift_reg, osc.noise);
}
static void reflect_dmc(Apu::dmc_t &state, Dmc &osc)
{
REFLECT(state.delay, osc.delay);
REFLECT(state.remain, osc.length_counter);
REFLECT(state.buf, osc.buf);
REFLECT(state.bits_remain, osc.bits_remain);
REFLECT(state.bits, osc.bits);
REFLECT(state.buf_full, osc.buf_full);
REFLECT(state.silence, osc.silence);
REFLECT(state.irq_flag, osc.irq_flag);
if (mode)
state.addr = osc.address | 0x8000;
else
osc.address = state.addr & 0x7fff;
}
};
inline void Apu::save_state(apu_state_t *state) const
{
for (int i = 0; i < osc_count * 4; i++)
{
int index = i >> 2;
state->apu.w40xx[i] = oscs[index]->regs[i & 3];
// if ( index < 4 )
// state->length_counters [index] = oscs [index]->length_counter;
}
state->apu.w40xx[0x11] = dmc.dac;
state->apu.w4015 = osc_enables;
state->apu.w4017 = frame_mode;
state->apu.frame_delay = frame_delay;
state->apu.frame_step = frame;
state->apu.irq_flag = irq_flag;
typedef apu_reflection<1> refl;
Apu &apu = *(Apu *)this; // const_cast
refl::reflect_square(state->square1, apu.square1);
refl::reflect_square(state->square2, apu.square2);
refl::reflect_triangle(state->triangle, apu.triangle);
refl::reflect_noise(state->noise, apu.noise);
refl::reflect_dmc(state->dmc, apu.dmc);
}
inline void Apu::load_state(apu_state_t const &state)
{
reset();
write_register(0, 0x4017, state.apu.w4017);
write_register(0, 0x4015, state.apu.w4015);
osc_enables = state.apu.w4015; // DMC clears bit 4
for (int i = 0; i < osc_count * 4; i++)
{
int n = state.apu.w40xx[i];
int index = i >> 2;
oscs[index]->regs[i & 3] = n;
write_register(0, 0x4000 + i, n);
// if ( index < 4 )
// oscs [index]->length_counter = state.length_counters [index];
}
frame_delay = state.apu.frame_delay;
frame = state.apu.frame_step;
irq_flag = state.apu.irq_flag;
typedef apu_reflection<0> refl;
apu_state_t &st = (apu_state_t &)state; // const_cast
refl::reflect_square(st.square1, square1);
refl::reflect_square(st.square2, square2);
refl::reflect_triangle(st.triangle, triangle);
refl::reflect_noise(st.noise, noise);
refl::reflect_dmc(st.dmc, dmc);
dmc.recalc_irq();
// force channels to have correct last_amp levels after load state
square1.run(last_time, last_time);
square2.run(last_time, last_time);
triangle.run(last_time, last_time);
noise.run(last_time, last_time);
dmc.run(last_time, last_time);
}
} // namespace quickNES

236
source/quickerNES/apu/buffer.cpp Normal file
View File

@ -0,0 +1,236 @@
// Emu 0.7.0. http://www.slack.net/~ant/libs/
#include "apu/buffer.hpp"
#include "apu/apu.hpp"
/* Library Copyright (C) 2003-2006 Shay Green. This library is free software;
you can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for more
details. You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// Buffer
Buffer::Buffer() : Multi_Buffer(1) {}
Buffer::~Buffer() {}
Multi_Buffer *set_apu(Buffer *buf, Apu *apu)
{
buf->set_apu(apu);
return buf;
}
void Buffer::enable_nonlinearity(bool b)
{
if (b)
clear();
Apu *apu = nonlin.enable(b, &tnd);
apu->osc_output(0, &buf);
apu->osc_output(1, &buf);
}
const char *Buffer::set_sample_rate(long rate, int msec)
{
enable_nonlinearity(nonlin.enabled); // reapply
buf.set_sample_rate(rate, msec);
tnd.set_sample_rate(rate, msec);
return Multi_Buffer::set_sample_rate(buf.sample_rate(), buf.length());
}
void Buffer::clock_rate(long rate)
{
buf.clock_rate(rate);
tnd.clock_rate(rate);
}
void Buffer::bass_freq(int freq)
{
buf.bass_freq(freq);
tnd.bass_freq(freq);
}
void Buffer::clear()
{
nonlin.clear();
buf.clear();
tnd.clear();
}
Buffer::channel_t Buffer::channel(int i)
{
channel_t c;
c.center = &buf;
if (2 <= i && i <= 4)
c.center = &tnd; // only use for triangle, noise, and dmc
c.left = c.center;
c.right = c.center;
return c;
}
void Buffer::end_frame(blip_time_t length, bool)
{
buf.end_frame(length);
tnd.end_frame(length);
}
long Buffer::samples_avail() const
{
return buf.samples_avail();
}
long Buffer::read_samples(blip_sample_t *out, long count)
{
count = nonlin.make_nonlinear(tnd, count);
if (count)
{
Blip_Reader lin;
Blip_Reader nonlin;
int lin_bass = lin.begin(buf);
int nonlin_bass = nonlin.begin(tnd);
if (out != 0)
{
for (int n = count; n--;)
{
int s = lin.read() + nonlin.read();
lin.next(lin_bass);
nonlin.next(nonlin_bass);
*out++ = s;
if ((int16_t)s != s)
out[-1] = 0x7FFF - (s >> 24);
}
}
else
{
// only run accumulators, do not output audio
for (int n = count; n--;)
{
lin.next(lin_bass);
nonlin.next(nonlin_bass);
}
}
lin.end(buf);
nonlin.end(tnd);
buf.remove_samples(count);
tnd.remove_samples(count);
}
return count;
}
void Buffer::SaveAudioBufferState()
{
SaveAudioBufferStatePrivate();
nonlin.SaveAudioBufferState();
buf.SaveAudioBufferState();
tnd.SaveAudioBufferState();
}
void Buffer::RestoreAudioBufferState()
{
RestoreAudioBufferStatePrivate();
nonlin.RestoreAudioBufferState();
buf.RestoreAudioBufferState();
tnd.RestoreAudioBufferState();
}
// Nonlinearizer
Nonlinearizer::Nonlinearizer()
{
apu = nullptr;
enabled = true;
float const gain = 0x7fff * 1.3f;
// don't use entire range, so any overflow will stay within table
int const range = (int)((double)table_size * Apu::nonlinear_tnd_gain());
for (int i = 0; i < table_size; i++)
{
int const offset = table_size - range;
int j = i - offset;
float n = 202.0f / (range - 1) * j;
float d = 0;
// Prevent division by zero
if (n)
d = gain * 163.67f / (24329.0f / n + 100.0f);
int out = (int)d;
table[j & (table_size - 1)] = out;
}
extra_accum = 0;
extra_prev = 0;
}
Apu *Nonlinearizer::enable(bool b, Blip_Buffer *buf)
{
apu->osc_output(2, buf);
apu->osc_output(3, buf);
apu->osc_output(4, buf);
enabled = b;
if (b)
apu->enable_nonlinear(1.0);
else
apu->volume(1.0);
return apu;
}
#define ENTRY(s) table[(s) >> (blip_sample_bits - table_bits - 1) & (table_size - 1)]
long Nonlinearizer::make_nonlinear(Blip_Buffer &buf, long count)
{
long avail = buf.samples_avail();
if (count > avail)
count = avail;
if (count && enabled)
{
Blip_Buffer::buf_t_ *p = buf.buffer_;
long accum = this->accum;
long prev = this->prev;
for (unsigned n = count; n; --n)
{
long entry = ENTRY(accum);
accum += *p;
*p++ = (entry - prev) << (blip_sample_bits - 16);
prev = entry;
}
this->prev = prev;
this->accum = accum;
}
return count;
}
void Nonlinearizer::clear()
{
accum = 0;
prev = ENTRY(86016000); // avoid thump due to APU's triangle dc bias
// TODO: still results in slight clicks and thumps
}
void Nonlinearizer::SaveAudioBufferState()
{
extra_accum = accum;
extra_prev = prev;
}
void Nonlinearizer::RestoreAudioBufferState()
{
accum = extra_accum;
prev = extra_prev;
}
} // namespace quickNES

82
source/quickerNES/apu/buffer.hpp Normal file
View File

@ -0,0 +1,82 @@
#pragma once
// NES non-linear audio buffer
// Emu 0.7.0
#include "Multi_Buffer.hpp"
#include <cstdint>
namespace quickerNES
{
class Apu;
class Nonlinearizer
{
private:
enum
{
table_bits = 11
};
enum
{
table_size = 1 << table_bits
};
int16_t table[table_size];
Apu *apu;
long accum;
long prev;
long extra_accum;
long extra_prev;
public:
Nonlinearizer();
bool enabled;
void clear();
void set_apu(Apu *a) { apu = a; }
Apu *enable(bool, Blip_Buffer *tnd);
long make_nonlinear(Blip_Buffer &buf, long count);
void SaveAudioBufferState();
void RestoreAudioBufferState();
};
class Buffer : public Multi_Buffer
{
public:
Buffer();
~Buffer();
// Setup APU for use with buffer, including setting its output to this buffer.
// If you're using Emu, this is automatically called for you.
void set_apu(Apu *apu) { nonlin.set_apu(apu); }
// Enable/disable non-linear output
void enable_nonlinearity(bool = true);
// Blip_Buffer to output other sound chips to
Blip_Buffer *buffer() { return &buf; }
// See Multi_Buffer.h
const char *set_sample_rate(long rate, int msec = blip_default_length);
void clock_rate(long);
void bass_freq(int);
void clear();
channel_t channel(int);
void end_frame(blip_time_t, bool unused = true);
long samples_avail() const;
long read_samples(blip_sample_t *, long);
private:
Blip_Buffer buf;
Blip_Buffer tnd;
Nonlinearizer nonlin;
friend Multi_Buffer *set_apu(Buffer *, Apu *);
public:
virtual void SaveAudioBufferState();
virtual void RestoreAudioBufferState();
};
} // namespace quickNES

518
source/quickerNES/apu/effectsBuffer.cpp Normal file
View File

@ -0,0 +1,518 @@
// Game_Music_Emu 0.3.0. http://www.slack.net/~ant/
#include <cstring>
#include "effectsBuffer.hpp"
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
typedef long fixed_t;
#define TO_FIXED(f) fixed_t((f) * (1L << 15) + 0.5)
#define FMUL(x, y) (((x) * (y)) >> 15)
const unsigned echo_size = 4096;
const unsigned echo_mask = echo_size - 1;
static_assert((echo_size & echo_mask) == 0); // must be power of 2
const unsigned reverb_size = 8192 * 2;
const unsigned reverb_mask = reverb_size - 1;
static_assert((reverb_size & reverb_mask) == 0); // must be power of 2
Effects_Buffer::config_t::config_t()
{
pan_1 = -0.15f;
pan_2 = 0.15f;
reverb_delay = 88.0f;
reverb_level = 0.12f;
echo_delay = 61.0f;
echo_level = 0.10f;
delay_variance = 18.0f;
effects_enabled = false;
}
void Effects_Buffer::set_depth(double d)
{
float f = (float)d;
config_t c;
c.pan_1 = -0.6f * f;
c.pan_2 = 0.6f * f;
c.reverb_delay = 880 * 0.1f;
c.echo_delay = 610 * 0.1f;
if (f > 0.5)
f = 0.5; // TODO: more linear reduction of extreme reverb/echo
c.reverb_level = 0.5f * f;
c.echo_level = 0.30f * f;
c.delay_variance = 180 * 0.1f;
c.effects_enabled = (d > 0.0f);
config(c);
}
Effects_Buffer::Effects_Buffer(bool center_only) : Multi_Buffer(2)
{
buf_count = center_only ? max_buf_count - 4 : max_buf_count;
echo_buf = NULL;
echo_pos = 0;
reverb_buf = NULL;
reverb_pos = 0;
stereo_remain = 0;
effect_remain = 0;
effects_enabled = false;
set_depth(0);
}
Effects_Buffer::~Effects_Buffer()
{
delete[] echo_buf;
delete[] reverb_buf;
}
const char *Effects_Buffer::set_sample_rate(long rate, int msec)
{
if (!echo_buf)
{
echo_buf = new blip_sample_t[echo_size];
}
if (!reverb_buf)
{
reverb_buf = new blip_sample_t[reverb_size];
}
for (int i = 0; i < buf_count; i++) bufs[i].set_sample_rate(rate, msec);
config(config_);
clear();
return Multi_Buffer::set_sample_rate(bufs[0].sample_rate(), bufs[0].length());
}
void Effects_Buffer::clock_rate(long rate)
{
for (int i = 0; i < buf_count; i++)
bufs[i].clock_rate(rate);
}
void Effects_Buffer::bass_freq(int freq)
{
for (int i = 0; i < buf_count; i++)
bufs[i].bass_freq(freq);
}
void Effects_Buffer::clear()
{
stereo_remain = 0;
effect_remain = 0;
if (echo_buf)
memset(echo_buf, 0, echo_size * sizeof *echo_buf);
if (reverb_buf)
memset(reverb_buf, 0, reverb_size * sizeof *reverb_buf);
for (int i = 0; i < buf_count; i++)
bufs[i].clear();
}
inline int pin_range(int n, int max, int min = 0)
{
if (n < min)
return min;
if (n > max)
return max;
return n;
}
void Effects_Buffer::config(const config_t &cfg)
{
channels_changed();
// clear echo and reverb buffers
if (!config_.effects_enabled && cfg.effects_enabled && echo_buf)
{
memset(echo_buf, 0, echo_size * sizeof(blip_sample_t));
memset(reverb_buf, 0, reverb_size * sizeof(blip_sample_t));
}
config_ = cfg;
if (config_.effects_enabled)
{
// convert to internal format
chans.pan_1_levels[0] = TO_FIXED(1) - TO_FIXED(config_.pan_1);
chans.pan_1_levels[1] = TO_FIXED(2) - chans.pan_1_levels[0];
chans.pan_2_levels[0] = TO_FIXED(1) - TO_FIXED(config_.pan_2);
chans.pan_2_levels[1] = TO_FIXED(2) - chans.pan_2_levels[0];
chans.reverb_level = TO_FIXED(config_.reverb_level);
chans.echo_level = TO_FIXED(config_.echo_level);
int delay_offset = int(1.0 / 2000 * config_.delay_variance * sample_rate());
int reverb_sample_delay = int(1.0 / 1000 * config_.reverb_delay * sample_rate());
chans.reverb_delay_l = pin_range(reverb_size -
(reverb_sample_delay - delay_offset) * 2,
reverb_size - 2,
0);
chans.reverb_delay_r = pin_range(reverb_size + 1 -
(reverb_sample_delay + delay_offset) * 2,
reverb_size - 1,
1);
int echo_sample_delay = int(1.0 / 1000 * config_.echo_delay * sample_rate());
chans.echo_delay_l = pin_range(echo_size - 1 - (echo_sample_delay - delay_offset),
echo_size - 1);
chans.echo_delay_r = pin_range(echo_size - 1 - (echo_sample_delay + delay_offset),
echo_size - 1);
// set up outputs
for (unsigned i = 0; i < chan_count; i++)
{
channel_t &o = channels[i];
if (i < 2)
{
o.center = &bufs[i];
o.left = &bufs[3];
o.right = &bufs[4];
}
else
{
o.center = &bufs[2];
o.left = &bufs[5];
o.right = &bufs[6];
}
}
}
else
{
// set up outputs
for (unsigned i = 0; i < chan_count; i++)
{
channel_t &o = channels[i];
o.center = &bufs[0];
o.left = &bufs[1];
o.right = &bufs[2];
}
}
if (buf_count < max_buf_count)
{
for (unsigned i = 0; i < chan_count; i++)
{
channel_t &o = channels[i];
o.left = o.center;
o.right = o.center;
}
}
}
void Effects_Buffer::end_frame(blip_time_t clock_count, bool stereo)
{
for (int i = 0; i < buf_count; i++)
bufs[i].end_frame(clock_count);
if (stereo && buf_count == max_buf_count)
stereo_remain = bufs[0].samples_avail() + bufs[0].output_latency();
if (effects_enabled || config_.effects_enabled)
effect_remain = bufs[0].samples_avail() + bufs[0].output_latency();
effects_enabled = config_.effects_enabled;
}
long Effects_Buffer::samples_avail() const
{
return bufs[0].samples_avail() * 2;
}
long Effects_Buffer::read_samples(blip_sample_t *out, long total_samples)
{
long remain = bufs[0].samples_avail();
if (remain > (total_samples >> 1))
remain = (total_samples >> 1);
total_samples = remain;
while (remain)
{
int active_bufs = buf_count;
long count = remain;
// optimizing mixing to skip any channels which had nothing added
if (effect_remain)
{
if (count > effect_remain)
count = effect_remain;
if (stereo_remain)
{
mix_enhanced(out, count);
}
else
{
mix_mono_enhanced(out, count);
active_bufs = 3;
}
}
else if (stereo_remain)
{
mix_stereo(out, count);
active_bufs = 3;
}
else
{
mix_mono(out, count);
active_bufs = 1;
}
out += count * 2;
remain -= count;
stereo_remain -= count;
if (stereo_remain < 0)
stereo_remain = 0;
effect_remain -= count;
if (effect_remain < 0)
effect_remain = 0;
for (int i = 0; i < buf_count; i++)
{
if (i < active_bufs)
bufs[i].remove_samples(count);
else
bufs[i].remove_silence(count); // keep time synchronized
}
}
return total_samples * 2;
}
void Effects_Buffer::mix_mono(blip_sample_t *out, long count)
{
Blip_Reader c;
int shift = c.begin(bufs[0]);
// unrolled loop
for (long n = count >> 1; n--;)
{
long cs0 = c.read();
c.next(shift);
long cs1 = c.read();
c.next(shift);
if ((int16_t)cs0 != cs0)
cs0 = 0x7FFF - (cs0 >> 24);
((uint32_t *)out)[0] = ((uint16_t)cs0) | (cs0 << 16);
if ((int16_t)cs1 != cs1)
cs1 = 0x7FFF - (cs1 >> 24);
((uint32_t *)out)[1] = ((uint16_t)cs1) | (cs1 << 16);
out += 4;
}
if (count & 1)
{
int s = c.read();
c.next(shift);
out[0] = s;
out[1] = s;
if ((int16_t)s != s)
{
s = 0x7FFF - (s >> 24);
out[0] = s;
out[1] = s;
}
}
c.end(bufs[0]);
}
void Effects_Buffer::mix_stereo(blip_sample_t *out, long count)
{
Blip_Reader l;
l.begin(bufs[1]);
Blip_Reader r;
r.begin(bufs[2]);
Blip_Reader c;
int shift = c.begin(bufs[0]);
while (count--)
{
int cs = c.read();
c.next(shift);
int left = cs + l.read();
int right = cs + r.read();
l.next(shift);
r.next(shift);
if ((int16_t)left != left)
left = 0x7FFF - (left >> 24);
out[0] = left;
out[1] = right;
out += 2;
if ((int16_t)right != right)
out[-1] = 0x7FFF - (right >> 24);
}
c.end(bufs[0]);
r.end(bufs[2]);
l.end(bufs[1]);
}
void Effects_Buffer::mix_mono_enhanced(blip_sample_t *out, long count)
{
Blip_Reader sq1;
sq1.begin(bufs[0]);
Blip_Reader sq2;
sq2.begin(bufs[1]);
Blip_Reader center;
int shift = center.begin(bufs[2]);
int echo_pos = this->echo_pos;
int reverb_pos = this->reverb_pos;
while (count--)
{
int sum1_s = sq1.read();
int sum2_s = sq2.read();
sq1.next(shift);
sq2.next(shift);
int new_reverb_l = FMUL(sum1_s, chans.pan_1_levels[0]) +
FMUL(sum2_s, chans.pan_2_levels[0]) +
reverb_buf[(reverb_pos + chans.reverb_delay_l) & reverb_mask];
int new_reverb_r = FMUL(sum1_s, chans.pan_1_levels[1]) +
FMUL(sum2_s, chans.pan_2_levels[1]) +
reverb_buf[(reverb_pos + chans.reverb_delay_r) & reverb_mask];
fixed_t reverb_level = chans.reverb_level;
reverb_buf[reverb_pos] = FMUL(new_reverb_l, reverb_level);
reverb_buf[reverb_pos + 1] = FMUL(new_reverb_r, reverb_level);
reverb_pos = (reverb_pos + 2) & reverb_mask;
int sum3_s = center.read();
center.next(shift);
int left = new_reverb_l + sum3_s + FMUL(chans.echo_level, echo_buf[(echo_pos + chans.echo_delay_l) & echo_mask]);
int right = new_reverb_r + sum3_s + FMUL(chans.echo_level, echo_buf[(echo_pos + chans.echo_delay_r) & echo_mask]);
echo_buf[echo_pos] = sum3_s;
echo_pos = (echo_pos + 1) & echo_mask;
if ((int16_t)left != left)
left = 0x7FFF - (left >> 24);
out[0] = left;
out[1] = right;
out += 2;
if ((int16_t)right != right)
out[-1] = 0x7FFF - (right >> 24);
}
this->reverb_pos = reverb_pos;
this->echo_pos = echo_pos;
sq1.end(bufs[0]);
sq2.end(bufs[1]);
center.end(bufs[2]);
}
void Effects_Buffer::mix_enhanced(blip_sample_t *out, long count)
{
Blip_Reader l1;
l1.begin(bufs[3]);
Blip_Reader r1;
r1.begin(bufs[4]);
Blip_Reader l2;
l2.begin(bufs[5]);
Blip_Reader r2;
r2.begin(bufs[6]);
Blip_Reader sq1;
sq1.begin(bufs[0]);
Blip_Reader sq2;
sq2.begin(bufs[1]);
Blip_Reader center;
int shift = center.begin(bufs[2]);
int echo_pos = this->echo_pos;
int reverb_pos = this->reverb_pos;
while (count--)
{
int sum1_s = sq1.read();
int sum2_s = sq2.read();
sq1.next(shift);
sq2.next(shift);
int new_reverb_l = FMUL(sum1_s, chans.pan_1_levels[0]) +
FMUL(sum2_s, chans.pan_2_levels[0]) + l1.read() +
reverb_buf[(reverb_pos + chans.reverb_delay_l) & reverb_mask];
int new_reverb_r = FMUL(sum1_s, chans.pan_1_levels[1]) +
FMUL(sum2_s, chans.pan_2_levels[1]) + r1.read() +
reverb_buf[(reverb_pos + chans.reverb_delay_r) & reverb_mask];
l1.next(shift);
r1.next(shift);
fixed_t reverb_level = chans.reverb_level;
reverb_buf[reverb_pos] = FMUL(new_reverb_l, reverb_level);
reverb_buf[reverb_pos + 1] = FMUL(new_reverb_r, reverb_level);
reverb_pos = (reverb_pos + 2) & reverb_mask;
int sum3_s = center.read();
center.next(shift);
int left = new_reverb_l + sum3_s + l2.read() + FMUL(chans.echo_level, echo_buf[(echo_pos + chans.echo_delay_l) & echo_mask]);
int right = new_reverb_r + sum3_s + r2.read() + FMUL(chans.echo_level, echo_buf[(echo_pos + chans.echo_delay_r) & echo_mask]);
l2.next(shift);
r2.next(shift);
echo_buf[echo_pos] = sum3_s;
echo_pos = (echo_pos + 1) & echo_mask;
if ((int16_t)left != left)
left = 0x7FFF - (left >> 24);
out[0] = left;
out[1] = right;
out += 2;
if ((int16_t)right != right)
out[-1] = 0x7FFF - (right >> 24);
}
this->reverb_pos = reverb_pos;
this->echo_pos = echo_pos;
sq1.end(bufs[0]);
sq2.end(bufs[1]);
center.end(bufs[2]);
l1.end(bufs[3]);
r1.end(bufs[4]);
l2.end(bufs[5]);
r2.end(bufs[6]);
}
} // namespace quickNES

104
source/quickerNES/apu/effectsBuffer.hpp Normal file
View File

@ -0,0 +1,104 @@
#pragma once
// Multi-channel effects buffer with panning, echo and reverb
// Game_Music_Emu 0.3.0
#include "Multi_Buffer.hpp"
#include <stdint.h>
namespace quickerNES
{
// Effects_Buffer uses several buffers and outputs stereo sample pairs.
class Effects_Buffer : public Multi_Buffer
{
public:
// If center_only is true, only center buffers are created and
// less memory is used.
Effects_Buffer(bool center_only = false);
// Channel Effect Center Pan
// ---------------------------------
// 0,5 reverb pan_1
// 1,6 reverb pan_2
// 2,7 echo -
// 3 echo -
// 4 echo -
// Channel configuration
struct config_t
{
double pan_1; // -1.0 = left, 0.0 = center, 1.0 = right
double pan_2;
double echo_delay; // msec
double echo_level; // 0.0 to 1.0
double reverb_delay; // msec
double delay_variance; // difference between left/right delays (msec)
double reverb_level; // 0.0 to 1.0
bool effects_enabled; // if false, use optimized simple mixer
config_t();
};
// Set configuration of buffer
virtual void config(const config_t &);
void set_depth(double);
public:
~Effects_Buffer();
const char *set_sample_rate(long samples_per_sec, int msec = blip_default_length);
void clock_rate(long);
void bass_freq(int);
void clear();
channel_t channel(int);
void end_frame(blip_time_t, bool was_stereo = true);
long read_samples(blip_sample_t *, long);
long samples_avail() const;
private:
typedef long fixed_t;
enum
{
max_buf_count = 7
};
Blip_Buffer bufs[max_buf_count];
enum
{
chan_count = 5
};
channel_t channels[chan_count];
config_t config_;
long stereo_remain;
long effect_remain;
int buf_count;
bool effects_enabled;
blip_sample_t *reverb_buf;
blip_sample_t *echo_buf;
int reverb_pos;
int echo_pos;
struct
{
fixed_t pan_1_levels[2];
fixed_t pan_2_levels[2];
int echo_delay_l;
int echo_delay_r;
fixed_t echo_level;
int reverb_delay_l;
int reverb_delay_r;
fixed_t reverb_level;
} chans;
void mix_mono(blip_sample_t *, long);
void mix_stereo(blip_sample_t *, long);
void mix_enhanced(blip_sample_t *, long);
void mix_mono_enhanced(blip_sample_t *, long);
};
inline Effects_Buffer::channel_t Effects_Buffer::channel(int i)
{
return channels[i % chan_count];
}
} // namespace quickNES

171
source/quickerNES/apu/fme7/apu.cpp
View File

@ -1,7 +1,7 @@
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "apu/fme7/apu.h"
#include "apu/fme7/apu.hpp"
#include <cstring>
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
@ -15,93 +15,94 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
void Nes_Fme7_Apu::reset()
namespace quickerNES
{
last_time = 0;
for ( int i = 0; i < osc_count; i++ )
oscs [i].last_amp = 0;
fme7_apu_state_t* state = this;
memset( state, 0, sizeof *state );
void Fme7_Apu::reset()
{
last_time = 0;
for (int i = 0; i < osc_count; i++)
oscs[i].last_amp = 0;
fme7_apu_state_t *state = this;
memset(state, 0, sizeof *state);
}
unsigned char Nes_Fme7_Apu::amp_table [16] =
{
#define ENTRY( n ) (unsigned char) (n * +amp_range + 0.5)
ENTRY(0.0000), ENTRY(0.0078), ENTRY(0.0110), ENTRY(0.0156),
ENTRY(0.0221), ENTRY(0.0312), ENTRY(0.0441), ENTRY(0.0624),
ENTRY(0.0883), ENTRY(0.1249), ENTRY(0.1766), ENTRY(0.2498),
ENTRY(0.3534), ENTRY(0.4998), ENTRY(0.7070), ENTRY(1.0000)
#undef ENTRY
unsigned char Fme7_Apu::amp_table[16] =
{
#define ENTRY(n) (unsigned char)(n * +amp_range + 0.5)
ENTRY(0.0000), ENTRY(0.0078), ENTRY(0.0110), ENTRY(0.0156), ENTRY(0.0221), ENTRY(0.0312), ENTRY(0.0441), ENTRY(0.0624), ENTRY(0.0883), ENTRY(0.1249), ENTRY(0.1766), ENTRY(0.2498), ENTRY(0.3534), ENTRY(0.4998), ENTRY(0.7070), ENTRY(1.0000)
#undef ENTRY
};
void Nes_Fme7_Apu::run_until( blip_time_t end_time )
void Fme7_Apu::run_until(blip_time_t end_time)
{
for ( int index = 0; index < osc_count; index++ )
{
int mode = regs [7] >> index;
int vol_mode = regs [010 + index];
int volume = amp_table [vol_mode & 0x0f];
if ( !oscs [index].output )
continue;
if ( (mode & 001) | (vol_mode & 0x10) )
volume = 0; // noise and envelope aren't supported
// period
int const period_factor = 16;
unsigned period = (regs [index * 2 + 1] & 0x0f) * 0x100 * period_factor +
regs [index * 2] * period_factor;
if ( period < 50 ) // around 22 kHz
{
volume = 0;
if ( !period ) // on my AY-3-8910A, period doesn't have extra one added
period = period_factor;
}
// current amplitude
int amp = volume;
if ( !phases [index] )
amp = 0;
int delta = amp - oscs [index].last_amp;
if ( delta )
{
oscs [index].last_amp = amp;
synth.offset( last_time, delta, oscs [index].output );
}
blip_time_t time = last_time + delays [index];
if ( time < end_time )
{
Blip_Buffer* const osc_output = oscs [index].output;
int delta = amp * 2 - volume;
if ( volume )
{
do
{
delta = -delta;
synth.offset_inline( time, delta, osc_output );
time += period;
}
while ( time < end_time );
oscs [index].last_amp = (delta + volume) >> 1;
phases [index] = (delta > 0);
}
else
{
// maintain phase when silent
int count = (end_time - time + period - 1) / period;
phases [index] ^= count & 1;
time += (long) count * period;
}
}
delays [index] = time - end_time;
}
last_time = end_time;
for (int index = 0; index < osc_count; index++)
{
int mode = regs[7] >> index;
int vol_mode = regs[010 + index];
int volume = amp_table[vol_mode & 0x0f];
if (!oscs[index].output)
continue;
if ((mode & 001) | (vol_mode & 0x10))
volume = 0; // noise and envelope aren't supported
// period
int const period_factor = 16;
unsigned period = (regs[index * 2 + 1] & 0x0f) * 0x100 * period_factor +
regs[index * 2] * period_factor;
if (period < 50) // around 22 kHz
{
volume = 0;
if (!period) // on my AY-3-8910A, period doesn't have extra one added
period = period_factor;
}
// current amplitude
int amp = volume;
if (!phases[index])
amp = 0;
int delta = amp - oscs[index].last_amp;
if (delta)
{
oscs[index].last_amp = amp;
synth.offset(last_time, delta, oscs[index].output);
}
blip_time_t time = last_time + delays[index];
if (time < end_time)
{
Blip_Buffer *const osc_output = oscs[index].output;
int delta = amp * 2 - volume;
if (volume)
{
do
{
delta = -delta;
synth.offset_inline(time, delta, osc_output);
time += period;
} while (time < end_time);
oscs[index].last_amp = (delta + volume) >> 1;
phases[index] = (delta > 0);
}
else
{
// maintain phase when silent
int count = (end_time - time + period - 1) / period;
phases[index] ^= count & 1;
time += (long)count * period;
}
}
delays[index] = time - end_time;
}
last_time = end_time;
}
} // namespace quickNES

131
source/quickerNES/apu/fme7/apu.h
View File

@ -1,131 +0,0 @@
#pragma once
// Sunsoft FME-7 sound emulator
// Nes_Emu 0.7.0
#include <cstdint>
#include "apu/Blip_Buffer.h"
struct fme7_apu_state_t
{
enum { reg_count = 14 };
uint8_t regs [reg_count];
uint8_t phases [3]; // 0 or 1
uint8_t latch;
uint16_t delays [3]; // a, b, c
};
static_assert( sizeof (fme7_apu_state_t) == 24 );
class Nes_Fme7_Apu : private fme7_apu_state_t {
public:
Nes_Fme7_Apu();
// See Nes_Apu.h for reference
void reset();
void volume( double );
void treble_eq( blip_eq_t const& );
void output( Blip_Buffer* );
enum { osc_count = 3 };
void osc_output( int index, Blip_Buffer* );
void end_frame( blip_time_t );
void save_state( fme7_apu_state_t* ) const;
void load_state( fme7_apu_state_t const& );
// Mask and addresses of registers
enum { addr_mask = 0xe000 };
enum { data_addr = 0xe000 };
enum { latch_addr = 0xc000 };
// (addr & addr_mask) == latch_addr
void write_latch( int );
// (addr & addr_mask) == data_addr
void write_data( blip_time_t, int data );
// End of public interface
private:
// noncopyable
Nes_Fme7_Apu( const Nes_Fme7_Apu& );
Nes_Fme7_Apu& operator = ( const Nes_Fme7_Apu& );
static unsigned char amp_table [16];
struct {
Blip_Buffer* output;
int last_amp;
} oscs [osc_count];
blip_time_t last_time;
enum { amp_range = 192 }; // can be any value; this gives best error/quality tradeoff
Blip_Synth<blip_good_quality,1> synth;
void run_until( blip_time_t );
};
inline void Nes_Fme7_Apu::volume( double v )
{
synth.volume( 0.38 / +amp_range * v ); // to do: fine-tune
}
inline void Nes_Fme7_Apu::treble_eq( blip_eq_t const& eq )
{
synth.treble_eq( eq );
}
inline void Nes_Fme7_Apu::osc_output( int i, Blip_Buffer* buf )
{
oscs [i].output = buf;
}
inline void Nes_Fme7_Apu::output( Blip_Buffer* buf )
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, buf );
}
inline Nes_Fme7_Apu::Nes_Fme7_Apu()
{
output( 0 );
volume( 1.0 );
reset();
}
inline void Nes_Fme7_Apu::write_latch( int data ) { latch = data; }
inline void Nes_Fme7_Apu::write_data( blip_time_t time, int data )
{
if ( (unsigned) latch >= reg_count )
{
#ifdef dprintf
dprintf( "FME7 write to %02X (past end of sound registers)\n", (int) latch );
#endif
return;
}
run_until( time );
regs [latch] = data;
}
inline void Nes_Fme7_Apu::end_frame( blip_time_t time )
{
if ( time > last_time )
run_until( time );
last_time -= time;
}
inline void Nes_Fme7_Apu::save_state( fme7_apu_state_t* out ) const
{
*out = *this;
}
inline void Nes_Fme7_Apu::load_state( fme7_apu_state_t const& in )
{
reset();
fme7_apu_state_t* state = this;
*state = in;
//Run sound channels for 0 cycles for clean audio after loading state
run_until(last_time);
}

155
source/quickerNES/apu/fme7/apu.hpp Normal file
View File

@ -0,0 +1,155 @@
#pragma once
// Sunsoft FME-7 sound emulator
// Emu 0.7.0
#include <cstdint>
#include "apu/Blip_Buffer.hpp"
namespace quickerNES
{
struct fme7_apu_state_t
{
enum
{
reg_count = 14
};
uint8_t regs[reg_count];
uint8_t phases[3]; // 0 or 1
uint8_t latch;
uint16_t delays[3]; // a, b, c
};
static_assert(sizeof(fme7_apu_state_t) == 24);
class Fme7_Apu : private fme7_apu_state_t
{
public:
Fme7_Apu();
// See Apu.h for reference
void reset();
void volume(double);
void treble_eq(blip_eq_t const &);
void output(Blip_Buffer *);
enum
{
osc_count = 3
};
void osc_output(int index, Blip_Buffer *);
void end_frame(blip_time_t);
void save_state(fme7_apu_state_t *) const;
void load_state(fme7_apu_state_t const &);
// Mask and addresses of registers
enum
{
addr_mask = 0xe000
};
enum
{
data_addr = 0xe000
};
enum
{
latch_addr = 0xc000
};
// (addr & addr_mask) == latch_addr
void write_latch(int);
// (addr & addr_mask) == data_addr
void write_data(blip_time_t, int data);
// End of public interface
private:
// noncopyable
Fme7_Apu(const Fme7_Apu &);
Fme7_Apu &operator=(const Fme7_Apu &);
static unsigned char amp_table[16];
struct
{
Blip_Buffer *output;
int last_amp;
} oscs[osc_count];
blip_time_t last_time;
enum
{
amp_range = 192
}; // can be any value; this gives best error/quality tradeoff
Blip_Synth<blip_good_quality, 1> synth;
void run_until(blip_time_t);
};
inline void Fme7_Apu::volume(double v)
{
synth.volume(0.38 / +amp_range * v); // to do: fine-tune
}
inline void Fme7_Apu::treble_eq(blip_eq_t const &eq)
{
synth.treble_eq(eq);
}
inline void Fme7_Apu::osc_output(int i, Blip_Buffer *buf)
{
oscs[i].output = buf;
}
inline void Fme7_Apu::output(Blip_Buffer *buf)
{
for (int i = 0; i < osc_count; i++)
osc_output(i, buf);
}
inline Fme7_Apu::Fme7_Apu()
{
output(0);
volume(1.0);
reset();
}
inline void Fme7_Apu::write_latch(int data) { latch = data; }
inline void Fme7_Apu::write_data(blip_time_t time, int data)
{
if ((unsigned)latch >= reg_count)
{
#ifdef dprintf
dprintf("FME7 write to %02X (past end of sound registers)\n", (int)latch);
#endif
return;
}
run_until(time);
regs[latch] = data;
}
inline void Fme7_Apu::end_frame(blip_time_t time)
{
if (time > last_time)
run_until(time);
last_time -= time;
}
inline void Fme7_Apu::save_state(fme7_apu_state_t *out) const
{
*out = *this;
}
inline void Fme7_Apu::load_state(fme7_apu_state_t const &in)
{
reset();
fme7_apu_state_t *state = this;
*state = in;
// Run sound channels for 0 cycles for clean audio after loading state
run_until(last_time);
}
} // namespace quickNES

238
source/quickerNES/apu/namco/apu.cpp
View File

@ -1,8 +1,8 @@
// Nes_Snd_Emu 0.1.7. http://www.slack.net/~ant/
// Snd_Emu 0.1.7. http://www.slack.net/~ant/
#include "apu/Blip_Buffer.h"
#include "apu/namco/apu.h"
#include "apu/namco/apu.hpp"
#include "apu/Blip_Buffer.hpp"
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -15,165 +15,169 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
Nes_Namco_Apu::Nes_Namco_Apu()
namespace quickerNES
{
output( 0 );
volume( 1.0 );
reset();
Namco_Apu::Namco_Apu()
{
output(0);
volume(1.0);
reset();
}
Nes_Namco_Apu::~Nes_Namco_Apu()
Namco_Apu::~Namco_Apu()
{
}
void Nes_Namco_Apu::reset()
void Namco_Apu::reset()
{
last_time = 0;
addr_reg = 0;
last_time = 0;
addr_reg = 0;
int i;
for ( i = 0; i < reg_count; i++ )
reg [i] = 0;
int i;
for (i = 0; i < reg_count; i++)
reg[i] = 0;
for ( i = 0; i < osc_count; i++ )
{
Namco_Osc& osc = oscs [i];
osc.delay = 0;
osc.last_amp = 0;
osc.wave_pos = 0;
}
for (i = 0; i < osc_count; i++)
{
Namco_Osc &osc = oscs[i];
osc.delay = 0;
osc.last_amp = 0;
osc.wave_pos = 0;
}
}
void Nes_Namco_Apu::output( Blip_Buffer* buf )
void Namco_Apu::output(Blip_Buffer *buf)
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, buf );
for (int i = 0; i < osc_count; i++)
osc_output(i, buf);
}
/*
void Nes_Namco_Apu::reflect_state( Tagged_Data& data )
void Namco_Apu::reflect_state( Tagged_Data& data )
{
reflect_int16( data, 'ADDR', &addr_reg );
reflect_int16( data, 'ADDR', &addr_reg );
static const char hex [17] = "0123456789ABCDEF";
int i;
for ( i = 0; i < reg_count; i++ )
reflect_int16( data, 'RG\0\0' + hex [i >> 4] * 0x100 + hex [i & 15], &reg [i] );
static const char hex [17] = "0123456789ABCDEF";
int i;
for ( i = 0; i < reg_count; i++ )
reflect_int16( data, 'RG\0\0' + hex [i >> 4] * 0x100 + hex [i & 15], &reg [i] );
for ( i = 0; i < osc_count; i++ )
{
reflect_int32( data, 'DLY0' + i, &oscs [i].delay );
reflect_int16( data, 'POS0' + i, &oscs [i].wave_pos );
}
for ( i = 0; i < osc_count; i++ )
{
reflect_int32( data, 'DLY0' + i, &oscs [i].delay );
reflect_int16( data, 'POS0' + i, &oscs [i].wave_pos );
}
}
*/
void Nes_Namco_Apu::end_frame( nes_time_t time )
void Namco_Apu::end_frame(nes_time_t time)
{
if ( time > last_time )
run_until( time );
if (time > last_time)
run_until(time);
last_time -= time;
last_time -= time;
}
void Nes_Namco_Apu::run_until( nes_time_t nes_end_time )
void Namco_Apu::run_until(nes_time_t nes_end_time)
{
int active_oscs = (reg [0x7F] >> 4 & 7) + 1;
for ( int i = osc_count - active_oscs; i < osc_count; i++ )
{
Namco_Osc& osc = oscs [i];
Blip_Buffer* output = osc.output;
if ( !output )
continue;
int active_oscs = (reg[0x7F] >> 4 & 7) + 1;
for (int i = osc_count - active_oscs; i < osc_count; i++)
{
Namco_Osc &osc = oscs[i];
Blip_Buffer *output = osc.output;
if (!output)
continue;
blip_resampled_time_t time =
output->resampled_time( last_time ) + osc.delay;
blip_resampled_time_t end_time = output->resampled_time( nes_end_time );
osc.delay = 0;
if ( time < end_time )
{
const uint8_t* osc_reg = &reg [i * 8 + 0x40];
if ( !(osc_reg [4] & 0xE0) )
continue;
blip_resampled_time_t time =
output->resampled_time(last_time) + osc.delay;
blip_resampled_time_t end_time = output->resampled_time(nes_end_time);
osc.delay = 0;
if (time < end_time)
{
const uint8_t *osc_reg = &reg[i * 8 + 0x40];
if (!(osc_reg[4] & 0xE0))
continue;
int volume = osc_reg [7] & 15;
if ( !volume )
continue;
int volume = osc_reg[7] & 15;
if (!volume)
continue;
long freq = (osc_reg [4] & 3) * 0x10000 + osc_reg [2] * 0x100L + osc_reg [0];
if ( freq < 64 * active_oscs )
continue; // prevent low frequencies from excessively delaying freq changes
blip_resampled_time_t period =
output->resampled_duration( 983040 ) / freq * active_oscs;
long freq = (osc_reg[4] & 3) * 0x10000 + osc_reg[2] * 0x100L + osc_reg[0];
if (freq < 64 * active_oscs)
continue; // prevent low frequencies from excessively delaying freq changes
blip_resampled_time_t period =
output->resampled_duration(983040) / freq * active_oscs;
int wave_size = 32 - (osc_reg [4] >> 2 & 7) * 4;
if ( !wave_size )
continue;
int wave_size = 32 - (osc_reg[4] >> 2 & 7) * 4;
if (!wave_size)
continue;
int last_amp = osc.last_amp;
int wave_pos = osc.wave_pos;
int last_amp = osc.last_amp;
int wave_pos = osc.wave_pos;
do
{
// read wave sample
int addr = wave_pos + osc_reg [6];
int sample = reg [addr >> 1] >> (addr << 2 & 4);
wave_pos++;
sample = (sample & 15) * volume;
do
{
// read wave sample
int addr = wave_pos + osc_reg[6];
int sample = reg[addr >> 1] >> (addr << 2 & 4);
wave_pos++;
sample = (sample & 15) * volume;
// output impulse if amplitude changed
int delta = sample - last_amp;
if ( delta )
{
last_amp = sample;
synth.offset_resampled( time, delta, output );
}
// output impulse if amplitude changed
int delta = sample - last_amp;
if (delta)
{
last_amp = sample;
synth.offset_resampled(time, delta, output);
}
// next sample
time += period;
if ( wave_pos >= wave_size )
wave_pos = 0;
}
while ( time < end_time );
// next sample
time += period;
if (wave_pos >= wave_size)
wave_pos = 0;
} while (time < end_time);
osc.wave_pos = wave_pos;
osc.last_amp = last_amp;
}
osc.delay = time - end_time;
}
osc.wave_pos = wave_pos;
osc.last_amp = last_amp;
}
osc.delay = time - end_time;
}
last_time = nes_end_time;
last_time = nes_end_time;
}
void Nes_Namco_Apu::save_state( namco_state_t* out ) const
void Namco_Apu::save_state(namco_state_t *out) const
{
out->addr = addr_reg;
for ( int r = 0; r < reg_count; r++ )
out->regs [ r ] = reg [ r ];
out->addr = addr_reg;
for (int r = 0; r < reg_count; r++)
out->regs[r] = reg[r];
for ( int i = 0; i < osc_count; i++ )
{
Namco_Osc const& osc = oscs [ i ];
for (int i = 0; i < osc_count; i++)
{
Namco_Osc const &osc = oscs[i];
out->delays [ i ] = osc.delay;
out->positions [ i ] = osc.wave_pos;
}
out->delays[i] = osc.delay;
out->positions[i] = osc.wave_pos;
}
}
void Nes_Namco_Apu::load_state( namco_state_t const& in )
void Namco_Apu::load_state(namco_state_t const &in)
{
reset();
addr_reg = in.addr;
for ( int r = 0; r < reg_count; r++ )
reg [ r ] = in.regs [ r ];
reset();
addr_reg = in.addr;
for (int r = 0; r < reg_count; r++)
reg[r] = in.regs[r];
for ( int i = 0; i < osc_count; i++ )
{
Namco_Osc& osc = oscs [ i ];
for (int i = 0; i < osc_count; i++)
{
Namco_Osc &osc = oscs[i];
osc.delay = in.delays [ i ];
osc.wave_pos = in.positions [ i ];
}
osc.delay = in.delays[i];
osc.wave_pos = in.positions[i];
}
run_until( last_time );
run_until(last_time);
}
} // namespace quickNES

97
source/quickerNES/apu/namco/apu.h
View File

@ -1,97 +0,0 @@
#pragma once
// Namco 106 sound chip emulator
// Nes_Snd_Emu 0.1.7
#include <cstdint>
#include "apu/apu.h"
struct namco_state_t
{
uint8_t regs [0x80];
uint8_t addr;
uint8_t unused;
uint8_t positions [8];
uint32_t delays [8];
};
static_assert( sizeof (namco_state_t) == 172 );
class Nes_Namco_Apu {
public:
Nes_Namco_Apu();
~Nes_Namco_Apu();
// See Nes_Apu.h for reference.
void volume( double );
void treble_eq( const blip_eq_t& );
void output( Blip_Buffer* );
enum { osc_count = 8 };
void osc_output( int index, Blip_Buffer* );
void reset();
void end_frame( nes_time_t );
// Read/write data register is at 0x4800
enum { data_reg_addr = 0x4800 };
void write_data( nes_time_t, int );
int read_data();
// Write-only address register is at 0xF800
enum { addr_reg_addr = 0xF800 };
void write_addr( int );
// to do: implement save/restore
void save_state( namco_state_t* out ) const;
void load_state( namco_state_t const& );
private:
// noncopyable
Nes_Namco_Apu( const Nes_Namco_Apu& );
Nes_Namco_Apu& operator = ( const Nes_Namco_Apu& );
struct Namco_Osc {
long delay;
Blip_Buffer* output;
short last_amp;
short wave_pos;
};
Namco_Osc oscs [osc_count];
nes_time_t last_time;
int addr_reg;
enum { reg_count = 0x80 };
uint8_t reg [reg_count];
Blip_Synth<blip_good_quality,15> synth;
uint8_t& access();
void run_until( nes_time_t );
};
inline uint8_t& Nes_Namco_Apu::access()
{
int addr = addr_reg & 0x7f;
if ( addr_reg & 0x80 )
addr_reg = (addr + 1) | 0x80;
return reg [addr];
}
inline void Nes_Namco_Apu::volume( double v ) { synth.volume( 0.10 / +osc_count * v ); }
inline void Nes_Namco_Apu::treble_eq( const blip_eq_t& eq ) { synth.treble_eq( eq ); }
inline void Nes_Namco_Apu::write_addr( int v ) { addr_reg = v; }
inline int Nes_Namco_Apu::read_data() { return access(); }
inline void Nes_Namco_Apu::osc_output( int i, Blip_Buffer* buf )
{
oscs [i].output = buf;
}
inline void Nes_Namco_Apu::write_data( nes_time_t time, int data )
{
run_until( time );
access() = data;
}

115
source/quickerNES/apu/namco/apu.hpp Normal file
View File

@ -0,0 +1,115 @@
#pragma once
// Namco 106 sound chip emulator
// Snd_Emu 0.1.7
#include <cstdint>
#include "apu/apu.hpp"
namespace quickerNES
{
struct namco_state_t
{
uint8_t regs[0x80];
uint8_t addr;
uint8_t unused;
uint8_t positions[8];
uint32_t delays[8];
};
static_assert(sizeof(namco_state_t) == 172);
class Namco_Apu
{
public:
Namco_Apu();
~Namco_Apu();
// See Apu.h for reference.
void volume(double);
void treble_eq(const blip_eq_t &);
void output(Blip_Buffer *);
enum
{
osc_count = 8
};
void osc_output(int index, Blip_Buffer *);
void reset();
void end_frame(nes_time_t);
// Read/write data register is at 0x4800
enum
{
data_reg_addr = 0x4800
};
void write_data(nes_time_t, int);
int read_data();
// Write-only address register is at 0xF800
enum
{
addr_reg_addr = 0xF800
};
void write_addr(int);
// to do: implement save/restore
void save_state(namco_state_t *out) const;
void load_state(namco_state_t const &);
private:
// noncopyable
Namco_Apu(const Namco_Apu &);
Namco_Apu &operator=(const Namco_Apu &);
struct Namco_Osc
{
long delay;
Blip_Buffer *output;
short last_amp;
short wave_pos;
};
Namco_Osc oscs[osc_count];
nes_time_t last_time;
int addr_reg;
enum
{
reg_count = 0x80
};
uint8_t reg[reg_count];
Blip_Synth<blip_good_quality, 15> synth;
uint8_t &access();
void run_until(nes_time_t);
};
inline uint8_t &Namco_Apu::access()
{
int addr = addr_reg & 0x7f;
if (addr_reg & 0x80)
addr_reg = (addr + 1) | 0x80;
return reg[addr];
}
inline void Namco_Apu::volume(double v) { synth.volume(0.10 / +osc_count * v); }
inline void Namco_Apu::treble_eq(const blip_eq_t &eq) { synth.treble_eq(eq); }
inline void Namco_Apu::write_addr(int v) { addr_reg = v; }
inline int Namco_Apu::read_data() { return access(); }
inline void Namco_Apu::osc_output(int i, Blip_Buffer *buf)
{
oscs[i].output = buf;
}
inline void Namco_Apu::write_data(nes_time_t time, int data)
{
run_until(time);
access() = data;
}
} // namespace quickNES

682
source/quickerNES/apu/oscs.cpp Normal file
View File

@ -0,0 +1,682 @@
// Snd_Emu 0.1.7. http://www.slack.net/~ant/
#include "apu.hpp"
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// Osc
void Osc::clock_length(int halt_mask)
{
if (length_counter && !(regs[0] & halt_mask))
length_counter--;
}
void Envelope::clock_envelope()
{
int period = regs[0] & 15;
if (reg_written[3])
{
reg_written[3] = false;
env_delay = period;
envelope = 15;
}
else if (--env_delay < 0)
{
env_delay = period;
if (envelope | (regs[0] & 0x20))
envelope = (envelope - 1) & 15;
}
}
int Envelope::volume() const
{
return length_counter == 0 ? 0 : (regs[0] & 0x10) ? (regs[0] & 15)
: envelope;
}
// Square
void Square::clock_sweep(int negative_adjust)
{
int sweep = regs[1];
if (--sweep_delay < 0)
{
reg_written[1] = true;
int period = this->period();
int shift = sweep & shift_mask;
if (shift && (sweep & 0x80) && period >= 8)
{
int offset = period >> shift;
if (sweep & negate_flag)
offset = negative_adjust - offset;
if (period + offset < 0x800)
{
period += offset;
// rewrite period
regs[2] = period & 0xff;
regs[3] = (regs[3] & ~7) | ((period >> 8) & 7);
}
}
}
if (reg_written[1])
{
reg_written[1] = false;
sweep_delay = (sweep >> 4) & 7;
}
}
// TODO: clean up
inline nes_time_t Square::maintain_phase(nes_time_t time, nes_time_t end_time, nes_time_t timer_period)
{
long remain = end_time - time;
if (remain > 0)
{
int count = (remain + timer_period - 1) / timer_period;
phase = (phase + count) & (phase_range - 1);
time += (long)count * timer_period;
}
return time;
}
void Square::run(nes_time_t time, nes_time_t end_time)
{
const int period = this->period();
const int timer_period = (period + 1) * 2;
if (!output)
{
delay = maintain_phase(time + delay, end_time, timer_period) - end_time;
return;
}
int offset = period >> (regs[1] & shift_mask);
if (regs[1] & negate_flag)
offset = 0;
const int volume = this->volume();
if (volume == 0 || period < 8 || (period + offset) >= 0x800)
{
if (last_amp)
{
synth.offset(time, -last_amp, output);
last_amp = 0;
}
time += delay;
time = maintain_phase(time, end_time, timer_period);
}
else
{
// handle duty select
int duty_select = (regs[0] >> 6) & 3;
int duty = 1 << duty_select; // 1, 2, 4, 2
int amp = 0;
if (duty_select == 3)
{
duty = 2; // negated 25%
amp = volume;
}
if (phase < duty)
amp ^= volume;
int delta = update_amp(amp);
if (delta)
synth.offset(time, delta, output);
time += delay;
if (time < end_time)
{
Blip_Buffer *const output = this->output;
const Synth &synth = this->synth;
int delta = amp * 2 - volume;
int phase = this->phase;
do {
phase = (phase + 1) & (phase_range - 1);
if (phase == 0 || phase == duty)
{
delta = -delta;
synth.offset_inline(time, delta, output);
}
time += timer_period;
} while (time < end_time);
last_amp = (delta + volume) >> 1;
this->phase = phase;
}
}
delay = time - end_time;
}
// Triangle
void Triangle::clock_linear_counter()
{
if (reg_written[3])
linear_counter = regs[0] & 0x7f;
else if (linear_counter)
linear_counter--;
if (!(regs[0] & 0x80))
reg_written[3] = false;
}
inline int Triangle::calc_amp() const
{
int amp = phase_range - phase;
if (amp < 0)
amp = phase - (phase_range + 1);
return amp;
}
// TODO: clean up
inline nes_time_t Triangle::maintain_phase(nes_time_t time, nes_time_t end_time, nes_time_t timer_period)
{
long remain = end_time - time;
if (remain > 0)
{
int count = (remain + timer_period - 1) / timer_period;
phase = ((unsigned)phase + 1 - count) & (phase_range * 2 - 1);
phase++;
time += (long)count * timer_period;
}
return time;
}
void Triangle::run(nes_time_t time, nes_time_t end_time)
{
const int timer_period = period() + 1;
if (!output)
{
time += delay;
delay = 0;
if (length_counter && linear_counter && timer_period >= 3)
delay = maintain_phase(time, end_time, timer_period) - end_time;
return;
}
// to do: track phase when period < 3
// to do: Output 7.5 on dac when period < 2? More accurate, but results in more clicks.
int delta = update_amp(calc_amp());
if (delta)
synth.offset(time, delta, output);
time += delay;
if (length_counter == 0 || linear_counter == 0 || timer_period < 3)
{
time = end_time;
}
else if (time < end_time)
{
Blip_Buffer *const output = this->output;
int phase = this->phase;
int volume = 1;
if (phase > phase_range)
{
phase -= phase_range;
volume = -volume;
}
do {
if (--phase == 0)
{
phase = phase_range;
volume = -volume;
}
else
{
synth.offset_inline(time, volume, output);
}
time += timer_period;
} while (time < end_time);
if (volume < 0)
phase += phase_range;
this->phase = phase;
last_amp = calc_amp();
}
delay = time - end_time;
}
// Dmc
void Dmc::reset()
{
address = 0;
dac = 0;
buf = 0;
bits_remain = 1;
bits = 0;
buf_full = false;
silence = true;
next_irq = Apu::no_irq;
irq_flag = false;
irq_enabled = false;
Osc::reset();
period = 0x1ac;
}
void Dmc::recalc_irq()
{
nes_time_t irq = Apu::no_irq;
if (irq_enabled && length_counter)
irq = apu->last_dmc_time + delay +
((length_counter - 1) * 8 + bits_remain - 1) * nes_time_t(period) + 1;
if (irq != next_irq)
{
next_irq = irq;
apu->irq_changed();
}
}
int Dmc::count_reads(nes_time_t time, nes_time_t *last_read) const
{
if (last_read)
*last_read = time;
if (length_counter == 0)
return 0; // not reading
long first_read = next_read_time();
long avail = time - first_read;
if (avail <= 0)
return 0;
int count = (avail - 1) / (period * 8) + 1;
if (!(regs[0] & loop_flag) && count > length_counter)
count = length_counter;
if (last_read)
*last_read = first_read + (count - 1) * (period * 8) + 1;
return count;
}
static const short dmc_period_table[2][16] = {
{0x1ac, 0x17c, 0x154, 0x140, 0x11e, 0x0fe, 0x0e2, 0x0d6, // NTSC
0x0be,
0x0a0,
0x08e,
0x080,
0x06a,
0x054,
0x048,
0x036},
{0x18e, 0x161, 0x13c, 0x129, 0x10a, 0x0ec, 0x0d2, 0x0c7, // PAL (totally untested)
0x0b1,
0x095,
0x084,
0x077,
0x062,
0x04e,
0x043,
0x032} // to do: verify PAL periods
};
inline void Dmc::reload_sample()
{
address = 0x4000 + regs[2] * 0x40;
length_counter = regs[3] * 0x10 + 1;
}
static const unsigned char dac_table[128] =
{
0,
1,
2,
3,
4,
5,
6,
7,
7,
8,
9,
10,
11,
12,
13,
14,
15,
15,
16,
17,
18,
19,
20,
20,
21,
22,
23,
24,
24,
25,
26,
27,
27,
28,
29,
30,
31,
31,
32,
33,
33,
34,
35,
36,
36,
37,
38,
38,
39,
40,
41,
41,
42,
43,
43,
44,
45,
45,
46,
47,
47,
48,
48,
49,
50,
50,
51,
52,
52,
53,
53,
54,
55,
55,
56,
56,
57,
58,
58,
59,
59,
60,
60,
61,
61,
62,
63,
63,
64,
64,
65,
65,
66,
66,
67,
67,
68,
68,
69,
70,
70,
71,
71,
72,
72,
73,
73,
74,
74,
75,
75,
75,
76,
76,
77,
77,
78,
78,
79,
79,
80,
80,
81,
81,
82,
82,
82,
83,
};
void Dmc::write_register(int addr, int data)
{
if (addr == 0)
{
period = dmc_period_table[pal_mode][data & 15];
irq_enabled = (data & 0xc0) == 0x80; // enabled only if loop disabled
irq_flag &= irq_enabled;
recalc_irq();
}
else if (addr == 1)
{
int old_dac = dac;
dac = data & 0x7F;
// adjust last_amp so that "pop" amplitude will be properly non-linear
// with respect to change in dac
int faked_nonlinear = dac - (dac_table[dac] - dac_table[old_dac]);
if (!nonlinear)
last_amp = faked_nonlinear;
}
}
void Dmc::start()
{
reload_sample();
fill_buffer();
recalc_irq();
}
void Dmc::fill_buffer()
{
if (!buf_full && length_counter)
{
buf = prg_reader(prg_reader_data, 0x8000u + address);
address = (address + 1) & 0x7FFF;
buf_full = true;
if (--length_counter == 0)
{
if (regs[0] & loop_flag)
{
reload_sample();
}
else
{
apu->osc_enables &= ~0x10;
irq_flag = irq_enabled;
next_irq = Apu::no_irq;
apu->irq_changed();
}
}
}
}
void Dmc::run(nes_time_t time, nes_time_t end_time)
{
int delta = update_amp(dac);
if (!output)
silence = true;
else if (delta)
synth.offset(time, delta, output);
time += delay;
if (time < end_time)
{
int bits_remain = this->bits_remain;
if (silence && !buf_full)
{
int count = (end_time - time + period - 1) / period;
bits_remain = (bits_remain - 1 + 8 - (count % 8)) % 8 + 1;
time += count * period;
}
else
{
Blip_Buffer *const output = this->output;
const int period = this->period;
int bits = this->bits;
int dac = this->dac;
do
{
if (!silence)
{
int step = (bits & 1) * 4 - 2;
bits >>= 1;
if (unsigned(dac + step) <= 0x7F)
{
dac += step;
synth.offset_inline(time, step, output);
}
}
time += period;
if (--bits_remain == 0)
{
bits_remain = 8;
if (!buf_full)
{
silence = true;
}
else
{
silence = false;
bits = buf;
buf_full = false;
if (!output)
silence = true;
fill_buffer();
}
}
} while (time < end_time);
this->dac = dac;
this->last_amp = dac;
this->bits = bits;
}
this->bits_remain = bits_remain;
}
delay = time - end_time;
}
// Noise
static const short noise_period_table[16] = {
0x004, 0x008, 0x010, 0x020, 0x040, 0x060, 0x080, 0x0A0, 0x0CA, 0x0FE, 0x17C, 0x1FC, 0x2FA, 0x3F8, 0x7F2, 0xFE4};
void Noise::run(nes_time_t time, nes_time_t end_time)
{
int period = noise_period_table[regs[2] & 15];
#if NES_APU_NOISE_LOW_CPU
if (period < 8)
{
period = 8;
}
#endif
if (!output)
{
// TODO: clean up
time += delay;
delay = time + (end_time - time + period - 1) / period * period - end_time;
return;
}
const int volume = this->volume();
int amp = (noise & 1) ? volume : 0;
int delta = update_amp(amp);
if (delta)
synth.offset(time, delta, output);
time += delay;
if (time < end_time)
{
const int mode_flag = 0x80;
if (!volume)
{
// round to next multiple of period
time += (end_time - time + period - 1) / period * period;
// approximate noise cycling while muted, by shuffling up noise register
// to do: precise muted noise cycling?
if (!(regs[2] & mode_flag))
{
int feedback = (noise << 13) ^ (noise << 14);
noise = (feedback & 0x4000) | (noise >> 1);
}
}
else
{
Blip_Buffer *const output = this->output;
// using resampled time avoids conversion in synth.offset()
blip_resampled_time_t rperiod = output->resampled_duration(period);
blip_resampled_time_t rtime = output->resampled_time(time);
int noise = this->noise;
int delta = amp * 2 - volume;
const int tap = (regs[2] & mode_flag ? 8 : 13);
do {
int feedback = (noise << tap) ^ (noise << 14);
time += period;
if ((noise + 1) & 2)
{
// bits 0 and 1 of noise differ
delta = -delta;
synth.offset_resampled(rtime, delta, output);
}
rtime += rperiod;
noise = (feedback & 0x4000) | (noise >> 1);
} while (time < end_time);
last_amp = (delta + volume) >> 1;
this->noise = noise;
}
}
delay = time - end_time;
}
} // namespace quickNES

172
source/quickerNES/apu/oscs.hpp Normal file
View File

@ -0,0 +1,172 @@
#pragma once
// Private oscillators used by Apu
// Snd_Emu 0.1.7
#include "Blip_Buffer.hpp"
namespace quickerNES
{
class Apu;
typedef long nes_time_t; // CPU clock cycle count
typedef unsigned nes_addr_t; // 16-bit memory address
struct Osc
{
unsigned char regs[4];
bool reg_written[4];
Blip_Buffer *output;
int length_counter; // length counter (0 if unused by oscillator)
int delay; // delay until next (potential) transition
int last_amp; // last amplitude oscillator was outputting
void clock_length(int halt_mask);
int period() const
{
return (regs[3] & 7) * 0x100 + (regs[2] & 0xff);
}
void reset()
{
delay = 0;
last_amp = 0;
}
int update_amp(int amp)
{
int delta = amp - last_amp;
last_amp = amp;
return delta;
}
};
struct Envelope : Osc
{
int envelope;
int env_delay;
void clock_envelope();
int volume() const;
void reset()
{
envelope = 0;
env_delay = 0;
Osc::reset();
}
};
// Square
struct Square : Envelope
{
enum
{
negate_flag = 0x08
};
enum
{
shift_mask = 0x07
};
enum
{
phase_range = 8
};
int phase;
int sweep_delay;
typedef Blip_Synth<blip_good_quality, 1> Synth;
Synth const &synth; // shared between squares
Square(Synth const *s) : synth(*s) {}
void clock_sweep(int adjust);
void run(nes_time_t, nes_time_t);
void reset()
{
sweep_delay = 0;
Envelope::reset();
}
nes_time_t maintain_phase(nes_time_t time, nes_time_t end_time, nes_time_t timer_period);
};
// Triangle
struct Triangle : Osc
{
enum
{
phase_range = 16
};
int phase;
int linear_counter;
Blip_Synth<blip_med_quality, 1> synth;
int calc_amp() const;
void run(nes_time_t, nes_time_t);
void clock_linear_counter();
void reset()
{
linear_counter = 0;
phase = 1;
Osc::reset();
}
nes_time_t maintain_phase(nes_time_t time, nes_time_t end_time, nes_time_t timer_period);
};
// Noise
struct Noise : Envelope
{
int noise;
Blip_Synth<blip_med_quality, 1> synth;
void run(nes_time_t, nes_time_t);
void reset()
{
noise = 1 << 14;
Envelope::reset();
}
};
// Dmc
struct Dmc : Osc
{
int address; // address of next byte to read
int period;
// int length_counter; // bytes remaining to play (already defined in Osc)
int buf;
int bits_remain;
int bits;
bool buf_full;
bool silence;
enum
{
loop_flag = 0x40
};
int dac;
nes_time_t next_irq;
bool irq_enabled;
bool irq_flag;
bool pal_mode;
bool nonlinear;
int (*prg_reader)(void *, nes_addr_t); // needs to be initialized to prg read function
void *prg_reader_data;
Apu *apu;
Blip_Synth<blip_med_quality, 1> synth;
void start();
void write_register(int, int);
void run(nes_time_t, nes_time_t);
void recalc_irq();
void fill_buffer();
void reload_sample();
void reset();
int count_reads(nes_time_t, nes_time_t *) const;
nes_time_t next_read_time() const;
};
} // namespace quickNES

333
source/quickerNES/apu/vrc6/apu.cpp
View File

@ -1,7 +1,7 @@
// Nes_Snd_Emu 0.1.7. http://www.slack.net/~ant/
// Snd_Emu 0.1.7. http://www.slack.net/~ant/
#include "apu/vrc6/apu.h"
#include "apu/vrc6/apu.hpp"
/* Copyright (C) 2003-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -14,199 +14,202 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
Nes_Vrc6_Apu::Nes_Vrc6_Apu()
namespace quickerNES
{
output( 0 );
volume( 1.0 );
reset();
Vrc6_Apu::Vrc6_Apu()
{
output(0);
volume(1.0);
reset();
}
Nes_Vrc6_Apu::~Nes_Vrc6_Apu()
Vrc6_Apu::~Vrc6_Apu()
{
}
void Nes_Vrc6_Apu::reset()
void Vrc6_Apu::reset()
{
last_time = 0;
for ( int i = 0; i < osc_count; i++ )
{
Vrc6_Osc& osc = oscs [i];
for ( int j = 0; j < reg_count; j++ )
osc.regs [j] = 0;
osc.delay = 0;
osc.last_amp = 0;
osc.phase = 1;
osc.amp = 0;
}
last_time = 0;
for (int i = 0; i < osc_count; i++)
{
Vrc6_Osc &osc = oscs[i];
for (int j = 0; j < reg_count; j++)
osc.regs[j] = 0;
osc.delay = 0;
osc.last_amp = 0;
osc.phase = 1;
osc.amp = 0;
}
}
void Nes_Vrc6_Apu::output( Blip_Buffer* buf )
void Vrc6_Apu::output(Blip_Buffer *buf)
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, buf );
for (int i = 0; i < osc_count; i++)
osc_output(i, buf);
}
void Nes_Vrc6_Apu::run_until( nes_time_t time )
void Vrc6_Apu::run_until(nes_time_t time)
{
run_square( oscs [0], time );
run_square( oscs [1], time );
run_saw( time );
last_time = time;
run_square(oscs[0], time);
run_square(oscs[1], time);
run_saw(time);
last_time = time;
}
void Nes_Vrc6_Apu::write_osc( nes_time_t time, int osc_index, int reg, int data )
void Vrc6_Apu::write_osc(nes_time_t time, int osc_index, int reg, int data)
{
run_until( time );
oscs [osc_index].regs [reg] = data;
run_until(time);
oscs[osc_index].regs[reg] = data;
}
void Nes_Vrc6_Apu::end_frame( nes_time_t time )
void Vrc6_Apu::end_frame(nes_time_t time)
{
if ( time > last_time )
run_until( time );
last_time -= time;
if (time > last_time)
run_until(time);
last_time -= time;
}
void Nes_Vrc6_Apu::save_state( vrc6_apu_state_t* out ) const
void Vrc6_Apu::save_state(vrc6_apu_state_t *out) const
{
out->saw_amp = oscs [2].amp;
for ( int i = 0; i < osc_count; i++ )
{
Vrc6_Osc const& osc = oscs [i];
for ( int r = 0; r < reg_count; r++ )
out->regs [i] [r] = osc.regs [r];
out->delays [i] = osc.delay;
out->phases [i] = osc.phase;
}
out->saw_amp = oscs[2].amp;
for (int i = 0; i < osc_count; i++)
{
Vrc6_Osc const &osc = oscs[i];
for (int r = 0; r < reg_count; r++)
out->regs[i][r] = osc.regs[r];
out->delays[i] = osc.delay;
out->phases[i] = osc.phase;
}
}
void Nes_Vrc6_Apu::load_state( vrc6_apu_state_t const& in )
void Vrc6_Apu::load_state(vrc6_apu_state_t const &in)
{
reset();
oscs [2].amp = in.saw_amp;
for ( int i = 0; i < osc_count; i++ )
{
Vrc6_Osc& osc = oscs [i];
for ( int r = 0; r < reg_count; r++ )
osc.regs [r] = in.regs [i] [r];
osc.delay = in.delays [i];
osc.phase = in.phases [i];
}
if ( !oscs [2].phase )
oscs [2].phase = 1;
reset();
oscs[2].amp = in.saw_amp;
for (int i = 0; i < osc_count; i++)
{
Vrc6_Osc &osc = oscs[i];
for (int r = 0; r < reg_count; r++)
osc.regs[r] = in.regs[i][r];
//Run sound channels for 0 cycles for clean audio after loading state
this->run_until(this->last_time);
osc.delay = in.delays[i];
osc.phase = in.phases[i];
}
if (!oscs[2].phase)
oscs[2].phase = 1;
// Run sound channels for 0 cycles for clean audio after loading state
this->run_until(this->last_time);
}
void Nes_Vrc6_Apu::run_square( Vrc6_Osc& osc, nes_time_t end_time )
void Vrc6_Apu::run_square(Vrc6_Osc &osc, nes_time_t end_time)
{
Blip_Buffer* output = osc.output;
if ( !output )
return;
int volume = osc.regs [0] & 15;
if ( !(osc.regs [2] & 0x80) )
volume = 0;
int gate = osc.regs [0] & 0x80;
int duty = ((osc.regs [0] >> 4) & 7) + 1;
int delta = ((gate || osc.phase < duty) ? volume : 0) - osc.last_amp;
nes_time_t time = last_time;
if ( delta )
{
osc.last_amp += delta;
square_synth.offset( time, delta, output );
}
time += osc.delay;
osc.delay = 0;
int period = osc.period();
if ( volume && !gate && period > 4 )
{
if ( time < end_time )
{
int phase = osc.phase;
do
{
phase++;
if ( phase == 16 )
{
phase = 0;
osc.last_amp = volume;
square_synth.offset( time, volume, output );
}
if ( phase == duty )
{
osc.last_amp = 0;
square_synth.offset( time, -volume, output );
}
time += period;
}
while ( time < end_time );
osc.phase = phase;
}
osc.delay = time - end_time;
}
Blip_Buffer *output = osc.output;
if (!output)
return;
int volume = osc.regs[0] & 15;
if (!(osc.regs[2] & 0x80))
volume = 0;
int gate = osc.regs[0] & 0x80;
int duty = ((osc.regs[0] >> 4) & 7) + 1;
int delta = ((gate || osc.phase < duty) ? volume : 0) - osc.last_amp;
nes_time_t time = last_time;
if (delta)
{
osc.last_amp += delta;
square_synth.offset(time, delta, output);
}
time += osc.delay;
osc.delay = 0;
int period = osc.period();
if (volume && !gate && period > 4)
{
if (time < end_time)
{
int phase = osc.phase;
do
{
phase++;
if (phase == 16)
{
phase = 0;
osc.last_amp = volume;
square_synth.offset(time, volume, output);
}
if (phase == duty)
{
osc.last_amp = 0;
square_synth.offset(time, -volume, output);
}
time += period;
} while (time < end_time);
osc.phase = phase;
}
osc.delay = time - end_time;
}
}
void Nes_Vrc6_Apu::run_saw( nes_time_t end_time )
void Vrc6_Apu::run_saw(nes_time_t end_time)
{
Vrc6_Osc& osc = oscs [2];
Blip_Buffer* output = osc.output;
if ( !output )
return;
int amp = osc.amp;
int amp_step = osc.regs [0] & 0x3F;
nes_time_t time = last_time;
int last_amp = osc.last_amp;
if ( !(osc.regs [2] & 0x80) || !(amp_step | amp) )
{
osc.delay = 0;
int delta = (amp >> 3) - last_amp;
last_amp = amp >> 3;
saw_synth.offset( time, delta, output );
}
else
{
time += osc.delay;
if ( time < end_time )
{
int period = osc.period() * 2;
int phase = osc.phase;
do
{
if ( --phase == 0 )
{
phase = 7;
amp = 0;
}
int delta = (amp >> 3) - last_amp;
if ( delta )
{
last_amp = amp >> 3;
saw_synth.offset( time, delta, output );
}
time += period;
amp = (amp + amp_step) & 0xFF;
}
while ( time < end_time );
osc.phase = phase;
osc.amp = amp;
}
osc.delay = time - end_time;
}
osc.last_amp = last_amp;
Vrc6_Osc &osc = oscs[2];
Blip_Buffer *output = osc.output;
if (!output)
return;
int amp = osc.amp;
int amp_step = osc.regs[0] & 0x3F;
nes_time_t time = last_time;
int last_amp = osc.last_amp;
if (!(osc.regs[2] & 0x80) || !(amp_step | amp))
{
osc.delay = 0;
int delta = (amp >> 3) - last_amp;
last_amp = amp >> 3;
saw_synth.offset(time, delta, output);
}
else
{
time += osc.delay;
if (time < end_time)
{
int period = osc.period() * 2;
int phase = osc.phase;
do
{
if (--phase == 0)
{
phase = 7;
amp = 0;
}
int delta = (amp >> 3) - last_amp;
if (delta)
{
last_amp = amp >> 3;
saw_synth.offset(time, delta, output);
}
time += period;
amp = (amp + amp_step) & 0xFF;
} while (time < end_time);
osc.phase = phase;
osc.amp = amp;
}
osc.delay = time - end_time;
}
osc.last_amp = last_amp;
}
} // namespace quickNES

94
source/quickerNES/apu/vrc6/apu.h
View File

@ -1,94 +0,0 @@
#pragma once
// Konami VRC6 sound chip emulator
// Nes_Snd_Emu 0.1.7
#include <cstdint>
#include "apu/apu.h"
#include "apu/Blip_Buffer.h"
struct vrc6_apu_state_t;
class Nes_Vrc6_Apu {
public:
Nes_Vrc6_Apu();
~Nes_Vrc6_Apu();
// See Nes_Apu.h for reference
void reset();
void volume( double );
void treble_eq( blip_eq_t const& );
void output( Blip_Buffer* );
enum { osc_count = 3 };
void osc_output( int index, Blip_Buffer* );
void end_frame( nes_time_t );
void save_state( vrc6_apu_state_t* ) const;
void load_state( vrc6_apu_state_t const& );
// Oscillator 0 write-only registers are at $9000-$9002
// Oscillator 1 write-only registers are at $A000-$A002
// Oscillator 2 write-only registers are at $B000-$B002
enum { reg_count = 3 };
enum { base_addr = 0x9000 };
enum { addr_step = 0x1000 };
void write_osc( nes_time_t, int osc, int reg, int data );
private:
// noncopyable
Nes_Vrc6_Apu( const Nes_Vrc6_Apu& );
Nes_Vrc6_Apu& operator = ( const Nes_Vrc6_Apu& );
struct Vrc6_Osc
{
uint8_t regs [3];
Blip_Buffer* output;
int delay;
int last_amp;
int phase;
int amp; // only used by saw
int period() const
{
return (regs [2] & 0x0f) * 0x100L + regs [1] + 1;
}
};
Vrc6_Osc oscs [osc_count];
nes_time_t last_time;
Blip_Synth<blip_med_quality,1> saw_synth;
Blip_Synth<blip_good_quality,1> square_synth;
void run_until( nes_time_t );
void run_square( Vrc6_Osc& osc, nes_time_t );
void run_saw( nes_time_t );
};
struct vrc6_apu_state_t
{
uint8_t regs [3] [3];
uint8_t saw_amp;
uint16_t delays [3];
uint8_t phases [3];
uint8_t unused;
};
static_assert( sizeof (vrc6_apu_state_t) == 20 );
inline void Nes_Vrc6_Apu::osc_output( int i, Blip_Buffer* buf )
{
oscs [i].output = buf;
}
inline void Nes_Vrc6_Apu::volume( double v )
{
double const factor = 0.0967 * 2;
saw_synth.volume( factor / 31 * v );
square_synth.volume( factor * 0.5 / 15 * v );
}
inline void Nes_Vrc6_Apu::treble_eq( blip_eq_t const& eq )
{
saw_synth.treble_eq( eq );
square_synth.treble_eq( eq );
}

112
source/quickerNES/apu/vrc6/apu.hpp Normal file
View File

@ -0,0 +1,112 @@
#pragma once
// Konami VRC6 sound chip emulator
// Snd_Emu 0.1.7
#include <cstdint>
#include "apu/Blip_Buffer.hpp"
#include "apu/apu.hpp"
namespace quickerNES
{
struct vrc6_apu_state_t;
class Vrc6_Apu
{
public:
Vrc6_Apu();
~Vrc6_Apu();
// See Apu.h for reference
void reset();
void volume(double);
void treble_eq(blip_eq_t const &);
void output(Blip_Buffer *);
enum
{
osc_count = 3
};
void osc_output(int index, Blip_Buffer *);
void end_frame(nes_time_t);
void save_state(vrc6_apu_state_t *) const;
void load_state(vrc6_apu_state_t const &);
// Oscillator 0 write-only registers are at $9000-$9002
// Oscillator 1 write-only registers are at $A000-$A002
// Oscillator 2 write-only registers are at $B000-$B002
enum
{
reg_count = 3
};
enum
{
base_addr = 0x9000
};
enum
{
addr_step = 0x1000
};
void write_osc(nes_time_t, int osc, int reg, int data);
private:
// noncopyable
Vrc6_Apu(const Vrc6_Apu &);
Vrc6_Apu &operator=(const Vrc6_Apu &);
struct Vrc6_Osc
{
uint8_t regs[3];
Blip_Buffer *output;
int delay;
int last_amp;
int phase;
int amp; // only used by saw
int period() const
{
return (regs[2] & 0x0f) * 0x100L + regs[1] + 1;
}
};
Vrc6_Osc oscs[osc_count];
nes_time_t last_time;
Blip_Synth<blip_med_quality, 1> saw_synth;
Blip_Synth<blip_good_quality, 1> square_synth;
void run_until(nes_time_t);
void run_square(Vrc6_Osc &osc, nes_time_t);
void run_saw(nes_time_t);
};
struct vrc6_apu_state_t
{
uint8_t regs[3][3];
uint8_t saw_amp;
uint16_t delays[3];
uint8_t phases[3];
uint8_t unused;
};
static_assert(sizeof(vrc6_apu_state_t) == 20);
inline void Vrc6_Apu::osc_output(int i, Blip_Buffer *buf)
{
oscs[i].output = buf;
}
inline void Vrc6_Apu::volume(double v)
{
double const factor = 0.0967 * 2;
saw_synth.volume(factor / 31 * v);
square_synth.volume(factor * 0.5 / 15 * v);
}
inline void Vrc6_Apu::treble_eq(blip_eq_t const &eq)
{
saw_synth.treble_eq(eq);
square_synth.treble_eq(eq);
}
} // namespace quickNES

311
source/quickerNES/apu/vrc7/apu.cpp
View File

@ -1,204 +1,211 @@
#include "apu/vrc7/apu.h"
#include "apu/vrc7/emu2413.h"
#include <cstring>
#include "apu/vrc7/apu.hpp"
#include "apu/vrc7/emu2413.hpp"
#define BYTESWAP(xxxx) {uint32_t _temp = (uint32_t)(xxxx);\
((uint8_t*)&(xxxx))[0] = (uint8_t)((_temp) >> 24);\
((uint8_t*)&(xxxx))[1] = (uint8_t)((_temp) >> 16);\
((uint8_t*)&(xxxx))[2] = (uint8_t)((_temp) >> 8);\
((uint8_t*)&(xxxx))[3] = (uint8_t)((_temp) >> 0);\
}
namespace quickerNES
{
#define BYTESWAP(xxxx) \
{ \
uint32_t _temp = (uint32_t)(xxxx); \
((uint8_t *)&(xxxx))[0] = (uint8_t)((_temp) >> 24); \
((uint8_t *)&(xxxx))[1] = (uint8_t)((_temp) >> 16); \
((uint8_t *)&(xxxx))[2] = (uint8_t)((_temp) >> 8); \
((uint8_t *)&(xxxx))[3] = (uint8_t)((_temp) >> 0); \
}
static bool IsLittleEndian()
{
int i = 42;
if (((char*)&i)[0] == 42)
{
return true;
}
return false;
int i = 42;
if (((char *)&i)[0] == 42)
{
return true;
}
return false;
}
Nes_Vrc7::Nes_Vrc7()
Vrc7::Vrc7()
{
opll = OPLL_new( 3579545 );
output( NULL );
volume( 1.0 );
reset();
opll = OPLL_new(3579545);
output(NULL);
volume(1.0);
reset();
}
Nes_Vrc7::~Nes_Vrc7()
Vrc7::~Vrc7()
{
OPLL_delete( ( OPLL * ) opll );
OPLL_delete((OPLL *)opll);
}
void Nes_Vrc7::reset()
void Vrc7::reset()
{
last_time = 0;
count = 0;
last_time = 0;
count = 0;
for ( int i = 0; i < osc_count; ++i )
{
Vrc7_Osc& osc = oscs [i];
for ( int j = 0; j < 3; ++j )
osc.regs [j] = 0;
osc.last_amp = 0;
}
for (int i = 0; i < osc_count; ++i)
{
Vrc7_Osc &osc = oscs[i];
for (int j = 0; j < 3; ++j)
osc.regs[j] = 0;
osc.last_amp = 0;
}
OPLL_reset( ( OPLL * ) opll );
OPLL_reset((OPLL *)opll);
}
void Nes_Vrc7::volume( double v )
void Vrc7::volume(double v)
{
synth.volume( v * 1. / 3. );
synth.volume(v * 1. / 3.);
}
void Nes_Vrc7::treble_eq( blip_eq_t const& eq )
void Vrc7::treble_eq(blip_eq_t const &eq)
{
synth.treble_eq( eq );
synth.treble_eq(eq);
}
void Nes_Vrc7::output( Blip_Buffer* buf )
void Vrc7::output(Blip_Buffer *buf)
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, buf );
for (int i = 0; i < osc_count; i++)
osc_output(i, buf);
}
void Nes_Vrc7::run_until( nes_time_t end_time )
void Vrc7::run_until(nes_time_t end_time)
{
nes_time_t time = last_time;
nes_time_t time = last_time;
while ( time < end_time )
{
if ( ++count == 36 )
{
count = 0;
bool run = false;
for ( unsigned i = 0; i < osc_count; ++i )
{
Vrc7_Osc & osc = oscs [i];
if ( osc.output )
{
if ( ! run )
{
run = true;
OPLL_run( ( OPLL * ) opll );
}
int amp = OPLL_calcCh( ( OPLL * ) opll, i );
int delta = amp - osc.last_amp;
if ( delta )
{
osc.last_amp = amp;
synth.offset( time, delta, osc.output );
}
}
}
}
++time;
}
while (time < end_time)
{
if (++count == 36)
{
count = 0;
bool run = false;
for (unsigned i = 0; i < osc_count; ++i)
{
Vrc7_Osc &osc = oscs[i];
if (osc.output)
{
if (!run)
{
run = true;
OPLL_run((OPLL *)opll);
}
int amp = OPLL_calcCh((OPLL *)opll, i);
int delta = amp - osc.last_amp;
if (delta)
{
osc.last_amp = amp;
synth.offset(time, delta, osc.output);
}
}
}
}
++time;
}
last_time = end_time;
last_time = end_time;
}
void Nes_Vrc7::write_reg( int data )
void Vrc7::write_reg(int data)
{
OPLL_writeIO( ( OPLL * ) opll, 0, data );
OPLL_writeIO((OPLL *)opll, 0, data);
}
void Nes_Vrc7::write_data( nes_time_t time, int data )
void Vrc7::write_data(nes_time_t time, int data)
{
if ( ( unsigned ) ( ( ( OPLL * ) opll )->adr - 0x10 ) < 0x36 )
{
int type = ( ( OPLL * ) opll )->adr >> 4;
int chan = ( ( OPLL * ) opll )->adr & 15;
if ( chan < 6 ) oscs [chan].regs [type-1] = data;
}
if ((unsigned)(((OPLL *)opll)->adr - 0x10) < 0x36)
{
int type = ((OPLL *)opll)->adr >> 4;
int chan = ((OPLL *)opll)->adr & 15;
run_until( time );
OPLL_writeIO( ( OPLL * ) opll, 1, data );
if (chan < 6) oscs[chan].regs[type - 1] = data;
}
run_until(time);
OPLL_writeIO((OPLL *)opll, 1, data);
}
void Nes_Vrc7::end_frame( nes_time_t time )
void Vrc7::end_frame(nes_time_t time)
{
if ( time > last_time )
run_until( time );
last_time -= time;
if (time > last_time)
run_until(time);
last_time -= time;
}
void Nes_Vrc7::save_snapshot( vrc7_snapshot_t* out )
void Vrc7::save_snapshot(vrc7_snapshot_t *out)
{
out->latch = ( ( OPLL * ) opll )->adr;
memcpy( out->inst, ( ( OPLL * ) opll )->CustInst, 8 );
for ( int i = 0; i < osc_count; ++i )
{
for ( int j = 0; j < 3; ++j )
{
out->regs [i] [j] = oscs [i].regs [j];
}
}
out->count = count;
out->internal_opl_state_size = sizeof(OPLL_STATE);
if (!IsLittleEndian())
{
BYTESWAP(out->internal_opl_state_size);
}
OPLL_serialize((OPLL*)opll, &(out->internal_opl_state));
OPLL_state_byteswap(&(out->internal_opl_state));
out->latch = ((OPLL *)opll)->adr;
memcpy(out->inst, ((OPLL *)opll)->CustInst, 8);
for (int i = 0; i < osc_count; ++i)
{
for (int j = 0; j < 3; ++j)
{
out->regs[i][j] = oscs[i].regs[j];
}
}
out->count = count;
out->internal_opl_state_size = sizeof(OPLL_STATE);
if (!IsLittleEndian())
{
BYTESWAP(out->internal_opl_state_size);
}
OPLL_serialize((OPLL *)opll, &(out->internal_opl_state));
OPLL_state_byteswap(&(out->internal_opl_state));
}
void Nes_Vrc7::load_snapshot( vrc7_snapshot_t & in, int dataSize )
void Vrc7::load_snapshot(vrc7_snapshot_t &in, int dataSize)
{
reset();
write_reg( in.latch );
int i;
for ( i = 0; i < osc_count; ++i )
{
for ( int j = 0; j < 3; ++j )
{
oscs [i].regs [j] = in.regs [i] [j];
}
}
count = in.count;
reset();
write_reg(in.latch);
int i;
for (i = 0; i < osc_count; ++i)
{
for (int j = 0; j < 3; ++j)
{
oscs[i].regs[j] = in.regs[i][j];
}
}
count = in.count;
for ( i = 0; i < 8; ++i )
{
OPLL_writeReg( ( OPLL * ) opll, i, in.inst [i] );
}
for (i = 0; i < 8; ++i)
{
OPLL_writeReg((OPLL *)opll, i, in.inst[i]);
}
for ( i = 0; i < 3; ++i )
{
for ( int j = 0; j < 6; ++j )
{
OPLL_writeReg( ( OPLL * ) opll, 0x10 + i * 0x10 + j, oscs [j].regs [i] );
}
}
if (!IsLittleEndian())
{
BYTESWAP(in.internal_opl_state_size);
}
if (in.internal_opl_state_size == sizeof(OPLL_STATE))
{
OPLL_state_byteswap(&(in.internal_opl_state));
OPLL_deserialize((OPLL*)opll, &(in.internal_opl_state));
}
update_last_amp();
for (i = 0; i < 3; ++i)
{
for (int j = 0; j < 6; ++j)
{
OPLL_writeReg((OPLL *)opll, 0x10 + i * 0x10 + j, oscs[j].regs[i]);
}
}
if (!IsLittleEndian())
{
BYTESWAP(in.internal_opl_state_size);
}
if (in.internal_opl_state_size == sizeof(OPLL_STATE))
{
OPLL_state_byteswap(&(in.internal_opl_state));
OPLL_deserialize((OPLL *)opll, &(in.internal_opl_state));
}
update_last_amp();
}
void Nes_Vrc7::update_last_amp()
void Vrc7::update_last_amp()
{
for (unsigned i = 0; i < osc_count; ++i)
{
Vrc7_Osc & osc = oscs[i];
if (osc.output)
{
int amp = OPLL_calcCh((OPLL *)opll, i);
int delta = amp - osc.last_amp;
if (delta)
{
osc.last_amp = amp;
synth.offset(last_time, delta, osc.output);
}
}
}
for (unsigned i = 0; i < osc_count; ++i)
{
Vrc7_Osc &osc = oscs[i];
if (osc.output)
{
int amp = OPLL_calcCh((OPLL *)opll, i);
int delta = amp - osc.last_amp;
if (delta)
{
osc.last_amp = amp;
synth.offset(last_time, delta, osc.output);
}
}
}
}
} // namespace quickNES

71
source/quickerNES/apu/vrc7/apu.h
View File

@ -1,71 +0,0 @@
#pragma once
// Konami VRC7 sound chip emulator
// Nes_Snd_Emu 0.1.7. Copyright (C) 2003-2005 Shay Green. GNU LGPL license.
#include <cstdint>
#include "apu/vrc7/emu2413_state.h"
#include "apu/Blip_Buffer.h"
struct vrc7_snapshot_t;
typedef long nes_time_t;
class Nes_Vrc7 {
public:
Nes_Vrc7();
~Nes_Vrc7();
// See Nes_Apu.h for reference
void reset();
void volume( double );
void treble_eq( blip_eq_t const& );
void output( Blip_Buffer* );
enum { osc_count = 6 };
void osc_output( int index, Blip_Buffer* );
void end_frame( nes_time_t );
void save_snapshot(vrc7_snapshot_t*);
void load_snapshot(vrc7_snapshot_t &, int dataSize);
void update_last_amp();
void write_reg( int reg );
void write_data( nes_time_t, int data );
private:
// noncopyable
Nes_Vrc7( const Nes_Vrc7& );
Nes_Vrc7& operator = ( const Nes_Vrc7& );
struct Vrc7_Osc
{
uint8_t regs [3];
Blip_Buffer* output;
int last_amp;
};
void * opll;
nes_time_t last_time;
Blip_Synth<blip_med_quality,2048*2> synth; // DB2LIN_AMP_BITS == 11, * 2
int count;
Vrc7_Osc oscs [osc_count];
void run_until( nes_time_t );
};
struct vrc7_snapshot_t
{
uint8_t latch;
uint8_t inst [8];
uint8_t regs [6] [3];
uint8_t count;
int internal_opl_state_size;
OPLL_STATE internal_opl_state;
};
static_assert( sizeof (vrc7_snapshot_t) == 28 + 440 + 4 );
inline void Nes_Vrc7::osc_output( int i, Blip_Buffer* buf )
{
oscs [i].output = buf;
}

79
source/quickerNES/apu/vrc7/apu.hpp Normal file
View File

@ -0,0 +1,79 @@
#pragma once
// Konami VRC7 sound chip emulator
// Snd_Emu 0.1.7. Copyright (C) 2003-2005 Shay Green. GNU LGPL license.
#include <cstdint>
#include "apu/Blip_Buffer.hpp"
#include "apu/vrc7/emu2413_state.hpp"
namespace quickerNES
{
struct vrc7_snapshot_t;
typedef long nes_time_t;
class Vrc7
{
public:
Vrc7();
~Vrc7();
// See Apu.h for reference
void reset();
void volume(double);
void treble_eq(blip_eq_t const &);
void output(Blip_Buffer *);
enum
{
osc_count = 6
};
void osc_output(int index, Blip_Buffer *);
void end_frame(nes_time_t);
void save_snapshot(vrc7_snapshot_t *);
void load_snapshot(vrc7_snapshot_t &, int dataSize);
void update_last_amp();
void write_reg(int reg);
void write_data(nes_time_t, int data);
private:
// noncopyable
Vrc7(const Vrc7 &);
Vrc7 &operator=(const Vrc7 &);
struct Vrc7_Osc
{
uint8_t regs[3];
Blip_Buffer *output;
int last_amp;
};
void *opll;
nes_time_t last_time;
Blip_Synth<blip_med_quality, 2048 * 2> synth; // DB2LIN_AMP_BITS == 11, * 2
int count;
Vrc7_Osc oscs[osc_count];
void run_until(nes_time_t);
};
struct vrc7_snapshot_t
{
uint8_t latch;
uint8_t inst[8];
uint8_t regs[6][3];
uint8_t count;
int internal_opl_state_size;
OPLL_STATE internal_opl_state;
};
static_assert(sizeof(vrc7_snapshot_t) == 28 + 440 + 4);
inline void Vrc7::osc_output(int i, Blip_Buffer *buf)
{
oscs[i].output = buf;
}
} // namespace quickNES

606
source/quickerNES/apu/vrc7/emu2413.cpp
View File

File diff suppressed because it is too large Load Diff

216
source/quickerNES/apu/vrc7/emu2413.h
View File

@ -1,216 +0,0 @@
#pragma once
typedef signed int e_int;
typedef unsigned int e_uint;
typedef signed char e_int8;
typedef unsigned char e_uint8;
typedef signed short e_int16;
typedef unsigned short e_uint16;
typedef signed int e_int32;
typedef unsigned int e_uint32;
#define INLINE inline
/* Size of Sintable ( 8 -- 18 can be used. 9 recommended.)*/
#define PG_BITS 9
#define PG_WIDTH (1<<PG_BITS)
/* Phase increment counter */
#define DP_BITS 18
#define DP_WIDTH (1<<DP_BITS)
#define DP_BASE_BITS (DP_BITS - PG_BITS)
/* Dynamic range (Accuracy of sin table) */
#define DB_BITS 8
#define DB_STEP (48.0/(1<<DB_BITS))
#define DB_MUTE (1<<DB_BITS)
/* Dynamic range of envelope */
#define EG_STEP 0.375
#define EG_BITS 7
#define EG_MUTE (1<<EG_BITS)
/* Dynamic range of total level */
#define TL_STEP 0.75
#define TL_BITS 6
#define TL_MUTE (1<<TL_BITS)
/* Dynamic range of sustine level */
#define SL_STEP 3.0
#define SL_BITS 4
#define SL_MUTE (1<<SL_BITS)
/* Bits for Pitch and Amp modulator */
#define PM_PG_BITS 8
#define PM_PG_WIDTH (1<<PM_PG_BITS)
#define PM_DP_BITS 16
#define PM_DP_WIDTH (1<<PM_DP_BITS)
#define AM_PG_BITS 8
#define AM_PG_WIDTH (1<<AM_PG_BITS)
#define AM_DP_BITS 16
#define AM_DP_WIDTH (1<<AM_DP_BITS)
#ifdef EMU2413_DLL_EXPORTS
#define EMU2413_API __declspec(dllexport)
#elif defined(EMU2413_DLL_IMPORTS)
#define EMU2413_API __declspec(dllimport)
#else
#define EMU2413_API
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define PI 3.14159265358979323846
enum {OPLL_VRC7_TONE=0} ;
/* voice data */
typedef struct {
e_uint32 TL,FB,EG,ML,AR,DR,SL,RR,KR,KL,AM,PM,WF ;
} OPLL_PATCH ;
/* slot */
typedef struct {
OPLL_PATCH patch;
e_int32 type ; /* 0 : modulator 1 : carrier */
/* OUTPUT */
e_int32 feedback ;
e_int32 output[2] ; /* Output value of slot */
/* for Phase Generator (PG) */
e_uint16 *sintbl ; /* Wavetable */
e_uint32 phase ; /* Phase */
e_uint32 dphase ; /* Phase increment amount */
e_uint32 pgout ; /* output */
/* for Envelope Generator (EG) */
e_int32 fnum ; /* F-Number */
e_int32 block ; /* Block */
e_int32 volume ; /* Current volume */
e_int32 sustine ; /* Sustine 1 = ON, 0 = OFF */
e_uint32 tll ; /* Total Level + Key scale level*/
e_uint32 rks ; /* Key scale offset (Rks) */
e_int32 eg_mode ; /* Current state */
e_uint32 eg_phase ; /* Phase */
e_uint32 eg_dphase ; /* Phase increment amount */
e_uint32 egout ; /* output */
} OPLL_SLOT ;
/* Mask */
#define OPLL_MASK_CH(x) (1<<(x))
/* opll */
typedef struct {
e_uint32 adr ;
e_int32 out ;
#ifndef EMU2413_COMPACTION
e_uint32 realstep ;
e_uint32 oplltime ;
e_uint32 opllstep ;
e_int32 prev, next ;
#endif
/* Register */
e_uint8 LowFreq[6];
e_uint8 HiFreq[6];
e_uint8 InstVol[6];
e_uint8 CustInst[8];
e_int32 slot_on_flag[6 * 2] ;
/* Pitch Modulator */
e_uint32 pm_phase ;
e_int32 lfo_pm ;
/* Amp Modulator */
e_int32 am_phase ;
e_int32 lfo_am ;
e_uint32 quality;
/* Channel Data */
e_int32 patch_number[6];
e_int32 key_status[6] ;
/* Slot */
OPLL_SLOT slot[6 * 2] ;
e_uint32 mask ;
/* Input clock */
e_uint32 clk;
/* WaveTable for each envelope amp */
e_uint16 fullsintable[PG_WIDTH];
e_uint16 halfsintable[PG_WIDTH];
e_uint16 *waveform[2];
/* LFO Table */
e_int32 pmtable[PM_PG_WIDTH];
e_int32 amtable[AM_PG_WIDTH];
/* Phase delta for LFO */
e_uint32 pm_dphase;
e_uint32 am_dphase;
/* dB to Liner table */
e_int16 DB2LIN_TABLE[(DB_MUTE + DB_MUTE) * 2];
/* Liner to Log curve conversion table (for Attack rate). */
e_uint16 AR_ADJUST_TABLE[1 << EG_BITS];
/* Phase incr table for Attack */
e_uint32 dphaseARTable[16][16];
/* Phase incr table for Decay and Release */
e_uint32 dphaseDRTable[16][16];
/* KSL + TL Table */
e_uint32 tllTable[16][8][1 << TL_BITS][4];
e_int32 rksTable[2][8][2];
/* Phase incr table for PG */
e_uint32 dphaseTable[512][8][16];
} OPLL ;
/* Create Object */
EMU2413_API OPLL *OPLL_new(e_uint32 clk) ;
EMU2413_API void OPLL_delete(OPLL *) ;
/* Setup */
EMU2413_API void OPLL_reset(OPLL *) ;
//EMU2413_API void OPLL_set_rate(OPLL *opll, e_uint32 r) ;
/* Port/Register access */
EMU2413_API void OPLL_writeIO(OPLL *, e_uint32 reg, e_uint32 val) ;
EMU2413_API void OPLL_writeReg(OPLL *, e_uint32 reg, e_uint32 val) ;
/* Synthsize */
EMU2413_API e_int16 OPLL_calc(OPLL *) ;
/* or */
EMU2413_API void OPLL_run(OPLL *) ;
EMU2413_API e_uint32 OPLL_calcCh(OPLL *, e_uint32 ch) ;
/* Misc */
EMU2413_API void OPLL_forceRefresh(OPLL *) ;
/* Channel Mask */
EMU2413_API e_uint32 OPLL_setMask(OPLL *, e_uint32 mask) ;
EMU2413_API e_uint32 OPLL_toggleMask(OPLL *, e_uint32 mask) ;
#ifdef __cplusplus
}
#endif

223
source/quickerNES/apu/vrc7/emu2413.hpp Normal file
View File

@ -0,0 +1,223 @@
#pragma once
namespace quickerNES
{
typedef signed int e_int;
typedef unsigned int e_uint;
typedef signed char e_int8;
typedef unsigned char e_uint8;
typedef signed short e_int16;
typedef unsigned short e_uint16;
typedef signed int e_int32;
typedef unsigned int e_uint32;
#define INLINE inline
/* Size of Sintable ( 8 -- 18 can be used. 9 recommended.)*/
#define PG_BITS 9
#define PG_WIDTH (1 << PG_BITS)
/* Phase increment counter */
#define DP_BITS 18
#define DP_WIDTH (1 << DP_BITS)
#define DP_BASE_BITS (DP_BITS - PG_BITS)
/* Dynamic range (Accuracy of sin table) */
#define DB_BITS 8
#define DB_STEP (48.0 / (1 << DB_BITS))
#define DB_MUTE (1 << DB_BITS)
/* Dynamic range of envelope */
#define EG_STEP 0.375
#define EG_BITS 7
#define EG_MUTE (1 << EG_BITS)
/* Dynamic range of total level */
#define TL_STEP 0.75
#define TL_BITS 6
#define TL_MUTE (1 << TL_BITS)
/* Dynamic range of sustine level */
#define SL_STEP 3.0
#define SL_BITS 4
#define SL_MUTE (1 << SL_BITS)
/* Bits for Pitch and Amp modulator */
#define PM_PG_BITS 8
#define PM_PG_WIDTH (1 << PM_PG_BITS)
#define PM_DP_BITS 16
#define PM_DP_WIDTH (1 << PM_DP_BITS)
#define AM_PG_BITS 8
#define AM_PG_WIDTH (1 << AM_PG_BITS)
#define AM_DP_BITS 16
#define AM_DP_WIDTH (1 << AM_DP_BITS)
#ifdef EMU2413_DLL_EXPORTS
#define EMU2413_API __declspec(dllexport)
#elif defined(EMU2413_DLL_IMPORTS)
#define EMU2413_API __declspec(dllimport)
#else
#define EMU2413_API
#endif
#ifdef __cplusplus
extern "C"
{
#endif
#define PI 3.14159265358979323846
enum
{
OPLL_VRC7_TONE = 0
};
/* voice data */
typedef struct
{
e_uint32 TL, FB, EG, ML, AR, DR, SL, RR, KR, KL, AM, PM, WF;
} OPLL_PATCH;
/* slot */
typedef struct
{
OPLL_PATCH patch;
e_int32 type; /* 0 : modulator 1 : carrier */
/* OUTPUT */
e_int32 feedback;
e_int32 output[2]; /* Output value of slot */
/* for Phase Generator (PG) */
e_uint16 *sintbl; /* Wavetable */
e_uint32 phase; /* Phase */
e_uint32 dphase; /* Phase increment amount */
e_uint32 pgout; /* output */
/* for Envelope Generator (EG) */
e_int32 fnum; /* F-Number */
e_int32 block; /* Block */
e_int32 volume; /* Current volume */
e_int32 sustine; /* Sustine 1 = ON, 0 = OFF */
e_uint32 tll; /* Total Level + Key scale level*/
e_uint32 rks; /* Key scale offset (Rks) */
e_int32 eg_mode; /* Current state */
e_uint32 eg_phase; /* Phase */
e_uint32 eg_dphase; /* Phase increment amount */
e_uint32 egout; /* output */
} OPLL_SLOT;
/* Mask */
#define OPLL_MASK_CH(x) (1 << (x))
/* opll */
typedef struct
{
e_uint32 adr;
e_int32 out;
#ifndef EMU2413_COMPACTION
e_uint32 realstep;
e_uint32 oplltime;
e_uint32 opllstep;
e_int32 prev, next;
#endif
/* Register */
e_uint8 LowFreq[6];
e_uint8 HiFreq[6];
e_uint8 InstVol[6];
e_uint8 CustInst[8];
e_int32 slot_on_flag[6 * 2];
/* Pitch Modulator */
e_uint32 pm_phase;
e_int32 lfo_pm;
/* Amp Modulator */
e_int32 am_phase;
e_int32 lfo_am;
e_uint32 quality;
/* Channel Data */
e_int32 patch_number[6];
e_int32 key_status[6];
/* Slot */
OPLL_SLOT slot[6 * 2];
e_uint32 mask;
/* Input clock */
e_uint32 clk;
/* WaveTable for each envelope amp */
e_uint16 fullsintable[PG_WIDTH];
e_uint16 halfsintable[PG_WIDTH];
e_uint16 *waveform[2];
/* LFO Table */
e_int32 pmtable[PM_PG_WIDTH];
e_int32 amtable[AM_PG_WIDTH];
/* Phase delta for LFO */
e_uint32 pm_dphase;
e_uint32 am_dphase;
/* dB to Liner table */
e_int16 DB2LIN_TABLE[(DB_MUTE + DB_MUTE) * 2];
/* Liner to Log curve conversion table (for Attack rate). */
e_uint16 AR_ADJUST_TABLE[1 << EG_BITS];
/* Phase incr table for Attack */
e_uint32 dphaseARTable[16][16];
/* Phase incr table for Decay and Release */
e_uint32 dphaseDRTable[16][16];
/* KSL + TL Table */
e_uint32 tllTable[16][8][1 << TL_BITS][4];
e_int32 rksTable[2][8][2];
/* Phase incr table for PG */
e_uint32 dphaseTable[512][8][16];
} OPLL;
/* Create Object */
EMU2413_API OPLL *OPLL_new(e_uint32 clk);
EMU2413_API void OPLL_delete(OPLL *);
/* Setup */
EMU2413_API void OPLL_reset(OPLL *);
// EMU2413_API void OPLL_set_rate(OPLL *opll, e_uint32 r) ;
/* Port/Register access */
EMU2413_API void OPLL_writeIO(OPLL *, e_uint32 reg, e_uint32 val);
EMU2413_API void OPLL_writeReg(OPLL *, e_uint32 reg, e_uint32 val);
/* Synthsize */
EMU2413_API e_int16 OPLL_calc(OPLL *);
/* or */
EMU2413_API void OPLL_run(OPLL *);
EMU2413_API e_uint32 OPLL_calcCh(OPLL *, e_uint32 ch);
/* Misc */
EMU2413_API void OPLL_forceRefresh(OPLL *);
/* Channel Mask */
EMU2413_API e_uint32 OPLL_setMask(OPLL *, e_uint32 mask);
EMU2413_API e_uint32 OPLL_toggleMask(OPLL *, e_uint32 mask);
#ifdef __cplusplus
}
#endif
} // namespace quickNES

177
source/quickerNES/apu/vrc7/emu2413_state.cpp
View File

@ -1,107 +1,116 @@
#include "emu2413_state.h"
#include "emu2413_state.hpp"
#include <stdint.h>
namespace quickerNES
{
#ifdef __cplusplus
extern "C"
{
#endif
int OPLL_serialize_size()
{
return sizeof(OPLL_STATE);
}
int OPLL_serialize_size()
{
return sizeof(OPLL_STATE);
}
void OPLL_serialize(const OPLL * opll, OPLL_STATE* state)
{
int i;
void OPLL_serialize(const OPLL *opll, OPLL_STATE *state)
{
int i;
state->pm_phase = opll->pm_phase;
state->am_phase = opll->am_phase;
state->pm_phase = opll->pm_phase;
state->am_phase = opll->am_phase;
for (i = 0; i < 12; i++)
{
OPLL_SLOT_STATE *slotState = &(state->slot[i]);
const OPLL_SLOT *slot= &(opll->slot[i]);
slotState->feedback = slot->feedback;
slotState->output[0] = slot->output[0];
slotState->output[1] = slot->output[1];
slotState->phase = slot->phase;
slotState->pgout = slot->pgout;
slotState->eg_mode = slot->eg_mode;
slotState->eg_phase = slot->eg_phase;
slotState->eg_dphase = slot->eg_dphase;
slotState->egout = slot->egout;
}
}
for (i = 0; i < 12; i++)
{
OPLL_SLOT_STATE *slotState = &(state->slot[i]);
const OPLL_SLOT *slot = &(opll->slot[i]);
slotState->feedback = slot->feedback;
slotState->output[0] = slot->output[0];
slotState->output[1] = slot->output[1];
slotState->phase = slot->phase;
slotState->pgout = slot->pgout;
slotState->eg_mode = slot->eg_mode;
slotState->eg_phase = slot->eg_phase;
slotState->eg_dphase = slot->eg_dphase;
slotState->egout = slot->egout;
}
}
#define BYTESWAP(xxxx) {uint32_t _temp = (uint32_t)(xxxx);\
((uint8_t*)&(xxxx))[0] = (uint8_t)((_temp) >> 24);\
((uint8_t*)&(xxxx))[1] = (uint8_t)((_temp) >> 16);\
((uint8_t*)&(xxxx))[2] = (uint8_t)((_temp) >> 8);\
((uint8_t*)&(xxxx))[3] = (uint8_t)((_temp) >> 0);\
}
#define BYTESWAP(xxxx) \
{ \
uint32_t _temp = (uint32_t)(xxxx); \
((uint8_t *)&(xxxx))[0] = (uint8_t)((_temp) >> 24); \
((uint8_t *)&(xxxx))[1] = (uint8_t)((_temp) >> 16); \
((uint8_t *)&(xxxx))[2] = (uint8_t)((_temp) >> 8); \
((uint8_t *)&(xxxx))[3] = (uint8_t)((_temp) >> 0); \
}
#define SET(xxxx, yyyy) \
{ \
if ((xxxx) != (yyyy)) \
{ \
(xxxx) = (yyyy); \
}
#define SET(xxxx,yyyy) { if ((xxxx) != (yyyy)) {\
(xxxx) = (yyyy);\
}
void OPLL_deserialize(OPLL *opll, const OPLL_STATE *state)
{
int i;
void OPLL_deserialize(OPLL * opll, const OPLL_STATE* state)
{
int i;
opll->pm_phase = state->pm_phase;
opll->am_phase = state->am_phase;
opll->pm_phase = state->pm_phase;
opll->am_phase = state->am_phase;
for (i = 0; i < 12; i++)
{
const OPLL_SLOT_STATE *slotState = &(state->slot[i]);
OPLL_SLOT *slot = &(opll->slot[i]);
slot->feedback = slotState->feedback;
slot->output[0] = slotState->output[0];
slot->output[1] = slotState->output[1];
slot->phase = slotState->phase;
slot->pgout = slotState->pgout;
slot->eg_mode = slotState->eg_mode;
slot->eg_phase = slotState->eg_phase;
slot->eg_dphase = slotState->eg_dphase;
slot->egout = slotState->egout;
}
}
for (i = 0; i < 12; i++)
{
const OPLL_SLOT_STATE *slotState = &(state->slot[i]);
OPLL_SLOT *slot = &(opll->slot[i]);
slot->feedback = slotState->feedback;
slot->output[0] = slotState->output[0];
slot->output[1] = slotState->output[1];
slot->phase = slotState->phase;
slot->pgout = slotState->pgout;
slot->eg_mode = slotState->eg_mode;
slot->eg_phase = slotState->eg_phase;
slot->eg_dphase = slotState->eg_dphase;
slot->egout = slotState->egout;
}
}
static bool IsLittleEndian()
{
int i = 42;
if (((char *)&i)[0] == 42)
{
return true;
}
return false;
}
static bool IsLittleEndian()
{
int i = 42;
if (((char*)&i)[0] == 42)
{
return true;
}
return false;
}
void OPLL_state_byteswap(OPLL_STATE *state)
{
int i;
if (IsLittleEndian()) return;
void OPLL_state_byteswap(OPLL_STATE *state)
{
int i;
if (IsLittleEndian()) return;
BYTESWAP(state->pm_phase);
BYTESWAP(state->am_phase);
BYTESWAP(state->pm_phase);
BYTESWAP(state->am_phase);
for (i = 0; i < 12; i++)
{
OPLL_SLOT_STATE *slotState = &(state->slot[i]);
BYTESWAP(slotState->feedback);
BYTESWAP(slotState->output[0]);
BYTESWAP(slotState->output[1]);
BYTESWAP(slotState->phase);
BYTESWAP(slotState->pgout);
BYTESWAP(slotState->eg_mode);
BYTESWAP(slotState->eg_phase);
BYTESWAP(slotState->eg_dphase);
BYTESWAP(slotState->egout);
}
}
for (i = 0; i < 12; i++)
{
OPLL_SLOT_STATE *slotState = &(state->slot[i]);
BYTESWAP(slotState->feedback);
BYTESWAP(slotState->output[0]);
BYTESWAP(slotState->output[1]);
BYTESWAP(slotState->phase);
BYTESWAP(slotState->pgout);
BYTESWAP(slotState->eg_mode);
BYTESWAP(slotState->eg_phase);
BYTESWAP(slotState->eg_dphase);
BYTESWAP(slotState->egout);
}
}
#ifdef __cplusplus
}
#endif
} // namespace quickNES

34
source/quickerNES/apu/vrc7/emu2413_state.h
View File

@ -1,34 +0,0 @@
#pragma once
#include "emu2413.h"
typedef struct {
e_int32 feedback;
e_int32 output[2];
e_uint32 phase;
e_uint32 pgout;
e_int32 eg_mode;
e_uint32 eg_phase;
e_uint32 eg_dphase;
e_uint32 egout;
} OPLL_SLOT_STATE;
typedef struct {
e_uint32 pm_phase;
e_int32 am_phase;
OPLL_SLOT_STATE slot[6 * 2];
} OPLL_STATE;
#ifdef __cplusplus
extern "C"
{
#endif
int OPLL_serialize_size();
void OPLL_serialize(const OPLL * opll, OPLL_STATE* state);
void OPLL_deserialize(OPLL * opll, const OPLL_STATE* state);
void OPLL_state_byteswap(OPLL_STATE *state);
#ifdef __cplusplus
}
#endif

41
source/quickerNES/apu/vrc7/emu2413_state.hpp Normal file
View File

@ -0,0 +1,41 @@
#pragma once
#include "emu2413.hpp"
namespace quickerNES
{
typedef struct
{
e_int32 feedback;
e_int32 output[2];
e_uint32 phase;
e_uint32 pgout;
e_int32 eg_mode;
e_uint32 eg_phase;
e_uint32 eg_dphase;
e_uint32 egout;
} OPLL_SLOT_STATE;
typedef struct
{
e_uint32 pm_phase;
e_int32 am_phase;
OPLL_SLOT_STATE slot[6 * 2];
} OPLL_STATE;
#ifdef __cplusplus
extern "C"
{
#endif
int OPLL_serialize_size();
void OPLL_serialize(const OPLL *opll, OPLL_STATE *state);
void OPLL_deserialize(OPLL *opll, const OPLL_STATE *state);
void OPLL_state_byteswap(OPLL_STATE *state);
#ifdef __cplusplus
}
#endif
} // namespace quickNES

117
source/quickerNES/cart.hpp Normal file
View File

@ -0,0 +1,117 @@
#pragma once
// NES cartridge data (PRG, CHR, mapper)
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for
more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Emu 0.7.0. http://www.slack.net/~ant/
#include <cstdint>
#include <cstdlib>
#include <cstring>
namespace quickerNES
{
class Cart
{
public:
Cart() = default;
struct ines_header_t
{
uint8_t signature[4];
uint8_t prg_count; // number of 16K PRG banks
uint8_t chr_count; // number of 8K CHR banks
uint8_t flags; // MMMM FTBV Mapper low, Four-screen, Trainer, Battery, V mirror
uint8_t flags2; // MMMM --XX Mapper high 4 bits
uint8_t zero[8]; // if zero [7] is non-zero, treat flags2 as zero
};
static_assert(sizeof(ines_header_t) == 16);
// Load iNES file
void load_ines(const uint8_t *buffer)
{
ines_header_t h;
size_t bufferPos = 0;
{
size_t copySize = sizeof(ines_header_t);
memcpy(&h, &buffer[bufferPos], copySize);
bufferPos += copySize;
}
if (h.zero[7]) h.flags2 = 0;
set_mapper(h.flags, h.flags2);
// skip trainer
if (h.flags & 0x04) bufferPos += 512;
// Allocating memory for prg and chr
prg_size_ = h.prg_count * 16 * 1024L;
chr_size_ = h.chr_count * 8 * 1024L;
auto p = malloc(prg_size_ + chr_size_);
prg_ = (uint8_t *)p;
chr_ = &prg_[prg_size_];
{
size_t copySize = prg_size();
memcpy(prg(), &buffer[bufferPos], copySize);
bufferPos += copySize;
}
{
size_t copySize = chr_size();
memcpy(chr(), &buffer[bufferPos], copySize);
bufferPos += copySize;
}
}
inline bool has_battery_ram() const { return mapper & 0x02; }
// Set mapper and information bytes. LSB and MSB are the standard iNES header
// bytes at offsets 6 and 7.
inline void set_mapper(int mapper_lsb, int mapper_msb)
{
mapper = mapper_msb * 0x100 + mapper_lsb;
}
inline int mapper_code() const { return ((mapper >> 8) & 0xf0) | ((mapper >> 4) & 0x0f); }
// Size of PRG data
long prg_size() const { return prg_size_; }
// Size of CHR data
long chr_size() const { return chr_size_; }
unsigned mapper_data() const { return mapper; }
// Initial mirroring setup
int mirroring() const { return mapper & 0x09; }
// Pointer to beginning of PRG data
inline uint8_t *prg() { return prg_; }
inline uint8_t const *prg() const { return prg_; }
// Pointer to beginning of CHR data
inline uint8_t *chr() { return chr_; }
inline uint8_t const *chr() const { return chr_; }
// End of public interface
private:
uint8_t *prg_;
uint8_t *chr_;
long prg_size_;
long chr_size_;
unsigned mapper;
};
} // namespace quickNES

1050
source/quickerNES/core.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

21
source/quickerNES/Nes_Cpu.cpp → source/quickerNES/cpu.cpp
View File

@ -1,10 +1,10 @@
// Nes_Emu 0.7.0. http://www.slack.net/~ant/nes-emu/
// Emu 0.7.0. http://www.slack.net/~ant/nes-emu/
#include <cstring>
#include <climits>
#include <cstdio>
#include <Nes_Cpu.h>
#include <Nes_Core.h>
#include "cpu.hpp"
#include "core.hpp"
/**
* Optimizations by Sergio Martin (eien86) 2023-2024
@ -22,6 +22,9 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
#define st_n 0x80
#define st_v 0x40
#define st_r 0x20
@ -127,7 +130,7 @@ imm##op: \
}
void Nes_Cpu::reset( void const* unmapped_page )
void Cpu::reset( void const* unmapped_page )
{
r.status = 0;
r.sp = 0;
@ -187,12 +190,12 @@ void Nes_Cpu::reset( void const* unmapped_page )
nz |= ~in & st_z; \
} while ( 0 )
inline int32_t Nes_Cpu::read( nes_addr_t addr )
inline int32_t Cpu::read( nes_addr_t addr )
{
return READ( addr );
}
inline void Nes_Cpu::write( nes_addr_t addr, int value )
inline void Cpu::write( nes_addr_t addr, int value )
{
WRITE( addr, value );
}
@ -201,7 +204,7 @@ inline void Nes_Cpu::write( nes_addr_t addr, int value )
extern uint8_t clock_table [256];
__attribute__((optimize("align-functions=" _PAGE_SIZE)))
Nes_Cpu::result_t Nes_Cpu::run ( nes_time_t end )
Cpu::result_t Cpu::run ( nes_time_t end )
{
set_end_time_( end );
clock_count = 0;
@ -1163,4 +1166,6 @@ uint8_t clock_table [256] = {
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// D
2,6,2,8,3,3,5,5,2,2,2,2,4,4,6,6,// E
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7 // F
};
};
} // namespace quickNES

143
source/quickerNES/cpu.hpp Normal file
View File

@ -0,0 +1,143 @@
#pragma once
// NES 6502 CPU emulator
// Emu 0.7.0
#include <cstdint>
namespace quickerNES
{
typedef long nes_time_t; // clock cycle count
typedef unsigned nes_addr_t; // 16-bit address
class Cpu
{
public:
// NES 6502 registers. *Not* kept updated during a call to run().
struct registers_t
{
uint16_t pc; // Should be more than 16 bits to allow overflow detection -- but I (eien86) removed it to maximize performance.
uint8_t a;
uint8_t x;
uint8_t y;
uint8_t status;
uint8_t sp;
};
// Map code memory (memory accessed via the program counter). Start and size
// must be multiple of page_size.
enum
{
page_bits = 11
};
enum
{
page_count = 0x10000 >> page_bits
};
enum
{
page_size = 1L << page_bits
};
// Clear registers, unmap memory, and map code pages to unmapped_page.
void reset(void const *unmapped_page = 0);
inline void map_code(nes_addr_t start, unsigned size, const void *data)
{
unsigned first_page = start / page_size;
const uint8_t *newPtr = (uint8_t *)data - start;
for (unsigned i = size / page_size; i--;) code_map[first_page + i] = newPtr;
}
// Access memory as the emulated CPU does.
int read(nes_addr_t);
void write(nes_addr_t, int data);
// Push a byte on the stack
inline void push_byte(int data)
{
int sp = r.sp;
r.sp = (sp - 1) & 0xFF;
low_mem[0x100 + sp] = data;
}
// Reasons that run() returns
enum result_t
{
result_cycles, // Requested number of cycles (or more) were executed
result_sei, // I flag just set and IRQ time would generate IRQ now
result_cli, // I flag just cleared but IRQ should occur *after* next instr
result_badop // unimplemented/illegal instruction
};
result_t run(nes_time_t end_time);
nes_time_t time() const { return clock_count; }
inline void reduce_limit(int offset)
{
clock_limit -= offset;
end_time_ -= offset;
irq_time_ -= offset;
}
inline void set_end_time_(nes_time_t t)
{
end_time_ = t;
update_clock_limit();
}
inline void set_irq_time_(nes_time_t t)
{
irq_time_ = t;
update_clock_limit();
}
unsigned long error_count() const { return error_count_; }
// If PC exceeds 0xFFFF and encounters page_wrap_opcode, it will be silently wrapped.
enum
{
page_wrap_opcode = 0xF2
};
// One of the many opcodes that are undefined and stop CPU emulation.
enum
{
bad_opcode = 0xD2
};
uint8_t const *code_map[page_count + 1];
nes_time_t clock_limit;
nes_time_t clock_count;
nes_time_t irq_time_;
nes_time_t end_time_;
unsigned long error_count_;
enum
{
irq_inhibit = 0x04
};
inline void update_clock_limit()
{
nes_time_t t = end_time_;
if (t > irq_time_ && !(r.status & irq_inhibit))
t = irq_time_;
clock_limit = t;
}
registers_t r;
bool isCorrectExecution = true;
// low_mem is a full page size so it can be mapped with code_map
uint8_t low_mem[page_size > 0x800 ? page_size : 0x800];
inline uint8_t *get_code(nes_addr_t addr)
{
return (uint8_t *)code_map[addr >> page_bits] + addr;
}
};
} // namespace quickNES

83
source/quickerNES/Nes_Emu.cpp → source/quickerNES/emu.cpp
View File

@ -1,8 +1,8 @@
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include <cstring>
#include "mappers/mapper.h"
#include "Nes_Emu.h"
#include "mappers/mapper.hpp"
#include "emu.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -15,19 +15,22 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
int const sound_fade_size = 384;
Nes_Emu::equalizer_t const Nes_Emu::nes_eq = { -1.0, 80 };
Nes_Emu::equalizer_t const Nes_Emu::famicom_eq = { -15.0, 80 };
Nes_Emu::equalizer_t const Nes_Emu::tv_eq = { -12.0, 180 };
Nes_Emu::equalizer_t const Nes_Emu::flat_eq = { 0.0, 1 };
Nes_Emu::equalizer_t const Nes_Emu::crisp_eq = { 5.0, 1 };
Nes_Emu::equalizer_t const Nes_Emu::tinny_eq = { -47.0, 2000 };
Emu::equalizer_t const Emu::nes_eq = { -1.0, 80 };
Emu::equalizer_t const Emu::famicom_eq = { -15.0, 80 };
Emu::equalizer_t const Emu::tv_eq = { -12.0, 180 };
Emu::equalizer_t const Emu::flat_eq = { 0.0, 1 };
Emu::equalizer_t const Emu::crisp_eq = { 5.0, 1 };
Emu::equalizer_t const Emu::tinny_eq = { -47.0, 2000 };
Nes_Emu::Nes_Emu()
Emu::Emu()
{
frame_ = &single_frame;
buffer_height_ = Nes_Ppu::buffer_height + 2;
buffer_height_ = Ppu::buffer_height + 2;
default_sound_buf = NULL;
sound_buf = &silent_buffer;
sound_buf_changed_count = 0;
@ -46,17 +49,17 @@ Nes_Emu::Nes_Emu()
extra_sound_buf_changed_count = 0;
}
Nes_Emu::~Nes_Emu()
Emu::~Emu()
{
delete default_sound_buf;
}
const char * Nes_Emu::init_()
const char * Emu::init_()
{
return emu.init();
}
inline const char * Nes_Emu::auto_init()
inline const char * Emu::auto_init()
{
if ( !init_called )
{
@ -67,40 +70,40 @@ inline const char * Nes_Emu::auto_init()
}
inline void Nes_Emu::clear_sound_buf()
inline void Emu::clear_sound_buf()
{
fade_sound_out = false;
fade_sound_in = true;
sound_buf->clear();
}
void Nes_Emu::set_cart( Nes_Cart const* new_cart )
void Emu::set_cart( Cart const* new_cart )
{
auto_init();
emu.open( new_cart );
channel_count_ = Nes_Apu::osc_count + emu.mapper->channel_count();
channel_count_ = Apu::osc_count + emu.mapper->channel_count();
sound_buf->set_channel_count( channel_count() );
set_equalizer( equalizer_ );
enable_sound( true );
reset();
}
void Nes_Emu::reset( bool full_reset, bool erase_battery_ram )
void Emu::reset( bool full_reset, bool erase_battery_ram )
{
clear_sound_buf();
set_timestamp( 0 );
emu.reset( full_reset, erase_battery_ram );
}
void Nes_Emu::set_palette_range( int begin, int end )
void Emu::set_palette_range( int begin, int end )
{
// round up to alignment
emu.ppu.palette_begin = (begin + palette_alignment - 1) & ~(palette_alignment - 1);
host_palette_size = end - emu.ppu.palette_begin;
}
const char * Nes_Emu::emulate_skip_frame( int joypad1, int joypad2 )
const char * Emu::emulate_skip_frame( int joypad1, int joypad2 )
{
char *old_host_pixels = host_pixels;
host_pixels = NULL;
@ -109,7 +112,7 @@ const char * Nes_Emu::emulate_skip_frame( int joypad1, int joypad2 )
return 0;
}
const char * Nes_Emu::emulate_frame( int joypad1, int joypad2 )
const char * Emu::emulate_frame( int joypad1, int joypad2 )
{
emu.ppu.host_pixels = NULL;
@ -163,41 +166,41 @@ const char * Nes_Emu::emulate_frame( int joypad1, int joypad2 )
// Extras
void Nes_Emu::load_ines( const uint8_t* buffer )
void Emu::load_ines( const uint8_t* buffer )
{
private_cart.load_ines( buffer );
set_cart( &private_cart );
}
void Nes_Emu::write_chr( void const* p, long count, long offset )
void Emu::write_chr( void const* p, long count, long offset )
{
long end = offset + count;
memcpy( (uint8_t*) chr_mem() + offset, p, count );
emu.ppu.rebuild_chr( offset, end );
}
const char * Nes_Emu::set_sample_rate( long rate, class Nes_Buffer* buf )
const char * Emu::set_sample_rate( long rate, class Buffer* buf )
{
extern Multi_Buffer* set_apu( class Nes_Buffer*, Nes_Apu* );
extern Multi_Buffer* set_apu( class Buffer*, Apu* );
auto_init();
return set_sample_rate( rate, set_apu( buf, &emu.impl->apu ) );
}
const char * Nes_Emu::set_sample_rate( long rate, class Nes_Effects_Buffer* buf )
const char * Emu::set_sample_rate( long rate, class Nes_Effects_Buffer* buf )
{
extern Multi_Buffer* set_apu( class Nes_Effects_Buffer*, Nes_Apu* );
extern Multi_Buffer* set_apu( class Nes_Effects_Buffer*, Apu* );
auto_init();
return set_sample_rate( rate, set_apu( buf, &emu.impl->apu ) );
}
// Sound
void Nes_Emu::set_frame_rate( double rate )
void Emu::set_frame_rate( double rate )
{
sound_buf->clock_rate( (long) (1789773 / 60.0 * rate) );
}
const char * Nes_Emu::set_sample_rate( long rate, Multi_Buffer* new_buf )
const char * Emu::set_sample_rate( long rate, Multi_Buffer* new_buf )
{
auto_init();
emu.impl->apu.volume( 1.0 ); // cancel any previous non-linearity
@ -213,13 +216,13 @@ const char * Nes_Emu::set_sample_rate( long rate, Multi_Buffer* new_buf )
return 0;
}
const char * Nes_Emu::set_sample_rate( long rate )
const char * Emu::set_sample_rate( long rate )
{
if ( !default_sound_buf ) default_sound_buf = new Mono_Buffer;
return set_sample_rate( rate, default_sound_buf );
}
void Nes_Emu::set_equalizer( equalizer_t const& eq )
void Emu::set_equalizer( equalizer_t const& eq )
{
equalizer_ = eq;
if ( cart() )
@ -231,14 +234,14 @@ void Nes_Emu::set_equalizer( equalizer_t const& eq )
}
}
void Nes_Emu::enable_sound( bool enabled )
void Emu::enable_sound( bool enabled )
{
if ( enabled )
{
for ( int i = channel_count(); i-- > 0; )
{
Blip_Buffer* buf = sound_buf->channel( i ).center;
int mapper_index = i - Nes_Apu::osc_count;
int mapper_index = i - Apu::osc_count;
if ( mapper_index < 0 )
emu.impl->apu.osc_output( i, buf );
else
@ -248,12 +251,12 @@ void Nes_Emu::enable_sound( bool enabled )
else
{
emu.impl->apu.output( NULL );
for ( int i = channel_count() - Nes_Apu::osc_count; i-- > 0; )
for ( int i = channel_count() - Apu::osc_count; i-- > 0; )
emu.mapper->set_channel_buf( i, NULL );
}
}
void Nes_Emu::fade_samples( blip_sample_t* p, int size, int step )
void Emu::fade_samples( blip_sample_t* p, int size, int step )
{
if ( size >= sound_fade_size )
{
@ -273,7 +276,7 @@ void Nes_Emu::fade_samples( blip_sample_t* p, int size, int step )
}
}
long Nes_Emu::read_samples( short* out, long out_size )
long Emu::read_samples( short* out, long out_size )
{
long count = sound_buf->read_samples( out, out_size );
if ( fade_sound_in )
@ -293,7 +296,7 @@ long Nes_Emu::read_samples( short* out, long out_size )
return count;
}
Nes_Emu::rgb_t const Nes_Emu::nes_colors [color_table_size] =
Emu::rgb_t const Emu::nes_colors [color_table_size] =
{
// generated with nes_ntsc default settings
{102,102,102},{ 0, 42,136},{ 20, 18,168},{ 59, 0,164},
@ -427,17 +430,19 @@ Nes_Emu::rgb_t const Nes_Emu::nes_colors [color_table_size] =
{136,190,197},{184,184,184},{ 0, 0, 0},{ 0, 0, 0}
};
void Nes_Emu::SaveAudioBufferState()
void Emu::SaveAudioBufferState()
{
extra_fade_sound_in = fade_sound_in;
extra_fade_sound_out = fade_sound_out;
extra_sound_buf_changed_count = sound_buf_changed_count;
sound_buf->SaveAudioBufferState();
}
void Nes_Emu::RestoreAudioBufferState()
void Emu::RestoreAudioBufferState()
{
fade_sound_in = extra_fade_sound_in;
fade_sound_out = extra_fade_sound_out;
sound_buf_changed_count = extra_sound_buf_changed_count;
sound_buf->RestoreAudioBufferState();
}
} // namespace quickNES

288
source/quickerNES/emu.hpp Normal file
View File

@ -0,0 +1,288 @@
#pragma once
// NES video game console emulator with snapshot support
// Emu 0.7.0
#include "cart.hpp"
#include "core.hpp"
#include "apu/Multi_Buffer.hpp"
namespace quickerNES
{
class State;
class Emu
{
public:
Emu();
virtual ~Emu();
// Basic setup
// Load iNES file into emulator and clear recording
void load_ines(const uint8_t *buffer);
// Set sample rate for sound generation
const char *set_sample_rate(long);
// Size and depth of graphics buffer required for rendering. Note that this
// is larger than the actual image, with a temporary area around the edge
// that gets filled with junk.
static const uint16_t buffer_width = Ppu::buffer_width;
uint16_t buffer_height() const { return buffer_height_; }
static const uint8_t bits_per_pixel = 8;
// Set graphics buffer to render pixels to. Pixels points to top-left pixel and
// row_bytes is the number of bytes to get to the next line (positive or negative).
void set_pixels(void *pixels, long row_bytes);
// Size of image generated in graphics buffer
static const uint16_t image_width = 256;
static const uint16_t image_height = 240;
const uint8_t *getHostPixels() const { return emu.ppu.host_pixels; }
size_t getLiteStateSize() const { return emu.getLiteStateSize(); }
size_t getStateSize() const { return emu.getStateSize(); }
// Basic emulation
// Emulate one video frame using joypad1 and joypad2 as input. Afterwards, image
// and sound are available for output using the accessors below.
virtual const char *emulate_frame(int joypad1, int joypad2 = 0);
// Emulate one video frame using joypad1 and joypad2 as input, but skips drawing.
// Afterwards, audio is available for output using the accessors below.
virtual const char *emulate_skip_frame(int joypad1, int joypad2 = 0);
// Maximum size of palette that can be generated
static const uint16_t max_palette_size = 256;
// Result of current frame
struct frame_t
{
static const uint8_t left = 8;
int joypad_read_count; // number of times joypads were strobed (read)
int burst_phase; // NTSC burst phase for frame (0, 1, or 2)
int sample_count; // number of samples (always a multiple of chan_count)
int chan_count; // 1: mono, 2: stereo
int top; // top-left position of image in graphics buffer
unsigned char *pixels; // pointer to top-left pixel of image
long pitch; // number of bytes to get to next row of image
int palette_begin; // first host palette entry, as set by set_palette_range()
int palette_size; // number of entries used for current frame
short palette[max_palette_size]; // [palette_begin to palette_begin+palette_size-1]
};
frame_t const &frame() const { return *frame_; }
// Read samples for the current frame. Returns number of samples read into buffer.
// Currently all samples must be read in one call.
virtual long read_samples(short *out, long max_samples);
// Additional features
// Use already-loaded cartridge. Retains pointer, so it must be kept around until
// closed. A cartridge can be shared among multiple emulators. After opening,
// cartridge's CHR data shouldn't be modified since a copy is cached internally.
void set_cart(Cart const *);
// Pointer to current cartridge, or NULL if none is loaded
Cart const *cart() const { return emu.cart; }
// Emulate powering NES off and then back on. If full_reset is false, emulates
// pressing the reset button only, which doesn't affect memory, otherwise
// emulates powering system off then on.
virtual void reset(bool full_reset = true, bool erase_battery_ram = false);
// Number of undefined CPU instructions encountered. Cleared after reset() and
// load_state(). A non-zero value indicates that cartridge is probably
// incompatible.
unsigned long error_count() const { return emu.error_count; }
// Sound
// Set sample rate and use a custom sound buffer instead of the default
// mono buffer, i.e. Buffer, Effects_Buffer, etc..
const char *set_sample_rate(long rate, Multi_Buffer *);
// Adjust effective frame rate by changing how many samples are generated each frame.
// Allows fine tuning of frame rate to improve synchronization.
void set_frame_rate(double rate);
// Number of sound channels for current cartridge
int channel_count() const { return channel_count_; }
// Frequency equalizer parameters
struct equalizer_t
{
double treble; // 5.0 = extra-crisp, -200.0 = muffled
long bass; // 0 = deep, 20000 = tinny
};
// Current frequency equalization
equalizer_t const &equalizer() const { return equalizer_; }
// Change frequency equalization
void set_equalizer(equalizer_t const &);
// Equalizer presets
static equalizer_t const nes_eq; // NES
static equalizer_t const famicom_eq; // Famicom
static equalizer_t const tv_eq; // TV speaker
static equalizer_t const flat_eq; // Flat EQ
static equalizer_t const crisp_eq; // Crisp EQ (Treble boost)
static equalizer_t const tinny_eq; // Tinny EQ (Like a handheld speaker)
// File save/load
// Save emulator state
size_t serializeState(uint8_t *buffer) const { return emu.serializeState(buffer); }
size_t deserializeState(const uint8_t *buffer) { return emu.deserializeState(buffer); }
// True if current cartridge claims it uses battery-backed memory
bool has_battery_ram() const { return cart()->has_battery_ram(); }
// Graphics
// Number of frames generated per second
enum
{
frame_rate = 60
};
// Size of fixed NES color table (including the 8 color emphasis modes)
enum
{
color_table_size = 8 * 64
};
// NES color lookup table based on standard NTSC TV decoder. Use nes_ntsc.h to
// generate a palette with custom parameters.
struct rgb_t
{
unsigned char red, green, blue;
};
static rgb_t const nes_colors[color_table_size];
// Hide/show/enhance sprites. Sprite mode does not affect emulation accuracy.
enum sprite_mode_t
{
sprites_hidden = 0,
sprites_visible = 8, // limit of 8 sprites per scanline as on NES (default)
sprites_enhanced = 64 // unlimited sprites per scanline (no flickering)
};
void set_sprite_mode(sprite_mode_t n) { emu.ppu.sprite_limit = n; }
// Set range of host palette entries to use in graphics buffer; default uses
// all of them. Begin will be rounded up to next multiple of palette_alignment.
// Use frame().palette_begin to find the adjusted beginning entry used.
enum
{
palette_alignment = 64
};
void set_palette_range(int begin, int end = 256);
// Access to emulated memory, for viewer/cheater/debugger
// CHR
uint8_t const *chr_mem();
long chr_size() const;
void write_chr(void const *, long count, long offset);
// Nametable
uint8_t *nametable_mem() { return emu.ppu.impl->nt_ram; }
long nametable_size() const { return 0x1000; }
// Built-in 2K memory
enum
{
low_mem_size = 0x800
};
uint8_t *low_mem() { return emu.low_mem; }
// Optional 8K memory
enum
{
high_mem_size = 0x2000
};
uint8_t *high_mem() { return emu.impl->sram; }
// Sprite memory
uint8_t *spr_mem() { return emu.ppu.getSpriteRAM(); }
uint16_t spr_mem_size() { return emu.ppu.getSpriteRAMSize(); }
// End of public interface
public:
const char *set_sample_rate(long rate, class Buffer *);
const char *set_sample_rate(long rate, class Nes_Effects_Buffer *);
void irq_changed() { emu.irq_changed(); }
private:
frame_t *frame_;
int buffer_height_;
bool fade_sound_in;
bool fade_sound_out;
virtual const char *init_();
virtual void loading_state(State const &) {}
long timestamp() const { return emu.nes.frame_count; }
void set_timestamp(long t) { emu.nes.frame_count = t; }
private:
// noncopyable
Emu(const Emu &);
Emu &operator=(const Emu &);
// sound
Multi_Buffer *default_sound_buf;
Multi_Buffer *sound_buf;
unsigned sound_buf_changed_count;
Silent_Buffer silent_buffer;
equalizer_t equalizer_;
int channel_count_;
bool sound_enabled;
void enable_sound(bool);
void clear_sound_buf();
void fade_samples(blip_sample_t *, int size, int step);
char *host_pixels;
int host_palette_size;
frame_t single_frame;
Cart private_cart;
Core emu; // large; keep at end
bool init_called;
const char *auto_init();
bool extra_fade_sound_in;
bool extra_fade_sound_out;
unsigned extra_sound_buf_changed_count;
public:
void SaveAudioBufferState();
void RestoreAudioBufferState();
};
inline void Emu::set_pixels(void *p, long n)
{
host_pixels = (char *)p + n;
emu.ppu.host_row_bytes = n;
}
inline uint8_t const *Emu::chr_mem()
{
return cart()->chr_size() ? (uint8_t *)cart()->chr() : emu.ppu.impl->chr_ram;
}
inline long Emu::chr_size() const
{
return cart()->chr_size() ? cart()->chr_size() : emu.ppu.chr_addr_size;
}
} // namespace quickNES

300
source/quickerNES/mappers/mapper.cpp
View File

@ -1,9 +1,9 @@
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.hpp"
#include "core.hpp"
#include <cstring>
#include "mappers/mapper.h"
#include "Nes_Core.h"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -76,215 +76,219 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#include "mappers/mapper244.hpp"
#include "mappers/mapper246.hpp"
Nes_Mapper::Nes_Mapper()
namespace quickerNES
{
emu_ = NULL;
static char c;
state = &c; // TODO: state must not be null?
state_size = 0;
Mapper::Mapper()
{
emu_ = NULL;
static char c;
state = &c; // TODO: state must not be null?
state_size = 0;
}
Nes_Mapper::~Nes_Mapper()
Mapper::~Mapper()
{
}
// Sets mirroring, maps first 8K CHR in, first and last 16K of PRG,
// intercepts writes to upper half of memory, and clears registered state.
void Nes_Mapper::default_reset_state()
void Mapper::default_reset_state()
{
int mirroring = cart_->mirroring();
if ( mirroring & 8 )
mirror_full();
else if ( mirroring & 1 )
mirror_vert();
else
mirror_horiz();
set_chr_bank( 0, bank_8k, 0 );
set_prg_bank( 0x8000, bank_16k, 0 );
set_prg_bank( 0xC000, bank_16k, last_bank );
intercept_writes( 0x8000, 0x8000 );
memset( state, 0, state_size );
int mirroring = cart_->mirroring();
if (mirroring & 8)
mirror_full();
else if (mirroring & 1)
mirror_vert();
else
mirror_horiz();
set_chr_bank(0, bank_8k, 0);
set_prg_bank(0x8000, bank_16k, 0);
set_prg_bank(0xC000, bank_16k, last_bank);
intercept_writes(0x8000, 0x8000);
memset(state, 0, state_size);
}
void Nes_Mapper::reset()
void Mapper::reset()
{
default_reset_state();
reset_state();
apply_mapping();
default_reset_state();
reset_state();
apply_mapping();
}
void mapper_state_t::write( const void* p, unsigned long s )
void mapper_state_t::write(const void *p, unsigned long s)
{
size = s;
memcpy( data, p, s );
size = s;
memcpy(data, p, s);
}
int mapper_state_t::read( void* p, unsigned long s ) const
int mapper_state_t::read(void *p, unsigned long s) const
{
if ( (long) s > size )
s = size;
memcpy( p, data, s );
return s;
if ((long)s > size)
s = size;
memcpy(p, data, s);
return s;
}
void Nes_Mapper::save_state( mapper_state_t& out )
void Mapper::save_state(mapper_state_t &out)
{
out.write( state, state_size );
out.write(state, state_size);
}
void Nes_Mapper::load_state( mapper_state_t const& in )
void Mapper::load_state(mapper_state_t const &in)
{
default_reset_state();
read_state( in );
apply_mapping();
default_reset_state();
read_state(in);
apply_mapping();
}
void Nes_Mapper::read_state( mapper_state_t const& in )
void Mapper::read_state(mapper_state_t const &in)
{
memset( state, 0, state_size );
in.read( state, state_size );
apply_mapping();
memset(state, 0, state_size);
in.read(state, state_size);
apply_mapping();
}
// Timing
void Nes_Mapper::irq_changed() { emu_->irq_changed(); }
nes_time_t Nes_Mapper::next_irq( nes_time_t ) { return no_irq; }
void Mapper::irq_changed() { emu_->irq_changed(); }
void Nes_Mapper::a12_clocked() { }
nes_time_t Mapper::next_irq(nes_time_t) { return no_irq; }
void Nes_Mapper::run_until( nes_time_t ) { }
void Mapper::a12_clocked() {}
void Nes_Mapper::end_frame( nes_time_t ) { }
void Mapper::run_until(nes_time_t) {}
bool Nes_Mapper::ppu_enabled() const { return emu().ppu.w2001 & 0x08; }
void Mapper::end_frame(nes_time_t) {}
bool Mapper::ppu_enabled() const { return emu().ppu.w2001 & 0x08; }
// Sound
int Nes_Mapper::channel_count() const { return 0; }
int Mapper::channel_count() const { return 0; }
void Nes_Mapper::set_channel_buf( int, Blip_Buffer* ) { }
void Mapper::set_channel_buf(int, Blip_Buffer *) {}
void Nes_Mapper::set_treble( blip_eq_t const& ) { }
void Mapper::set_treble(blip_eq_t const &) {}
// Memory mapping
void Nes_Mapper::set_prg_bank( nes_addr_t addr, bank_size_t bs, int bank )
void Mapper::set_prg_bank(nes_addr_t addr, bank_size_t bs, int bank)
{
int bank_size = 1 << bs;
int bank_count = cart_->prg_size() >> bs;
if ( bank < 0 )
bank += bank_count;
if ( bank >= bank_count )
bank %= bank_count;
emu().map_code( addr, bank_size, cart_->prg() + (bank << bs) );
if ( unsigned (addr - 0x6000) < 0x2000 )
emu().enable_prg_6000();
int bank_size = 1 << bs;
int bank_count = cart_->prg_size() >> bs;
if (bank < 0)
bank += bank_count;
if (bank >= bank_count)
bank %= bank_count;
emu().map_code(addr, bank_size, cart_->prg() + (bank << bs));
if (unsigned(addr - 0x6000) < 0x2000)
emu().enable_prg_6000();
}
void Nes_Mapper::set_chr_bank( nes_addr_t addr, bank_size_t bs, int bank )
void Mapper::set_chr_bank(nes_addr_t addr, bank_size_t bs, int bank)
{
emu().ppu.render_until( emu().clock() );
emu().ppu.set_chr_bank( addr, 1 << bs, bank << bs );
emu().ppu.render_until(emu().clock());
emu().ppu.set_chr_bank(addr, 1 << bs, bank << bs);
}
void Nes_Mapper::set_chr_bank_ex( nes_addr_t addr, bank_size_t bs, int bank )
void Mapper::set_chr_bank_ex(nes_addr_t addr, bank_size_t bs, int bank)
{
emu().ppu.render_until( emu().clock() );
emu().ppu.set_chr_bank_ex( addr, 1 << bs, bank << bs );
emu().ppu.render_until(emu().clock());
emu().ppu.set_chr_bank_ex(addr, 1 << bs, bank << bs);
}
void Nes_Mapper::mirror_manual( int page0, int page1, int page2, int page3 )
void Mapper::mirror_manual(int page0, int page1, int page2, int page3)
{
emu().ppu.render_bg_until( emu().clock() );
emu().ppu.set_nt_banks( page0, page1, page2, page3 );
emu().ppu.render_bg_until(emu().clock());
emu().ppu.set_nt_banks(page0, page1, page2, page3);
}
void Nes_Mapper::intercept_reads( nes_addr_t addr, unsigned size )
void Mapper::intercept_reads(nes_addr_t addr, unsigned size)
{
emu().add_mapper_intercept( addr, size, true, false );
emu().add_mapper_intercept(addr, size, true, false);
}
void Nes_Mapper::intercept_writes( nes_addr_t addr, unsigned size )
void Mapper::intercept_writes(nes_addr_t addr, unsigned size)
{
emu().add_mapper_intercept( addr, size, false, true );
emu().add_mapper_intercept(addr, size, false, true);
}
void Nes_Mapper::enable_sram( bool enabled, bool read_only )
void Mapper::enable_sram(bool enabled, bool read_only)
{
emu_->enable_sram( enabled, read_only );
emu_->enable_sram(enabled, read_only);
}
Nes_Mapper* Nes_Mapper::getMapperFromCode(const int mapperCode)
Mapper *Mapper::getMapperFromCode(const int mapperCode)
{
Nes_Mapper* mapper = nullptr;
Mapper *mapper = nullptr;
// Now checking if the detected mapper code is supported
if (mapperCode == 0) mapper = new Mapper000();
if (mapperCode == 1) mapper = new Mapper001();
if (mapperCode == 2) mapper = new Mapper002();
if (mapperCode == 3) mapper = new Mapper003();
if (mapperCode == 4) mapper = new Mapper004();
if (mapperCode == 5) mapper = new Mapper005();
if (mapperCode == 7) mapper = new Mapper007();
if (mapperCode == 9) mapper = new Mapper009();
if (mapperCode == 10) mapper = new Mapper010();
if (mapperCode == 11) mapper = new Mapper011();
if (mapperCode == 15) mapper = new Mapper015();
if (mapperCode == 19) mapper = new Mapper019();
if (mapperCode == 21) mapper = new Mapper021();
if (mapperCode == 22) mapper = new Mapper022();
if (mapperCode == 23) mapper = new Mapper023();
if (mapperCode == 24) mapper = new Mapper024();
if (mapperCode == 25) mapper = new Mapper025();
if (mapperCode == 26) mapper = new Mapper026();
if (mapperCode == 30) mapper = new Mapper030();
if (mapperCode == 32) mapper = new Mapper032();
if (mapperCode == 33) mapper = new Mapper033();
if (mapperCode == 34) mapper = new Mapper034();
if (mapperCode == 60) mapper = new Mapper060();
if (mapperCode == 66) mapper = new Mapper066();
if (mapperCode == 69) mapper = new Mapper069();
if (mapperCode == 70) mapper = new Mapper070();
if (mapperCode == 71) mapper = new Mapper071();
if (mapperCode == 73) mapper = new Mapper073();
if (mapperCode == 75) mapper = new Mapper075();
if (mapperCode == 78) mapper = new Mapper078();
if (mapperCode == 79) mapper = new Mapper079();
if (mapperCode == 85) mapper = new Mapper085();
if (mapperCode == 86) mapper = new Mapper086();
if (mapperCode == 87) mapper = new Mapper087();
if (mapperCode == 88) mapper = new Mapper088();
if (mapperCode == 89) mapper = new Mapper089();
if (mapperCode == 93) mapper = new Mapper093();
if (mapperCode == 94) mapper = new Mapper094();
if (mapperCode == 97) mapper = new Mapper097();
if (mapperCode == 113) mapper = new Mapper113();
if (mapperCode == 140) mapper = new Mapper140();
if (mapperCode == 152) mapper = new Mapper152();
if (mapperCode == 154) mapper = new Mapper154();
if (mapperCode == 156) mapper = new Mapper156();
if (mapperCode == 180) mapper = new Mapper180();
if (mapperCode == 184) mapper = new Mapper184();
if (mapperCode == 190) mapper = new Mapper190();
if (mapperCode == 193) mapper = new Mapper193();
if (mapperCode == 206) mapper = new Mapper206();
if (mapperCode == 207) mapper = new Mapper207();
if (mapperCode == 232) mapper = new Mapper232();
if (mapperCode == 240) mapper = new Mapper240();
if (mapperCode == 241) mapper = new Mapper241();
if (mapperCode == 244) mapper = new Mapper244();
if (mapperCode == 246) mapper = new Mapper246();
// Now checking if the detected mapper code is supported
if (mapperCode == 0) mapper = new Mapper000();
if (mapperCode == 1) mapper = new Mapper001();
if (mapperCode == 2) mapper = new Mapper002();
if (mapperCode == 3) mapper = new Mapper003();
if (mapperCode == 4) mapper = new Mapper004();
if (mapperCode == 5) mapper = new Mapper005();
if (mapperCode == 7) mapper = new Mapper007();
if (mapperCode == 9) mapper = new Mapper009();
if (mapperCode == 10) mapper = new Mapper010();
if (mapperCode == 11) mapper = new Mapper011();
if (mapperCode == 15) mapper = new Mapper015();
if (mapperCode == 19) mapper = new Mapper019();
if (mapperCode == 21) mapper = new Mapper021();
if (mapperCode == 22) mapper = new Mapper022();
if (mapperCode == 23) mapper = new Mapper023();
if (mapperCode == 24) mapper = new Mapper024();
if (mapperCode == 25) mapper = new Mapper025();
if (mapperCode == 26) mapper = new Mapper026();
if (mapperCode == 30) mapper = new Mapper030();
if (mapperCode == 32) mapper = new Mapper032();
if (mapperCode == 33) mapper = new Mapper033();
if (mapperCode == 34) mapper = new Mapper034();
if (mapperCode == 60) mapper = new Mapper060();
if (mapperCode == 66) mapper = new Mapper066();
if (mapperCode == 69) mapper = new Mapper069();
if (mapperCode == 70) mapper = new Mapper070();
if (mapperCode == 71) mapper = new Mapper071();
if (mapperCode == 73) mapper = new Mapper073();
if (mapperCode == 75) mapper = new Mapper075();
if (mapperCode == 78) mapper = new Mapper078();
if (mapperCode == 79) mapper = new Mapper079();
if (mapperCode == 85) mapper = new Mapper085();
if (mapperCode == 86) mapper = new Mapper086();
if (mapperCode == 87) mapper = new Mapper087();
if (mapperCode == 88) mapper = new Mapper088();
if (mapperCode == 89) mapper = new Mapper089();
if (mapperCode == 93) mapper = new Mapper093();
if (mapperCode == 94) mapper = new Mapper094();
if (mapperCode == 97) mapper = new Mapper097();
if (mapperCode == 113) mapper = new Mapper113();
if (mapperCode == 140) mapper = new Mapper140();
if (mapperCode == 152) mapper = new Mapper152();
if (mapperCode == 154) mapper = new Mapper154();
if (mapperCode == 156) mapper = new Mapper156();
if (mapperCode == 180) mapper = new Mapper180();
if (mapperCode == 184) mapper = new Mapper184();
if (mapperCode == 190) mapper = new Mapper190();
if (mapperCode == 193) mapper = new Mapper193();
if (mapperCode == 206) mapper = new Mapper206();
if (mapperCode == 207) mapper = new Mapper207();
if (mapperCode == 232) mapper = new Mapper232();
if (mapperCode == 240) mapper = new Mapper240();
if (mapperCode == 241) mapper = new Mapper241();
if (mapperCode == 244) mapper = new Mapper244();
if (mapperCode == 246) mapper = new Mapper246();
return mapper;
}
return mapper;
}
} // namespace quickNES

203
source/quickerNES/mappers/mapper.h
View File

@ -1,203 +0,0 @@
#pragma once
// NES mapper interface
// Nes_Emu 0.7.0
#include <climits>
#include "Nes_Cart.h"
#include "Nes_Cpu.h"
class Blip_Buffer;
class blip_eq_t;
class Nes_Core;
// Increase this (and let me know) if your mapper requires more state. This only
// sets the size of the in-memory buffer; it doesn't affect the file format at all.
static unsigned const max_mapper_state_size = 512; //was 256, needed more for VRC7 audio state
struct mapper_state_t
{
int size;
union {
double align;
uint8_t data [max_mapper_state_size];
};
void write( const void* p, unsigned long s );
int read( void* p, unsigned long s ) const;
};
class Nes_Mapper {
public:
virtual ~Nes_Mapper();
// Reset mapper to power-up state.
virtual void reset();
// Save snapshot of mapper state. Default saves registered state.
virtual void save_state( mapper_state_t& );
// Resets mapper, loads state, then applies it
virtual void load_state( mapper_state_t const& );
// I/O
// Read from memory
virtual int read( nes_time_t, nes_addr_t );
// Write to memory
virtual void write( nes_time_t, nes_addr_t, int data ) = 0;
// Write to memory below 0x8000 (returns false if mapper didn't handle write)
virtual bool write_intercepted( nes_time_t, nes_addr_t, int data );
// Timing
// Time returned when current mapper state won't ever cause an IRQ
enum { no_irq = LONG_MAX / 2 };
// Time next IRQ will occur at
virtual nes_time_t next_irq( nes_time_t present );
// Run mapper until given time
virtual void run_until( nes_time_t );
// End video frame of given length
virtual void end_frame( nes_time_t length );
// Sound
// Number of sound channels
virtual int channel_count() const;
// Set sound buffer for channel to output to, or NULL to silence channel.
virtual void set_channel_buf( int index, Blip_Buffer* );
// Set treble equalization
virtual void set_treble( blip_eq_t const& );
// Misc
// Called when bit 12 of PPU's VRAM address changes from 0 to 1 due to
// $2006 and $2007 accesses (but not due to PPU scanline rendering).
virtual void a12_clocked();
void* state;
unsigned state_size;
protected:
// Services provided for derived mapper classes
Nes_Mapper();
// Register state data to automatically save and load. Be sure the binary
// layout is suitable for use in a file, including any byte-order issues.
// Automatically cleared to zero by default reset().
void register_state( void*, unsigned );
// Enable 8K of RAM at 0x6000-0x7FFF, optionally read-only.
void enable_sram( bool enabled = true, bool read_only = false );
// Cause CPU writes within given address range to call mapper's write() function.
// Might map a larger address range, which the mapper can ignore and pass to
// Nes_Mapper::write(). The range 0x8000-0xffff is always intercepted by the mapper.
void intercept_writes( nes_addr_t addr, unsigned size );
// Cause CPU reads within given address range to call mapper's read() function.
// Might map a larger address range, which the mapper can ignore and pass to
// Nes_Mapper::read(). CPU opcode/operand reads and low-memory reads always
// go directly to memory and cannot be intercepted.
void intercept_reads( nes_addr_t addr, unsigned size );
// Bank sizes for mapping
enum bank_size_t { // 1 << bank_Xk = X * 1024
bank_1k = 10,
bank_2k = 11,
bank_4k = 12,
bank_8k = 13,
bank_16k = 14,
bank_32k = 15
};
// Index of last PRG/CHR bank. Last_bank selects last bank, last_bank - 1
// selects next-to-last bank, etc.
enum { last_bank = -1 };
// Map 'size' bytes from 'PRG + bank * size' to CPU address space starting at 'addr'
void set_prg_bank( nes_addr_t addr, bank_size_t size, int bank );
// Map 'size' bytes from 'CHR + bank * size' to PPU address space starting at 'addr'
void set_chr_bank( nes_addr_t addr, bank_size_t size, int bank );
void set_chr_bank_ex( nes_addr_t addr, bank_size_t size, int bank );
// Set PPU mirroring. All mappings implemented using mirror_manual().
void mirror_manual( int page0, int page1, int page2, int page3 );
void mirror_single( int page );
void mirror_horiz( int page = 0 );
void mirror_vert( int page = 0 );
void mirror_full();
// True if PPU rendering is enabled. Some mappers watch PPU memory accesses to determine
// when scanlines occur, and can only do this when rendering is enabled.
bool ppu_enabled() const;
// Cartridge being emulated
Nes_Cart const& cart() const { return *cart_; }
// Must be called when next_irq()'s return value is earlier than previous,
// current CPU run can be stopped earlier. Best to call whenever time may
// have changed (no performance impact if called even when time didn't change).
void irq_changed();
// Handle data written to mapper that doesn't handle bus conflict arising due to
// PRG also reading data. Returns data that mapper should act as if were
// written. Currently always returns 'data' and just checks that data written is
// the same as byte in PRG at same address and writes debug message if it doesn't.
int handle_bus_conflict( nes_addr_t addr, int data );
// Reference to emulator that uses this mapper.
Nes_Core& emu() const { return *emu_; }
protected:
// Services derived classes provide
// Read state from snapshot. Default reads data into registered state, then calls
// apply_mapping().
virtual void read_state( mapper_state_t const& );
// Called by default reset() before apply_mapping() is called.
virtual void reset_state() { }
// End of general interface
public:
Nes_Cart const* cart_;
Nes_Core* emu_;
// Apply current mapping state to hardware. Called after reading mapper state
// from a snapshot.
virtual void apply_mapping() = 0;
void default_reset_state();
static Nes_Mapper* getMapperFromCode(const int mapperCode);
};
inline int Nes_Mapper::handle_bus_conflict( nes_addr_t addr, int data ) { return data; }
inline void Nes_Mapper::mirror_horiz( int p ) { mirror_manual( p, p, p ^ 1, p ^ 1 ); }
inline void Nes_Mapper::mirror_vert( int p ) { mirror_manual( p, p ^ 1, p, p ^ 1 ); }
inline void Nes_Mapper::mirror_single( int p ) { mirror_manual( p, p, p, p ); }
inline void Nes_Mapper::mirror_full() { mirror_manual( 0, 1, 2, 3 ); }
inline void Nes_Mapper::register_state( void* p, unsigned s )
{
state = p;
state_size = s;
}
inline bool Nes_Mapper::write_intercepted( nes_time_t, nes_addr_t, int ) { return false; }
inline int Nes_Mapper::read( nes_time_t, nes_addr_t ) { return -1; } // signal to caller

212
source/quickerNES/mappers/mapper.hpp Normal file
View File

@ -0,0 +1,212 @@
#pragma once
// NES mapper interface
// Emu 0.7.0
#include <climits>
#include "cart.hpp"
#include "cpu.hpp"
namespace quickerNES
{
class Blip_Buffer;
class blip_eq_t;
class Core;
// Increase this (and let me know) if your mapper requires more state. This only
// sets the size of the in-memory buffer; it doesn't affect the file format at all.
static unsigned const max_mapper_state_size = 512; // was 256, needed more for VRC7 audio state
struct mapper_state_t
{
int size;
union
{
double align;
uint8_t data[max_mapper_state_size];
};
void write(const void *p, unsigned long s);
int read(void *p, unsigned long s) const;
};
class Mapper
{
public:
virtual ~Mapper();
// Reset mapper to power-up state.
virtual void reset();
// Save snapshot of mapper state. Default saves registered state.
virtual void save_state(mapper_state_t &);
// Resets mapper, loads state, then applies it
virtual void load_state(mapper_state_t const &);
// I/O
// Read from memory
virtual int read(nes_time_t, nes_addr_t);
// Write to memory
virtual void write(nes_time_t, nes_addr_t, int data) = 0;
// Write to memory below 0x8000 (returns false if mapper didn't handle write)
virtual bool write_intercepted(nes_time_t, nes_addr_t, int data);
// Timing
// Time returned when current mapper state won't ever cause an IRQ
enum
{
no_irq = LONG_MAX / 2
};
// Time next IRQ will occur at
virtual nes_time_t next_irq(nes_time_t present);
// Run mapper until given time
virtual void run_until(nes_time_t);
// End video frame of given length
virtual void end_frame(nes_time_t length);
// Sound
// Number of sound channels
virtual int channel_count() const;
// Set sound buffer for channel to output to, or NULL to silence channel.
virtual void set_channel_buf(int index, Blip_Buffer *);
// Set treble equalization
virtual void set_treble(blip_eq_t const &);
// Misc
// Called when bit 12 of PPU's VRAM address changes from 0 to 1 due to
// $2006 and $2007 accesses (but not due to PPU scanline rendering).
virtual void a12_clocked();
void *state;
unsigned state_size;
protected:
// Services provided for derived mapper classes
Mapper();
// Register state data to automatically save and load. Be sure the binary
// layout is suitable for use in a file, including any byte-order issues.
// Automatically cleared to zero by default reset().
void register_state(void *, unsigned);
// Enable 8K of RAM at 0x6000-0x7FFF, optionally read-only.
void enable_sram(bool enabled = true, bool read_only = false);
// Cause CPU writes within given address range to call mapper's write() function.
// Might map a larger address range, which the mapper can ignore and pass to
// Mapper::write(). The range 0x8000-0xffff is always intercepted by the mapper.
void intercept_writes(nes_addr_t addr, unsigned size);
// Cause CPU reads within given address range to call mapper's read() function.
// Might map a larger address range, which the mapper can ignore and pass to
// Mapper::read(). CPU opcode/operand reads and low-memory reads always
// go directly to memory and cannot be intercepted.
void intercept_reads(nes_addr_t addr, unsigned size);
// Bank sizes for mapping
enum bank_size_t
{ // 1 << bank_Xk = X * 1024
bank_1k = 10,
bank_2k = 11,
bank_4k = 12,
bank_8k = 13,
bank_16k = 14,
bank_32k = 15
};
// Index of last PRG/CHR bank. Last_bank selects last bank, last_bank - 1
// selects next-to-last bank, etc.
enum
{
last_bank = -1
};
// Map 'size' bytes from 'PRG + bank * size' to CPU address space starting at 'addr'
void set_prg_bank(nes_addr_t addr, bank_size_t size, int bank);
// Map 'size' bytes from 'CHR + bank * size' to PPU address space starting at 'addr'
void set_chr_bank(nes_addr_t addr, bank_size_t size, int bank);
void set_chr_bank_ex(nes_addr_t addr, bank_size_t size, int bank);
// Set PPU mirroring. All mappings implemented using mirror_manual().
void mirror_manual(int page0, int page1, int page2, int page3);
void mirror_single(int page);
void mirror_horiz(int page = 0);
void mirror_vert(int page = 0);
void mirror_full();
// True if PPU rendering is enabled. Some mappers watch PPU memory accesses to determine
// when scanlines occur, and can only do this when rendering is enabled.
bool ppu_enabled() const;
// Cartridge being emulated
Cart const &cart() const { return *cart_; }
// Must be called when next_irq()'s return value is earlier than previous,
// current CPU run can be stopped earlier. Best to call whenever time may
// have changed (no performance impact if called even when time didn't change).
void irq_changed();
// Handle data written to mapper that doesn't handle bus conflict arising due to
// PRG also reading data. Returns data that mapper should act as if were
// written. Currently always returns 'data' and just checks that data written is
// the same as byte in PRG at same address and writes debug message if it doesn't.
int handle_bus_conflict(nes_addr_t addr, int data);
// Reference to emulator that uses this mapper.
Core &emu() const { return *emu_; }
protected:
// Services derived classes provide
// Read state from snapshot. Default reads data into registered state, then calls
// apply_mapping().
virtual void read_state(mapper_state_t const &);
// Called by default reset() before apply_mapping() is called.
virtual void reset_state() {}
// End of general interface
public:
Cart const *cart_;
Core *emu_;
// Apply current mapping state to hardware. Called after reading mapper state
// from a snapshot.
virtual void apply_mapping() = 0;
void default_reset_state();
static Mapper *getMapperFromCode(const int mapperCode);
};
inline int Mapper::handle_bus_conflict(nes_addr_t addr, int data) { return data; }
inline void Mapper::mirror_horiz(int p) { mirror_manual(p, p, p ^ 1, p ^ 1); }
inline void Mapper::mirror_vert(int p) { mirror_manual(p, p ^ 1, p, p ^ 1); }
inline void Mapper::mirror_single(int p) { mirror_manual(p, p, p, p); }
inline void Mapper::mirror_full() { mirror_manual(0, 1, 2, 3); }
inline void Mapper::register_state(void *p, unsigned s)
{
state = p;
state_size = s;
}
inline bool Mapper::write_intercepted(nes_time_t, nes_addr_t, int) { return false; }
inline int Mapper::read(nes_time_t, nes_addr_t) { return -1; } // signal to caller
} // namespace quickNES

30
source/quickerNES/mappers/mapper000.hpp
View File

@ -2,9 +2,9 @@
// Common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -19,14 +19,20 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// NROM
class Mapper000 : public Nes_Mapper {
public:
Mapper000() { }
virtual void apply_mapping() { }
virtual void write( nes_time_t, nes_addr_t, int )
{
// empty
}
namespace quickerNES
{
class Mapper000 : public Mapper
{
public:
Mapper000() {}
virtual void apply_mapping() {}
virtual void write(nes_time_t, nes_addr_t, int)
{
// empty
}
};
} // namespace quickNES

205
source/quickerNES/mappers/mapper001.hpp
View File

@ -1,8 +1,8 @@
#pragma once
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
#include <cstring>
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
@ -16,111 +16,114 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// MMC1
struct mmc1_state_t
{
uint8_t regs [4]; // current registers (5 bits each)
uint8_t bit; // number of bits in buffer (0 to 4)
uint8_t buf; // currently buffered bits (new bits added to bottom)
uint8_t regs[4]; // current registers (5 bits each)
uint8_t bit; // number of bits in buffer (0 to 4)
uint8_t buf; // currently buffered bits (new bits added to bottom)
};
static_assert( sizeof (mmc1_state_t) == 6 );
static_assert(sizeof(mmc1_state_t) == 6);
class Mapper001 : public Nes_Mapper, mmc1_state_t {
public:
Mapper001()
{
mmc1_state_t* state = this;
register_state( state, sizeof *state );
}
virtual void reset_state()
{
regs [0] = 0x0f;
regs [1] = 0x00;
regs [2] = 0x01;
regs [3] = 0x00;
}
virtual void apply_mapping()
{
enable_sram(); // early MMC1 always had SRAM enabled
register_changed( 0 );
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
if ( !(data & 0x80) )
{
buf |= (data & 1) << bit;
bit++;
if ( bit >= 5 )
{
int reg = addr >> 13 & 3;
regs [reg] = buf & 0x1f;
bit = 0;
buf = 0;
register_changed( reg );
}
}
else
{
bit = 0;
buf = 0;
regs [0] |= 0x0c;
register_changed( 0 );
}
}
class Mapper001 : public Mapper, mmc1_state_t
{
public:
Mapper001()
{
mmc1_state_t *state = this;
register_state(state, sizeof *state);
}
void register_changed( int reg )
{
// Mirroring
if ( reg == 0 )
{
int mode = regs [0] & 3;
if ( mode < 2 )
mirror_single( mode & 1 );
else if ( mode == 2 )
mirror_vert();
else
mirror_horiz();
}
// CHR
if ( reg < 3 && cart().chr_size() > 0 )
{
if ( regs [0] & 0x10 )
{
set_chr_bank( 0x0000, bank_4k, regs [1] );
set_chr_bank( 0x1000, bank_4k, regs [2] );
}
else
{
set_chr_bank( 0, bank_8k, regs [1] >> 1 );
}
}
// PRG
int bank = (regs [1] & 0x10) | (regs [3] & 0x0f);
if ( !(regs [0] & 0x08) )
{
set_prg_bank( 0x8000, bank_32k, bank >> 1 );
}
else if ( regs [0] & 0x04 )
{
set_prg_bank( 0x8000, bank_16k, bank );
set_prg_bank( 0xC000, bank_16k, bank | 0x0f );
}
else
{
set_prg_bank( 0x8000, bank_16k, bank & ~0x0f );
set_prg_bank( 0xC000, bank_16k, bank );
}
}
virtual void reset_state()
{
regs[0] = 0x0f;
regs[1] = 0x00;
regs[2] = 0x01;
regs[3] = 0x00;
}
virtual void apply_mapping()
{
enable_sram(); // early MMC1 always had SRAM enabled
register_changed(0);
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
if (!(data & 0x80))
{
buf |= (data & 1) << bit;
bit++;
if (bit >= 5)
{
int reg = addr >> 13 & 3;
regs[reg] = buf & 0x1f;
bit = 0;
buf = 0;
register_changed(reg);
}
}
else
{
bit = 0;
buf = 0;
regs[0] |= 0x0c;
register_changed(0);
}
}
void register_changed(int reg)
{
// Mirroring
if (reg == 0)
{
int mode = regs[0] & 3;
if (mode < 2)
mirror_single(mode & 1);
else if (mode == 2)
mirror_vert();
else
mirror_horiz();
}
// CHR
if (reg < 3 && cart().chr_size() > 0)
{
if (regs[0] & 0x10)
{
set_chr_bank(0x0000, bank_4k, regs[1]);
set_chr_bank(0x1000, bank_4k, regs[2]);
}
else
{
set_chr_bank(0, bank_8k, regs[1] >> 1);
}
}
// PRG
int bank = (regs[1] & 0x10) | (regs[3] & 0x0f);
if (!(regs[0] & 0x08))
{
set_prg_bank(0x8000, bank_32k, bank >> 1);
}
else if (regs[0] & 0x04)
{
set_prg_bank(0x8000, bank_16k, bank);
set_prg_bank(0xC000, bank_16k, bank | 0x0f);
}
else
{
set_prg_bank(0x8000, bank_16k, bank & ~0x0f);
set_prg_bank(0xC000, bank_16k, bank);
}
}
};
} // namespace quickNES

48
source/quickerNES/mappers/mapper002.hpp
View File

@ -2,9 +2,9 @@
// Common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -17,26 +17,32 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// UNROM
class Mapper002 : public Nes_Mapper {
uint8_t bank;
public:
Mapper002()
{
register_state( &bank, 1 );
}
virtual void apply_mapping()
{
enable_sram(); // at least one UNROM game needs sram (Bomberman 2)
set_prg_bank( 0x8000, bank_16k, bank );
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
bank = handle_bus_conflict( addr, data );
set_prg_bank( 0x8000, bank_16k, data );
}
class Mapper002 : public Mapper
{
uint8_t bank;
public:
Mapper002()
{
register_state(&bank, 1);
}
virtual void apply_mapping()
{
enable_sram(); // at least one UNROM game needs sram (Bomberman 2)
set_prg_bank(0x8000, bank_16k, bank);
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
bank = handle_bus_conflict(addr, data);
set_prg_bank(0x8000, bank_16k, data);
}
};
} // namespace quickNES

46
source/quickerNES/mappers/mapper003.hpp
View File

@ -2,9 +2,9 @@
// Common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -17,25 +17,31 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// CNROM
class Mapper003 : public Nes_Mapper {
uint8_t bank;
public:
Mapper003()
{
register_state( &bank, 1 );
}
virtual void apply_mapping()
{
set_chr_bank( 0, bank_8k, bank & 7 );
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
bank = handle_bus_conflict( addr, data );
set_chr_bank( 0, bank_8k, bank & 7 );
}
class Mapper003 : public Mapper
{
uint8_t bank;
public:
Mapper003()
{
register_state(&bank, 1);
}
virtual void apply_mapping()
{
set_chr_bank(0, bank_8k, bank & 7);
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
bank = handle_bus_conflict(addr, data);
set_chr_bank(0, bank_8k, bank & 7);
}
};
} // namespace quickNES

436
source/quickerNES/mappers/mapper004.hpp
View File

@ -1,11 +1,11 @@
#pragma once
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
#include "core.hpp"
#include <cstring>
#include "Nes_Core.h"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -18,235 +18,241 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// 264 or less breaks Gargoyle's Quest II
// 267 or less breaks Magician
int const irq_fine_tune = 268;
nes_time_t const first_scanline = 20 * Nes_Ppu::scanline_len + irq_fine_tune;
nes_time_t const last_scanline = first_scanline + 240 * Nes_Ppu::scanline_len;
nes_time_t const first_scanline = 20 * Ppu::scanline_len + irq_fine_tune;
nes_time_t const last_scanline = first_scanline + 240 * Ppu::scanline_len;
// MMC3
struct mmc3_state_t
{
uint8_t banks [8]; // last writes to $8001 indexed by (mode & 7)
uint8_t mode; // $8000
uint8_t mirror; // $a000
uint8_t sram_mode; // $a001
uint8_t irq_ctr; // internal counter
uint8_t irq_latch; // $c000
uint8_t irq_enabled;// last write was to 0) $e000, 1) $e001
uint8_t irq_flag;
uint8_t banks[8]; // last writes to $8001 indexed by (mode & 7)
uint8_t mode; // $8000
uint8_t mirror; // $a000
uint8_t sram_mode; // $a001
uint8_t irq_ctr; // internal counter
uint8_t irq_latch; // $c000
uint8_t irq_enabled; // last write was to 0) $e000, 1) $e001
uint8_t irq_flag;
};
static_assert( sizeof (mmc3_state_t) == 15 );
static_assert(sizeof(mmc3_state_t) == 15);
class Mapper004 : public Nes_Mapper, mmc3_state_t {
public:
Mapper004()
{
mmc3_state_t* state = this;
register_state( state, sizeof *state );
}
virtual void reset_state()
{
memcpy( banks, "\0\2\4\5\6\7\0\1", sizeof banks );
counter_just_clocked = 0;
next_time = 0;
mirror = 1;
class Mapper004 : public Mapper, mmc3_state_t
{
public:
Mapper004()
{
mmc3_state_t *state = this;
register_state(state, sizeof *state);
}
/* Cart specified vertical mirroring */
if ( cart().mirroring() & 1 )
mirror = 0;
}
void start_frame() { next_time = first_scanline; }
virtual void apply_mapping()
{
write( 0, 0xA000, mirror );
write( 0, 0xA001, sram_mode );
update_chr_banks();
update_prg_banks();
start_frame();
}
void clock_counter()
{
if ( counter_just_clocked )
counter_just_clocked--;
if ( !irq_ctr-- )
{
irq_ctr = irq_latch;
//if ( !irq_latch )
//dprintf( "MMC3 IRQ counter reloaded with 0\n" );
}
//dprintf( "%6d MMC3 IRQ clocked\n", time / ppu_overclock );
if ( irq_ctr == 0 )
{
//if ( irq_enabled && !irq_flag )
//dprintf( "%6d MMC3 IRQ triggered: %f\n", time / ppu_overclock, time / scanline_len.0 - 20 );
irq_flag = irq_enabled;
}
}
virtual void a12_clocked()
{
clock_counter();
if ( irq_enabled )
irq_changed();
}
virtual void end_frame( nes_time_t end_time )
{
run_until( end_time );
start_frame();
}
virtual nes_time_t next_irq( nes_time_t present )
{
run_until( present );
if ( !irq_enabled )
return no_irq;
if ( irq_flag )
return 0;
if ( !ppu_enabled() )
return no_irq;
int remain = irq_ctr - 1;
if ( remain < 0 )
remain = irq_latch;
long time = remain * 341L + next_time;
if ( time > last_scanline )
return no_irq;
return time / ppu_overclock + 1;
}
virtual void reset_state()
{
memcpy(banks, "\0\2\4\5\6\7\0\1", sizeof banks);
void run_until( nes_time_t end_time )
{
bool bg_enabled = ppu_enabled();
if (next_time < 0) next_time = 0;
counter_just_clocked = 0;
next_time = 0;
mirror = 1;
end_time *= ppu_overclock;
while ( next_time < end_time && next_time <= last_scanline )
{
if ( bg_enabled )
clock_counter();
next_time += Nes_Ppu::scanline_len;
}
}
/* Cart specified vertical mirroring */
if (cart().mirroring() & 1)
mirror = 0;
}
void update_chr_banks()
{
int chr_xor = (mode >> 7 & 1) * 0x1000;
set_chr_bank( 0x0000 ^ chr_xor, bank_2k, banks [0] >> 1 );
set_chr_bank( 0x0800 ^ chr_xor, bank_2k, banks [1] >> 1 );
set_chr_bank( 0x1000 ^ chr_xor, bank_1k, banks [2] );
set_chr_bank( 0x1400 ^ chr_xor, bank_1k, banks [3] );
set_chr_bank( 0x1800 ^ chr_xor, bank_1k, banks [4] );
set_chr_bank( 0x1c00 ^ chr_xor, bank_1k, banks [5] );
}
void start_frame() { next_time = first_scanline; }
void update_prg_banks()
{
set_prg_bank( 0xA000, bank_8k, banks [7] );
nes_addr_t addr = 0x8000 + 0x4000 * (mode >> 6 & 1);
set_prg_bank( addr, bank_8k, banks [6] );
set_prg_bank( addr ^ 0x4000, bank_8k, last_bank - 1 );
}
virtual void apply_mapping()
{
write(0, 0xA000, mirror);
write(0, 0xA001, sram_mode);
update_chr_banks();
update_prg_banks();
start_frame();
}
void write_irq( nes_addr_t addr, int data )
{
switch ( addr & 0xE001 )
{
case 0xC000:
irq_latch = data;
break;
case 0xC001:
/* MMC3 IRQ counter pathological behavior triggered if
* counter_just_clocked is 1 */
counter_just_clocked = 2;
irq_ctr = 0;
break;
case 0xE000:
irq_flag = false;
irq_enabled = false;
break;
case 0xE001:
irq_enabled = true;
break;
}
if ( irq_enabled )
irq_changed();
}
void clock_counter()
{
if (counter_just_clocked)
counter_just_clocked--;
void write( nes_time_t time, nes_addr_t addr, int data )
{
switch ( addr & 0xE001 )
{
case 0x8000: {
int changed = mode ^ data;
mode = data;
// avoid unnecessary bank updates
if ( changed & 0x80 )
update_chr_banks();
if ( changed & 0x40 )
update_prg_banks();
break;
}
case 0x8001: {
int bank = mode & 7;
banks [bank] = data;
if ( bank < 6 )
update_chr_banks();
else
update_prg_banks();
break;
}
case 0xA000:
mirror = data;
if ( !(cart().mirroring() & 0x08) )
{
if ( mirror & 1 )
mirror_horiz();
else
mirror_vert();
}
break;
case 0xA001:
sram_mode = data;
//dprintf( "%02X->%04X\n", data, addr );
// Startropics 1 & 2 use MMC6 and always enable low 512 bytes of SRAM
if ( (data & 0x3F) == 0x30 )
enable_sram( true );
else
enable_sram( data & 0x80, data & 0x40 );
break;
default:
run_until( time );
write_irq( addr, data );
break;
}
}
if (!irq_ctr--)
{
irq_ctr = irq_latch;
// if ( !irq_latch )
// dprintf( "MMC3 IRQ counter reloaded with 0\n" );
}
nes_time_t next_time;
int counter_just_clocked; // used only for debugging
// dprintf( "%6d MMC3 IRQ clocked\n", time / ppu_overclock );
if (irq_ctr == 0)
{
// if ( irq_enabled && !irq_flag )
// dprintf( "%6d MMC3 IRQ triggered: %f\n", time / ppu_overclock, time / scanline_len.0 - 20 );
irq_flag = irq_enabled;
}
}
virtual void a12_clocked()
{
clock_counter();
if (irq_enabled)
irq_changed();
}
virtual void end_frame(nes_time_t end_time)
{
run_until(end_time);
start_frame();
}
virtual nes_time_t next_irq(nes_time_t present)
{
run_until(present);
if (!irq_enabled)
return no_irq;
if (irq_flag)
return 0;
if (!ppu_enabled())
return no_irq;
int remain = irq_ctr - 1;
if (remain < 0)
remain = irq_latch;
long time = remain * 341L + next_time;
if (time > last_scanline)
return no_irq;
return time / ppu_overclock + 1;
}
void run_until(nes_time_t end_time)
{
bool bg_enabled = ppu_enabled();
if (next_time < 0) next_time = 0;
end_time *= ppu_overclock;
while (next_time < end_time && next_time <= last_scanline)
{
if (bg_enabled)
clock_counter();
next_time += Ppu::scanline_len;
}
}
void update_chr_banks()
{
int chr_xor = (mode >> 7 & 1) * 0x1000;
set_chr_bank(0x0000 ^ chr_xor, bank_2k, banks[0] >> 1);
set_chr_bank(0x0800 ^ chr_xor, bank_2k, banks[1] >> 1);
set_chr_bank(0x1000 ^ chr_xor, bank_1k, banks[2]);
set_chr_bank(0x1400 ^ chr_xor, bank_1k, banks[3]);
set_chr_bank(0x1800 ^ chr_xor, bank_1k, banks[4]);
set_chr_bank(0x1c00 ^ chr_xor, bank_1k, banks[5]);
}
void update_prg_banks()
{
set_prg_bank(0xA000, bank_8k, banks[7]);
nes_addr_t addr = 0x8000 + 0x4000 * (mode >> 6 & 1);
set_prg_bank(addr, bank_8k, banks[6]);
set_prg_bank(addr ^ 0x4000, bank_8k, last_bank - 1);
}
void write_irq(nes_addr_t addr, int data)
{
switch (addr & 0xE001)
{
case 0xC000:
irq_latch = data;
break;
case 0xC001:
/* MMC3 IRQ counter pathological behavior triggered if
* counter_just_clocked is 1 */
counter_just_clocked = 2;
irq_ctr = 0;
break;
case 0xE000:
irq_flag = false;
irq_enabled = false;
break;
case 0xE001:
irq_enabled = true;
break;
}
if (irq_enabled)
irq_changed();
}
void write(nes_time_t time, nes_addr_t addr, int data)
{
switch (addr & 0xE001)
{
case 0x8000:
{
int changed = mode ^ data;
mode = data;
// avoid unnecessary bank updates
if (changed & 0x80)
update_chr_banks();
if (changed & 0x40)
update_prg_banks();
break;
}
case 0x8001:
{
int bank = mode & 7;
banks[bank] = data;
if (bank < 6)
update_chr_banks();
else
update_prg_banks();
break;
}
case 0xA000:
mirror = data;
if (!(cart().mirroring() & 0x08))
{
if (mirror & 1)
mirror_horiz();
else
mirror_vert();
}
break;
case 0xA001:
sram_mode = data;
// dprintf( "%02X->%04X\n", data, addr );
// Startropics 1 & 2 use MMC6 and always enable low 512 bytes of SRAM
if ((data & 0x3F) == 0x30)
enable_sram(true);
else
enable_sram(data & 0x80, data & 0x40);
break;
default:
run_until(time);
write_irq(addr, data);
break;
}
}
nes_time_t next_time;
int counter_just_clocked; // used only for debugging
};
} // namespace quickNES

244
source/quickerNES/mappers/mapper005.hpp
View File

@ -2,11 +2,10 @@
// NES MMC5 mapper, currently only tailored for Castlevania 3 (U)
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "Nes_Core.h"
#include "core.hpp"
#include "mappers/mapper.hpp"
#include <cstring>
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
@ -20,129 +19,134 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
struct mmc5_state_t
{
enum { reg_count = 0x30 };
uint8_t regs [0x30];
uint8_t irq_enabled;
enum
{
reg_count = 0x30
};
uint8_t regs[0x30];
uint8_t irq_enabled;
};
static_assert( sizeof (mmc5_state_t) == 0x31 );
static_assert(sizeof(mmc5_state_t) == 0x31);
// MMC5
class Mapper005 : public Nes_Mapper, mmc5_state_t {
public:
Mapper005()
{
mmc5_state_t* state = this;
register_state( state, sizeof *state );
}
virtual void reset_state()
{
irq_time = no_irq;
regs [0x00] = 2;
regs [0x01] = 3;
regs [0x14] = 0x7f;
regs [0x15] = 0x7f;
regs [0x16] = 0x7f;
regs [0x17] = 0x7f;
}
virtual void read_state( mapper_state_t const& in )
{
Nes_Mapper::read_state( in );
irq_time = no_irq;
}
enum { regs_addr = 0x5100 };
virtual nes_time_t next_irq( nes_time_t )
{
if ( irq_enabled & 0x80 )
return irq_time;
return no_irq;
}
virtual bool write_intercepted( nes_time_t time, nes_addr_t addr, int data )
{
int reg = addr - regs_addr;
if ( (unsigned) reg < reg_count )
{
regs [reg] = data;
switch ( reg )
{
case 0x05:
mirror_manual( data & 3, data >> 2 & 3,
data >> 4 & 3, data >> 6 & 3 );
break;
case 0x15:
set_prg_bank( 0x8000, bank_16k, data >> 1 & 0x3f );
break;
case 0x16:
set_prg_bank( 0xC000, bank_8k, data & 0x7f );
break;
case 0x17:
set_prg_bank( 0xE000, bank_8k, data & 0x7f );
break;
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x28:
case 0x29:
case 0x2a:
case 0x2b:
set_chr_bank( ((reg >> 1 & 4) + (reg & 3)) * 0x400, bank_1k, data );
break;
}
}
else if ( addr == 0x5203 )
{
irq_time = no_irq;
if ( data && data < 240 )
{
irq_time = (341 * 21 + 128 + (data * 341)) / 3;
if ( irq_time < time )
irq_time = no_irq;
}
irq_changed();
}
else if ( addr == 0x5204 )
{
irq_enabled = data;
irq_changed();
}
else
{
return false;
}
return true;
}
void apply_mapping()
{
static unsigned char list [] = {
0x05, 0x15, 0x16, 0x17,
0x20, 0x21, 0x22, 0x23,
0x28, 0x29, 0x2a, 0x2b
};
for ( int i = 0; i < (int) sizeof list; i++ )
write_intercepted( 0, regs_addr + list [i], regs [list [i]] );
intercept_writes( 0x5100, 0x200 );
}
class Mapper005 : public Mapper, mmc5_state_t
{
public:
Mapper005()
{
mmc5_state_t *state = this;
register_state(state, sizeof *state);
}
virtual void write( nes_time_t, nes_addr_t, int ) { }
virtual void reset_state()
{
irq_time = no_irq;
regs[0x00] = 2;
regs[0x01] = 3;
regs[0x14] = 0x7f;
regs[0x15] = 0x7f;
regs[0x16] = 0x7f;
regs[0x17] = 0x7f;
}
nes_time_t irq_time;
virtual void read_state(mapper_state_t const &in)
{
Mapper::read_state(in);
irq_time = no_irq;
}
enum
{
regs_addr = 0x5100
};
virtual nes_time_t next_irq(nes_time_t)
{
if (irq_enabled & 0x80)
return irq_time;
return no_irq;
}
virtual bool write_intercepted(nes_time_t time, nes_addr_t addr, int data)
{
int reg = addr - regs_addr;
if ((unsigned)reg < reg_count)
{
regs[reg] = data;
switch (reg)
{
case 0x05:
mirror_manual(data & 3, data >> 2 & 3, data >> 4 & 3, data >> 6 & 3);
break;
case 0x15:
set_prg_bank(0x8000, bank_16k, data >> 1 & 0x3f);
break;
case 0x16:
set_prg_bank(0xC000, bank_8k, data & 0x7f);
break;
case 0x17:
set_prg_bank(0xE000, bank_8k, data & 0x7f);
break;
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x28:
case 0x29:
case 0x2a:
case 0x2b:
set_chr_bank(((reg >> 1 & 4) + (reg & 3)) * 0x400, bank_1k, data);
break;
}
}
else if (addr == 0x5203)
{
irq_time = no_irq;
if (data && data < 240)
{
irq_time = (341 * 21 + 128 + (data * 341)) / 3;
if (irq_time < time)
irq_time = no_irq;
}
irq_changed();
}
else if (addr == 0x5204)
{
irq_enabled = data;
irq_changed();
}
else
{
return false;
}
return true;
}
void apply_mapping()
{
static unsigned char list[] = {
0x05, 0x15, 0x16, 0x17, 0x20, 0x21, 0x22, 0x23, 0x28, 0x29, 0x2a, 0x2b};
for (int i = 0; i < (int)sizeof list; i++)
write_intercepted(0, regs_addr + list[i], regs[list[i]]);
intercept_writes(0x5100, 0x200);
}
virtual void write(nes_time_t, nes_addr_t, int) {}
nes_time_t irq_time;
};
} // namespace quickNES

65
source/quickerNES/mappers/mapper007.hpp
View File

@ -2,9 +2,9 @@
// Common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -17,34 +17,39 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// AOROM
class Mapper007 : public Nes_Mapper {
uint8_t bank;
public:
Mapper007()
{
register_state( &bank, 1 );
}
virtual void apply_mapping()
{
int b = bank;
bank = ~b; // force update
write( 0, 0, b );
}
virtual void write( nes_time_t, nes_addr_t, int data )
{
int changed = bank ^ data;
bank = data;
if ( changed & 0x10 )
mirror_single( bank >> 4 & 1 );
if ( changed & 0x0f )
set_prg_bank( 0x8000, bank_32k, bank & 7 );
}
};
class Mapper007 : public Mapper
{
uint8_t bank;
public:
Mapper007()
{
register_state(&bank, 1);
}
virtual void apply_mapping()
{
int b = bank;
bank = ~b; // force update
write(0, 0, b);
}
virtual void write(nes_time_t, nes_addr_t, int data)
{
int changed = bank ^ data;
bank = data;
if (changed & 0x10)
mirror_single(bank >> 4 & 1);
if (changed & 0x0f)
set_prg_bank(0x8000, bank_32k, bank & 7);
}
};
} // namespace quickNES

112
source/quickerNES/mappers/mapper009.hpp
View File

@ -1,59 +1,81 @@
#pragma once
#include "mappers/mapper.hpp"
#include <cstring>
#include "mappers/mapper.h"
// MMC2
class Mapper009: public Nes_Mapper
namespace quickerNES
{
uint8_t regs[6]; // A,B,C,D,E,F
void mirror(uint8_t val)
{
if (val & 1)
mirror_horiz();
else
mirror_vert();
}
// MMC2
public:
Mapper009()
{
register_state(regs, sizeof(regs));
}
class Mapper009 : public Mapper
{
uint8_t regs[6]; // A,B,C,D,E,F
virtual void reset_state()
{
std::memset(regs, 0, sizeof(regs));
}
void mirror(uint8_t val)
{
if (val & 1)
mirror_horiz();
else
mirror_vert();
}
virtual void apply_mapping()
{
mirror(regs[5]);
set_prg_bank(0x8000, bank_8k, regs[0]);
set_prg_bank(0xa000, bank_8k, 13);
set_prg_bank(0xc000, bank_8k, 14);
set_prg_bank(0xe000, bank_8k, 15);
public:
Mapper009()
{
register_state(regs, sizeof(regs));
}
set_chr_bank(0x0000, bank_4k, regs[1]);
set_chr_bank(0x1000, bank_4k, regs[3]);
virtual void reset_state()
{
std::memset(regs, 0, sizeof(regs));
}
set_chr_bank_ex(0x0000, bank_4k, regs[2]);
set_chr_bank_ex(0x1000, bank_4k, regs[4]);
}
virtual void apply_mapping()
{
mirror(regs[5]);
set_prg_bank(0x8000, bank_8k, regs[0]);
set_prg_bank(0xa000, bank_8k, 13);
set_prg_bank(0xc000, bank_8k, 14);
set_prg_bank(0xe000, bank_8k, 15);
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
switch (addr >> 12)
{
case 0xa: regs[0] = data; set_prg_bank(0x8000, bank_8k, data); break;
case 0xb: regs[1] = data; set_chr_bank(0x0000, bank_4k, data); break;
case 0xc: regs[2] = data; set_chr_bank_ex(0x0000, bank_4k, data); break;
case 0xd: regs[3] = data; set_chr_bank(0x1000, bank_4k, data); break;
case 0xe: regs[4] = data; set_chr_bank_ex(0x1000, bank_4k, data); break;
case 0xf: regs[5] = data; mirror(data); break;
}
}
set_chr_bank(0x0000, bank_4k, regs[1]);
set_chr_bank(0x1000, bank_4k, regs[3]);
set_chr_bank_ex(0x0000, bank_4k, regs[2]);
set_chr_bank_ex(0x1000, bank_4k, regs[4]);
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
switch (addr >> 12)
{
case 0xa:
regs[0] = data;
set_prg_bank(0x8000, bank_8k, data);
break;
case 0xb:
regs[1] = data;
set_chr_bank(0x0000, bank_4k, data);
break;
case 0xc:
regs[2] = data;
set_chr_bank_ex(0x0000, bank_4k, data);
break;
case 0xd:
regs[3] = data;
set_chr_bank(0x1000, bank_4k, data);
break;
case 0xe:
regs[4] = data;
set_chr_bank_ex(0x1000, bank_4k, data);
break;
case 0xf:
regs[5] = data;
mirror(data);
break;
}
}
};
} // namespace quickNES

109
source/quickerNES/mappers/mapper010.hpp
View File

@ -1,56 +1,79 @@
#pragma once
#include "mappers/mapper.hpp"
#include <cstring>
#include "mappers/mapper.h"
// MMC4
class Mapper010: public Nes_Mapper
namespace quickerNES
{
uint8_t regs[6]; // A,B,C,D,E,F
void mirror(uint8_t val)
{
if (val & 1)
mirror_horiz();
else
mirror_vert();
}
// MMC4
public:
Mapper010()
{
register_state(regs, sizeof(regs));
}
class Mapper010 : public Mapper
{
uint8_t regs[6]; // A,B,C,D,E,F
virtual void reset_state()
{
std::memset(regs, 0, sizeof(regs));
}
void mirror(uint8_t val)
{
if (val & 1)
mirror_horiz();
else
mirror_vert();
}
virtual void apply_mapping()
{
enable_sram();
public:
Mapper010()
{
register_state(regs, sizeof(regs));
}
mirror(regs[5]);
set_prg_bank(0x8000, bank_16k, regs[0]);
virtual void reset_state()
{
std::memset(regs, 0, sizeof(regs));
}
set_chr_bank(0x0000, bank_4k, regs[1]);
set_chr_bank(0x1000, bank_4k, regs[3]);
virtual void apply_mapping()
{
enable_sram();
set_chr_bank_ex(0x0000, bank_4k, regs[2]);
set_chr_bank_ex(0x1000, bank_4k, regs[4]);
}
mirror(regs[5]);
set_prg_bank(0x8000, bank_16k, regs[0]);
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
switch (addr >> 12)
{
case 0xa: regs[0] = data; set_prg_bank(0x8000, bank_16k, data); break;
case 0xb: regs[1] = data; set_chr_bank(0x0000, bank_4k, data); break;
case 0xc: regs[2] = data; set_chr_bank_ex(0x0000, bank_4k, data); break;
case 0xd: regs[3] = data; set_chr_bank(0x1000, bank_4k, data); break;
case 0xe: regs[4] = data; set_chr_bank_ex(0x1000, bank_4k, data); break;
case 0xf: regs[5] = data; mirror(data); break;
}
}
set_chr_bank(0x0000, bank_4k, regs[1]);
set_chr_bank(0x1000, bank_4k, regs[3]);
set_chr_bank_ex(0x0000, bank_4k, regs[2]);
set_chr_bank_ex(0x1000, bank_4k, regs[4]);
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
switch (addr >> 12)
{
case 0xa:
regs[0] = data;
set_prg_bank(0x8000, bank_16k, data);
break;
case 0xb:
regs[1] = data;
set_chr_bank(0x0000, bank_4k, data);
break;
case 0xc:
regs[2] = data;
set_chr_bank_ex(0x0000, bank_4k, data);
break;
case 0xd:
regs[3] = data;
set_chr_bank(0x1000, bank_4k, data);
break;
case 0xe:
regs[4] = data;
set_chr_bank_ex(0x1000, bank_4k, data);
break;
case 0xf:
regs[5] = data;
mirror(data);
break;
}
}
};
} // namespace quickNES

63
source/quickerNES/mappers/mapper011.hpp
View File

@ -2,9 +2,9 @@
// Optional less-common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -17,32 +17,39 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
// Color Dreams
class Mapper011 : public Nes_Mapper {
uint8_t bank;
public:
Mapper011()
{
register_state( &bank, 1 );
}
virtual void apply_mapping()
{
int b = bank;
bank = ~b;
write( 0, 0, b );
}
virtual void write( nes_time_t, nes_addr_t, int data )
{
int changed = bank ^ data;
bank = data;
if ( changed & 0x0f )
set_prg_bank( 0x8000, bank_32k, bank & 0x0f );
if ( changed & 0xf0 )
set_chr_bank( 0, bank_8k, bank >> 4 );
}
class Mapper011 : public Mapper
{
uint8_t bank;
public:
Mapper011()
{
register_state(&bank, 1);
}
virtual void apply_mapping()
{
int b = bank;
bank = ~b;
write(0, 0, b);
}
virtual void write(nes_time_t, nes_addr_t, int data)
{
int changed = bank ^ data;
bank = data;
if (changed & 0x0f)
set_prg_bank(0x8000, bank_32k, bank & 0x0f);
if (changed & 0xf0)
set_chr_bank(0, bank_8k, bank >> 4);
}
};
} // namespace quickNES

123
source/quickerNES/mappers/mapper015.hpp
View File

@ -17,76 +17,81 @@
* 100-in-1 Contra Function 16
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
namespace quickerNES
{
struct Mapper015_state_t
{
uint8_t prg_bank [ 4 ];
uint8_t mirroring;
uint8_t prg_bank[4];
uint8_t mirroring;
};
static_assert( sizeof (Mapper015_state_t) == 5 );
static_assert(sizeof(Mapper015_state_t) == 5);
// K-1029, K-1030P
class Mapper015 : public Nes_Mapper, Mapper015_state_t {
public:
Mapper015()
{
i = 0;
Mapper015_state_t* state = this;
register_state( state, sizeof *state );
}
class Mapper015 : public Mapper, Mapper015_state_t
{
public:
Mapper015()
{
i = 0;
Mapper015_state_t *state = this;
register_state(state, sizeof *state);
}
virtual void reset_state()
{
write( 0, 0x8000, 0 );
}
virtual void reset_state()
{
write(0, 0x8000, 0);
}
virtual void apply_mapping()
{
enable_sram();
set_chr_bank ( 0, bank_8k, 0 );
for ( i = 0; i < sizeof prg_bank; i++ )
set_prg_bank ( 0x8000 + ( i * 0x2000 ), bank_8k, prg_bank [i] );
switch ( mirroring )
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
}
}
virtual void apply_mapping()
{
enable_sram();
set_chr_bank(0, bank_8k, 0);
for (i = 0; i < sizeof prg_bank; i++)
set_prg_bank(0x8000 + (i * 0x2000), bank_8k, prg_bank[i]);
switch (mirroring)
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
}
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
uint8_t bank = ( data & 0x3F ) << 1;
uint8_t sbank = ( data >> 7 ) & 1;
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
uint8_t bank = (data & 0x3F) << 1;
uint8_t sbank = (data >> 7) & 1;
mirroring = ( data >> 6 ) & 1;
switch ( addr & 3 )
{
case 0:
for ( i = 0; i < sizeof prg_bank; i++ )
prg_bank [ i ] = bank + i;
apply_mapping();
break;
case 2:
for ( i = 0; i < sizeof prg_bank; i++ )
prg_bank [ i ] = bank | sbank;
apply_mapping();
break;
case 1:
case 3:
for ( i = 0; i < sizeof prg_bank; i++ )
{
if ( i >= 2 && !( addr & 2 ) )
bank = 0x7E;
prg_bank [ i ] = bank + ( i & 1 );
}
apply_mapping();
break;
}
}
unsigned long int i;
mirroring = (data >> 6) & 1;
switch (addr & 3)
{
case 0:
for (i = 0; i < sizeof prg_bank; i++)
prg_bank[i] = bank + i;
apply_mapping();
break;
case 2:
for (i = 0; i < sizeof prg_bank; i++)
prg_bank[i] = bank | sbank;
apply_mapping();
break;
case 1:
case 3:
for (i = 0; i < sizeof prg_bank; i++)
{
if (i >= 2 && !(addr & 2))
bank = 0x7E;
prg_bank[i] = bank + (i & 1);
}
apply_mapping();
break;
}
}
unsigned long int i;
};
} // namespace quickNES

298
source/quickerNES/mappers/mapper019.hpp
View File

@ -2,10 +2,10 @@
// Namco 106 mapper
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "apu/namco/apu.h"
#include "apu/namco/apu.hpp"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -20,179 +20,183 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// to do: CHR mapping and nametable handling needs work
namespace quickerNES
{
struct namco106_state_t
{
uint8_t regs [16];
uint16_t irq_ctr;
uint8_t irq_pending;
uint8_t unused1 [1];
namco_state_t sound_state;
uint8_t regs[16];
uint16_t irq_ctr;
uint8_t irq_pending;
uint8_t unused1[1];
namco_state_t sound_state;
};
static_assert( sizeof (namco106_state_t) == 20 + sizeof (namco_state_t) );
static_assert(sizeof(namco106_state_t) == 20 + sizeof(namco_state_t));
// Namco106
class Mapper019 : public Nes_Mapper, namco106_state_t {
public:
Mapper019()
{
namco106_state_t* state = this;
register_state( state, sizeof *state );
}
class Mapper019 : public Mapper, namco106_state_t
{
public:
Mapper019()
{
namco106_state_t *state = this;
register_state(state, sizeof *state);
}
virtual int channel_count() const { return sound.osc_count; }
virtual int channel_count() const { return sound.osc_count; }
virtual void set_channel_buf( int i, Blip_Buffer* b ) { sound.osc_output( i, b ); }
virtual void set_channel_buf(int i, Blip_Buffer *b) { sound.osc_output(i, b); }
virtual void set_treble( blip_eq_t const& eq ) { sound.treble_eq( eq ); }
virtual void set_treble(blip_eq_t const &eq) { sound.treble_eq(eq); }
void reset_state()
{
regs [12] = 0;
regs [13] = 1;
regs [14] = last_bank - 1;
sound.reset();
}
void reset_state()
{
regs[12] = 0;
regs[13] = 1;
regs[14] = last_bank - 1;
sound.reset();
}
virtual void apply_mapping()
{
last_time = 0;
enable_sram();
intercept_writes( 0x4800, 1 );
intercept_reads ( 0x4800, 1 );
virtual void apply_mapping()
{
last_time = 0;
enable_sram();
intercept_writes(0x4800, 1);
intercept_reads(0x4800, 1);
intercept_writes( 0x5000, 0x1000 );
intercept_reads ( 0x5000, 0x1000 );
intercept_writes(0x5000, 0x1000);
intercept_reads(0x5000, 0x1000);
for ( int i = 0; i < (int) sizeof regs; i++ )
write( 0, 0x8000 + i * 0x800, regs [i] );
}
for (int i = 0; i < (int)sizeof regs; i++)
write(0, 0x8000 + i * 0x800, regs[i]);
}
virtual nes_time_t next_irq( nes_time_t time )
{
if ( irq_pending )
return time;
virtual nes_time_t next_irq(nes_time_t time)
{
if (irq_pending)
return time;
if ( !(irq_ctr & 0x8000) )
return no_irq;
if (!(irq_ctr & 0x8000))
return no_irq;
return 0x10000 - irq_ctr + last_time;
}
return 0x10000 - irq_ctr + last_time;
}
virtual void run_until( nes_time_t end_time )
{
long count = irq_ctr + (end_time - last_time);
if ( irq_ctr & 0x8000 )
{
if ( count > 0xffff )
{
count = 0xffff;
irq_pending = true;
}
}
else if ( count > 0x7fff )
{
count = 0x7fff;
}
virtual void run_until(nes_time_t end_time)
{
long count = irq_ctr + (end_time - last_time);
if (irq_ctr & 0x8000)
{
if (count > 0xffff)
{
count = 0xffff;
irq_pending = true;
}
}
else if (count > 0x7fff)
{
count = 0x7fff;
}
irq_ctr = count;
last_time = end_time;
}
irq_ctr = count;
last_time = end_time;
}
virtual void end_frame( nes_time_t end_time )
{
if ( end_time > last_time )
run_until( end_time );
last_time -= end_time;
sound.end_frame( end_time );
}
virtual void end_frame(nes_time_t end_time)
{
if (end_time > last_time)
run_until(end_time);
last_time -= end_time;
sound.end_frame(end_time);
}
virtual int read( nes_time_t time, nes_addr_t addr )
{
if ( addr == 0x4800 )
return sound.read_data();
virtual int read(nes_time_t time, nes_addr_t addr)
{
if (addr == 0x4800)
return sound.read_data();
if ( addr == 0x5000 )
{
irq_pending = false;
return irq_ctr & 0xff;
}
if (addr == 0x5000)
{
irq_pending = false;
return irq_ctr & 0xff;
}
if ( addr == 0x5800 )
{
irq_pending = false;
return irq_ctr >> 8;
}
if (addr == 0x5800)
{
irq_pending = false;
return irq_ctr >> 8;
}
return Nes_Mapper::read( time, addr );
}
return Mapper::read(time, addr);
}
virtual bool write_intercepted( nes_time_t time, nes_addr_t addr, int data )
{
if ( addr == 0x4800 )
{
sound.write_data( time, data );
}
else if ( addr == 0x5000 )
{
irq_ctr = (irq_ctr & 0xff00) | data;
irq_pending = false;
irq_changed();
}
else if ( addr == 0x5800 )
{
irq_ctr = (data << 8) | (irq_ctr & 0xff);
irq_pending = false;
irq_changed();
}
else
{
return false;
}
virtual bool write_intercepted(nes_time_t time, nes_addr_t addr, int data)
{
if (addr == 0x4800)
{
sound.write_data(time, data);
}
else if (addr == 0x5000)
{
irq_ctr = (irq_ctr & 0xff00) | data;
irq_pending = false;
irq_changed();
}
else if (addr == 0x5800)
{
irq_ctr = (data << 8) | (irq_ctr & 0xff);
irq_pending = false;
irq_changed();
}
else
{
return false;
}
return true;
}
return true;
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
int reg = addr >> 11 & 0x0F;
regs [reg] = data;
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
int reg = addr >> 11 & 0x0F;
regs[reg] = data;
int prg_bank = reg - 0x0c;
if ( (unsigned) prg_bank < 3 )
{
if ( prg_bank == 0 && (data & 0x40) )
mirror_vert();
set_prg_bank( 0x8000 | (prg_bank << bank_8k), bank_8k, data & 0x3F );
}
else if ( reg < 8 )
{
set_chr_bank( reg * 0x400, bank_1k, data );
}
else if ( reg < 0x0c )
{
mirror_manual( regs [8] & 1, regs [9] & 1, regs [10] & 1, regs [11] & 1 );
}
else
{
sound.write_addr( data );
}
}
int prg_bank = reg - 0x0c;
if ((unsigned)prg_bank < 3)
{
if (prg_bank == 0 && (data & 0x40))
mirror_vert();
set_prg_bank(0x8000 | (prg_bank << bank_8k), bank_8k, data & 0x3F);
}
else if (reg < 8)
{
set_chr_bank(reg * 0x400, bank_1k, data);
}
else if (reg < 0x0c)
{
mirror_manual(regs[8] & 1, regs[9] & 1, regs[10] & 1, regs[11] & 1);
}
else
{
sound.write_addr(data);
}
}
void save_state( mapper_state_t& out )
{
sound.save_state( &sound_state );
Nes_Mapper::save_state( out );
}
void save_state(mapper_state_t &out)
{
sound.save_state(&sound_state);
Mapper::save_state(out);
}
void read_state( mapper_state_t const& in )
{
Nes_Mapper::read_state( in );
sound.load_state( sound_state );
}
void read_state(mapper_state_t const &in)
{
Mapper::read_state(in);
sound.load_state(sound_state);
}
Nes_Namco_Apu sound;
nes_time_t last_time;
Namco_Apu sound;
nes_time_t last_time;
};
} // namespace quickNES

433
source/quickerNES/mappers/mapper021.hpp
View File

@ -17,7 +17,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*
* General code is from FCEUX https://sourceforge.net/p/fceultra/code/HEAD/tree/fceu/trunk/src/boards/vrc2and4.cpp
* IRQ portion is from existing VRC6/VRC7 by Shay Green
* This mapper was ported by retrowertz for Libretro port of QuickNES.
@ -26,225 +26,234 @@
* VRC-2/VRC-4 Konami
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
namespace quickerNES
{
struct vrc2_state_t
{
uint8_t prg_banks [ 2 ];
uint8_t chr_banks [ 8 ];
uint8_t mirroring;
uint8_t prg_swap;
uint8_t irq_latch;
uint8_t irq_control;
uint8_t prg_banks[2];
uint8_t chr_banks[8];
uint8_t mirroring;
uint8_t prg_swap;
uint8_t irq_latch;
uint8_t irq_control;
// internal state
uint16_t next_time;
uint8_t irq_pending;
// internal state
uint16_t next_time;
uint8_t irq_pending;
};
static_assert( sizeof ( vrc2_state_t ) == 18 );
static_assert(sizeof(vrc2_state_t) == 18);
template <bool type_a, bool type_b>
class Mapper_VRC2_4 : public Nes_Mapper, vrc2_state_t {
public:
Mapper_VRC2_4()
{
if (type_a && type_b) // mapper 21
{
is22 = 0;
reg1mask = 0x42;
reg2mask = 0x84;
}
else if (!type_a && type_b) // mapper 22
{
is22 = 1;
reg1mask = 2;
reg2mask = 1;
}
else if (!type_a && !type_b) // mapper 23
{
is22 = 0;
reg1mask = 0x15;
reg2mask = 0x2a;
}
else if (type_a && !type_b) // mapper 25
{
is22 = 0;
reg1mask = 0xa;
reg2mask = 0x5;
}
vrc2_state_t * state = this;
register_state( state, sizeof * state );
}
void reset_state()
{
}
void apply_mapping()
{
if ( !is22 ) enable_sram();
update_prg();
update_chr();
set_mirroring();
}
void reset_timer( nes_time_t present )
{
next_time = present + unsigned ( ( 0x100 - irq_latch ) * timer_period ) / 4;
}
virtual void run_until( nes_time_t end_time )
{
if ( irq_control & 2 )
{
while ( next_time < end_time )
{
// printf( "%d timer expired\n", next_time );
irq_pending = true;
reset_timer( next_time );
}
}
}
virtual void end_frame( nes_time_t end_time )
{
run_until( end_time );
// to do: next_time might go negative if IRQ is disabled
next_time -= end_time;
}
virtual nes_time_t next_irq( nes_time_t present )
{
if ( irq_pending )
return present;
if ( irq_control & 2 )
return next_time + 1;
return no_irq;
}
void write_irq( nes_time_t time, nes_addr_t addr, int data );
void write( nes_time_t time, nes_addr_t addr, int data )
{
addr = ( addr & 0xF000 ) | !!( addr & reg2mask ) << 1 | !!( addr & reg1mask );
if( addr >= 0xB000 && addr <= 0xE003)
{
unsigned banknumber = ( ( addr >> 1 ) & 1 ) | ( ( addr - 0xB000 ) >> 11 );
unsigned offset = ( addr & 1 ) << 2;
chr_banks [ banknumber ] &= ( 0xF0 ) >> offset;
chr_banks [ banknumber ] |= ( data & 0xF ) << offset;
chr_banks [ banknumber ] |= ( offset ? ( ( data & 0x10 ) << 4 ) : 0 );
update_chr();
}
else
{
switch ( addr & 0xF003 )
{
case 0x8000:
case 0x8001:
case 0x8002:
case 0x8003:
prg_banks [ 0 ] = data & 0x1F;
update_prg();
break;
case 0xA000:
case 0xA001:
case 0xA002:
case 0xA003:
prg_banks [ 1 ] = data & 0x1F;
update_prg();
break;
case 0x9000:
case 0x9001:
mirroring = data;
set_mirroring();
break;
case 0x9002:
case 0x9003:
prg_swap = data;
update_prg();
break;
case 0xF000:
case 0xF001:
case 0xF002:
case 0xF003:
write_irq( time, addr, data );
break;
}
}
}
unsigned is22, reg1mask, reg2mask;
enum { timer_period = 113 * 4 + 3 };
private:
void set_mirroring()
{
switch ( mirroring & 3 )
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
case 2:
case 3: mirror_single( mirroring & 1 ); break;
}
}
void update_prg()
{
if ( prg_swap & 2 )
{
set_prg_bank( 0x8000, bank_8k, ( 0xFE ) );
set_prg_bank( 0xC000, bank_8k, prg_banks [ 0 ] );
}
else
{
set_prg_bank( 0x8000, bank_8k, prg_banks [ 0 ] );
set_prg_bank( 0xC000, bank_8k, ( 0xFE ) );
}
set_prg_bank( 0xA000, bank_8k, prg_banks [ 1 ] );
set_prg_bank( 0xE000, bank_8k, ( 0xFF ) );
}
void update_chr()
{
for ( int i = 0; i < (int) sizeof chr_banks; i++ )
set_chr_bank( i * 0x400, bank_1k, chr_banks [ i ] >> is22 );
}
};
template <bool type_a, bool type_b>
void Mapper_VRC2_4<type_a, type_b>::write_irq( nes_time_t time,
nes_addr_t addr, int data )
class Mapper_VRC2_4 : public Mapper, vrc2_state_t
{
// IRQ
run_until( time );
//printf("%6d VRC2_4 [%d] A:%04x V:%02x\n", time, addr & 3, addr, data);
switch ( addr & 3 )
{
case 0:
irq_latch = ( irq_latch & 0xF0 ) | ( data & 0xF );
break;
case 1:
irq_latch = ( irq_latch & 0x0F ) | ( ( data & 0xF ) << 4 );
break;
case 2:
irq_pending = false;
irq_control = data & 3;
if ( data & 2 ) reset_timer( time );
break;
case 3:
irq_pending = false;
irq_control = ( irq_control & ~2 ) | ( ( irq_control << 1 ) & 2 );
break;
}
irq_changed();
public:
Mapper_VRC2_4()
{
if (type_a && type_b) // mapper 21
{
is22 = 0;
reg1mask = 0x42;
reg2mask = 0x84;
}
else if (!type_a && type_b) // mapper 22
{
is22 = 1;
reg1mask = 2;
reg2mask = 1;
}
else if (!type_a && !type_b) // mapper 23
{
is22 = 0;
reg1mask = 0x15;
reg2mask = 0x2a;
}
else if (type_a && !type_b) // mapper 25
{
is22 = 0;
reg1mask = 0xa;
reg2mask = 0x5;
}
vrc2_state_t *state = this;
register_state(state, sizeof *state);
}
void reset_state()
{
}
void apply_mapping()
{
if (!is22) enable_sram();
update_prg();
update_chr();
set_mirroring();
}
void reset_timer(nes_time_t present)
{
next_time = present + unsigned((0x100 - irq_latch) * timer_period) / 4;
}
virtual void run_until(nes_time_t end_time)
{
if (irq_control & 2)
{
while (next_time < end_time)
{
// printf( "%d timer expired\n", next_time );
irq_pending = true;
reset_timer(next_time);
}
}
}
virtual void end_frame(nes_time_t end_time)
{
run_until(end_time);
// to do: next_time might go negative if IRQ is disabled
next_time -= end_time;
}
virtual nes_time_t next_irq(nes_time_t present)
{
if (irq_pending)
return present;
if (irq_control & 2)
return next_time + 1;
return no_irq;
}
void write_irq(nes_time_t time, nes_addr_t addr, int data);
void write(nes_time_t time, nes_addr_t addr, int data)
{
addr = (addr & 0xF000) | !!(addr & reg2mask) << 1 | !!(addr & reg1mask);
if (addr >= 0xB000 && addr <= 0xE003)
{
unsigned banknumber = ((addr >> 1) & 1) | ((addr - 0xB000) >> 11);
unsigned offset = (addr & 1) << 2;
chr_banks[banknumber] &= (0xF0) >> offset;
chr_banks[banknumber] |= (data & 0xF) << offset;
chr_banks[banknumber] |= (offset ? ((data & 0x10) << 4) : 0);
update_chr();
}
else
{
switch (addr & 0xF003)
{
case 0x8000:
case 0x8001:
case 0x8002:
case 0x8003:
prg_banks[0] = data & 0x1F;
update_prg();
break;
case 0xA000:
case 0xA001:
case 0xA002:
case 0xA003:
prg_banks[1] = data & 0x1F;
update_prg();
break;
case 0x9000:
case 0x9001:
mirroring = data;
set_mirroring();
break;
case 0x9002:
case 0x9003:
prg_swap = data;
update_prg();
break;
case 0xF000:
case 0xF001:
case 0xF002:
case 0xF003:
write_irq(time, addr, data);
break;
}
}
}
unsigned is22, reg1mask, reg2mask;
enum
{
timer_period = 113 * 4 + 3
};
private:
void set_mirroring()
{
switch (mirroring & 3)
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
case 2:
case 3: mirror_single(mirroring & 1); break;
}
}
void update_prg()
{
if (prg_swap & 2)
{
set_prg_bank(0x8000, bank_8k, (0xFE));
set_prg_bank(0xC000, bank_8k, prg_banks[0]);
}
else
{
set_prg_bank(0x8000, bank_8k, prg_banks[0]);
set_prg_bank(0xC000, bank_8k, (0xFE));
}
set_prg_bank(0xA000, bank_8k, prg_banks[1]);
set_prg_bank(0xE000, bank_8k, (0xFF));
}
void update_chr()
{
for (int i = 0; i < (int)sizeof chr_banks; i++)
set_chr_bank(i * 0x400, bank_1k, chr_banks[i] >> is22);
}
};
template <bool type_a, bool type_b>
void Mapper_VRC2_4<type_a, type_b>::write_irq(nes_time_t time,
nes_addr_t addr,
int data)
{
// IRQ
run_until(time);
// printf("%6d VRC2_4 [%d] A:%04x V:%02x\n", time, addr & 3, addr, data);
switch (addr & 3)
{
case 0:
irq_latch = (irq_latch & 0xF0) | (data & 0xF);
break;
case 1:
irq_latch = (irq_latch & 0x0F) | ((data & 0xF) << 4);
break;
case 2:
irq_pending = false;
irq_control = data & 3;
if (data & 2) reset_timer(time);
break;
case 3:
irq_pending = false;
irq_control = (irq_control & ~2) | ((irq_control << 1) & 2);
break;
}
irq_changed();
}
typedef Mapper_VRC2_4<true, true> Mapper021;
typedef Mapper_VRC2_4<true,true> Mapper021;
} // namespace quickNES

11
source/quickerNES/mappers/mapper022.hpp
View File

@ -17,7 +17,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*
* General code is from FCEUX https://sourceforge.net/p/fceultra/code/HEAD/tree/fceu/trunk/src/boards/vrc2and4.cpp
* IRQ portion is from existing VRC6/VRC7 by Shay Green
* This mapper was ported by retrowertz for Libretro port of QuickNES.
@ -26,7 +26,12 @@
* VRC-2/VRC-4 Konami
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
#include "mappers/mapper021.hpp"
typedef Mapper_VRC2_4<false,true> Mapper022;
namespace quickerNES
{
typedef Mapper_VRC2_4<false, true> Mapper022;
} // namespace quickNES

11
source/quickerNES/mappers/mapper023.hpp
View File

@ -17,7 +17,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*
* General code is from FCEUX https://sourceforge.net/p/fceultra/code/HEAD/tree/fceu/trunk/src/boards/vrc2and4.cpp
* IRQ portion is from existing VRC6/VRC7 by Shay Green
* This mapper was ported by retrowertz for Libretro port of QuickNES.
@ -26,6 +26,11 @@
* VRC-2/VRC-4 Konami
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
typedef Mapper_VRC2_4<false, false> Mapper023;
namespace quickerNES
{
typedef Mapper_VRC2_4<false, false> Mapper023;
} // namespace quickNES

408
source/quickerNES/mappers/mapper024.hpp
View File

@ -1,11 +1,11 @@
#pragma once
#pragma once
// Konami VRC6 mapper
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "apu/vrc6/apu.hpp"
#include "mappers/mapper.hpp"
#include <cstring>
#include "mappers/mapper.h"
#include "apu/vrc6/apu.h"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -18,211 +18,219 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
struct vrc6_state_t
{
// written registers
uint8_t prg_16k_bank;
// could move sound regs int and out of vrc6_apu_state_t for state saving,
// allowing them to be stored here
uint8_t old_sound_regs [3] [3]; // to do: eliminate this duplicate
uint8_t mirroring;
uint8_t prg_8k_bank;
uint8_t chr_banks [8];
uint8_t irq_reload;
uint8_t irq_mode;
// internal state
uint16_t next_time;
uint8_t irq_pending;
uint8_t unused;
vrc6_apu_state_t sound_state;
// written registers
uint8_t prg_16k_bank;
// could move sound regs int and out of vrc6_apu_state_t for state saving,
// allowing them to be stored here
uint8_t old_sound_regs[3][3]; // to do: eliminate this duplicate
uint8_t mirroring;
uint8_t prg_8k_bank;
uint8_t chr_banks[8];
uint8_t irq_reload;
uint8_t irq_mode;
// internal state
uint16_t next_time;
uint8_t irq_pending;
uint8_t unused;
vrc6_apu_state_t sound_state;
};
static_assert( sizeof (vrc6_state_t) == 26 + sizeof (vrc6_apu_state_t) );
static_assert(sizeof(vrc6_state_t) == 26 + sizeof(vrc6_apu_state_t));
template <int swapMask>
class Mapper_Vrc6 : public Nes_Mapper, vrc6_state_t {
public:
Mapper_Vrc6( )
{
swap_mask = swapMask;
vrc6_state_t* state = this;
register_state( state, sizeof *state );
}
virtual int channel_count() const { return sound.osc_count; }
virtual void set_channel_buf( int i, Blip_Buffer* b ) { sound.osc_output( i, b ); }
virtual void set_treble( blip_eq_t const& eq ) { sound.treble_eq( eq ); }
virtual void reset_state()
{
prg_8k_bank = last_bank - 1;
sound.reset();
}
virtual void save_state( mapper_state_t& out )
{
sound.save_state( &sound_state );
Nes_Mapper::save_state( out );
}
virtual void apply_mapping()
{
enable_sram();
set_prg_bank( 0x8000, bank_16k, prg_16k_bank );
set_prg_bank( 0xC000, bank_8k, prg_8k_bank );
for ( int i = 0; i < (int) sizeof chr_banks; i++ )
set_chr_bank( i * 0x400, bank_1k, chr_banks [i] );
write_bank( 0xb003, mirroring );
}
void reset_timer( nes_time_t present )
{
next_time = present + unsigned ((0x100 - irq_reload) * timer_period) / 4;
}
virtual void run_until( nes_time_t end_time )
{
if ( irq_mode & 2 )
{
while ( next_time < end_time )
{
//dprintf( "%d timer expired\n", next_time );
irq_pending = true;
reset_timer( next_time );
}
}
}
virtual void end_frame( nes_time_t end_time )
{
run_until( end_time );
// to do: next_time might go negative if IRQ is disabled
next_time -= end_time;
sound.end_frame( end_time );
}
virtual nes_time_t next_irq( nes_time_t present )
{
if ( irq_pending )
return present;
if ( irq_mode & 2 )
return next_time + 1;
return no_irq;
}
virtual void write( nes_time_t time, nes_addr_t addr, int data )
{
int osc = unsigned (addr - sound.base_addr) / sound.addr_step;
if ( (addr + 1) & 2 ) // optionally swap 1 and 2
addr ^= swap_mask;
int reg = addr & 3;
if ( (unsigned) osc < sound.osc_count && reg < sound.reg_count )
sound.write_osc( time, osc, reg, data );
else if ( addr < 0xf000 )
write_bank( addr, data );
else
write_irq( time, addr, data );
}
int swap_mask;
Nes_Vrc6_Apu sound;
enum { timer_period = 113 * 4 + 3 };
void read_state( mapper_state_t const& in )
class Mapper_Vrc6 : public Mapper, vrc6_state_t
{
Nes_Mapper::read_state( in );
// to do: eliminate when format is updated
// old-style registers
static char zero [sizeof old_sound_regs] = { 0 };
if ( 0 != memcmp( old_sound_regs, zero, sizeof zero ) )
{
/* Using old VRC6 sound register format */
memcpy( sound_state.regs, old_sound_regs, sizeof sound_state.regs );
memset( old_sound_regs, 0, sizeof old_sound_regs );
}
sound.load_state( sound_state );
}
public:
Mapper_Vrc6()
{
swap_mask = swapMask;
vrc6_state_t *state = this;
register_state(state, sizeof *state);
}
void write_irq( nes_time_t time, nes_addr_t addr, int data )
{
// IRQ
run_until( time );
//dprintf( "%d VRC6 IRQ [%d] = %02X\n", time, addr & 3, data );
switch ( addr & 3 )
{
case 0:
irq_reload = data;
break;
case 1:
irq_pending = false;
irq_mode = data;
if ( data & 2 )
reset_timer( time );
break;
case 2:
irq_pending = false;
irq_mode = (irq_mode & ~2) | ((irq_mode << 1) & 2);
break;
}
irq_changed();
}
virtual int channel_count() const { return sound.osc_count; }
void write_bank( nes_addr_t addr, int data )
{
switch ( addr & 0xf003 )
{
case 0x8000:
prg_16k_bank = data;
set_prg_bank( 0x8000, bank_16k, data );
break;
case 0xb003: {
mirroring = data;
//dprintf( "Change mirroring %d\n", data );
// emu()->enable_sram( data & 0x80 ); // to do: needed?
int page = data >> 5 & 1;
if ( data & 8 )
mirror_single( ((data >> 2) ^ page) & 1 );
else if ( data & 4 )
mirror_horiz( page );
else
mirror_vert( page );
break;
}
case 0xc000:
prg_8k_bank = data;
set_prg_bank( 0xC000, bank_8k, data );
break;
default:
int bank = (addr >> 11 & 4) | (addr & 3);
if ( addr >= 0xd000 )
{
//dprintf( "change chr bank %d\n", bank );
chr_banks [bank] = data;
set_chr_bank( bank * 0x400, bank_1k, data );
}
break;
}
virtual void set_channel_buf(int i, Blip_Buffer *b) { sound.osc_output(i, b); }
virtual void set_treble(blip_eq_t const &eq) { sound.treble_eq(eq); }
virtual void reset_state()
{
prg_8k_bank = last_bank - 1;
sound.reset();
}
virtual void save_state(mapper_state_t &out)
{
sound.save_state(&sound_state);
Mapper::save_state(out);
}
virtual void apply_mapping()
{
enable_sram();
set_prg_bank(0x8000, bank_16k, prg_16k_bank);
set_prg_bank(0xC000, bank_8k, prg_8k_bank);
for (int i = 0; i < (int)sizeof chr_banks; i++)
set_chr_bank(i * 0x400, bank_1k, chr_banks[i]);
write_bank(0xb003, mirroring);
}
void reset_timer(nes_time_t present)
{
next_time = present + unsigned((0x100 - irq_reload) * timer_period) / 4;
}
virtual void run_until(nes_time_t end_time)
{
if (irq_mode & 2)
{
while (next_time < end_time)
{
// dprintf( "%d timer expired\n", next_time );
irq_pending = true;
reset_timer(next_time);
}
}
}
virtual void end_frame(nes_time_t end_time)
{
run_until(end_time);
// to do: next_time might go negative if IRQ is disabled
next_time -= end_time;
sound.end_frame(end_time);
}
virtual nes_time_t next_irq(nes_time_t present)
{
if (irq_pending)
return present;
if (irq_mode & 2)
return next_time + 1;
return no_irq;
}
virtual void write(nes_time_t time, nes_addr_t addr, int data)
{
int osc = unsigned(addr - sound.base_addr) / sound.addr_step;
if ((addr + 1) & 2) // optionally swap 1 and 2
addr ^= swap_mask;
int reg = addr & 3;
if ((unsigned)osc < sound.osc_count && reg < sound.reg_count)
sound.write_osc(time, osc, reg, data);
else if (addr < 0xf000)
write_bank(addr, data);
else
write_irq(time, addr, data);
}
int swap_mask;
Vrc6_Apu sound;
enum
{
timer_period = 113 * 4 + 3
};
void read_state(mapper_state_t const &in)
{
Mapper::read_state(in);
// to do: eliminate when format is updated
// old-style registers
static char zero[sizeof old_sound_regs] = {0};
if (0 != memcmp(old_sound_regs, zero, sizeof zero))
{
/* Using old VRC6 sound register format */
memcpy(sound_state.regs, old_sound_regs, sizeof sound_state.regs);
memset(old_sound_regs, 0, sizeof old_sound_regs);
}
sound.load_state(sound_state);
}
void write_irq(nes_time_t time, nes_addr_t addr, int data)
{
// IRQ
run_until(time);
// dprintf( "%d VRC6 IRQ [%d] = %02X\n", time, addr & 3, data );
switch (addr & 3)
{
case 0:
irq_reload = data;
break;
case 1:
irq_pending = false;
irq_mode = data;
if (data & 2)
reset_timer(time);
break;
case 2:
irq_pending = false;
irq_mode = (irq_mode & ~2) | ((irq_mode << 1) & 2);
break;
}
irq_changed();
}
void write_bank(nes_addr_t addr, int data)
{
switch (addr & 0xf003)
{
case 0x8000:
prg_16k_bank = data;
set_prg_bank(0x8000, bank_16k, data);
break;
case 0xb003:
{
mirroring = data;
// dprintf( "Change mirroring %d\n", data );
// emu()->enable_sram( data & 0x80 ); // to do: needed?
int page = data >> 5 & 1;
if (data & 8)
mirror_single(((data >> 2) ^ page) & 1);
else if (data & 4)
mirror_horiz(page);
else
mirror_vert(page);
break;
}
case 0xc000:
prg_8k_bank = data;
set_prg_bank(0xC000, bank_8k, data);
break;
default:
int bank = (addr >> 11 & 4) | (addr & 3);
if (addr >= 0xd000)
{
// dprintf( "change chr bank %d\n", bank );
chr_banks[bank] = data;
set_chr_bank(bank * 0x400, bank_1k, data);
}
break;
}
}
};
typedef Mapper_Vrc6<0> Mapper024;
typedef Mapper_Vrc6<0> Mapper024;
} // namespace quickNES

11
source/quickerNES/mappers/mapper025.hpp
View File

@ -17,7 +17,7 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*
* General code is from FCEUX https://sourceforge.net/p/fceultra/code/HEAD/tree/fceu/trunk/src/boards/vrc2and4.cpp
* IRQ portion is from existing VRC6/VRC7 by Shay Green
* This mapper was ported by retrowertz for Libretro port of QuickNES.
@ -26,6 +26,11 @@
* VRC-2/VRC-4 Konami
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
typedef Mapper_VRC2_4<true,false> Mapper025;
namespace quickerNES
{
typedef Mapper_VRC2_4<true, false> Mapper025;
} // namespace quickNES

11
source/quickerNES/mappers/mapper026.hpp
View File

@ -2,8 +2,13 @@
// Konami VRC6 mapper
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
typedef Mapper_Vrc6<3> Mapper026;
namespace quickerNES
{
typedef Mapper_Vrc6<3> Mapper026;
} // namespace quickNES

39
source/quickerNES/mappers/mapper030.hpp
View File

@ -21,31 +21,36 @@
* 3/24/18
*
* Unrom-512
*
* NOTE:
*
* NOTE:
* No flash and one screen mirroring support.
* Tested only on Troll Burner and Mystic Origins demo.
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
// Unrom512
// Unrom512
class Mapper030 : public Nes_Mapper {
public:
Mapper030() { }
namespace quickerNES
{
void reset_state() { }
class Mapper030 : public Mapper
{
public:
Mapper030() {}
void apply_mapping() { }
void reset_state() {}
void write( nes_time_t, nes_addr_t addr, int data )
{
if ( ( addr & 0xF000 ) >= 0x8000 )
{
set_prg_bank(0x8000, bank_16k, data & 0x1F);
set_chr_bank(0x0000, bank_8k, (data >> 5) & 0x3);
}
}
void apply_mapping() {}
void write(nes_time_t, nes_addr_t addr, int data)
{
if ((addr & 0xF000) >= 0x8000)
{
set_prg_bank(0x8000, bank_16k, data & 0x1F);
set_chr_bank(0x0000, bank_8k, (data >> 5) & 0x3);
}
}
};
} // namespace quickNES

167
source/quickerNES/mappers/mapper032.hpp
View File

@ -23,96 +23,107 @@
*
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
namespace quickerNES
{
struct mapper32_state_t
{
uint8_t chr_bank [ 8 ];
uint8_t prg_bank [ 2 ];
uint8_t prg_mode;
uint8_t mirr;
uint8_t chr_bank[8];
uint8_t prg_bank[2];
uint8_t prg_mode;
uint8_t mirr;
};
static_assert( sizeof ( mapper32_state_t ) == 12 );
static_assert(sizeof(mapper32_state_t) == 12);
// Irem_G101
class Mapper032 : public Nes_Mapper, mapper32_state_t {
public:
Mapper032()
{
mapper32_state_t * state = this;
register_state( state, sizeof * state );
}
class Mapper032 : public Mapper, mapper32_state_t
{
public:
Mapper032()
{
mapper32_state_t *state = this;
register_state(state, sizeof *state);
}
virtual void reset_state()
{
prg_bank [ 0 ] = ~1;
prg_bank [ 1 ] = ~0;
enable_sram();
}
virtual void reset_state()
{
prg_bank[0] = ~1;
prg_bank[1] = ~0;
enable_sram();
}
virtual void apply_mapping()
{
if ( prg_mode == 0 )
{
set_prg_bank ( 0x8000, bank_8k, prg_bank [ 0 ] );
set_prg_bank ( 0xA000, bank_8k, prg_bank [ 1 ] );
set_prg_bank ( 0xC000, bank_8k, ~1 );
set_prg_bank ( 0xE000, bank_8k, ~0 );
}
else
{
set_prg_bank ( 0xC000, bank_8k, prg_bank [ 0 ] );
set_prg_bank ( 0xA000, bank_8k, prg_bank [ 1 ] );
set_prg_bank ( 0x8000, bank_8k, ~1 );
set_prg_bank ( 0xE000, bank_8k, ~0 );
}
virtual void apply_mapping()
{
if (prg_mode == 0)
{
set_prg_bank(0x8000, bank_8k, prg_bank[0]);
set_prg_bank(0xA000, bank_8k, prg_bank[1]);
set_prg_bank(0xC000, bank_8k, ~1);
set_prg_bank(0xE000, bank_8k, ~0);
}
else
{
set_prg_bank(0xC000, bank_8k, prg_bank[0]);
set_prg_bank(0xA000, bank_8k, prg_bank[1]);
set_prg_bank(0x8000, bank_8k, ~1);
set_prg_bank(0xE000, bank_8k, ~0);
}
for ( unsigned long int i = 0; i < sizeof chr_bank; i++)
set_chr_bank( ( i << 10 ), bank_1k, chr_bank [ i ] );
for (unsigned long int i = 0; i < sizeof chr_bank; i++)
set_chr_bank((i << 10), bank_1k, chr_bank[i]);
switch ( mirr )
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
}
}
switch (mirr)
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
}
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
switch ( addr & 0xF000 )
{
case 0x8000:
prg_bank [ 0 ] = data;
switch ( prg_mode )
{
case 0: set_prg_bank ( 0x8000, bank_8k, data ); break;
case 1: set_prg_bank ( 0xC000, bank_8k, data ); break;
}
break;
case 0x9000:
mirr = data & 1;
prg_mode = ( data >> 1 ) & 1;
switch ( data & 1 )
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
}
break;
case 0xA000:
prg_bank [ 1 ] = data;
set_prg_bank ( 0xA000, bank_8k, data );
break;
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
switch (addr & 0xF000)
{
case 0x8000:
prg_bank[0] = data;
switch (prg_mode)
{
case 0: set_prg_bank(0x8000, bank_8k, data); break;
case 1: set_prg_bank(0xC000, bank_8k, data); break;
}
break;
case 0x9000:
mirr = data & 1;
prg_mode = (data >> 1) & 1;
switch (data & 1)
{
case 0: mirror_vert(); break;
case 1: mirror_horiz(); break;
}
break;
case 0xA000:
prg_bank[1] = data;
set_prg_bank(0xA000, bank_8k, data);
break;
}
switch ( addr & 0xF007 )
{
case 0xB000: case 0xB001: case 0xB002: case 0xB003:
case 0xB004: case 0xB005: case 0xB006: case 0xB007:
chr_bank [ addr & 0x07 ] = data;
set_chr_bank( ( addr & 0x07 ) << 10, bank_1k, data );
break;
}
}
switch (addr & 0xF007)
{
case 0xB000:
case 0xB001:
case 0xB002:
case 0xB003:
case 0xB004:
case 0xB005:
case 0xB006:
case 0xB007:
chr_bank[addr & 0x07] = data;
set_chr_bank((addr & 0x07) << 10, bank_1k, data);
break;
}
}
};
} // namespace quickNES

124
source/quickerNES/mappers/mapper033.hpp
View File

@ -20,73 +20,87 @@
* This mapper was added by retrowertz for Libretro port of QuickNES.
*
* Mapper 33 - Taito TC0190
*
*
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
namespace quickerNES
{
struct tc0190_state_t
{
uint8_t preg [ 2 ];
uint8_t creg [ 6 ];
uint8_t mirr;
uint8_t preg[2];
uint8_t creg[6];
uint8_t mirr;
};
static_assert( sizeof ( tc0190_state_t ) == 9 );
static_assert(sizeof(tc0190_state_t) == 9);
// TaitoTC0190
class Mapper033 : public Nes_Mapper, tc0190_state_t {
public:
Mapper033()
{
tc0190_state_t *state = this;
register_state( state, sizeof *state );
}
class Mapper033 : public Mapper, tc0190_state_t
{
public:
Mapper033()
{
tc0190_state_t *state = this;
register_state(state, sizeof *state);
}
virtual void reset_state()
{ }
virtual void reset_state()
{
}
virtual void apply_mapping()
{
for ( int i = 0; i < 2; i++ )
{
set_prg_bank ( 0x8000 + ( i << 13 ), bank_8k, preg [ i ] );
set_chr_bank ( 0x0000 + ( i << 11 ), bank_2k, creg [ i ] );
}
virtual void apply_mapping()
{
for (int i = 0; i < 2; i++)
{
set_prg_bank(0x8000 + (i << 13), bank_8k, preg[i]);
set_chr_bank(0x0000 + (i << 11), bank_2k, creg[i]);
}
for ( int i = 0; i < 4; i++ )
set_chr_bank ( 0x1000 + ( i << 10 ), bank_1k, creg [ 2 + i ] );
for (int i = 0; i < 4; i++)
set_chr_bank(0x1000 + (i << 10), bank_1k, creg[2 + i]);
if ( mirr ) mirror_horiz();
else mirror_vert();
}
if (mirr)
mirror_horiz();
else
mirror_vert();
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
switch ( addr & 0xA003 )
{
case 0x8000:
preg [ 0 ] = data & 0x3F;
mirr = data >> 6;
set_prg_bank ( 0x8000, bank_8k, preg [ 0 ] );
if ( mirr ) mirror_horiz();
else mirror_vert();
break;
case 0x8001:
preg [ 1 ] = data & 0x3F;
set_prg_bank ( 0xA000, bank_8k, preg [ 1 ] );
break;
case 0x8002: case 0x8003:
addr &= 0x01;
creg [ addr ] = data;
set_chr_bank ( addr << 11, bank_2k, creg [ addr ] );
break;
case 0xA000: case 0xA001:
case 0xA002: case 0xA003:
addr &= 0x03;
creg [ 2 + addr ] = data;
set_chr_bank ( 0x1000 | ( addr << 10 ), bank_1k, creg [ 2 + addr ] );
break;
}
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
switch (addr & 0xA003)
{
case 0x8000:
preg[0] = data & 0x3F;
mirr = data >> 6;
set_prg_bank(0x8000, bank_8k, preg[0]);
if (mirr)
mirror_horiz();
else
mirror_vert();
break;
case 0x8001:
preg[1] = data & 0x3F;
set_prg_bank(0xA000, bank_8k, preg[1]);
break;
case 0x8002:
case 0x8003:
addr &= 0x01;
creg[addr] = data;
set_chr_bank(addr << 11, bank_2k, creg[addr]);
break;
case 0xA000:
case 0xA001:
case 0xA002:
case 0xA003:
addr &= 0x03;
creg[2 + addr] = data;
set_chr_bank(0x1000 | (addr << 10), bank_1k, creg[2 + addr]);
break;
}
}
};
} // namespace quickNES

46
source/quickerNES/mappers/mapper034.hpp
View File

@ -2,9 +2,9 @@
// Optional less-common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -19,23 +19,29 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Nina-1 (Deadly Towers only)
class Mapper034 : public Nes_Mapper {
uint8_t bank;
public:
Mapper034()
{
register_state( &bank, 1 );
}
virtual void apply_mapping()
{
write( 0, 0, bank );
}
virtual void write( nes_time_t, nes_addr_t, int data )
{
bank = data;
set_prg_bank( 0x8000, bank_32k, bank );
}
namespace quickerNES
{
class Mapper034 : public Mapper
{
uint8_t bank;
public:
Mapper034()
{
register_state(&bank, 1);
}
virtual void apply_mapping()
{
write(0, 0, bank);
}
virtual void write(nes_time_t, nes_addr_t, int data)
{
bank = data;
set_prg_bank(0x8000, bank_32k, bank);
}
};
} // namespace quickNES

52
source/quickerNES/mappers/mapper060.hpp
View File

@ -17,34 +17,40 @@
* 4-in-1 Multicart ( Reset-based )
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
// NROM-128 4-in-1 multicart
class Mapper060 : public Nes_Mapper {
public:
Mapper060()
{
last_game = 2;
register_state( &game_sel, 1 );
}
namespace quickerNES
{
virtual void reset_state()
{
game_sel = last_game;
game_sel++;
game_sel &= 3;
}
class Mapper060 : public Mapper
{
public:
Mapper060()
{
last_game = 2;
register_state(&game_sel, 1);
}
virtual void apply_mapping()
{
set_prg_bank ( 0x8000, bank_16k, game_sel );
set_prg_bank ( 0xC000, bank_16k, game_sel );
set_chr_bank ( 0, bank_8k, game_sel );
last_game = game_sel;
}
virtual void reset_state()
{
game_sel = last_game;
game_sel++;
game_sel &= 3;
}
virtual void write( nes_time_t, nes_addr_t addr, int data ) { }
virtual void apply_mapping()
{
set_prg_bank(0x8000, bank_16k, game_sel);
set_prg_bank(0xC000, bank_16k, game_sel);
set_chr_bank(0, bank_8k, game_sel);
last_game = game_sel;
}
uint8_t game_sel, last_game;
virtual void write(nes_time_t, nes_addr_t addr, int data) {}
uint8_t game_sel, last_game;
};
} // namespace quickNES

62
source/quickerNES/mappers/mapper066.hpp
View File

@ -2,9 +2,9 @@
// Optional less-common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -19,31 +19,37 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// GNROM
class Mapper066 : public Nes_Mapper {
uint8_t bank;
public:
Mapper066()
{
register_state( &bank, 1 );
}
virtual void apply_mapping()
{
int b = bank;
bank = ~b;
write( 0, 0, b );
}
virtual void write( nes_time_t, nes_addr_t, int data )
{
int changed = bank ^ data;
bank = data;
if ( changed & 0x30 )
set_prg_bank( 0x8000, bank_32k, bank >> 4 & 3 );
if ( changed & 0x03 )
set_chr_bank( 0, bank_8k, bank & 3 );
}
namespace quickerNES
{
class Mapper066 : public Mapper
{
uint8_t bank;
public:
Mapper066()
{
register_state(&bank, 1);
}
virtual void apply_mapping()
{
int b = bank;
bank = ~b;
write(0, 0, b);
}
virtual void write(nes_time_t, nes_addr_t, int data)
{
int changed = bank ^ data;
bank = data;
if (changed & 0x30)
set_prg_bank(0x8000, bank_32k, bank >> 4 & 3);
if (changed & 0x03)
set_chr_bank(0, bank_8k, bank & 3);
}
};
} // namespace quickNES

313
source/quickerNES/mappers/mapper069.hpp
View File

@ -2,10 +2,10 @@
// Sunsoft FME-7 mapper
// Nes_Emu 0.7.0. http://www.slack.net/~ant/libs/
// Emu 0.7.0. http://www.slack.net/~ant/libs/
#include "mappers/mapper.h"
#include "apu/fme7/apu.h"
#include "apu/fme7/apu.hpp"
#include "mappers/mapper.hpp"
/* Copyright (C) 2005 Chris Moeller */
/* Copyright (C) 2005-2006 Shay Green. This module is free software; you
@ -19,172 +19,175 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
struct fme7_state_t
{
// first 16 bytes in register order
uint8_t regs [13];
uint8_t irq_mode;
uint16_t irq_count;
uint8_t command;
uint8_t irq_pending;
fme7_apu_state_t sound_state; // only used when saving/restoring state
// first 16 bytes in register order
uint8_t regs[13];
uint8_t irq_mode;
uint16_t irq_count;
uint8_t command;
uint8_t irq_pending;
fme7_apu_state_t sound_state; // only used when saving/restoring state
};
static_assert( sizeof (fme7_state_t) == 18 + sizeof (fme7_apu_state_t) );
static_assert(sizeof(fme7_state_t) == 18 + sizeof(fme7_apu_state_t));
// Fme7
class Mapper069 : public Nes_Mapper, fme7_state_t {
public:
Mapper069()
{
fme7_state_t* state = this;
register_state( state, sizeof *state );
}
virtual int channel_count() const { return sound.osc_count; }
class Mapper069 : public Mapper, fme7_state_t
{
public:
Mapper069()
{
fme7_state_t *state = this;
register_state(state, sizeof *state);
}
virtual void set_channel_buf( int i, Blip_Buffer* b ) { sound.osc_output( i, b ); }
virtual int channel_count() const { return sound.osc_count; }
virtual void set_treble( blip_eq_t const& eq ) { sound.treble_eq( eq ); }
virtual void reset_state()
{
regs [8] = 0x40; // wram disabled
irq_count = 0xFFFF;
sound.reset();
}
virtual void save_state( mapper_state_t& out )
{
sound.save_state( &sound_state );
Nes_Mapper::save_state( out );
}
virtual void read_state( mapper_state_t const& in )
{
Nes_Mapper::read_state( in );
sound.load_state( sound_state );
}
virtual void apply_mapping()
{
last_time = 0;
for ( int i = 0; i < (int) sizeof regs; i++ )
write_register( i, regs [i] );
}
virtual void set_channel_buf(int i, Blip_Buffer *b) { sound.osc_output(i, b); }
virtual void run_until( nes_time_t end_time )
{
int new_count = irq_count - (end_time - last_time);
last_time = end_time;
if ( new_count <= 0 && (irq_mode & 0x81) == 0x81 )
irq_pending = true;
if ( irq_mode & 0x01 )
irq_count = new_count & 0xFFFF;
}
virtual nes_time_t next_irq( nes_time_t )
{
if ( irq_pending )
return 0;
if ( (irq_mode & 0x81) == 0x81 )
return last_time + irq_count + 1;
return no_irq;
}
virtual void end_frame( nes_time_t end_time )
{
if ( end_time > last_time )
run_until( end_time );
last_time -= end_time;
sound.end_frame( end_time );
}
virtual void write( nes_time_t time, nes_addr_t addr, int data )
{
switch ( addr & 0xE000 )
{
case 0x8000:
command = data & 0x0F;
break;
case 0xA000:
if ( command < 0x0D )
write_register( command, data );
else
write_irq( time, command, data );
break;
case 0xC000:
sound.write_latch( data );
break;
case 0xE000:
sound.write_data( time, data );
break;
}
}
virtual void set_treble(blip_eq_t const &eq) { sound.treble_eq(eq); }
virtual void reset_state()
{
regs[8] = 0x40; // wram disabled
irq_count = 0xFFFF;
sound.reset();
}
void write_irq( nes_time_t time, int index, int data )
{
run_until( time );
switch ( index )
{
case 0x0D:
irq_mode = data;
irq_pending = false;
irq_changed();
break;
virtual void save_state(mapper_state_t &out)
{
sound.save_state(&sound_state);
Mapper::save_state(out);
}
case 0x0E:
irq_count = (irq_count & 0xFF00) | data;
break;
virtual void read_state(mapper_state_t const &in)
{
Mapper::read_state(in);
sound.load_state(sound_state);
}
case 0x0F:
irq_count = data << 8 | (irq_count & 0xFF);
break;
}
}
virtual void apply_mapping()
{
last_time = 0;
for (int i = 0; i < (int)sizeof regs; i++)
write_register(i, regs[i]);
}
void write_register( int index, int data )
{
regs [index] = data;
int prg_bank = index - 0x09;
if ( (unsigned) prg_bank < 3 ) // most common
{
set_prg_bank( 0x8000 | (prg_bank << bank_8k), bank_8k, data );
}
else if ( index == 0x08 )
{
enable_sram( (data & 0xC0) == 0xC0 );
if ( !(data & 0xC0) )
set_prg_bank( 0x6000, bank_8k, data & 0x3F );
}
else if ( index < 0x08 )
{
set_chr_bank( index * 0x400, bank_1k, data );
}
else
{
if ( data & 2 )
mirror_single( data & 1 );
else if ( data & 1 )
mirror_horiz();
else
mirror_vert();
}
}
virtual void run_until(nes_time_t end_time)
{
int new_count = irq_count - (end_time - last_time);
last_time = end_time;
nes_time_t last_time;
Nes_Fme7_Apu sound;
if (new_count <= 0 && (irq_mode & 0x81) == 0x81)
irq_pending = true;
if (irq_mode & 0x01)
irq_count = new_count & 0xFFFF;
}
virtual nes_time_t next_irq(nes_time_t)
{
if (irq_pending)
return 0;
if ((irq_mode & 0x81) == 0x81)
return last_time + irq_count + 1;
return no_irq;
}
virtual void end_frame(nes_time_t end_time)
{
if (end_time > last_time)
run_until(end_time);
last_time -= end_time;
sound.end_frame(end_time);
}
virtual void write(nes_time_t time, nes_addr_t addr, int data)
{
switch (addr & 0xE000)
{
case 0x8000:
command = data & 0x0F;
break;
case 0xA000:
if (command < 0x0D)
write_register(command, data);
else
write_irq(time, command, data);
break;
case 0xC000:
sound.write_latch(data);
break;
case 0xE000:
sound.write_data(time, data);
break;
}
}
void write_irq(nes_time_t time, int index, int data)
{
run_until(time);
switch (index)
{
case 0x0D:
irq_mode = data;
irq_pending = false;
irq_changed();
break;
case 0x0E:
irq_count = (irq_count & 0xFF00) | data;
break;
case 0x0F:
irq_count = data << 8 | (irq_count & 0xFF);
break;
}
}
void write_register(int index, int data)
{
regs[index] = data;
int prg_bank = index - 0x09;
if ((unsigned)prg_bank < 3) // most common
{
set_prg_bank(0x8000 | (prg_bank << bank_8k), bank_8k, data);
}
else if (index == 0x08)
{
enable_sram((data & 0xC0) == 0xC0);
if (!(data & 0xC0))
set_prg_bank(0x6000, bank_8k, data & 0x3F);
}
else if (index < 0x08)
{
set_chr_bank(index * 0x400, bank_1k, data);
}
else
{
if (data & 2)
mirror_single(data & 1);
else if (data & 1)
mirror_horiz();
else
mirror_vert();
}
}
nes_time_t last_time;
Fme7_Apu sound;
};
} // namespace quickNES

92
source/quickerNES/mappers/mapper070.hpp
View File

@ -23,59 +23,65 @@
*
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
// Mapper_74x161x162x32
template < int mapperId >
class Mapper_74x161x162x32 : public Nes_Mapper {
public:
Mapper_74x161x162x32()
{
register_state( &bank, 1 );
}
namespace quickerNES
{
virtual void reset_state()
{
if ( mapperId == 86 )
bank = ~0;
}
template <int mapperId>
class Mapper_74x161x162x32 : public Mapper
{
public:
Mapper_74x161x162x32()
{
register_state(&bank, 1);
}
virtual void apply_mapping()
{
if ( mapperId == 152 ) write( 0, 0, bank );
if ( mapperId == 70 ) write( 0, 0, bank );
if ( mapperId == 86 )
{
intercept_writes( 0x6000, 1 );
write_intercepted( 0, 0x6000, bank );
}
}
virtual void reset_state()
{
if (mapperId == 86)
bank = ~0;
}
virtual bool write_intercepted( nes_time_t, nes_addr_t addr, int data )
{
if ( addr != 0x6000 ) return false;
if ( mapperId == 152 ) return false;
if ( mapperId == 70 ) return false;
virtual void apply_mapping()
{
if (mapperId == 152) write(0, 0, bank);
if (mapperId == 70) write(0, 0, bank);
if (mapperId == 86)
{
intercept_writes(0x6000, 1);
write_intercepted(0, 0x6000, bank);
}
}
bank = data;
set_prg_bank( 0x8000, bank_32k, ( bank >> 4 ) & 0x03 );
set_chr_bank( 0x0000, bank_8k, ( ( bank >> 4 ) & 0x04 ) | ( bank & 0x03 ) );
virtual bool write_intercepted(nes_time_t, nes_addr_t addr, int data)
{
if (addr != 0x6000) return false;
if (mapperId == 152) return false;
if (mapperId == 70) return false;
return true;
}
bank = data;
set_prg_bank(0x8000, bank_32k, (bank >> 4) & 0x03);
set_chr_bank(0x0000, bank_8k, ((bank >> 4) & 0x04) | (bank & 0x03));
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
if ( mapperId == 86) return;
return true;
}
bank = handle_bus_conflict (addr, data );
set_prg_bank( 0x8000, bank_16k, ( bank >> 4 ) & 0x07 );
set_chr_bank( 0x0000, bank_8k, bank & 0x0F );
mirror_single( ( bank >> 7) & 0x01 );
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
if (mapperId == 86) return;
uint8_t bank;
bank = handle_bus_conflict(addr, data);
set_prg_bank(0x8000, bank_16k, (bank >> 4) & 0x07);
set_chr_bank(0x0000, bank_8k, bank & 0x0F);
mirror_single((bank >> 7) & 0x01);
}
uint8_t bank;
};
typedef Mapper_74x161x162x32<70> Mapper070;
typedef Mapper_74x161x162x32<70> Mapper070;
} // namespace quickNES

71
source/quickerNES/mappers/mapper071.hpp
View File

@ -2,9 +2,9 @@
// Optional less-common simple mappers
// Nes_Emu 0.7.0. http://www.slack.net/~ant/
// Emu 0.7.0. http://www.slack.net/~ant/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -17,38 +17,41 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
// Camerica
// Camerica
class Mapper071 : public Nes_Mapper {
uint8_t regs [3];
public:
Mapper071()
{
register_state( regs, sizeof regs );
}
virtual void apply_mapping()
{
write( 0, 0xc000, regs [0] );
if ( regs [1] & 0x80 )
write( 0, 0x9000, regs [1] );
}
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
if ( addr >= 0xc000 )
{
regs [0] = data;
set_prg_bank( 0x8000, bank_16k, data );
}
else if ( (addr & 0xf000) == 0x9000 )
{
regs [1] = 0x80 | data;
mirror_single( (data >> 4) & 1 );
}
}
namespace quickerNES
{
class Mapper071 : public Mapper
{
uint8_t regs[3];
public:
Mapper071()
{
register_state(regs, sizeof regs);
}
virtual void apply_mapping()
{
write(0, 0xc000, regs[0]);
if (regs[1] & 0x80)
write(0, 0x9000, regs[1]);
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
if (addr >= 0xc000)
{
regs[0] = data;
set_prg_bank(0x8000, bank_16k, data);
}
else if ((addr & 0xf000) == 0x9000)
{
regs[1] = 0x80 | data;
mirror_single((data >> 4) & 1);
}
}
};
} // namespace quickNES

172
source/quickerNES/mappers/mapper073.hpp
View File

@ -23,115 +23,115 @@
* VRC-3 Konami, Salamander
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
namespace quickerNES
{
struct vrc3_state_t
{
bool irq_enable;
bool irq_awk;
uint16_t irq_latch;
uint16_t irq_counter;
bool irq_enable;
bool irq_awk;
uint16_t irq_latch;
uint16_t irq_counter;
uint8_t irq_pending;
uint16_t next_time;
uint8_t irq_pending;
uint16_t next_time;
};
// VRC3
class Mapper073 : public Nes_Mapper, vrc3_state_t {
public:
Mapper073()
{
vrc3_state_t * state = this;
register_state( state, sizeof * state );
}
class Mapper073 : public Mapper, vrc3_state_t
{
public:
Mapper073()
{
vrc3_state_t *state = this;
register_state(state, sizeof *state);
}
void reset_state()
{
}
void reset_state()
{
}
void apply_mapping()
{
enable_sram();
mirror_vert();
}
void apply_mapping()
{
enable_sram();
mirror_vert();
}
virtual void run_until( nes_time_t end_time )
{
if ( irq_enable )
{
long counter = irq_counter + ( end_time - next_time );
virtual void run_until(nes_time_t end_time)
{
if (irq_enable)
{
long counter = irq_counter + (end_time - next_time);
if ( counter > 0xFFFF )
{
irq_pending = true;
irq_enable = irq_awk;
irq_counter = irq_latch;
}
else
irq_counter = counter;
}
if (counter > 0xFFFF)
{
irq_pending = true;
irq_enable = irq_awk;
irq_counter = irq_latch;
}
else
irq_counter = counter;
}
next_time = end_time;
}
next_time = end_time;
}
virtual void end_frame( nes_time_t end_time )
{
if ( end_time > next_time )
run_until( end_time );
virtual void end_frame(nes_time_t end_time)
{
if (end_time > next_time)
run_until(end_time);
next_time -= end_time;
}
next_time -= end_time;
}
virtual nes_time_t next_irq( nes_time_t present )
{
if ( irq_pending )
return present;
virtual nes_time_t next_irq(nes_time_t present)
{
if (irq_pending)
return present;
if ( !irq_enable )
return no_irq;
if (!irq_enable)
return no_irq;
return 0x10000 - irq_counter + next_time;
}
return 0x10000 - irq_counter + next_time;
}
void write_irq_counter( int shift, int data )
{
irq_latch &= ~( 0xF << shift );
irq_latch |= data << shift;
}
void write_irq_counter(int shift, int data)
{
irq_latch &= ~(0xF << shift);
irq_latch |= data << shift;
}
void write( nes_time_t time, nes_addr_t addr, int data )
{
data &= 0xF;
void write(nes_time_t time, nes_addr_t addr, int data)
{
data &= 0xF;
switch ( addr >> 12 )
{
case 0xF: set_prg_bank( 0x8000, bank_16k, data ); break;
case 0x8: write_irq_counter( 0, data ); break;
case 0x9: write_irq_counter( 4, data ); break;
case 0xA: write_irq_counter( 8, data ); break;
case 0xB: write_irq_counter( 12, data ); break;
case 0xC:
irq_pending = false;
irq_awk = data & 1;
irq_enable = data & 2;
switch (addr >> 12)
{
case 0xF: set_prg_bank(0x8000, bank_16k, data); break;
case 0x8: write_irq_counter(0, data); break;
case 0x9: write_irq_counter(4, data); break;
case 0xA: write_irq_counter(8, data); break;
case 0xB: write_irq_counter(12, data); break;
case 0xC:
irq_pending = false;
irq_awk = data & 1;
irq_enable = data & 2;
if ( irq_enable )
irq_counter = irq_latch;
if (irq_enable)
irq_counter = irq_latch;
break;
case 0xD:
irq_pending = false;
irq_enable = irq_awk;
break;
}
break;
case 0xD:
irq_pending = false;
irq_enable = irq_awk;
break;
}
irq_changed();
}
irq_changed();
}
};
// void register_vrc3_mapper();
// void register_vrc3_mapper()
// {
// register_mapper< Mapper073> ( 73 );
// }
} // namespace quickNES

156
source/quickerNES/mappers/mapper075.hpp
View File

@ -17,93 +17,97 @@
* VRC-1 Konami
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
namespace quickerNES
{
struct vrc1_state_t
{
uint8_t prg_banks [ 3 ];
uint8_t chr_banks [ 2 ];
uint8_t chr_banks_hi [ 2 ];
uint8_t mirroring;
uint8_t prg_banks[3];
uint8_t chr_banks[2];
uint8_t chr_banks_hi[2];
uint8_t mirroring;
};
static_assert( sizeof ( vrc1_state_t ) == 8 );
static_assert(sizeof(vrc1_state_t) == 8);
// VRC1
// VRC1
class Mapper075 : public Nes_Mapper, vrc1_state_t {
public:
Mapper075()
{
vrc1_state_t * state = this;
register_state( state, sizeof * state );
}
class Mapper075 : public Mapper, vrc1_state_t
{
public:
Mapper075()
{
vrc1_state_t *state = this;
register_state(state, sizeof *state);
}
void reset_state()
{
}
void reset_state()
{
}
void apply_mapping()
{
update_prg_banks();
update_chr_banks();
update_mirroring();
}
void apply_mapping()
{
update_prg_banks();
update_chr_banks();
update_mirroring();
}
void write( nes_time_t, nes_addr_t addr, int data )
{
switch ( addr & 0xF000 )
{
case 0x8000:
prg_banks [ 0 ] = data & 0xF;
update_prg_banks();
break;
case 0x9000:
mirroring = data & 1;
chr_banks_hi [ 0 ] = ( data & 2 ) << 3;
chr_banks_hi [ 1 ] = ( data & 4 ) << 2;
update_chr_banks();
update_mirroring();
break;
case 0xa000:
prg_banks [ 1 ] = data & 0xF;
update_prg_banks();
break;
case 0xc000:
prg_banks [ 2 ] = data & 0xF;
update_prg_banks();
break;
case 0xe000:
chr_banks [ 0 ] = data & 0xF;
update_chr_banks();
break;
case 0xf000:
chr_banks [ 1 ] = data & 0xF;
update_chr_banks();
break;
}
}
void write(nes_time_t, nes_addr_t addr, int data)
{
switch (addr & 0xF000)
{
case 0x8000:
prg_banks[0] = data & 0xF;
update_prg_banks();
break;
case 0x9000:
mirroring = data & 1;
chr_banks_hi[0] = (data & 2) << 3;
chr_banks_hi[1] = (data & 4) << 2;
update_chr_banks();
update_mirroring();
break;
case 0xa000:
prg_banks[1] = data & 0xF;
update_prg_banks();
break;
case 0xc000:
prg_banks[2] = data & 0xF;
update_prg_banks();
break;
case 0xe000:
chr_banks[0] = data & 0xF;
update_chr_banks();
break;
case 0xf000:
chr_banks[1] = data & 0xF;
update_chr_banks();
break;
}
}
void update_prg_banks()
{
set_prg_bank( 0x8000, bank_8k, prg_banks [ 0 ] );
set_prg_bank( 0xa000, bank_8k, prg_banks [ 1 ] );
set_prg_bank( 0xc000, bank_8k, prg_banks [ 2 ] );
}
void update_prg_banks()
{
set_prg_bank(0x8000, bank_8k, prg_banks[0]);
set_prg_bank(0xa000, bank_8k, prg_banks[1]);
set_prg_bank(0xc000, bank_8k, prg_banks[2]);
}
void update_chr_banks()
{
set_chr_bank( 0x0000, bank_4k, chr_banks [ 0 ] | chr_banks_hi [ 0 ] );
set_chr_bank( 0x1000, bank_4k, chr_banks [ 1 ] | chr_banks_hi [ 1 ] );
}
void update_chr_banks()
{
set_chr_bank(0x0000, bank_4k, chr_banks[0] | chr_banks_hi[0]);
set_chr_bank(0x1000, bank_4k, chr_banks[1] | chr_banks_hi[1]);
}
void update_mirroring()
{
switch ( mirroring & 1 )
{
case 1: mirror_horiz(); break;
case 0: mirror_vert(); break;
}
}
void update_mirroring()
{
switch (mirroring & 1)
{
case 1: mirror_horiz(); break;
case 0: mirror_vert(); break;
}
}
};
} // namespace quickNES

132
source/quickerNES/mappers/mapper078.hpp
View File

@ -1,74 +1,80 @@
#pragma once
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
// Holy Diver and Uchuusen - Cosmo Carrier.
class Mapper078 : public Nes_Mapper {
// lower 8 bits are the reg at 8000:ffff
// next two bits are autodetecting type
// 0 = unknown 1 = cosmo carrier 2 = holy diver
int reg;
void writeinternal(int data, int changed)
{
reg &= 0x300;
reg |= data;
namespace quickerNES
{
if (changed & 0x07)
set_prg_bank(0x8000, bank_16k, reg & 0x07);
if (changed & 0xf0)
set_chr_bank(0x0000, bank_8k, (reg >> 4) & 0x0f);
if (changed & 0x08)
{
// set mirroring based on memorized board type
if (reg & 0x100)
{
mirror_single((reg >> 3) & 1);
}
else if (reg & 0x200)
{
if (reg & 0x08)
mirror_vert();
else
mirror_horiz();
}
else
{
// if you don't set something here, holy diver dumps with 4sc set will
// savestate as 4k NTRAM. then when you later set H\V mapping, state size mismatch.
mirror_single(1);
}
}
}
class Mapper078 : public Mapper
{
// lower 8 bits are the reg at 8000:ffff
// next two bits are autodetecting type
// 0 = unknown 1 = cosmo carrier 2 = holy diver
int reg;
void writeinternal(int data, int changed)
{
reg &= 0x300;
reg |= data;
public:
Mapper078()
{
register_state(&reg, 4);
}
if (changed & 0x07)
set_prg_bank(0x8000, bank_16k, reg & 0x07);
if (changed & 0xf0)
set_chr_bank(0x0000, bank_8k, (reg >> 4) & 0x0f);
if (changed & 0x08)
{
// set mirroring based on memorized board type
if (reg & 0x100)
{
mirror_single((reg >> 3) & 1);
}
else if (reg & 0x200)
{
if (reg & 0x08)
mirror_vert();
else
mirror_horiz();
}
else
{
// if you don't set something here, holy diver dumps with 4sc set will
// savestate as 4k NTRAM. then when you later set H\V mapping, state size mismatch.
mirror_single(1);
}
}
}
virtual void reset_state()
{
reg = 0;
}
public:
Mapper078()
{
register_state(&reg, 4);
}
virtual void apply_mapping()
{
writeinternal(reg, 0xff);
}
virtual void reset_state()
{
reg = 0;
}
virtual void write( nes_time_t, nes_addr_t addr, int data)
{
// heuristic: if the first write ever to the register is 0,
// we're on holy diver, otherwise, carrier. it works for these two games...
if (!(reg & 0x300))
{
reg |= data ? 0x100 : 0x200;
writeinternal(data, 0xff);
}
else
{
writeinternal(data, reg ^ data);
}
}
virtual void apply_mapping()
{
writeinternal(reg, 0xff);
}
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
// heuristic: if the first write ever to the register is 0,
// we're on holy diver, otherwise, carrier. it works for these two games...
if (!(reg & 0x300))
{
reg |= data ? 0x100 : 0x200;
writeinternal(data, 0xff);
}
else
{
writeinternal(data, reg ^ data);
}
}
};
} // namespace quickNES

104
source/quickerNES/mappers/mapper079.hpp
View File

@ -25,66 +25,74 @@
* Nina-03 / Nina-06
*/
#include "mappers/mapper.h"
#include "mappers/mapper.hpp"
template < bool multicart >
class Mapper_AveNina : public Nes_Mapper {
public:
Mapper_AveNina()
{
register_state( &regs, 1 );
}
namespace quickerNES
{
void write_regs();
template <bool multicart>
class Mapper_AveNina : public Mapper
{
public:
Mapper_AveNina()
{
register_state(&regs, 1);
}
virtual void reset_state()
{
intercept_writes( 0x4000, 0x1000 );
intercept_writes( 0x5000, 0x1000 );
}
void write_regs();
virtual void apply_mapping()
{
write_intercepted( 0, 0x4100, regs );
}
virtual void reset_state()
{
intercept_writes(0x4000, 0x1000);
intercept_writes(0x5000, 0x1000);
}
virtual bool write_intercepted( nes_time_t, nes_addr_t addr , int data )
{
if ( addr < 0x4100 || addr > 0x5FFF )
return false;
virtual void apply_mapping()
{
write_intercepted(0, 0x4100, regs);
}
if ( addr & 0x100 )
regs = data;
virtual bool write_intercepted(nes_time_t, nes_addr_t addr, int data)
{
if (addr < 0x4100 || addr > 0x5FFF)
return false;
write_regs();
return true;
}
if (addr & 0x100)
regs = data;
virtual void write( nes_time_t, nes_addr_t addr, int data )
{
if ( multicart == 0 &&
( ( addr == 0x8000 ) || ( addr & 0xFCB0 ) == 0xFCB0 ) )
set_chr_bank( 0, bank_8k, data & 0x07 );
}
write_regs();
return true;
}
uint8_t regs;
virtual void write(nes_time_t, nes_addr_t addr, int data)
{
if (multicart == 0 &&
((addr == 0x8000) || (addr & 0xFCB0) == 0xFCB0))
set_chr_bank(0, bank_8k, data & 0x07);
}
uint8_t regs;
};
template < bool multicart >
void Mapper_AveNina< multicart >::write_regs()
template <bool multicart>
void Mapper_AveNina<multicart>::write_regs()
{
if ( multicart == 0 )
{
set_prg_bank ( 0x8000, bank_32k, ( regs >> 3 ) & 0x01 );
set_chr_bank ( 0, bank_8k, regs & 0x07 );
}
else
{
set_prg_bank ( 0x8000, bank_32k, ( regs >> 3 ) & 0x07 );
set_chr_bank ( 0x0000, bank_8k, ( ( regs >> 3 ) & 0x08 ) | ( regs & 0x07 ) );
if ( regs & 0x80 ) mirror_vert();
else mirror_horiz();
}
if (multicart == 0)
{
set_prg_bank(0x8000, bank_32k, (regs >> 3) & 0x01);
set_chr_bank(0, bank_8k, regs & 0x07);
}
else
{
set_prg_bank(0x8000, bank_32k, (regs >> 3) & 0x07);
set_chr_bank(0x0000, bank_8k, ((regs >> 3) & 0x08) | (regs & 0x07));
if (regs & 0x80)
mirror_vert();
else
mirror_horiz();
}
}
typedef Mapper_AveNina<false> Mapper079;
} // namespace quickNES

383
source/quickerNES/mappers/mapper085.hpp
View File

@ -1,10 +1,10 @@
#pragma once
// Nes_Emu 0.5.4. http://www.slack.net/~ant/
// Emu 0.5.4. http://www.slack.net/~ant/
#include "apu/vrc7/apu.hpp"
#include "mappers/mapper.hpp"
#include <cstring>
#include "mappers/mapper.h"
#include "apu/vrc7/apu.h"
/* Copyright (C) 2004-2005 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
@ -17,201 +17,212 @@ more details. You should have received a copy of the GNU Lesser General
Public License along with this module; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
namespace quickerNES
{
struct vrc7_state_t
{
// written registers
uint8_t mirroring;
uint8_t prg_banks [3];
uint8_t chr_banks [8];
uint8_t irq_reload;
uint8_t irq_mode;
// internal state
uint16_t next_time;
uint8_t irq_pending;
uint8_t unused;
vrc7_snapshot_t sound_state;
// written registers
uint8_t mirroring;
uint8_t prg_banks[3];
uint8_t chr_banks[8];
uint8_t irq_reload;
uint8_t irq_mode;
// internal state
uint16_t next_time;
uint8_t irq_pending;
uint8_t unused;
vrc7_snapshot_t sound_state;
};
static_assert( sizeof (vrc7_state_t) == 20 + sizeof (vrc7_snapshot_t) );
static_assert(sizeof(vrc7_state_t) == 20 + sizeof(vrc7_snapshot_t));
// Vrc7
class Mapper085 : public Nes_Mapper, vrc7_state_t {
public:
Mapper085()
{
vrc7_state_t* state = this;
register_state( state, sizeof *state );
}
virtual int channel_count() const { return sound.osc_count; }
virtual void set_channel_buf( int i, Blip_Buffer* b ) { sound.osc_output( i, b ); }
virtual void set_treble( blip_eq_t const& eq ) { sound.treble_eq( eq ); }
virtual void save_state( mapper_state_t & out )
{
sound.save_snapshot( &sound_state );
Nes_Mapper::save_state( out );
}
virtual void load_state( mapper_state_t const& in )
{
Nes_Mapper::load_state( in );
sound.load_snapshot( sound_state, in.size );
}
virtual void reset_state()
{
mirroring = 0;
memset( prg_banks, 0, sizeof prg_banks );
memset( chr_banks, 0, sizeof chr_banks );
memset( &sound_state, 0, sizeof sound_state );
irq_reload = 0;
irq_mode = 0;
irq_pending = false;
next_time = 0;
sound.reset();
set_prg_bank( 0xE000, bank_8k, last_bank );
apply_mapping();
}
class Mapper085 : public Mapper, vrc7_state_t
{
public:
Mapper085()
{
vrc7_state_t *state = this;
register_state(state, sizeof *state);
}
void write_prg_bank( int bank, int data )
{
prg_banks [bank] = data;
set_prg_bank( 0x8000 | ( bank << bank_8k ), bank_8k, data );
}
void write_chr_bank( int bank, int data )
{
//dprintf( "change chr bank %d\n", bank );
chr_banks [bank] = data;
set_chr_bank( bank * 0x400, bank_1k, data );
}
void write_mirroring( int data )
{
mirroring = data;
//dprintf( "Change mirroring %d\n", data );
enable_sram( data & 128, data & 64 );
virtual int channel_count() const { return sound.osc_count; }
if ( data & 2 )
mirror_single( data & 1 );
else if ( data & 1 )
mirror_horiz();
else
mirror_vert();
}
virtual void set_channel_buf(int i, Blip_Buffer *b) { sound.osc_output(i, b); }
void apply_mapping()
{
size_t i;
virtual void set_treble(blip_eq_t const &eq) { sound.treble_eq(eq); }
for ( i = 0; i < sizeof prg_banks; i++ )
write_prg_bank( i, prg_banks [i] );
for ( i = 0; i < sizeof chr_banks; i++ )
write_chr_bank( i, chr_banks [i] );
write_mirroring( mirroring );
}
void reset_timer( nes_time_t present )
{
next_time = present + unsigned ((0x100 - irq_reload) * timer_period) / 4;
}
virtual void run_until( nes_time_t end_time )
{
if ( irq_mode & 2 )
{
while ( next_time < end_time )
{
//dprintf( "%d timer expired\n", next_time );
irq_pending = true;
reset_timer( next_time );
}
}
}
virtual void end_frame( nes_time_t end_time )
{
run_until( end_time );
next_time -= end_time;
sound.end_frame( end_time );
}
virtual nes_time_t next_irq( nes_time_t present )
{
if ( irq_pending )
return present;
if ( irq_mode & 2 )
return next_time + 1;
return no_irq;
}
virtual void write( nes_time_t time, nes_addr_t addr, int data )
{
addr |= ( addr & 8 ) << 1;
virtual void save_state(mapper_state_t &out)
{
sound.save_snapshot(&sound_state);
Mapper::save_state(out);
}
if ( addr >= 0xe010 )
{
// IRQ
run_until( time );
//dprintf( "%d VRC6 IRQ [%d] = %02X\n", time, addr & 3, data );
switch ( addr & 0xf010 )
{
case 0xe010:
irq_reload = data;
break;
case 0xf000:
irq_pending = false;
irq_mode = data;
if ( data & 2 )
reset_timer( time );
break;
case 0xf010:
irq_pending = false;
irq_mode = (irq_mode & ~2) | ((irq_mode << 1) & 2);
break;
}
irq_changed();
}
else if ( ( unsigned ) ( addr - 0xa000 ) < 0x4000 )
{
write_chr_bank( ((addr >> 4) & 1) | (((addr - 0xa000) >> 11)&~1), data );
}
else switch ( addr & 0xf010 )
{
case 0x8000: write_prg_bank( 0, data ); break;
case 0x8010: write_prg_bank( 1, data ); break;
case 0x9000: write_prg_bank( 2, data ); break;
case 0xe000:
write_mirroring( data );
break;
virtual void load_state(mapper_state_t const &in)
{
Mapper::load_state(in);
sound.load_snapshot(sound_state, in.size);
}
case 0x9010:
if ( addr & 0x20 ) sound.write_data( time, data );
else sound.write_reg( data );
break;
}
}
virtual void reset_state()
{
mirroring = 0;
Nes_Vrc7 sound;
enum { timer_period = 113 * 4 + 3 };
memset(prg_banks, 0, sizeof prg_banks);
memset(chr_banks, 0, sizeof chr_banks);
memset(&sound_state, 0, sizeof sound_state);
irq_reload = 0;
irq_mode = 0;
irq_pending = false;
next_time = 0;
sound.reset();
set_prg_bank(0xE000, bank_8k, last_bank);
apply_mapping();
}
void write_prg_bank(int bank, int data)
{
prg_banks[bank] = data;
set_prg_bank(0x8000 | (bank << bank_8k), bank_8k, data);
}
void write_chr_bank(int bank, int data)
{
// dprintf( "change chr bank %d\n", bank );
chr_banks[bank] = data;
set_chr_bank(bank * 0x400, bank_1k, data);
}
void write_mirroring(int data)
{
mirroring = data;
// dprintf( "Change mirroring %d\n", data );
enable_sram(data & 128, data & 64);
if (data & 2)
mirror_single(data & 1);
else if (data & 1)
mirror_horiz();
else
mirror_vert();
}
void apply_mapping()
{
size_t i;
for (i = 0; i < sizeof prg_banks; i++)
write_prg_bank(i, prg_banks[i]);
for (i = 0; i < sizeof chr_banks; i++)
write_chr_bank(i, chr_banks[i]);
write_mirroring(mirroring);
}
void reset_timer(nes_time_t present)
{
next_time = present + unsigned((0x100 - irq_reload) * timer_period) / 4;
}
virtual void run_until(nes_time_t end_time)
{
if (irq_mode & 2)
{
while (next_time < end_time)
{
// dprintf( "%d timer expired\n", next_time );
irq_pending = true;
reset_timer(next_time);
}
}
}
virtual void end_frame(nes_time_t end_time)
{
run_until(end_time);
next_time -= end_time;
sound.end_frame(end_time);
}
virtual nes_time_t next_irq(nes_time_t present)
{
if (irq_pending)
return present;
if (irq_mode & 2)
return next_time + 1;
return no_irq;
}
virtual void write(nes_time_t time, nes_addr_t addr, int data)
{
addr |= (addr & 8) << 1;
if (addr >= 0xe010)
{
// IRQ
run_until(time);
// dprintf( "%d VRC6 IRQ [%d] = %02X\n", time, addr & 3, data );
switch (addr & 0xf010)
{
case 0xe010:
irq_reload = data;
break;
case 0xf000:
irq_pending = false;
irq_mode = data;
if (data & 2)
reset_timer(time);
break;
case 0xf010:
irq_pending = false;
irq_mode = (irq_mode & ~2) | ((irq_mode << 1) & 2);
break;
}
irq_changed();
}
else if ((unsigned)(addr - 0xa000) < 0x4000)
{
write_chr_bank(((addr >> 4) & 1) | (((addr - 0xa000) >> 11) & ~1), data);
}
else
switch (addr & 0xf010)
{
case 0x8000: write_prg_bank(0, data); break;
case 0x8010: write_prg_bank(1, data); break;
case 0x9000: write_prg_bank(2, data); break;
case 0xe000:
write_mirroring(data);
break;
case 0x9010:
if (addr & 0x20)
sound.write_data(time, data);
else
sound.write_reg(data);
break;
}
}
Vrc7 sound;
enum
{
timer_period = 113 * 4 + 3
};
};
} // namespace quickNES

7
source/quickerNES/mappers/mapper086.hpp
View File

@ -21,4 +21,9 @@
*
*/
typedef Mapper_74x161x162x32<86> Mapper086;
namespace quickerNES
{
typedef Mapper_74x161x162x32<86> Mapper086;
} // namespace quickNES

Some files were not shown because too many files have changed in this diff Show More