pysoundmonitor 0.1.0__py3-none-any.whl

pysoundmonitor/__init__.py

@@ -0,0 +1,38 @@
+"""Pure-Python reader and detector for Soundmonitor (64'er / Hulsbeck) SID tunes.
+
+Soundmonitor is HVSC tracker #6. Its player is relocatable and the SID-header
+addresses are not a reliable locator, so this package finds the engine by a
+small hardware-register fingerprint and decodes the documented section->stream
+song-data structures into a :class:`Song` model. Scope is the container/detection
+plus a song-data reader -- not a byte-exact playback engine.
+"""
+
+from .errors import SidParseError, SoundMonitorError
+from .model import (
+    FilterTail,
+    Instrument,
+    NoteFreqTable,
+    Row,
+    Section,
+    Song,
+)
+from .reader import find_fingerprint, parse, read
+from .sidparser import SoundMonitorSidParser
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "FilterTail",
+    "Instrument",
+    "NoteFreqTable",
+    "Row",
+    "Section",
+    "SidParseError",
+    "Song",
+    "SoundMonitorError",
+    "SoundMonitorSidParser",
+    "__version__",
+    "find_fingerprint",
+    "parse",
+    "read",
+]

pysoundmonitor/constants.py

@@ -0,0 +1,144 @@
+"""Documented Soundmonitor (64'er / Hulsbeck) song-data layout constants.
+
+Every value here is a *structural fact* transcribed from the reverse-engineering
+architecture reference (``re-trackers/Soundmonitor/soundmonitor-architecture.md``)
+- table geometry, the 16-byte instrument-record field map, section-header and row
+layouts, and a tiny relocation-invariant engine fingerprint. No player code is
+reproduced: the fingerprint is expressed purely as writes to fixed C64 hardware
+registers plus an immediate guard constant, which are functional facts, not
+copyrightable expression.
+"""
+
+from __future__ import annotations
+
+# --- Recognizer fingerprint (relocation-invariant) --------------------------
+# Soundmonitor is CIA-timed and programs its OWN play period: the section loader
+# reads the CIA-1 Timer-A latch from the per-section header and writes it to the
+# fixed hardware registers $DC04/$DC05, guarding the hi byte with ``CMP #$06``.
+# These target absolute hardware addresses that never relocate, so the sequence
+# is a load-address-independent signature of the engine.
+STA_DC04 = bytes((0x8D, 0x04, 0xDC))  # STA $DC04  (Timer-A latch lo)
+STA_DC05 = bytes((0x8D, 0x05, 0xDC))  # STA $DC05  (Timer-A latch hi)
+CMP_06 = bytes((0xC9, 0x06))  # CMP #$06   (hi-latch guard)
+# Max byte gap between the two CIA stores for the fingerprint to match.
+FINGERPRINT_WINDOW = 0x10
+
+# ``LDA abs,X`` opcode: the section loader indexes the page-aligned split
+# pointer tables (and the note-freq tables) with it, so its operands recover the
+# data-region base page and the note-freq table addresses relocation-tolerantly.
+LDA_ABSX = 0xBD
+# ``CPX abs`` / ``LDX abs`` opcodes: the section-advance code compares the live
+# section index against ``sec_last`` (``CPX``) and reloads ``sec_start``
+# (``LDX``) from two adjacent player globals, so their operands recover the song
+# section bounds relocation-tolerantly (see ``_recover_section_bounds``).
+CPX_ABS = 0xEC
+LDX_ABS = 0xAE
+
+# --- Data-region table geometry (byte offsets from the data base) -----------
+# The per-tune data region is a run of page-aligned split (lo/hi) pointer and
+# transpose tables indexed by the section number, followed by the instrument
+# records. Layout mirrors the Only_3 map ($A000 base) from the architecture doc.
+PAGE = 0x100
+V0_PTR_LO = 0x000
+V0_PTR_HI = 0x100
+V0_XPOSE = 0x200
+V0_XPOSE2 = 0x300
+V1_PTR_LO = 0x400
+V1_PTR_HI = 0x500
+V1_XPOSE = 0x600
+V1_XPOSE2 = 0x700
+V2_PTR_LO = 0x800
+V2_PTR_HI = 0x900
+V2_XPOSE = 0xA00
+V2_XPOSE2 = 0xB00
+SECTION_HEADER_PTR_LO = 0xC00
+SECTION_HEADER_PTR_HI = 0xD00
+INSTRUMENTS = 0xE00
+
+# Per-voice (stream-ptr-lo, stream-ptr-hi, transpose) page offsets, voice order.
+VOICE_PTR_LO = (V0_PTR_LO, V1_PTR_LO, V2_PTR_LO)
+VOICE_PTR_HI = (V0_PTR_HI, V1_PTR_HI, V2_PTR_HI)
+VOICE_XPOSE = (V0_XPOSE, V1_XPOSE, V2_XPOSE)
+
+# Pages that must all be present for a run of pages to be the data region.
+BASE_PROBE_OFFSETS = (V0_PTR_LO, V1_PTR_LO, V2_PTR_LO, SECTION_HEADER_PTR_LO)
+
+# --- Instrument records -----------------------------------------------------
+INSTRUMENT_STRIDE = 24  # record spacing: 16 record bytes + 8-byte filter tail
+INSTRUMENT_RECORD_LEN = 16
+FILTER_TAIL_LEN = 8
+# record[16] doubles as the filter-tail vol/mode byte and the "no tail" marker.
+FILTER_MARKER = 16
+NO_FILTER_TAIL = 0xFF
+MAX_INSTRUMENTS = INSTRUMENT_STRIDE  # ctrl low-nibble + base can reach this many
+
+# 16-byte instrument record field offsets (architecture doc record map).
+INST_CTRL_GATE = 0  # key-on CTRL (waveform + gate)
+INST_AD = 1
+INST_SR = 2
+INST_GLIDE_RATE_LO = 3
+INST_PW = 4  # lo-nibble<<4 -> PW lo, hi-nibble -> PW hi
+INST_PW_UP_DWELL = 5
+INST_PW_DOWN_DWELL = 6
+INST_PW_STEP = 7
+INST_SUSTAIN_CTRL = 8  # re-emitted on a rest (gate off)
+INST_MODE = 9  # bit5 abs/PW-up-suppress, bit4 PW-sweep enable, bits0/1 glide mode
+INST_GLIDE_ENABLE = 10
+INST_GLIDE_RATE_HI = 11
+INST_VIB_DEPTH = 12
+INST_VIB_PERIOD = 13  # &$7F half-period, bit7 direction
+INST_VIB_DELAY = 14
+INST_DETUNE = 15
+
+# 8-byte filter tail field offsets (relative to the tail start = record[16]).
+FT_VOL_MODE = 0
+FT_RES_FILT = 1  # -> $D417
+FT_CUTOFF_HI = 2  # cutoff-hi seed
+FT_UP_DWELL = 3
+FT_DOWN_DWELL = 4
+FT_STEP = 5
+FT_BOUND = 6
+FT_FLAGS = 7  # per-voice init/reload/reinit/ping-pong bits
+
+# --- Section header ---------------------------------------------------------
+SH_LATCH_LO = 0  # CIA Timer-A latch lo (play-cadence source)
+SH_LATCH_HI = 1
+SH_TEMPO = 2  # tempo divider reload
+SH_PATLEN = 3  # pattern length / row loop
+SH_VOL_RAMP = 4  # volume-ramp config ($FF = none)
+SH_BASE_VOL = 5  # steady base-volume nibble
+SH_ARP_TABLE = 6  # start of the 8-entry arp-note table
+ARP_TABLE_LEN = 8
+SECTION_HEADER_LEN = SH_ARP_TABLE + ARP_TABLE_LEN
+
+# --- Pattern rows (per voice, per section: flat 2-byte [note][ctrl] rows) ----
+ROW_LEN = 2
+NOTE_REST = 0x00  # re-emit the saved sustain ctrl
+NOTE_TIE = 0x80  # leave the voice untouched (legato hold)
+NOTE_TRIGGER = 0x80  # note bit7: new-note key-on trigger
+NOTE_INDEX_MASK = 0x7F  # note bits0-6: freq-table index
+CTRL_INSTR_MASK = 0x0F  # ctrl bits0-3: instrument index
+CTRL_PORTAMENTO = 0x10  # ctrl bit4: keep old freq (slide)
+CTRL_ABSOLUTE = 0x20  # ctrl bit5: skip the section transpose
+CTRL_ARP_ENABLE = 0x40  # ctrl bit6: enable the arp/glide-target chain
+CTRL_INSTR_BASE = 0x80  # ctrl bit7 clear: add the per-section instrument base
+
+# Cap on rows/sections walked, so a malformed image cannot loop unboundedly.
+MAX_SECTIONS = 256
+MAX_PATTERN_LEN = 256
+
+# --- Note-frequency tables --------------------------------------------------
+# Two parallel u8 tables (freq hi, then freq lo) of one entry per semitone; the
+# hi table is an octave ramp (non-decreasing, doubling per octave). The lo table
+# starts exactly ``NOTE_FREQ_LEN`` bytes after the hi table (the two tables abut,
+# and the player reads ``LDA NoteFreqHi,X`` / ``LDA NoteFreqLo,X`` -- adjacent
+# absolute-indexed operands whose difference IS the table length). On real HVSC
+# tunes the tables are 95 entries (the hi ramp climbs 01..f8 over indices 0..94).
+NOTE_FREQ_LEN = 95
+# Candidate table lengths tried (largest valid wins) when the pair is located
+# from the player's paired ``LDA`` operands.
+NOTE_FREQ_LENGTHS = (96, 95)
+# Content signature used to validate a candidate hi table.
+NOTE_FREQ_HI_START_MAX = 0x04  # first hi byte is small (low octave)
+NOTE_FREQ_HI_END_MIN = 0x20  # last hi byte has climbed into the high octaves
+NOTE_FREQ_MIN_STEPS = 6  # at least this many upward steps across the ramp

pysoundmonitor/errors.py

@@ -0,0 +1,11 @@
+"""Exceptions for pysoundmonitor."""
+
+from pysidtracker import SidError
+
+
+class SoundMonitorError(SidError):
+    """Base error for all pysoundmonitor failures."""
+
+
+class SidParseError(SoundMonitorError):
+    """A SID/PRG image could not be parsed as a Soundmonitor tune."""

pysoundmonitor/model.py

@@ -0,0 +1,206 @@
+"""Dataclass model of a decoded Soundmonitor song.
+
+The song is a *section sequence*; each section carries a CIA play cadence, a
+tempo, an arp table, and three per-voice ``[note][ctrl]`` pattern streams. New-
+note rows reference a 16-byte instrument record (optionally trailed by an 8-byte
+global-filter tail). See ``docs/format.md`` for the layout narrative.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+from . import constants as c
+
+
+@dataclass
+class Row:
+    """One decoded pattern row (``note`` byte + ``ctrl`` byte)."""
+
+    note: int
+    ctrl: int
+    is_rest: bool
+    is_tie: bool
+    trigger: bool
+    freq_index: int
+    instrument: int
+    portamento: bool
+    absolute: bool
+    arp_enable: bool
+    instrument_base: bool
+
+    @classmethod
+    def decode(cls, note: int, ctrl: int) -> "Row":
+        """Decode a raw ``(note, ctrl)`` pair per the documented row encoding."""
+        is_rest = note == c.NOTE_REST
+        is_tie = note == c.NOTE_TIE
+        # A tie is note==$80: bit7 set with a zero index; it is a hold, not a
+        # key-on. A rest is note==$00. Any other value is a real note.
+        trigger = bool(note & c.NOTE_TRIGGER) and not is_tie
+        return cls(
+            note=note,
+            ctrl=ctrl,
+            is_rest=is_rest,
+            is_tie=is_tie,
+            trigger=trigger,
+            freq_index=note & c.NOTE_INDEX_MASK,
+            instrument=ctrl & c.CTRL_INSTR_MASK,
+            portamento=bool(ctrl & c.CTRL_PORTAMENTO),
+            absolute=bool(ctrl & c.CTRL_ABSOLUTE),
+            arp_enable=bool(ctrl & c.CTRL_ARP_ENABLE),
+            instrument_base=not ctrl & c.CTRL_INSTR_BASE,
+        )
+
+
+@dataclass
+class FilterTail:
+    """The optional 8-byte global-filter tail of an instrument record."""
+
+    vol_mode: int
+    res_filt: int
+    cutoff_hi: int
+    up_dwell: int
+    down_dwell: int
+    step: int
+    bound: int
+    flags: int
+    raw: bytes
+
+    @classmethod
+    def from_bytes(cls, tail: bytes) -> "FilterTail":
+        """Decode an 8-byte filter tail."""
+        return cls(
+            vol_mode=tail[c.FT_VOL_MODE],
+            res_filt=tail[c.FT_RES_FILT],
+            cutoff_hi=tail[c.FT_CUTOFF_HI],
+            up_dwell=tail[c.FT_UP_DWELL],
+            down_dwell=tail[c.FT_DOWN_DWELL],
+            step=tail[c.FT_STEP],
+            bound=tail[c.FT_BOUND],
+            flags=tail[c.FT_FLAGS],
+            raw=bytes(tail),
+        )
+
+
+@dataclass
+class Instrument:
+    """A decoded 16-byte instrument record (+ optional filter tail)."""
+
+    index: int
+    ctrl_gate: int
+    ad: int
+    sr: int
+    glide_rate_lo: int
+    pw: int
+    pw_up_dwell: int
+    pw_down_dwell: int
+    pw_step: int
+    sustain_ctrl: int
+    mode: int
+    glide_enable: int
+    glide_rate_hi: int
+    vib_depth: int
+    vib_period: int
+    vib_delay: int
+    detune: int
+    raw: bytes
+    filter: Optional[FilterTail] = None
+
+    @property
+    def pw_lo(self) -> int:
+        """Seeded pulse-width low byte (``(pw & $0F) << 4``)."""
+        return (self.pw & 0x0F) << 4
+
+    @property
+    def pw_hi(self) -> int:
+        """Seeded pulse-width high nibble (``pw >> 4``)."""
+        return self.pw >> 4
+
+    @classmethod
+    def from_record(cls, index: int, record: bytes) -> "Instrument":
+        """Decode a record of at least 16 bytes (24 with a filter tail).
+
+        The tail is present when the marker byte ``record[16]`` is not ``$FF``
+        and the buffer carries the 8 trailing bytes.
+        """
+        tail = None
+        if (
+            len(record) >= c.FILTER_MARKER + c.FILTER_TAIL_LEN
+            and record[c.FILTER_MARKER] != c.NO_FILTER_TAIL
+        ):
+            tail = FilterTail.from_bytes(
+                record[c.FILTER_MARKER : c.FILTER_MARKER + c.FILTER_TAIL_LEN]
+            )
+        return cls(
+            index=index,
+            ctrl_gate=record[c.INST_CTRL_GATE],
+            ad=record[c.INST_AD],
+            sr=record[c.INST_SR],
+            glide_rate_lo=record[c.INST_GLIDE_RATE_LO],
+            pw=record[c.INST_PW],
+            pw_up_dwell=record[c.INST_PW_UP_DWELL],
+            pw_down_dwell=record[c.INST_PW_DOWN_DWELL],
+            pw_step=record[c.INST_PW_STEP],
+            sustain_ctrl=record[c.INST_SUSTAIN_CTRL],
+            mode=record[c.INST_MODE],
+            glide_enable=record[c.INST_GLIDE_ENABLE],
+            glide_rate_hi=record[c.INST_GLIDE_RATE_HI],
+            vib_depth=record[c.INST_VIB_DEPTH],
+            vib_period=record[c.INST_VIB_PERIOD],
+            vib_delay=record[c.INST_VIB_DELAY],
+            detune=record[c.INST_DETUNE],
+            raw=bytes(record[: c.INSTRUMENT_RECORD_LEN]),
+            filter=tail,
+        )
+
+
+@dataclass
+class Section:
+    """One song-step: cadence + tempo + arp table + three voice streams."""
+
+    index: int
+    header_addr: int
+    cia_latch: int
+    tempo: int
+    pattern_length: int
+    vol_ramp: int
+    base_volume: int
+    arp_table: Tuple[int, ...]
+    transpose: Tuple[int, int, int]
+    voices: List[List[Row]]
+
+    @property
+    def cadence(self) -> int:
+        """Play period in CPU cycles per call (``CIA latch + 1``)."""
+        return self.cia_latch + 1
+
+
+@dataclass
+class NoteFreqTable:
+    """The parallel note-frequency hi/lo tables (one entry per semitone)."""
+
+    hi: List[int]
+    lo: List[int]
+    addr: Optional[int] = None
+
+    def freq(self, index: int) -> int:
+        """16-bit SID frequency for semitone ``index``."""
+        return (self.hi[index] << 8) | self.lo[index]
+
+
+@dataclass
+class Song:
+    """A decoded Soundmonitor tune."""
+
+    base: int
+    player_anchor: int
+    header: object = None
+    sections: List[Section] = field(default_factory=list)
+    instruments: List[Instrument] = field(default_factory=list)
+    note_freq: Optional[NoteFreqTable] = None
+
+    @property
+    def cia_latch(self) -> Optional[int]:
+        """CIA latch of the first section (the initial play cadence)."""
+        return self.sections[0].cia_latch if self.sections else None

pysoundmonitor/reader.py

@@ -0,0 +1,384 @@
+"""Decode a Soundmonitor ``.sid``/``.prg`` image into a :class:`Song`.
+
+The player is relocatable and the SID-header addresses are not a reliable
+locator, so the song data is found *relocation- and build-tolerantly* from the
+player's own code operands: the engine is recognised by its CIA section-loader
+fingerprint or its note-frequency tables, the data-region base page comes from
+the loader's table-indexing operands, the section bounds from the section-advance
+``CPX``/``LDX`` operands, and the note-freq tables from the paired ``LDA`` reads.
+A packed/relocating tune is unpacked by emulating its init first. The documented
+structures are then decoded into the model; this is a song-data reader, not a
+playback engine.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Set
+
+import numpy as np
+
+from pysidtracker import SidImage, read_bytes
+
+from . import constants as c
+from .errors import SidParseError
+from .model import Instrument, NoteFreqTable, Row, Section, Song
+
+
+def _operand_targets(image: SidImage, opcode: int) -> Dict[int, int]:
+    """Map every absolute operand of ``opcode`` in the image to its first site.
+
+    An absolute-addressed 6502 instruction is ``opcode lo hi``; this returns
+    ``{lo | hi<<8: site_address}`` for every occurrence, letting a relocatable
+    player's own table/global addresses be recovered from its code operands.
+    """
+    mem = np.frombuffer(bytes(image.mem), dtype=np.uint8)
+    sites = np.nonzero(mem[:-2] == opcode)[0]
+    targets: Dict[int, int] = {}
+    for site in sites.tolist():
+        target = int(mem[site + 1]) | (int(mem[site + 2]) << 8)
+        targets.setdefault(target, site)
+    return targets
+
+
+def find_cia_fingerprint(image: SidImage) -> Optional[int]:
+    """Address of the CIA-timer section-loader fingerprint, or ``None``.
+
+    Matches the relocation-invariant ``STA $DC04 ... CMP #$06 ... STA $DC05``
+    sequence (writes to fixed hardware registers). Present in the CIA-timed
+    builds ($C000 Hulsbeck / $1000); absent in the fixed-cadence builds, which
+    are recognised by their note-freq tables instead.
+    """
+    span = len(c.STA_DC04) + c.FINGERPRINT_WINDOW
+    for pos in image.find_all(c.STA_DC04):
+        window = image.slice(pos, min(span, len(image.mem) - pos))
+        hi = window.find(c.STA_DC05, len(c.STA_DC04))
+        if hi < 0:
+            continue
+        guard = window.find(c.CMP_06, len(c.STA_DC04))
+        if 0 <= guard < hi:
+            return pos
+    return None
+
+
+def find_fingerprint(image: SidImage) -> Optional[int]:
+    """Address of the Soundmonitor engine, or ``None`` -- build-tolerant.
+
+    Returns the CIA section-loader fingerprint when present (the CIA-timed
+    builds), else the note-frequency hi-table address (the fixed-cadence
+    builds carry the same octave-ramp tables, read via paired ``LDA`` operands).
+    Either is a truthy relocation-tolerant anchor for :meth:`detect`.
+    """
+    cia = find_cia_fingerprint(image)
+    if cia is not None:
+        return cia
+    freq = _find_note_freq_addr(image)
+    if freq is not None:
+        return freq
+    return None
+
+
+def _base_candidates(image: SidImage) -> List[int]:
+    """Candidate data-region base addresses from the loader's table operands.
+
+    The section loader reads the split pointer tables with ``LDA $pp00,X``; a
+    base page is any ``$pp00`` operand whose voice/section-header lo tables are
+    all present. A relocated image can present a run of consecutive candidate
+    pages; the caller disambiguates by which one actually decodes sections.
+    """
+    pages: Set[int] = set()
+    for target in _operand_targets(image, c.LDA_ABSX):
+        if target & 0xFF == 0x00:
+            pages.add(target >> 8)
+    probe_pages = {off >> 8 for off in c.BASE_PROBE_OFFSETS}
+    return [
+        page << 8
+        for page in sorted(pages)
+        if all((page + rel) in pages for rel in probe_pages)
+    ]
+
+
+def _bounds_candidates(image: SidImage) -> List[tuple]:
+    """Candidate ``(sec_start, sec_last)`` pairs from the section-advance code.
+
+    ``SUB_c940`` does ``CPX sec_last`` then, on wrap, ``LDX sec_start``; the two
+    globals are adjacent (``sec_last`` at ``A``, ``sec_start`` at ``A+1``), so a
+    ``CPX $A`` whose neighbour ``$A+1`` is an ``LDX`` operand pins the bounds.
+    ``sec_start`` may exceed ``sec_last`` (the section counter wraps mod 256).
+    """
+    cpx = _operand_targets(image, c.CPX_ABS)
+    ldx = _operand_targets(image, c.LDX_ABS)
+    out: List[tuple] = []
+    for last_addr in sorted(cpx):
+        if last_addr + 1 in ldx:
+            out.append((image.peek(last_addr + 1), image.peek(last_addr)))
+    return out
+
+
+def _section_span(start: int, last: int) -> List[int]:
+    """Section indices from ``start`` up to ``last`` inclusive, wrapping mod 256."""
+    count = ((last - start) & 0xFF) + 1
+    return [(start + k) & 0xFF for k in range(count)]
+
+
+def _section_ok(image: SidImage, base: int, index: int) -> bool:
+    """Cheap validity probe: header + all voice stream pointers land in-image."""
+    header = image.ptr(
+        base + c.SECTION_HEADER_PTR_LO, base + c.SECTION_HEADER_PTR_HI, index
+    )
+    if not _in_image(image, header):
+        return False
+    patlen = image.peek(header + c.SH_PATLEN)
+    if patlen == 0 or patlen > c.MAX_PATTERN_LEN:
+        return False
+    for voice in range(3):
+        stream = image.ptr(
+            base + c.VOICE_PTR_LO[voice], base + c.VOICE_PTR_HI[voice], index
+        )
+        if not _in_image(image, stream):
+            return False
+    return True
+
+
+def _count_sections(image: SidImage, base: int, start: int, last: int) -> int:
+    """Valid sections decodable from ``start`` to ``last`` (stops at first bad)."""
+    count = 0
+    for index in _section_span(start, last):
+        if not _section_ok(image, base, index):
+            break
+        count += 1
+    return count
+
+
+def _plan(image: SidImage) -> tuple:
+    """Choose ``(base, start, last, count)`` that decodes the most valid sections.
+
+    Enumerates the operand-recovered base and section-bound candidates (falling
+    back to the load page and a full walk) and picks the combination yielding the
+    largest bounded run of valid sections -- robust to base ambiguity and to the
+    relocation-dependent player globals that a blind walk would run into garbage.
+    """
+    bases = _base_candidates(image) or [image.load & 0xFF00]
+    bounds = _bounds_candidates(image) or [(0, c.MAX_SECTIONS - 1)]
+    best = (bases[0], bounds[0][0], bounds[0][1], -1)
+    for base in bases:
+        for start, last in bounds:
+            count = _count_sections(image, base, start, last)
+            if count > best[3]:
+                best = (base, start, last, count)
+    return best
+
+
+def _recover_base(image: SidImage) -> int:
+    """The chosen data-region base address (see :func:`_plan`)."""
+    return _plan(image)[0]
+
+
+def _in_image(image: SidImage, addr: int) -> bool:
+    return image.load <= addr < image.end
+
+
+def _decode_stream(image: SidImage, addr: int, rows: int) -> List[Row]:
+    out: List[Row] = []
+    rows = min(rows, c.MAX_PATTERN_LEN)
+    for row in range(rows):
+        base = addr + row * c.ROW_LEN
+        out.append(Row.decode(image.peek(base), image.peek(base + 1)))
+    return out
+
+
+def _decode_section(image: SidImage, base: int, index: int) -> Optional[Section]:
+    header = image.ptr(
+        base + c.SECTION_HEADER_PTR_LO, base + c.SECTION_HEADER_PTR_HI, index
+    )
+    if not _in_image(image, header):
+        return None
+    patlen = image.peek(header + c.SH_PATLEN)
+    if patlen == 0 or patlen > c.MAX_PATTERN_LEN:
+        return None
+    latch = image.peek(header + c.SH_LATCH_LO) | (
+        image.peek(header + c.SH_LATCH_HI) << 8
+    )
+    arp = tuple(image.peek(header + c.SH_ARP_TABLE + i) for i in range(c.ARP_TABLE_LEN))
+    voices: List[List[Row]] = []
+    transpose = []
+    for voice in range(3):
+        stream = image.ptr(
+            base + c.VOICE_PTR_LO[voice], base + c.VOICE_PTR_HI[voice], index
+        )
+        if not _in_image(image, stream):
+            return None
+        voices.append(_decode_stream(image, stream, patlen))
+        transpose.append(image.peek(base + c.VOICE_XPOSE[voice] + index))
+    return Section(
+        index=index,
+        header_addr=header,
+        cia_latch=latch,
+        tempo=image.peek(header + c.SH_TEMPO),
+        pattern_length=patlen,
+        vol_ramp=image.peek(header + c.SH_VOL_RAMP),
+        base_volume=image.peek(header + c.SH_BASE_VOL),
+        arp_table=arp,
+        transpose=(transpose[0], transpose[1], transpose[2]),
+        voices=voices,
+    )
+
+
+def _decode_sections(
+    image: SidImage, base: int, start: int, last: int
+) -> List[Section]:
+    """Decode the song's sections over ``start..last`` (inclusive, wrapping).
+
+    Stops at the first invalid section. ``base`` and the ``(start, last)`` bounds
+    come from :func:`_plan`, which recovers them from the player's own operands
+    (so a bounded, correct set is decoded rather than walking a relocation-
+    dependent table into garbage and hitting the 256 cap).
+    """
+    sections: List[Section] = []
+    for index in _section_span(start, last):
+        section = _decode_section(image, base, index)
+        if section is None:
+            break
+        sections.append(section)
+    return sections
+
+
+def _instrument_indices(sections: List[Section]) -> List[int]:
+    used: Set[int] = set()
+    for section in sections:
+        for voice in section.voices:
+            for row in voice:
+                if row.trigger:
+                    used.add(row.instrument)
+    return sorted(used)
+
+
+def _decode_instruments(
+    image: SidImage, base: int, indices: List[int]
+) -> List[Instrument]:
+    out: List[Instrument] = []
+    table = base + c.INSTRUMENTS
+    for index in indices:
+        addr = table + index * c.INSTRUMENT_STRIDE
+        if not _in_image(image, addr):
+            continue
+        record = image.slice(addr, c.INSTRUMENT_STRIDE)
+        out.append(Instrument.from_record(index, record))
+    return out
+
+
+def decode_note_freq(
+    image: SidImage, addr: int, length: int = c.NOTE_FREQ_LEN
+) -> NoteFreqTable:
+    """Decode the parallel hi/lo note-frequency tables at ``addr``."""
+    hi = list(image.slice(addr, length))
+    lo = list(image.slice(addr + length, length))
+    return NoteFreqTable(hi=hi, lo=lo, addr=addr)
+
+
+def _valid_freq_hi(image: SidImage, addr: int, length: int) -> bool:
+    """Is ``[addr, addr+length)`` a valid note-freq hi octave ramp?"""
+    if addr < 0 or addr + length > len(image.mem):
+        return False
+    hi = np.frombuffer(image.slice(addr, length), dtype=np.uint8).astype(np.int16)
+    if hi[0] == 0 or hi[0] > c.NOTE_FREQ_HI_START_MAX:
+        return False
+    if hi[-1] < c.NOTE_FREQ_HI_END_MIN:
+        return False
+    diffs = np.diff(hi)
+    if not bool((diffs >= 0).all()):
+        return False
+    return int((diffs > 0).sum()) >= c.NOTE_FREQ_MIN_STEPS
+
+
+def _find_note_freq(image: SidImage) -> Optional[tuple]:
+    """Locate the note-freq tables from the player's paired ``LDA`` operands.
+
+    The player reads ``LDA NoteFreqHi,X`` and ``LDA NoteFreqLo,X``; the two
+    absolute-indexed operands abut (``lo = hi + length``), so a pair of
+    ``LDA abs,X`` targets that differ by a candidate table length and whose hi
+    table is a valid octave ramp pins the tables regardless of relocation.
+    Returns ``(hi_addr, length)`` or ``None``.
+    """
+    targets = set(_operand_targets(image, c.LDA_ABSX))
+    for hi_addr in sorted(targets):
+        for length in c.NOTE_FREQ_LENGTHS:
+            if hi_addr + length not in targets:
+                continue
+            if _valid_freq_hi(image, hi_addr, length):
+                return (hi_addr, length)
+    return None
+
+
+def _find_note_freq_addr(image: SidImage) -> Optional[int]:
+    found = _find_note_freq(image)
+    return found[0] if found is not None else None
+
+
+def locate_note_freq(image: SidImage) -> Optional[NoteFreqTable]:
+    """Locate and decode the note-frequency tables, or ``None``.
+
+    Uses the relocation-tolerant paired-operand locator (:func:`_find_note_freq`);
+    returns ``None`` only when the player carries no such table pair.
+    """
+    found = _find_note_freq(image)
+    if found is None:
+        return None
+    hi_addr, length = found
+    return decode_note_freq(image, hi_addr, length)
+
+
+def _run_init(image: SidImage) -> bool:
+    """Emulate the tune's init so a packed/relocating player lands in memory.
+
+    Returns ``True`` if init ran. A no-op (returns ``False``) for a bare ``.prg``
+    with no header, or when the optional emulator dependency is unavailable.
+    """
+    if image.header is None:
+        return False
+    try:
+        from pysidtracker import run_init
+        from pysidtracker.image import MEM_SIZE
+
+        run_init(image)
+        image.end = MEM_SIZE
+        return True
+    except SidParseError:
+        return False
+
+
+def parse(data: bytes) -> Song:
+    """Decode raw ``.sid``/``.prg`` ``data`` into a :class:`Song`.
+
+    Recognises the engine build-tolerantly (CIA-timed or fixed-cadence). A
+    packed/relocating tune only exposes its player and song tables after its init
+    routine has moved/decompressed them, so init is emulated and decoding retried
+    whenever the engine is absent or no section decodes in the directly loaded
+    image. Raises :class:`SidParseError` if the engine is not found either way.
+    """
+    image = SidImage.from_bytes(data)
+    anchor = find_fingerprint(image)
+    plan = _plan(image) if anchor is not None else None
+    if (anchor is None or plan[3] <= 0) and _run_init(image):
+        retry = find_fingerprint(image)
+        if retry is not None:
+            anchor = retry
+        plan = _plan(image)
+    if anchor is None:
+        raise SidParseError("Soundmonitor engine fingerprint not found in image")
+    base, start, last, _count = plan
+    sections = _decode_sections(image, base, start, last)
+    instruments = _decode_instruments(image, base, _instrument_indices(sections))
+    note_freq = locate_note_freq(image)
+    return Song(
+        base=base,
+        player_anchor=anchor,
+        header=image.header,
+        sections=sections,
+        instruments=instruments,
+        note_freq=note_freq,
+    )
+
+
+def read(src) -> Song:
+    """Read ``src`` (path, ``bytes``, or file-like) and :func:`parse` it."""
+    return parse(read_bytes(src))

pysoundmonitor/sidparser.py

@@ -0,0 +1,32 @@
+"""The :class:`~pysidtracker.BaseSidParser` implementation for Soundmonitor."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pysidtracker import BaseSidParser, SidImage
+
+from .errors import SidParseError
+from .model import Song
+from .reader import find_fingerprint, parse
+
+
+class SoundMonitorSidParser(BaseSidParser):
+    """Parse Soundmonitor tunes and recognise the engine for ``detect()``.
+
+    ``recognize`` returns the address of a tiny relocation-invariant fingerprint
+    (the CIA Timer-A latch programming in the section loader), so a directly
+    loaded tune classifies as :attr:`PlayroutineKind.DIRECT` and a
+    packed/relocated one as :attr:`PlayroutineKind.RELOCATED`/``PACKED`` after
+    the base library emulates its init.
+    """
+
+    error_class: type = SidParseError
+
+    def parse(self, data: bytes, **kwargs: Any) -> Song:
+        """Decode ``data`` into a :class:`~pysoundmonitor.model.Song`."""
+        return parse(data)
+
+    def recognize(self, image: SidImage) -> object:
+        """Return the fingerprint address if the engine is present, else ``None``."""
+        return find_fingerprint(image)

pysoundmonitor-0.1.0.dist-info/METADATA

@@ -0,0 +1,285 @@
+Metadata-Version: 2.4
+Name: pysoundmonitor
+Version: 0.1.0
+Summary: Pure-Python reader and detector for Soundmonitor (64'er / Hulsbeck) SID tunes
+Author: Josh Bailey
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
+Project-URL: Homepage, https://github.com/anarkiwi/pysoundmonitor
+Project-URL: Source, https://github.com/anarkiwi/pysoundmonitor
+Project-URL: Issues, https://github.com/anarkiwi/pysoundmonitor/issues
+Keywords: sid,c64,soundmonitor,hulsbeck,tracker,chiptune
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pysidtracker>=0.1
+Requires-Dist: numpy>=1.23
+Provides-Extra: emu
+Requires-Dist: pysidtracker[emu]; extra == "emu"
+Provides-Extra: dev
+Requires-Dist: black>=24; extra == "dev"
+Requires-Dist: py65>=1.1; extra == "dev"
+Requires-Dist: pylint>=3; extra == "dev"
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov>=4; extra == "dev"
+Requires-Dist: pytest-xdist>=3; extra == "dev"
+Dynamic: license-file
+
+# pysoundmonitor
+
+Pure-Python reader and detector for **Soundmonitor** (64'er / Chris Hulsbeck)
+SID tunes — HVSC tracker #6. Built on [`pysidtracker`](https://github.com/anarkiwi/pysidtracker).
+
+The Soundmonitor player is relocatable and the SID-header addresses are not a
+reliable locator, so the engine is found by a small relocation-invariant
+hardware-register fingerprint and the documented section→stream song data is
+decoded into a model. Scope is container/detection + a song-data reader, not a
+byte-exact playback engine.
+
+## Install
+
+```sh
+pip install pysoundmonitor
+```
+
+## Usage
+
+```python
+import pysoundmonitor as psm
+
+song = psm.read("tune.sid")            # or psm.parse(raw_bytes)
+print(song.cia_latch, len(song.sections), len(song.instruments))
+for section in song.sections:
+    print(section.cadence, section.tempo, section.pattern_length)
+
+# Relocation-tolerant detection (untrustworthy header):
+det = psm.SoundMonitorSidParser().detect("tune.sid")
+print(det.kind)          # DIRECT / RELOCATED / PACKED / UNKNOWN
+```
+
+## Development
+
+```sh
+pip install -e ".[dev]"
+pytest                    # offline synthetic fixtures
+python scripts/fetch_tunes.py   # cache the HVSC reference tune (never committed)
+```
+
+Test tunes are HVSC copyright works: fetched + cached on demand (gitignored),
+never committed.
+
+## Docs
+
+- [`docs/format.md`](docs/format.md) — Soundmonitor container, detection, and
+  song-data model.
+
+## License
+
+Apache-2.0.

pysoundmonitor-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pysoundmonitor/__init__.py,sha256=7rOwvmX9pIww9YXanaYAbN_fy0BLSN5p1LJDye5xEZs,994
+pysoundmonitor/constants.py,sha256=kXsspoW0ERIiCqvqEfk5FuO3f3KUiiYmHJJw7GWdjTQ,6488
+pysoundmonitor/errors.py,sha256=4rRSBZgRXAVmNkCXrX0bt5j92YKyx_XfqHKFLn72N88,275
+pysoundmonitor/model.py,sha256=PetCsvipqSzKQZNaikn1t64rnCTdp_KwVCyBsrJfcdk,6027
+pysoundmonitor/reader.py,sha256=6RTcQshu-gzcGgkghv-ugyir0DJ8mGca2E8XF9ZNuNE,14379
+pysoundmonitor/sidparser.py,sha256=AosS1OGoe7nLSp_55Dt_J9Dc__X8to-Z-BhVW_nKajY,1143
+pysoundmonitor-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pysoundmonitor-0.1.0.dist-info/METADATA,sha256=V3PfdHROJcF6NZl_LJXUowBEpFcD3cPWFQFzfOQVXpU,15732
+pysoundmonitor-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pysoundmonitor-0.1.0.dist-info/top_level.txt,sha256=q6FIHsUsEn7MI8HICcNZHDL_NZ3NjCZXdELgicqBCKo,15
+pysoundmonitor-0.1.0.dist-info/RECORD,,

pysoundmonitor-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pysoundmonitor-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pysoundmonitor-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pysoundmonitor