spc_parser.h

Go to the documentation of this file.

#ifndef YAZE_ZELDA3_MUSIC_SPC_PARSER_H
#define YAZE_ZELDA3_MUSIC_SPC_PARSER_H
 
#include <cstdint>
#include <vector>
 
#include "absl/status/statusor.h"
#include "rom/rom.h"
#include "zelda3/music/song_data.h"
 
namespace yaze {
namespace zelda3 {
namespace music {
 
// ROM offsets for sound bank block headers (from usdasm disassembly)
// Each bank has a block header: [size:2][aram_addr:2][data:size]
//
// Banks 0, 1, 3 are contiguous starting at $19:8000 (PC 0xC8000)
// Bank 2 (dungeon) is separate at $1B:8000 (PC 0xD8000)
//
// Song table blocks (loading to ARAM $D000):
// - Overworld: $1A:9EF5 (PC 0xD1EF5)
// - Dungeon:   $1B:8000 (PC 0xD8000)
// - Credits:   $1A:D380 (PC 0xD5380)
constexpr uint32_t kSoundBankOffsets[] = {
    0xC8000,   // Bank 0 (common) - start of contiguous region
    0xD1EF5,   // Bank 1 (overworld) - song table block
    0xD8000,   // Bank 2 (dungeon) - separate region
    0xD5380    // Bank 3 (credits) - song table block
};
 
class SpcParser {
 public:
  struct ParseContext {
    Rom* rom = nullptr;
    uint8_t current_bank = 0;
    uint32_t bank_offset = 0;
 
    // Parsing state
    std::vector<uint16_t> visited_addresses;  // Prevent infinite loops
    int max_parse_depth = 100;
    int current_depth = 0;
  };
 
  // =========================================================================
  // Song Parsing
  // =========================================================================
 
  static absl::StatusOr<MusicSong> ParseSong(Rom& rom, uint16_t address,
                                              uint8_t bank);
 
  static absl::StatusOr<std::vector<uint16_t>> ReadSongPointerTable(
      Rom& rom, uint16_t table_address, uint8_t bank, int max_entries = 40);
 
  static absl::StatusOr<MusicTrack> ParseTrack(Rom& rom, uint16_t address,
                                                uint8_t bank,
                                                int max_ticks = 50000);
 
  // =========================================================================
  // Address Resolution
  // =========================================================================
 
  static uint32_t SpcAddressToRomOffset(Rom& rom, uint16_t spc_address,
                                         uint8_t bank);
 
  static const uint8_t* GetSpcData(Rom& rom, uint16_t spc_address,
                                    uint8_t bank, int* out_length = nullptr);
 
  // =========================================================================
  // Command Utilities
  // =========================================================================
 
  static int GetCommandParamCount(uint8_t opcode) {
    if (opcode < 0xE0) return 0;
    return kCommandParamCount[opcode - 0xE0];
  }
 
  static bool IsNotePitch(uint8_t byte) {
    return byte >= kNoteMinPitch && byte <= kNoteRest;
  }
 
  static bool IsDuration(uint8_t byte) {
    return byte < 0x80;
  }
 
  static bool IsCommand(uint8_t byte) {
    return byte >= 0xE0;
  }
 
 private:
  // Internal parsing with context
  static absl::StatusOr<MusicTrack> ParseTrackInternal(ParseContext& ctx,
                                                        uint16_t address,
                                                        int max_ticks);
 
  // Parse subroutine call
  static absl::StatusOr<int> ParseSubroutine(ParseContext& ctx,
                                              uint16_t address,
                                              int repeat_count,
                                              int remaining_ticks);
};
 
class SpcSerializer {
 public:
  struct SerializeResult {
    std::vector<uint8_t> data;
    std::vector<uint16_t> relocations;  // Offsets that need address fixup
    uint16_t base_address = 0;
  };
 
  // =========================================================================
  // Song Serialization
  // =========================================================================
 
  static absl::StatusOr<SerializeResult> SerializeSong(const MusicSong& song,
                                                        uint16_t base_address);
 
  static std::vector<uint8_t> SerializeTrack(const MusicTrack& track);
 
  static int CalculateRequiredSpace(const MusicSong& song);
 
  // =========================================================================
  // Event Serialization
  // =========================================================================
 
  static std::vector<uint8_t> SerializeNote(const Note& note,
                                             uint8_t* current_duration);
 
  static std::vector<uint8_t> SerializeCommand(const MusicCommand& command);
 
  static void ApplyBaseAddress(SerializeResult* result,
                               uint16_t new_base_address);
};
 
class BrrCodec {
 public:
  static std::vector<int16_t> Decode(const std::vector<uint8_t>& brr_data,
                                      int* loop_start = nullptr);
 
  static std::vector<uint8_t> Encode(const std::vector<int16_t>& pcm_data,
                                      int loop_start = -1);
 
 private:
  // Filter coefficients for BRR decoding
  static constexpr int kFilter1[4] = {0, 15, 61, 115};
  static constexpr int kFilter2[4] = {0, 4, 5, 6};
  static constexpr int kFilter3[4] = {0, 0, 15, 13};
};
 
}  // namespace music
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_ZELDA3_MUSIC_SPC_PARSER_H