web-a2e 1.0.0

package/src/core/assembler/assembler.hpp

@@ -0,0 +1,115 @@
+/*
+ * assembler.hpp - 65C02 multi-pass assembler
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+namespace a2e {
+
+// Maximum error message length
+static constexpr int ASM_MAX_ERROR_MSG = 80;
+
+// Assembly error
+struct AsmError {
+  int lineNumber;
+  char message[ASM_MAX_ERROR_MSG];
+};
+
+// Symbol entry for exposing the symbol table
+struct AsmSymbol {
+  char name[64];
+  int32_t value;
+};
+
+// Assembly result
+struct AsmResult {
+  std::vector<uint8_t> output;
+  std::vector<AsmError> errors;
+  std::vector<AsmSymbol> symbols;
+  uint16_t origin;
+  uint16_t endAddress;
+  bool success;
+};
+
+class Assembler {
+public:
+  Assembler();
+
+  /**
+   * Assemble source text into machine code.
+   * @param source  Null-terminated source string
+   * @return Assembly result with output bytes and errors
+   */
+  AsmResult assemble(const char* source);
+
+private:
+  // Parsed source line
+  struct ParsedLine {
+    std::string label;
+    std::string mnemonic;
+    std::string operand;
+    int lineNumber;
+  };
+
+  // Reverse opcode table: reverseOpcodes[mnemonicIndex][addrMode] = opcode byte
+  // 0xFF = invalid combination
+  uint8_t reverseOpcodes[99][16];
+  bool reverseTableBuilt;
+
+  // Symbol table: label -> address
+  std::unordered_map<std::string, int32_t> symbols;
+
+  void buildReverseOpcodeTable();
+  std::vector<ParsedLine> parseSource(const char* source);
+  ParsedLine parseLine(const char* line, int lineNumber);
+
+  // Expression evaluation
+  int32_t evaluateExpression(const std::string& expr, bool& error,
+                             std::string& errorMsg, int lineNumber);
+  int32_t evalAddSub(const char*& p, bool& error, std::string& errorMsg,
+                     int lineNumber);
+  int32_t evalMulDiv(const char*& p, bool& error, std::string& errorMsg,
+                     int lineNumber);
+  int32_t evalUnary(const char*& p, bool& error, std::string& errorMsg,
+                    int lineNumber);
+  int32_t evalPrimary(const char*& p, bool& error, std::string& errorMsg,
+                      int lineNumber);
+
+  // Addressing mode detection
+  uint8_t detectAddressingMode(const std::string& mnemonic,
+                               const std::string& operand,
+                               int32_t value, bool valueKnown);
+
+  // Instruction sizing
+  int getInstructionSize(const std::string& mnemonic,
+                         const std::string& operand,
+                         bool labelsComplete);
+
+  // Directive processing
+  int getDirectiveSize(const std::string& directive, const std::string& operand,
+                       bool& error, std::string& errorMsg, int lineNumber);
+  void emitDirective(const std::string& directive, const std::string& operand,
+                     std::vector<uint8_t>& output,
+                     bool& error, std::string& errorMsg, int lineNumber);
+
+  // Mnemonic lookup
+  int findMnemonicIndex(const std::string& mnemonic);
+
+  // Helper to check if a mnemonic is a branch instruction
+  bool isBranchMnemonic(int mnemonicIndex);
+  bool isZPRMnemonic(int mnemonicIndex);
+
+  // Current PC during assembly
+  uint16_t pc;
+};
+
+} // namespace a2e

package/src/core/audio/audio.cpp

@@ -0,0 +1,160 @@
+/*
+ * audio.cpp - Speaker audio emulation implementation
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#include "audio.hpp"
+#include "../cards/mockingboard_card.hpp"
+#include <cmath>
+
+namespace a2e {
+
+Audio::Audio() {
+  toggleCycles_.reserve(MAX_TOGGLES);
+  reset();
+}
+
+void Audio::reset() {
+  speakerState_ = false;
+  toggleCycles_.clear();
+  toggleReadIndex_ = 0;
+  lastSampleCycle_ = 0;
+  filterState_ = 0.0f;
+  dcOffset_ = 0.0f;
+}
+
+void Audio::toggleSpeaker(uint64_t cycleCount) {
+  // Record the toggle event
+  if (toggleCycles_.size() < MAX_TOGGLES) {
+    toggleCycles_.push_back(cycleCount);
+  }
+}
+
+int Audio::generateStereoSamples(float *buffer, int sampleCount,
+                                  uint64_t currentCycle) {
+  if (sampleCount <= 0) {
+    return sampleCount;
+  }
+
+  // First generate mono speaker samples into a temp buffer
+  std::vector<float> speakerBuffer(sampleCount);
+
+  uint64_t startCycle = lastSampleCycle_;
+  uint64_t endCycle = currentCycle;
+  uint64_t totalCycles = endCycle - startCycle;
+
+  // Sanity check: if cycle range is too large (more than 2x expected), clamp it
+  uint64_t expectedCycles = static_cast<uint64_t>(sampleCount * CYCLES_PER_SAMPLE);
+  if (totalCycles == 0 || totalCycles > expectedCycles * 2) {
+    totalCycles = expectedCycles;
+    startCycle = endCycle - totalCycles;
+  }
+
+  double cyclesPerSample = static_cast<double>(totalCycles) / sampleCount;
+
+  // Process each sample for speaker
+  for (int i = 0; i < sampleCount; i++) {
+    uint64_t sampleCycleStart =
+        startCycle + static_cast<uint64_t>(i * cyclesPerSample);
+    uint64_t sampleCycleEnd =
+        startCycle + static_cast<uint64_t>((i + 1) * cyclesPerSample);
+
+    float highTime = 0.0f;
+    float lowTime = 0.0f;
+    uint64_t lastCycle = sampleCycleStart;
+    bool currentState = speakerState_;
+
+    while (toggleReadIndex_ < toggleCycles_.size() &&
+           toggleCycles_[toggleReadIndex_] < sampleCycleEnd) {
+      uint64_t toggleCycle = toggleCycles_[toggleReadIndex_];
+
+      if (toggleCycle >= sampleCycleStart) {
+        float cycles = static_cast<float>(toggleCycle - lastCycle);
+        if (currentState) {
+          highTime += cycles;
+        } else {
+          lowTime += cycles;
+        }
+        lastCycle = toggleCycle;
+      }
+
+      currentState = !currentState;
+      toggleReadIndex_++;
+    }
+
+    float cycles = static_cast<float>(sampleCycleEnd - lastCycle);
+    if (currentState) {
+      highTime += cycles;
+    } else {
+      lowTime += cycles;
+    }
+
+    speakerState_ = currentState;
+
+    float totalTime = highTime + lowTime;
+    float rawValue = 0.0f;
+    if (totalTime > 0) {
+      rawValue = (highTime - lowTime) / totalTime;
+    }
+
+    filterState_ = filterState_ + FILTER_ALPHA * (rawValue - filterState_);
+    dcOffset_ = DC_ALPHA * dcOffset_ + (1.0f - DC_ALPHA) * filterState_;
+    float dcCorrected = filterState_ - dcOffset_;
+    float sample = std::max(-1.0f, std::min(1.0f, dcCorrected));
+
+    speakerBuffer[i] = sample;
+  }
+
+  if (toggleReadIndex_ > 0) {
+    toggleCycles_.erase(toggleCycles_.begin(),
+                        toggleCycles_.begin() + toggleReadIndex_);
+    toggleReadIndex_ = 0;
+  }
+
+  lastSampleCycle_ = currentCycle;
+
+  // When muted, zero the output but keep speaker state tracking intact
+  if (muted_) {
+    for (int i = 0; i < sampleCount * 2; i++) {
+      buffer[i] = 0.0f;
+    }
+    // Still consume Mockingboard samples to keep them in sync
+    if (mockingboard_) {
+      std::vector<float> mbDiscard(sampleCount * 2);
+      mockingboard_->consumeStereoSamples(mbDiscard.data(), sampleCount);
+    }
+    return sampleCount;
+  }
+
+  // Get stereo Mockingboard samples (incrementally generated during CPU execution)
+  std::vector<float> mbBuffer(sampleCount * 2, 0.0f);
+  if (mockingboard_) {
+    mockingboard_->consumeStereoSamples(mbBuffer.data(), sampleCount);
+  }
+
+  // Mix speaker (center) with Mockingboard stereo
+  // Scale both sources by 0.5 to prevent clipping when both are active
+  constexpr float MIX_SCALE = 0.5f;
+
+  for (int i = 0; i < sampleCount; i++) {
+    float speakerSample = speakerBuffer[i] * MIX_SCALE;
+
+    // Mockingboard: PSG1 left, PSG2 right (already properly normalized)
+    float mbLeft = mbBuffer[i * 2] * MIX_SCALE;
+    float mbRight = mbBuffer[i * 2 + 1] * MIX_SCALE;
+
+    // Mix: speaker goes to both channels
+    float left = speakerSample + mbLeft;
+    float right = speakerSample + mbRight;
+
+    // Clamp to valid range (should rarely clip now)
+    buffer[i * 2] = std::max(-1.0f, std::min(1.0f, left));
+    buffer[i * 2 + 1] = std::max(-1.0f, std::min(1.0f, right));
+  }
+
+  return sampleCount;
+}
+
+} // namespace a2e

package/src/core/audio/audio.hpp

@@ -0,0 +1,81 @@
+/*
+ * audio.hpp - Speaker audio emulation
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include "../types.hpp"
+#include <array>
+#include <cstdint>
+#include <vector>
+
+namespace a2e {
+
+// Forward declaration
+class MockingboardCard;
+
+class Audio {
+public:
+  static constexpr int BUFFER_SIZE = 4096;
+  static constexpr int MAX_TOGGLES = 8192;
+
+  Audio();
+
+  // Speaker toggle (called when $C030 is accessed)
+  void toggleSpeaker(uint64_t cycleCount);
+
+  // Generate stereo audio samples (interleaved L/R)
+  // Mockingboard: PSG1 on left, PSG2 on right
+  // Speaker: centered (both channels)
+  // Returns the number of sample frames generated
+  int generateStereoSamples(float *buffer, int sampleCount, uint64_t currentCycle);
+
+  // Reset
+  void reset();
+
+  // Volume control (0.0 - 1.0)
+  void setVolume(float volume) { volume_ = volume; }
+  float getVolume() const { return volume_; }
+
+  // Mute control
+  void setMuted(bool muted) { muted_ = muted; }
+  bool isMuted() const { return muted_; }
+
+  // Speaker state (for state serialization)
+  bool getSpeakerState() const { return speakerState_; }
+
+  // Mockingboard connection
+  void setMockingboard(MockingboardCard* mb) { mockingboard_ = mb; }
+
+private:
+  // Speaker state
+  bool speakerState_ = false;
+
+  // Toggle event recording
+  std::vector<uint64_t> toggleCycles_;
+  size_t toggleReadIndex_ = 0;
+
+  // Audio generation state
+  uint64_t lastSampleCycle_ = 0;
+
+  // Simple low-pass filter state
+  // Alpha ~0.15 gives cutoff ~7.8kHz at 48kHz, preserving speaker harmonics
+  float filterState_ = 0.0f;
+  static constexpr float FILTER_ALPHA = 0.15f;
+
+  // Volume
+  float volume_ = 0.5f;
+  bool muted_ = false;
+
+  // DC offset removal - fast enough to track speaker state changes
+  float dcOffset_ = 0.0f;
+  static constexpr float DC_ALPHA = 0.995f;
+
+  // Mockingboard
+  MockingboardCard* mockingboard_ = nullptr;
+};
+
+} // namespace a2e