mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
279 lines
9.7 KiB
Python
279 lines
9.7 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
S3C Audio Shim for Sound Card Testing
|
|
Extracts S3C manifold processing from Lean for main machine sound card testing
|
|
"""
|
|
|
|
import numpy as np
|
|
import json
|
|
from dataclasses import dataclass
|
|
from typing import Optional, Tuple
|
|
import sys
|
|
|
|
# Try to import pyaudio for sound card testing
|
|
try:
|
|
import pyaudio
|
|
PYAUDIO_AVAILABLE = True
|
|
except ImportError:
|
|
PYAUDIO_AVAILABLE = False
|
|
print("Warning: pyaudio not available. Sound card testing disabled.")
|
|
print("Install with: pip install pyaudio")
|
|
|
|
@dataclass
|
|
class ShellCoords:
|
|
"""Shell coordinates for integer decomposition n = k^2 + a"""
|
|
k: int # Shell index (coarse handle)
|
|
a: int # Lower offset (medium handle)
|
|
b: int # Upper offset (fine handle)
|
|
mass: int # Intersection form a*b
|
|
width: int # Shell width = 2k+1 = a+b+1
|
|
|
|
@dataclass
|
|
class ManifoldHandle:
|
|
"""3-handle manifold structure for soundwave features"""
|
|
handleK: int # Coarse handle (amplitude envelope)
|
|
handleA: int # Medium handle (spectral content)
|
|
handleB: int # Fine handle (phase information)
|
|
|
|
@dataclass
|
|
class ThreePointContact:
|
|
"""3-point contact detection"""
|
|
kappaA: bool # Forward spectral prediction
|
|
kappaB: bool # Temporal midpoint
|
|
kappaC: bool # Backward phase correction
|
|
|
|
@dataclass
|
|
class JScore:
|
|
"""J-score interaction: J(n) = ab*F_m + (a-b)*F_p + <chi, F_c>"""
|
|
massResonance: int # ab*F_m
|
|
mirrorResonance: int # (a-b)*F_p
|
|
spectralCoupling: int # <chi, F_c>
|
|
total: int # J(n)
|
|
|
|
@dataclass
|
|
class S3CState:
|
|
"""S3C audio processing state"""
|
|
sample: int
|
|
handles: ManifoldHandle
|
|
contact: ThreePointContact
|
|
jScore: JScore
|
|
emit: bool
|
|
|
|
def shell_decomposition(n: int) -> ShellCoords:
|
|
"""Compute shell decomposition n = k^2 + a"""
|
|
k = int(np.sqrt(n))
|
|
k_sq = k * k
|
|
a = n - k_sq
|
|
k1_sq = (k + 1) * (k + 1)
|
|
b = k1_sq - n
|
|
mass = a * b
|
|
width = a + b + 1
|
|
return ShellCoords(k=k, a=a, b=b, mass=mass, width=width)
|
|
|
|
def audio_to_manifold(sample: int) -> ManifoldHandle:
|
|
"""Map audio sample to 3-handle manifold"""
|
|
coords = shell_decomposition(sample)
|
|
return ManifoldHandle(
|
|
handleK=coords.k,
|
|
handleA=coords.a,
|
|
handleB=coords.b
|
|
)
|
|
|
|
def detect_contact(handles: ManifoldHandle) -> ThreePointContact:
|
|
"""Detect 3-point contact from manifold handles"""
|
|
kappaA = handles.handleA > 0
|
|
kappaB = handles.handleK > 0
|
|
kappaC = handles.handleB > 0
|
|
return ThreePointContact(kappaA=kappaA, kappaB=kappaB, kappaC=kappaC)
|
|
|
|
def compute_j_score(handles: ManifoldHandle) -> JScore:
|
|
"""Compute J-score from manifold handles"""
|
|
massResonance = handles.handleA * handles.handleB # ab
|
|
mirrorResonance = abs(handles.handleA - handles.handleB) # |a-b|
|
|
spectralCoupling = handles.handleK # chi ~ k
|
|
total = massResonance + mirrorResonance + spectralCoupling
|
|
return JScore(
|
|
massResonance=massResonance,
|
|
mirrorResonance=mirrorResonance,
|
|
spectralCoupling=spectralCoupling,
|
|
total=total
|
|
)
|
|
|
|
def emission_gate(contact: ThreePointContact, jScore: JScore) -> bool:
|
|
"""Emission gate: emit only if kappa_A AND kappa_C AND J > 0"""
|
|
return contact.kappaA and contact.kappaC and jScore.total > 0
|
|
|
|
def process_audio_sample(sample: int) -> S3CState:
|
|
"""Process audio sample through S3C manifold"""
|
|
handles = audio_to_manifold(sample)
|
|
contact = detect_contact(handles)
|
|
jScore = compute_j_score(handles)
|
|
emit = emission_gate(contact, jScore)
|
|
return S3CState(
|
|
sample=sample,
|
|
handles=handles,
|
|
contact=contact,
|
|
jScore=jScore,
|
|
emit=emit
|
|
)
|
|
|
|
def progressive_binding_cost(n: int) -> float:
|
|
"""1/n progressive binding cost"""
|
|
if n == 0:
|
|
return 1.0
|
|
return 1.0 / n
|
|
|
|
def is_throat(handles: ManifoldHandle) -> bool:
|
|
"""Throat blending at a = b (shell midpoint)"""
|
|
return handles.handleA == handles.handleB
|
|
|
|
class S3CAudioProcessor:
|
|
"""S3C audio processor for sound card testing"""
|
|
|
|
def __init__(self, sample_rate: int = 44100, chunk_size: int = 1024):
|
|
if not PYAUDIO_AVAILABLE:
|
|
raise RuntimeError("pyaudio not available. Install with: pip install pyaudio")
|
|
self.sample_rate = sample_rate
|
|
self.chunk_size = chunk_size
|
|
self.paudio = pyaudio.PyAudio()
|
|
self.stream = None
|
|
self.emitted_count = 0
|
|
self.total_count = 0
|
|
|
|
def start_input(self):
|
|
"""Start audio input stream"""
|
|
self.stream = self.paudio.open(
|
|
format=pyaudio.paInt16,
|
|
channels=1,
|
|
rate=self.sample_rate,
|
|
input=True,
|
|
frames_per_buffer=self.chunk_size
|
|
)
|
|
|
|
def stop(self):
|
|
"""Stop audio stream"""
|
|
if self.stream:
|
|
self.stream.stop_stream()
|
|
self.stream.close()
|
|
self.paudio.terminate()
|
|
|
|
def process_chunk(self, chunk: np.ndarray) -> list:
|
|
"""Process audio chunk through S3C manifold"""
|
|
results = []
|
|
for sample in chunk:
|
|
# Convert 16-bit signed to unsigned
|
|
unsigned_sample = int(sample) + 32768
|
|
state = process_audio_sample(unsigned_sample)
|
|
results.append(state)
|
|
self.total_count += 1
|
|
if state.emit:
|
|
self.emitted_count += 1
|
|
return results
|
|
|
|
def get_emission_rate(self) -> float:
|
|
"""Get emission rate"""
|
|
if self.total_count == 0:
|
|
return 0.0
|
|
return self.emitted_count / self.total_count
|
|
|
|
def process_audio_stream(self, duration_seconds: float = 5.0) -> dict:
|
|
"""Process audio stream for specified duration"""
|
|
self.start_input()
|
|
|
|
results = []
|
|
try:
|
|
chunks = int(self.sample_rate * duration_seconds / self.chunk_size)
|
|
for i in range(chunks):
|
|
data = self.stream.read(self.chunk_size)
|
|
chunk = np.frombuffer(data, dtype=np.int16)
|
|
chunk_results = self.process_chunk(chunk)
|
|
results.extend(chunk_results)
|
|
|
|
# Print progress
|
|
if i % 10 == 0:
|
|
print(f"Processed chunk {i}/{chunks}, emission rate: {self.get_emission_rate():.3f}")
|
|
|
|
finally:
|
|
self.stop()
|
|
|
|
return {
|
|
'total_samples': self.total_count,
|
|
'emitted_samples': self.emitted_count,
|
|
'emission_rate': self.get_emission_rate(),
|
|
'results': results[:100] # Return first 100 results for analysis
|
|
}
|
|
|
|
def main():
|
|
"""Main entry point for S3C audio testing"""
|
|
print("S3C Audio Processor - Sound Card Testing")
|
|
print("=" * 50)
|
|
|
|
# Test with synthetic data first
|
|
print("\nTesting with synthetic audio samples...")
|
|
test_samples = [100, 256, 1000, 5000, 10000]
|
|
for sample in test_samples:
|
|
state = process_audio_sample(sample)
|
|
print(f"Sample {sample}: k={state.handles.handleK}, a={state.handles.handleA}, b={state.handles.handleB}, "
|
|
f"mass={state.jScore.massResonance}, emit={state.emit}")
|
|
|
|
# Test with sound card if requested
|
|
if len(sys.argv) > 1 and sys.argv[1] == '--soundcard':
|
|
if not PYAUDIO_AVAILABLE:
|
|
print("\nError: pyaudio not available. Cannot test with sound card.")
|
|
print("Install with: pip install pyaudio")
|
|
sys.exit(1)
|
|
|
|
print("\nInitializing sound card...")
|
|
processor = S3CAudioProcessor(sample_rate=44100, chunk_size=1024)
|
|
|
|
print("Processing audio stream (5 seconds)...")
|
|
print("Speak or play audio to test S3C manifold processing...")
|
|
|
|
results = processor.process_audio_stream(duration_seconds=5.0)
|
|
|
|
print("\n" + "=" * 50)
|
|
print("Results:")
|
|
print(f"Total samples: {results['total_samples']}")
|
|
print(f"Emitted samples: {results['emitted_samples']}")
|
|
print(f"Emission rate: {results['emission_rate']:.3f}")
|
|
|
|
# Save results to JSON
|
|
with open('/home/allaun/Documents/Research Stack/data/s3c_audio_test_results.json', 'w') as f:
|
|
# Convert dataclasses to dicts for JSON serialization
|
|
serializable_results = []
|
|
for state in results['results']:
|
|
serializable_results.append({
|
|
'sample': state.sample,
|
|
'handles': {
|
|
'handleK': state.handles.handleK,
|
|
'handleA': state.handles.handleA,
|
|
'handleB': state.handles.handleB
|
|
},
|
|
'contact': {
|
|
'kappaA': state.contact.kappaA,
|
|
'kappaB': state.contact.kappaB,
|
|
'kappaC': state.contact.kappaC
|
|
},
|
|
'jScore': {
|
|
'massResonance': state.jScore.massResonance,
|
|
'mirrorResonance': state.jScore.mirrorResonance,
|
|
'spectralCoupling': state.jScore.spectralCoupling,
|
|
'total': state.jScore.total
|
|
},
|
|
'emit': state.emit
|
|
})
|
|
|
|
json.dump({
|
|
'total_samples': results['total_samples'],
|
|
'emitted_samples': results['emitted_samples'],
|
|
'emission_rate': results['emission_rate'],
|
|
'results': serializable_results
|
|
}, f, indent=2)
|
|
|
|
print(f"\nResults saved to /home/allaun/Documents/Research Stack/data/s3c_audio_test_results.json")
|
|
else:
|
|
print("\nTo test with sound card, run:")
|
|
print("python3 s3c_audio_shim.py --soundcard")
|
|
|
|
if __name__ == '__main__':
|
|
main()
|