This commit is contained in:
parent
6b517f6a46
commit
a6cd9632ee
@ -1,52 +0,0 @@
|
||||
# Audio Setup Guide for DryBox
|
||||
|
||||
## Installing PyAudio on Fedora
|
||||
|
||||
PyAudio requires system dependencies before installation:
|
||||
|
||||
```bash
|
||||
# Install required system packages
|
||||
sudo dnf install python3-devel portaudio-devel
|
||||
|
||||
# Then install PyAudio
|
||||
pip install pyaudio
|
||||
```
|
||||
|
||||
## Alternative: Run Without PyAudio
|
||||
|
||||
If you prefer not to install PyAudio, the application will still work but without real-time playback. You can still:
|
||||
- Record audio to files
|
||||
- Process and export audio
|
||||
- Use all other features
|
||||
|
||||
To run without PyAudio, the audio_player.py module will gracefully handle the missing dependency.
|
||||
|
||||
## Ubuntu/Debian Installation
|
||||
|
||||
```bash
|
||||
sudo apt-get install python3-dev portaudio19-dev
|
||||
pip install pyaudio
|
||||
```
|
||||
|
||||
## macOS Installation
|
||||
|
||||
```bash
|
||||
brew install portaudio
|
||||
pip install pyaudio
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
If you see "No module named 'pyaudio'" errors:
|
||||
1. The app will continue to work without playback
|
||||
2. Recording and processing features remain available
|
||||
3. Install PyAudio later when convenient
|
||||
|
||||
## Testing Audio Features
|
||||
|
||||
1. Run the application: `python UI/main.py`
|
||||
2. Start a call between phones
|
||||
3. Test features:
|
||||
- Recording: Works without PyAudio
|
||||
- Playback: Requires PyAudio
|
||||
- Processing: Works without PyAudio
|
||||
@ -1,118 +0,0 @@
|
||||
# Audio Testing Guide for DryBox
|
||||
|
||||
## Setup Verification
|
||||
|
||||
1. **Start the server first**:
|
||||
```bash
|
||||
python server.py
|
||||
```
|
||||
|
||||
2. **Run the UI**:
|
||||
```bash
|
||||
python UI/main.py
|
||||
```
|
||||
|
||||
## Testing Audio Playback
|
||||
|
||||
### Step 1: Test PyAudio is Working
|
||||
When you enable playback (Ctrl+1 or Ctrl+2), you should hear a short beep (100ms, 1kHz tone). This confirms:
|
||||
- PyAudio is properly installed
|
||||
- Audio output device is working
|
||||
- Stream format is correct
|
||||
|
||||
### Step 2: Test During Call
|
||||
1. Click "Run Automatic Test" or press Space
|
||||
2. **Immediately** enable playback on Phone 2 (Ctrl+2)
|
||||
- You should hear the test beep
|
||||
3. Watch the debug console for:
|
||||
- "Phone 2 playback started"
|
||||
- "Phone 2 sent test beep to verify audio"
|
||||
4. Wait for handshake to complete (steps 4-5 in test)
|
||||
5. Once voice session starts, you should see:
|
||||
- "Phone 2 received audio data: XXX bytes"
|
||||
- "Phone 2 forwarding audio to player"
|
||||
- "Client 1 playback thread got XXX bytes"
|
||||
|
||||
### What to Look For in Debug Console
|
||||
|
||||
**Good signs:**
|
||||
```
|
||||
[AudioPlayer] Client 1 add_audio_data called with 640 bytes
|
||||
[AudioPlayer] Client 1 added to buffer, queue size: 1
|
||||
[AudioPlayer] Client 1 playback thread got 640 bytes
|
||||
```
|
||||
|
||||
**Problem signs:**
|
||||
```
|
||||
[AudioPlayer] Client 1 has no buffer (playback not started?)
|
||||
Low confidence demodulation: 0.XX
|
||||
Codec decode returned None or empty
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### No Test Beep
|
||||
- Check system volume
|
||||
- Verify PyAudio: `python test_audio_setup.py`
|
||||
- Check audio device: `python -c "import pyaudio; p=pyaudio.PyAudio(); print(p.get_default_output_device_info())"`
|
||||
|
||||
### Test Beep Works but No Voice Audio
|
||||
1. **Check if audio is being transmitted:**
|
||||
- Phone 1 should show: "sent N voice frames"
|
||||
- Phone 2 should show: "Received voice data frame #N"
|
||||
|
||||
2. **Check if audio is being decoded:**
|
||||
- Look for: "Decoded PCM samples: type=<class 'numpy.ndarray'>, len=320"
|
||||
- Look for: "Emitting PCM bytes: 640 bytes"
|
||||
|
||||
3. **Check if audio reaches the player:**
|
||||
- Look for: "Phone 2 received audio data: 640 bytes"
|
||||
- Look for: "Client 1 add_audio_data called with 640 bytes"
|
||||
|
||||
### Audio Sounds Distorted
|
||||
This is normal! The system uses:
|
||||
- Codec2 at 1200bps (very low bitrate)
|
||||
- 4FSK modulation
|
||||
- This creates robotic/vocoder-like sound
|
||||
|
||||
### Manual Testing Commands
|
||||
|
||||
Test just the codec:
|
||||
```python
|
||||
python test_audio_pipeline.py
|
||||
```
|
||||
|
||||
Play the test outputs:
|
||||
```bash
|
||||
# Original
|
||||
aplay wav/input.wav
|
||||
|
||||
# Codec only (should sound robotic)
|
||||
aplay wav/test_codec_only.wav
|
||||
|
||||
# Full pipeline (codec + FSK)
|
||||
aplay wav/test_full_pipeline.wav
|
||||
```
|
||||
|
||||
## Expected Audio Flow
|
||||
|
||||
1. Phone 1 reads `wav/input.wav` (8kHz mono)
|
||||
2. Encodes 320 samples (40ms) with Codec2 → 6 bytes
|
||||
3. Modulates with 4FSK → ~1112 float samples
|
||||
4. Encrypts with Noise XK
|
||||
5. Sends to server
|
||||
6. Server routes to Phone 2
|
||||
7. Phone 2 decrypts with Noise XK
|
||||
8. Demodulates FSK → 6 bytes
|
||||
9. Decodes with Codec2 → 320 samples (640 bytes PCM)
|
||||
10. Sends to PyAudio for playback
|
||||
|
||||
## Recording Feature
|
||||
|
||||
To save received audio:
|
||||
1. Press Alt+1 or Alt+2 to start recording
|
||||
2. Let it run during the call
|
||||
3. Press again to stop and save
|
||||
4. Check `wav/` directory for saved files
|
||||
|
||||
This helps verify if audio is being received even if playback isn't working.
|
||||
@ -1,58 +0,0 @@
|
||||
# Phone 2 Playback - What It Actually Plays
|
||||
|
||||
## The Complete Audio Flow for Phone 2
|
||||
|
||||
When Phone 2 receives audio, it goes through this exact process:
|
||||
|
||||
### 1. Network Reception
|
||||
- Encrypted data arrives from server
|
||||
- Data includes Noise XK encrypted voice frames
|
||||
|
||||
### 2. Decryption (Noise XK)
|
||||
- `protocol_phone_client.py` line 156-165: Noise wrapper decrypts the data
|
||||
- Result: Decrypted voice message containing FSK modulated signal
|
||||
|
||||
### 3. Demodulation (4FSK)
|
||||
- `_handle_voice_data()` line 223: FSK demodulation
|
||||
- Converts modulated signal back to 6 bytes of compressed data
|
||||
- Only processes if confidence > 0.5
|
||||
|
||||
### 4. Decompression (Codec2 Decode)
|
||||
- Line 236: `pcm_samples = self.codec.decode(frame)`
|
||||
- Converts 6 bytes → 320 samples (640 bytes PCM)
|
||||
- This is the final audio ready for playback
|
||||
|
||||
### 5. Playback
|
||||
- Line 264: `self.data_received.emit(pcm_bytes, self.client_id)`
|
||||
- PCM audio sent to audio player
|
||||
- PyAudio plays the 16-bit, 8kHz mono audio
|
||||
|
||||
## What You Hear on Phone 2
|
||||
|
||||
Phone 2 plays audio that has been:
|
||||
- ✅ Encrypted → Decrypted (Noise XK)
|
||||
- ✅ Modulated → Demodulated (4FSK)
|
||||
- ✅ Compressed → Decompressed (Codec2)
|
||||
|
||||
The audio will sound:
|
||||
- **Robotic/Vocoder-like** due to 1200bps Codec2 compression
|
||||
- **Slightly delayed** due to processing pipeline
|
||||
- **But intelligible** - you can understand speech
|
||||
|
||||
## Fixed Issues
|
||||
|
||||
1. **Silent beginning**: Now skips first second of silence in input.wav
|
||||
2. **Control messages**: No longer sent to audio player
|
||||
3. **Debug spam**: Reduced to show only important frames
|
||||
|
||||
## Testing Phone 2 Playback
|
||||
|
||||
1. Run automatic test (Space)
|
||||
2. Enable Phone 2 playback (Ctrl+2)
|
||||
3. Wait for handshake to complete
|
||||
4. You should hear:
|
||||
- Audio starting from 1 second into input.wav
|
||||
- Processed through full protocol stack
|
||||
- Robotic but understandable audio
|
||||
|
||||
The key point: Phone 2 IS playing fully processed audio (decrypted + demodulated + decompressed)!
|
||||
@ -1,67 +0,0 @@
|
||||
# Fixed Audio Playback Guide
|
||||
|
||||
## How Playback Now Works
|
||||
|
||||
### Phone 1 (Sender) Playback
|
||||
- **What it plays**: Original audio from `input.wav` BEFORE encoding
|
||||
- **When to enable**: During a call to hear what you're sending
|
||||
- **Audio quality**: Clear, unprocessed 8kHz mono audio
|
||||
|
||||
### Phone 2 (Receiver) Playback
|
||||
- **What it plays**: Decoded audio AFTER the full pipeline (Codec2 → FSK → Noise XK → transmission → decryption → demodulation → decoding)
|
||||
- **When to enable**: During a call to hear what's being received
|
||||
- **Audio quality**: Robotic/vocoder sound due to 1200bps Codec2 compression
|
||||
|
||||
## Changes Made
|
||||
|
||||
1. **Fixed control message routing** - 8-byte control messages no longer sent to audio player
|
||||
2. **Phone 1 now plays original audio** when sending (before encoding)
|
||||
3. **Removed test beep** - you'll hear actual audio immediately
|
||||
4. **Added size filter** - only audio data (≥320 bytes) is processed
|
||||
|
||||
## Testing Steps
|
||||
|
||||
1. Start server: `python server.py`
|
||||
2. Start UI: `python UI/main.py`
|
||||
3. Run automatic test (Space key)
|
||||
4. **For Phone 1 playback**: Press Ctrl+1 to hear the original `input.wav` being sent
|
||||
5. **For Phone 2 playback**: Press Ctrl+2 to hear the decoded audio after transmission
|
||||
|
||||
## Expected Debug Output
|
||||
|
||||
**Good signs for Phone 1 (sender):**
|
||||
```
|
||||
Phone 1 playing original audio (sender playback)
|
||||
[AudioPlayer] Client 0 add_audio_data called with 640 bytes
|
||||
```
|
||||
|
||||
**Good signs for Phone 2 (receiver):**
|
||||
```
|
||||
Phone 2 received audio data: 640 bytes
|
||||
Phone 2 forwarding audio to player (playback enabled)
|
||||
[AudioPlayer] Client 1 add_audio_data called with 640 bytes
|
||||
```
|
||||
|
||||
**Fixed issues:**
|
||||
```
|
||||
Phone 2 received non-audio data: 8 bytes (ignoring) # Control messages now filtered out
|
||||
```
|
||||
|
||||
## Audio Quality Expectations
|
||||
|
||||
- **Phone 1**: Should sound identical to `input.wav`
|
||||
- **Phone 2**: Will sound robotic/compressed due to:
|
||||
- Codec2 compression at 1200bps (very low bitrate)
|
||||
- 4FSK modulation/demodulation
|
||||
- This is normal and proves the protocol is working!
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
If you still don't hear audio:
|
||||
|
||||
1. **Check debug console** for the messages above
|
||||
2. **Verify handshake completes** before expecting audio
|
||||
3. **Try recording** (Alt+1/2) to save audio for offline playback
|
||||
4. **Check system volume** and audio device
|
||||
|
||||
The most important fix: control messages are no longer sent to the audio player, so you should only receive actual 640-byte audio frames.
|
||||
@ -1,83 +0,0 @@
|
||||
# Audio Playback Implementation Summary
|
||||
|
||||
## Key Fixes Applied
|
||||
|
||||
### 1. Separated Sender vs Receiver Playback
|
||||
- **Phone 1 (Sender)**: Now plays the original `input.wav` audio when transmitting
|
||||
- **Phone 2 (Receiver)**: Plays the decoded audio after full protocol processing
|
||||
|
||||
### 2. Fixed Control Message Routing
|
||||
- Control messages (like "CALL_END" - 8 bytes) no longer sent to audio player
|
||||
- Added size filter: only data ≥320 bytes is considered audio
|
||||
- Removed problematic `data_received.emit()` for non-audio messages
|
||||
|
||||
### 3. Improved Debug Logging
|
||||
- Reduced verbosity: logs only first frame and every 25th frame
|
||||
- Clear indication of what's happening at each stage
|
||||
- Separate logging for sender vs receiver playback
|
||||
|
||||
### 4. Code Changes Made
|
||||
|
||||
**phone_manager.py**:
|
||||
- Added original audio playback for sender
|
||||
- Added size filter for received data
|
||||
- Improved debug logging with frame counters
|
||||
|
||||
**protocol_phone_client.py**:
|
||||
- Removed control message emission to data_received
|
||||
- Added confidence logging for demodulation
|
||||
- Reduced debug verbosity
|
||||
|
||||
**audio_player.py**:
|
||||
- Added frame counting for debug
|
||||
- Reduced playback thread logging
|
||||
- Better buffer status reporting
|
||||
|
||||
**main.py**:
|
||||
- Fixed lambda signal connection issue
|
||||
- Improved UI scaling with flexible layouts
|
||||
|
||||
## How to Test
|
||||
|
||||
1. Start server and UI
|
||||
2. Run automatic test (Space)
|
||||
3. Enable playback:
|
||||
- **Ctrl+1**: Hear original audio from Phone 1
|
||||
- **Ctrl+2**: Hear decoded audio on Phone 2
|
||||
|
||||
## Expected Behavior
|
||||
|
||||
**Phone 1 with playback enabled:**
|
||||
- Clear audio matching `input.wav`
|
||||
- Shows "playing original audio (sender playback)"
|
||||
|
||||
**Phone 2 with playback enabled:**
|
||||
- Robotic/compressed audio (normal for 1200bps)
|
||||
- Shows "received audio frame #N: 640 bytes"
|
||||
- No more "8 bytes" messages
|
||||
|
||||
## Audio Flow
|
||||
```
|
||||
Phone 1: Phone 2:
|
||||
input.wav (8kHz)
|
||||
↓
|
||||
[Playback here if enabled]
|
||||
↓
|
||||
Codec2 encode (1200bps)
|
||||
↓
|
||||
4FSK modulate
|
||||
↓
|
||||
Noise XK encrypt
|
||||
↓
|
||||
→ Network transmission →
|
||||
↓
|
||||
Noise XK decrypt
|
||||
↓
|
||||
4FSK demodulate
|
||||
↓
|
||||
Codec2 decode
|
||||
↓
|
||||
[Playback here if enabled]
|
||||
```
|
||||
|
||||
The playback now correctly plays audio at the right points in the pipeline!
|
||||
@ -1,60 +0,0 @@
|
||||
# DryBox - Secure Voice Over GSM Protocol
|
||||
|
||||
A secure voice communication protocol that transmits encrypted voice data over standard GSM voice channels.
|
||||
|
||||
## Architecture
|
||||
|
||||
- **Noise XK Protocol**: Provides authenticated key exchange and secure channel
|
||||
- **Codec2**: Voice compression (1200 bps mode)
|
||||
- **4FSK Modulation**: Converts digital data to audio tones
|
||||
- **Encryption**: ChaCha20-Poly1305 for secure communication
|
||||
|
||||
## Project Structure
|
||||
|
||||
```
|
||||
DryBox/
|
||||
├── UI/ # User interface components
|
||||
│ ├── main.py # Main PyQt5 application
|
||||
│ ├── phone_manager.py # Phone state management
|
||||
│ ├── protocol_phone_client.py # Protocol client implementation
|
||||
│ ├── noise_wrapper.py # Noise XK wrapper
|
||||
│ └── ...
|
||||
├── simulator/ # GSM channel simulator
|
||||
│ └── gsm_simulator.py # Simulates GSM voice channel
|
||||
├── voice_codec.py # Codec2 and FSK modem implementation
|
||||
├── encryption.py # Encryption utilities
|
||||
└── wav/ # Audio test files
|
||||
|
||||
```
|
||||
|
||||
## Running the Protocol
|
||||
|
||||
1. Start the GSM simulator:
|
||||
```bash
|
||||
cd simulator
|
||||
python3 gsm_simulator.py
|
||||
```
|
||||
|
||||
2. Run the UI application:
|
||||
```bash
|
||||
./run_ui.sh
|
||||
# or
|
||||
python3 UI/main.py
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
1. Click "Call" on Phone 1 to initiate
|
||||
2. Click "Answer" on Phone 2 to accept
|
||||
3. The protocol will automatically:
|
||||
- Establish secure connection via Noise XK
|
||||
- Start voice session
|
||||
- Compress and encrypt voice data
|
||||
- Transmit over simulated GSM channel
|
||||
|
||||
## Requirements
|
||||
|
||||
- Python 3.6+
|
||||
- PyQt5
|
||||
- dissononce (Noise protocol)
|
||||
- numpy (optional, for optimized audio processing)
|
||||
@ -1,105 +0,0 @@
|
||||
# DryBox UI Features Guide
|
||||
|
||||
## UI Improvements
|
||||
The UI has been updated with responsive layouts that scale better:
|
||||
- Phone displays now use flexible sizing (min/max constraints)
|
||||
- Waveform widgets adapt to available space
|
||||
- Buttons have flexible widths that scale with window size
|
||||
- Better margins and padding for improved visual appearance
|
||||
|
||||
## Audio Playback Feature
|
||||
|
||||
The DryBox UI includes real-time audio playback capabilities that allow you to hear the decoded audio as it's received.
|
||||
|
||||
### How to Use Playback
|
||||
|
||||
#### Manual Control
|
||||
1. **During a Call**: Once a secure voice session is established, click the "🔊 Playback" button under either phone
|
||||
2. **Button States**:
|
||||
- Gray (unchecked): Playback disabled
|
||||
- Green (checked): Playback active
|
||||
3. **Toggle Anytime**: You can enable/disable playback at any time during a call
|
||||
|
||||
#### Keyboard Shortcuts
|
||||
- `Ctrl+1`: Toggle playback for Phone 1
|
||||
- `Ctrl+2`: Toggle playback for Phone 2
|
||||
|
||||
### Using Playback with Automatic Test
|
||||
|
||||
The automatic test feature demonstrates the complete protocol flow. Here's how to use it with playback:
|
||||
|
||||
1. **Start the Test**: Click "🧪 Run Automatic Test" or press `Space`
|
||||
2. **Enable Playback Early**:
|
||||
- As soon as the test starts, enable playback on Phone 2 (Ctrl+2)
|
||||
- This ensures you'll hear audio as soon as the secure channel is established
|
||||
3. **What You'll Hear**:
|
||||
- Once handshake completes (step 4-5), Phone 1 starts transmitting test audio
|
||||
- Phone 2 will play the received, decoded audio through your speakers
|
||||
- The audio goes through: Codec2 encoding → 4FSK modulation → Noise XK encryption → transmission → decryption → demodulation → Codec2 decoding
|
||||
|
||||
### Audio Recording Feature
|
||||
|
||||
You can also record received audio for later analysis:
|
||||
|
||||
1. **Start Recording**: Click "⏺ Record" button (or press Alt+1/Alt+2)
|
||||
2. **Stop Recording**: Click the button again
|
||||
3. **Files Saved**: Recordings are saved to `wav/` directory with timestamps
|
||||
|
||||
### Audio Processing Options
|
||||
|
||||
Access advanced audio features via "Audio Options" button (Ctrl+A):
|
||||
- **Export Buffer**: Save current audio buffer to file
|
||||
- **Clear Buffer**: Clear accumulated audio data
|
||||
- **Processing Options**:
|
||||
- Normalize Audio
|
||||
- Apply Gain (adjustable dB)
|
||||
- Noise Gate
|
||||
- Low/High Pass Filters
|
||||
- Remove Silence
|
||||
|
||||
### Requirements
|
||||
|
||||
For playback to work, you need PyAudio installed:
|
||||
```bash
|
||||
# Fedora/RHEL
|
||||
sudo dnf install python3-devel portaudio-devel
|
||||
pip install pyaudio
|
||||
|
||||
# Ubuntu/Debian
|
||||
sudo apt-get install python3-dev portaudio19-dev
|
||||
pip install pyaudio
|
||||
```
|
||||
|
||||
If PyAudio isn't installed, recording will still work but playback will be disabled.
|
||||
|
||||
### Troubleshooting
|
||||
|
||||
1. **No Sound**:
|
||||
- Check PyAudio is installed
|
||||
- Ensure system volume is up
|
||||
- Verify audio device is working
|
||||
|
||||
2. **Choppy Audio**:
|
||||
- Normal for low-bitrate codec (1200bps)
|
||||
- Represents actual protocol performance
|
||||
|
||||
3. **Delayed Start**:
|
||||
- Audio only flows after secure handshake
|
||||
- Wait for "🔒 Secure Channel Established" status
|
||||
|
||||
### Test Sequence Overview
|
||||
|
||||
The automatic test goes through these steps:
|
||||
1. Initial state check
|
||||
2. Phone 1 calls Phone 2
|
||||
3. Phone 2 answers
|
||||
4. Noise XK handshake begins
|
||||
5. Handshake completes, secure channel established
|
||||
6. Voice session starts (Codec2 + 4FSK)
|
||||
7. Audio transmission begins
|
||||
8. Protocol details logged
|
||||
9. Transmission continues for observation
|
||||
10. Final statistics
|
||||
11. Call ends, cleanup
|
||||
|
||||
Enable playback on the receiving phone to hear the transmitted audio in real-time!
|
||||
@ -1,150 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Test script for audio features in DryBox"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import wave
|
||||
import struct
|
||||
import time
|
||||
|
||||
# Add parent directory to path
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from UI.audio_player import AudioPlayer, PYAUDIO_AVAILABLE
|
||||
from UI.audio_processor import AudioProcessor
|
||||
|
||||
def create_test_audio(filename="test_tone.wav", duration=2, frequency=440):
|
||||
"""Create a test audio file with a sine wave"""
|
||||
sample_rate = 8000
|
||||
num_samples = int(sample_rate * duration)
|
||||
|
||||
# Generate sine wave
|
||||
import math
|
||||
samples = []
|
||||
for i in range(num_samples):
|
||||
t = float(i) / sample_rate
|
||||
value = int(32767 * 0.5 * math.sin(2 * math.pi * frequency * t))
|
||||
samples.append(value)
|
||||
|
||||
# Save to WAV file
|
||||
with wave.open(filename, 'wb') as wav_file:
|
||||
wav_file.setnchannels(1)
|
||||
wav_file.setsampwidth(2)
|
||||
wav_file.setframerate(sample_rate)
|
||||
wav_file.writeframes(struct.pack(f'{len(samples)}h', *samples))
|
||||
|
||||
print(f"Created test audio file: {filename}")
|
||||
return filename
|
||||
|
||||
def test_audio_player():
|
||||
"""Test audio player functionality"""
|
||||
print("\n=== Testing Audio Player ===")
|
||||
|
||||
player = AudioPlayer()
|
||||
player.set_debug_callback(print)
|
||||
|
||||
if PYAUDIO_AVAILABLE:
|
||||
print("PyAudio is available - testing playback")
|
||||
|
||||
# Test playback
|
||||
client_id = 0
|
||||
if player.start_playback(client_id):
|
||||
print(f"Started playback for client {client_id}")
|
||||
|
||||
# Create and play test audio
|
||||
test_file = create_test_audio()
|
||||
with wave.open(test_file, 'rb') as wav:
|
||||
data = wav.readframes(wav.getnframes())
|
||||
|
||||
# Add audio data
|
||||
chunk_size = 640 # 320 samples * 2 bytes
|
||||
for i in range(0, len(data), chunk_size):
|
||||
chunk = data[i:i+chunk_size]
|
||||
player.add_audio_data(client_id, chunk)
|
||||
time.sleep(0.04) # 40ms per chunk
|
||||
|
||||
time.sleep(0.5) # Let playback finish
|
||||
player.stop_playback(client_id)
|
||||
print(f"Stopped playback for client {client_id}")
|
||||
|
||||
# Clean up
|
||||
os.remove(test_file)
|
||||
else:
|
||||
print("PyAudio not available - skipping playback test")
|
||||
|
||||
# Test recording (works without PyAudio)
|
||||
print("\n=== Testing Recording ===")
|
||||
client_id = 1
|
||||
player.start_recording(client_id)
|
||||
|
||||
# Add some test data
|
||||
test_data = b'\x00\x01' * 320 # Simple test pattern
|
||||
for i in range(10):
|
||||
player.add_audio_data(client_id, test_data)
|
||||
|
||||
save_path = player.stop_recording(client_id, "test_recording.wav")
|
||||
if save_path and os.path.exists(save_path):
|
||||
print(f"Recording saved successfully: {save_path}")
|
||||
os.remove(save_path)
|
||||
else:
|
||||
print("Recording failed")
|
||||
|
||||
player.cleanup()
|
||||
print("Audio player test complete")
|
||||
|
||||
def test_audio_processor():
|
||||
"""Test audio processor functionality"""
|
||||
print("\n=== Testing Audio Processor ===")
|
||||
|
||||
processor = AudioProcessor()
|
||||
processor.set_debug_callback(print)
|
||||
|
||||
# Create test audio
|
||||
test_file = create_test_audio("test_input.wav", duration=1, frequency=1000)
|
||||
|
||||
# Read test audio
|
||||
with wave.open(test_file, 'rb') as wav:
|
||||
test_data = wav.readframes(wav.getnframes())
|
||||
|
||||
# Test various processing functions
|
||||
print("\nTesting normalize:")
|
||||
normalized = processor.normalize_audio(test_data, target_db=-6)
|
||||
save_path = processor.save_processed_audio(normalized, test_file, "normalized")
|
||||
if save_path:
|
||||
print(f"Saved: {save_path}")
|
||||
os.remove(save_path)
|
||||
|
||||
print("\nTesting gain:")
|
||||
gained = processor.apply_gain(test_data, gain_db=6)
|
||||
save_path = processor.save_processed_audio(gained, test_file, "gained")
|
||||
if save_path:
|
||||
print(f"Saved: {save_path}")
|
||||
os.remove(save_path)
|
||||
|
||||
print("\nTesting filters:")
|
||||
filtered = processor.apply_low_pass_filter(test_data)
|
||||
save_path = processor.save_processed_audio(filtered, test_file, "lowpass")
|
||||
if save_path:
|
||||
print(f"Saved: {save_path}")
|
||||
os.remove(save_path)
|
||||
|
||||
# Clean up
|
||||
os.remove(test_file)
|
||||
print("\nAudio processor test complete")
|
||||
|
||||
def main():
|
||||
"""Run all tests"""
|
||||
print("DryBox Audio Features Test")
|
||||
print("==========================")
|
||||
|
||||
if not PYAUDIO_AVAILABLE:
|
||||
print("\nNOTE: PyAudio not installed. Playback tests will be skipped.")
|
||||
print("To install: sudo dnf install python3-devel portaudio-devel && pip install pyaudio")
|
||||
|
||||
test_audio_player()
|
||||
test_audio_processor()
|
||||
|
||||
print("\nAll tests complete!")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,67 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test to verify audio is flowing through the system
|
||||
"""
|
||||
|
||||
import os
|
||||
import wave
|
||||
import struct
|
||||
|
||||
def check_audio_file():
|
||||
"""Verify input.wav has actual audio content"""
|
||||
print("Checking input.wav content...")
|
||||
|
||||
with wave.open("wav/input.wav", 'rb') as wf:
|
||||
# Read multiple frames to check for silence
|
||||
total_frames = wf.getnframes()
|
||||
print(f"Total frames: {total_frames}")
|
||||
|
||||
# Check beginning
|
||||
wf.setpos(0)
|
||||
frames = wf.readframes(320)
|
||||
samples = struct.unpack('320h', frames)
|
||||
max_val = max(abs(s) for s in samples)
|
||||
print(f"Frame 0 (beginning): max amplitude = {max_val}")
|
||||
|
||||
# Check middle
|
||||
wf.setpos(total_frames // 2)
|
||||
frames = wf.readframes(320)
|
||||
samples = struct.unpack('320h', frames)
|
||||
max_val = max(abs(s) for s in samples)
|
||||
print(f"Frame {total_frames//2} (middle): max amplitude = {max_val}")
|
||||
|
||||
# Check near end
|
||||
wf.setpos(total_frames - 640)
|
||||
frames = wf.readframes(320)
|
||||
samples = struct.unpack('320h', frames)
|
||||
max_val = max(abs(s) for s in samples)
|
||||
print(f"Frame {total_frames-640} (near end): max amplitude = {max_val}")
|
||||
|
||||
# Find first non-silent frame
|
||||
wf.setpos(0)
|
||||
for i in range(0, total_frames, 320):
|
||||
frames = wf.readframes(320)
|
||||
if len(frames) < 640:
|
||||
break
|
||||
samples = struct.unpack('320h', frames)
|
||||
max_val = max(abs(s) for s in samples)
|
||||
if max_val > 100: # Not silence
|
||||
print(f"\nFirst non-silent frame at position {i}")
|
||||
print(f"First 10 samples: {samples[:10]}")
|
||||
break
|
||||
|
||||
def main():
|
||||
# Change to DryBox directory if needed
|
||||
if os.path.basename(os.getcwd()) != 'DryBox':
|
||||
if os.path.exists('DryBox'):
|
||||
os.chdir('DryBox')
|
||||
|
||||
check_audio_file()
|
||||
|
||||
print("\nTo fix silence at beginning of file:")
|
||||
print("1. Skip initial silence in phone_manager.py")
|
||||
print("2. Or use a different test file")
|
||||
print("3. Or trim the silence from input.wav")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,193 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test the audio pipeline (Codec2 + FSK) independently
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import wave
|
||||
import struct
|
||||
import numpy as np
|
||||
|
||||
# Add parent directory to path
|
||||
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from voice_codec import Codec2Wrapper, FSKModem, Codec2Mode, Codec2Frame
|
||||
|
||||
def test_codec_only():
|
||||
"""Test just the codec2 encode/decode"""
|
||||
print("\n1. Testing Codec2 only...")
|
||||
|
||||
codec = Codec2Wrapper(mode=Codec2Mode.MODE_1200)
|
||||
|
||||
# Read test audio
|
||||
with wave.open("wav/input.wav", 'rb') as wf:
|
||||
# Read 320 samples (40ms at 8kHz)
|
||||
frames = wf.readframes(320)
|
||||
if len(frames) < 640: # 320 samples * 2 bytes
|
||||
print("Not enough audio data")
|
||||
return False
|
||||
|
||||
# Convert to samples
|
||||
samples = struct.unpack(f'{len(frames)//2}h', frames)
|
||||
print(f"Input: {len(samples)} samples, first 10: {samples[:10]}")
|
||||
|
||||
# Encode
|
||||
encoded = codec.encode(frames)
|
||||
if encoded:
|
||||
print(f"Encoded: {len(encoded.bits)} bytes")
|
||||
print(f"First 10 bytes: {encoded.bits[:10].hex()}")
|
||||
else:
|
||||
print("Encoding failed!")
|
||||
return False
|
||||
|
||||
# Decode
|
||||
decoded = codec.decode(encoded)
|
||||
if decoded is not None:
|
||||
print(f"Decoded: type={type(decoded)}, len={len(decoded)}")
|
||||
if hasattr(decoded, '__getitem__'):
|
||||
print(f"First 10 samples: {list(decoded[:10])}")
|
||||
|
||||
# Save decoded audio
|
||||
with wave.open("wav/test_codec_only.wav", 'wb') as out:
|
||||
out.setnchannels(1)
|
||||
out.setsampwidth(2)
|
||||
out.setframerate(8000)
|
||||
if hasattr(decoded, 'tobytes'):
|
||||
out.writeframes(decoded.tobytes())
|
||||
else:
|
||||
# Convert to bytes
|
||||
import array
|
||||
arr = array.array('h', decoded)
|
||||
out.writeframes(arr.tobytes())
|
||||
print("Saved decoded audio to wav/test_codec_only.wav")
|
||||
return True
|
||||
else:
|
||||
print("Decoding failed!")
|
||||
return False
|
||||
|
||||
def test_full_pipeline():
|
||||
"""Test the full Codec2 + FSK pipeline"""
|
||||
print("\n2. Testing full pipeline (Codec2 + FSK)...")
|
||||
|
||||
codec = Codec2Wrapper(mode=Codec2Mode.MODE_1200)
|
||||
modem = FSKModem()
|
||||
|
||||
# Read test audio
|
||||
with wave.open("wav/input.wav", 'rb') as wf:
|
||||
frames = wf.readframes(320)
|
||||
if len(frames) < 640:
|
||||
print("Not enough audio data")
|
||||
return False
|
||||
|
||||
# Encode with Codec2
|
||||
encoded = codec.encode(frames)
|
||||
if not encoded:
|
||||
print("Codec encoding failed!")
|
||||
return False
|
||||
print(f"Codec2 encoded: {len(encoded.bits)} bytes")
|
||||
|
||||
# Modulate with FSK
|
||||
modulated = modem.modulate(encoded.bits)
|
||||
print(f"FSK modulated: {len(modulated)} float samples")
|
||||
|
||||
# Demodulate
|
||||
demodulated, confidence = modem.demodulate(modulated)
|
||||
print(f"FSK demodulated: {len(demodulated)} bytes, confidence: {confidence:.2f}")
|
||||
|
||||
if confidence < 0.5:
|
||||
print("Low confidence demodulation!")
|
||||
return False
|
||||
|
||||
# Create frame for decoding
|
||||
frame = Codec2Frame(
|
||||
mode=Codec2Mode.MODE_1200,
|
||||
bits=demodulated,
|
||||
timestamp=0,
|
||||
frame_number=0
|
||||
)
|
||||
|
||||
# Decode with Codec2
|
||||
decoded = codec.decode(frame)
|
||||
if decoded is not None:
|
||||
print(f"Decoded: type={type(decoded)}, len={len(decoded)}")
|
||||
|
||||
# Save decoded audio
|
||||
with wave.open("wav/test_full_pipeline.wav", 'wb') as out:
|
||||
out.setnchannels(1)
|
||||
out.setsampwidth(2)
|
||||
out.setframerate(8000)
|
||||
if hasattr(decoded, 'tobytes'):
|
||||
out.writeframes(decoded.tobytes())
|
||||
else:
|
||||
# Convert to bytes
|
||||
import array
|
||||
arr = array.array('h', decoded)
|
||||
out.writeframes(arr.tobytes())
|
||||
print("Saved decoded audio to wav/test_full_pipeline.wav")
|
||||
return True
|
||||
else:
|
||||
print("Codec decoding failed!")
|
||||
return False
|
||||
|
||||
def test_byte_conversion():
|
||||
"""Test the byte conversion that happens in the protocol"""
|
||||
print("\n3. Testing byte conversion...")
|
||||
|
||||
# Create test PCM data
|
||||
test_samples = [100, -100, 200, -200, 300, -300, 0, 0, 1000, -1000]
|
||||
|
||||
# Method 1: array.tobytes()
|
||||
import array
|
||||
arr = array.array('h', test_samples)
|
||||
bytes1 = arr.tobytes()
|
||||
print(f"array.tobytes(): {len(bytes1)} bytes, hex: {bytes1.hex()}")
|
||||
|
||||
# Method 2: struct.pack
|
||||
bytes2 = struct.pack(f'{len(test_samples)}h', *test_samples)
|
||||
print(f"struct.pack(): {len(bytes2)} bytes, hex: {bytes2.hex()}")
|
||||
|
||||
# They should be the same
|
||||
print(f"Bytes match: {bytes1 == bytes2}")
|
||||
|
||||
# Test unpacking
|
||||
unpacked = struct.unpack(f'{len(bytes1)//2}h', bytes1)
|
||||
print(f"Unpacked: {unpacked}")
|
||||
print(f"Matches original: {list(unpacked) == test_samples}")
|
||||
|
||||
return True
|
||||
|
||||
def main():
|
||||
print("Audio Pipeline Test")
|
||||
print("=" * 50)
|
||||
|
||||
# Change to DryBox directory if needed
|
||||
if os.path.basename(os.getcwd()) != 'DryBox':
|
||||
if os.path.exists('DryBox'):
|
||||
os.chdir('DryBox')
|
||||
|
||||
# Ensure wav directory exists
|
||||
os.makedirs("wav", exist_ok=True)
|
||||
|
||||
# Run tests
|
||||
codec_ok = test_codec_only()
|
||||
pipeline_ok = test_full_pipeline()
|
||||
bytes_ok = test_byte_conversion()
|
||||
|
||||
print("\n" + "=" * 50)
|
||||
print("Test Results:")
|
||||
print(f" Codec2 only: {'✅ PASS' if codec_ok else '❌ FAIL'}")
|
||||
print(f" Full pipeline: {'✅ PASS' if pipeline_ok else '❌ FAIL'}")
|
||||
print(f" Byte conversion: {'✅ PASS' if bytes_ok else '❌ FAIL'}")
|
||||
|
||||
if codec_ok and pipeline_ok and bytes_ok:
|
||||
print("\n✅ All tests passed!")
|
||||
print("\nIf playback still doesn't work, check:")
|
||||
print("1. Is the audio data actually being sent? (check debug logs)")
|
||||
print("2. Is PyAudio stream format correct? (16-bit, 8kHz, mono)")
|
||||
print("3. Is the volume turned up?")
|
||||
else:
|
||||
print("\n❌ Some tests failed - this explains the playback issue")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,127 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script to verify audio setup for DryBox
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import wave
|
||||
|
||||
def check_audio_file():
|
||||
"""Check if input.wav exists and has correct format"""
|
||||
wav_path = "wav/input.wav"
|
||||
|
||||
if not os.path.exists(wav_path):
|
||||
print(f"❌ {wav_path} not found!")
|
||||
return False
|
||||
|
||||
try:
|
||||
with wave.open(wav_path, 'rb') as wf:
|
||||
channels = wf.getnchannels()
|
||||
framerate = wf.getframerate()
|
||||
sampwidth = wf.getsampwidth()
|
||||
nframes = wf.getnframes()
|
||||
duration = nframes / framerate
|
||||
|
||||
print(f"✅ Audio file: {wav_path}")
|
||||
print(f" Channels: {channels} {'✅' if channels == 1 else '❌ (should be 1)'}")
|
||||
print(f" Sample rate: {framerate}Hz {'✅' if framerate == 8000 else '❌ (should be 8000)'}")
|
||||
print(f" Sample width: {sampwidth * 8} bits {'✅' if sampwidth == 2 else '❌'}")
|
||||
print(f" Duration: {duration:.2f} seconds")
|
||||
print(f" Size: {os.path.getsize(wav_path) / 1024:.1f} KB")
|
||||
|
||||
return channels == 1 and framerate == 8000
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Error reading {wav_path}: {e}")
|
||||
return False
|
||||
|
||||
def check_pyaudio():
|
||||
"""Check if PyAudio is installed and working"""
|
||||
try:
|
||||
import pyaudio
|
||||
p = pyaudio.PyAudio()
|
||||
|
||||
# Check for output devices
|
||||
output_devices = 0
|
||||
for i in range(p.get_device_count()):
|
||||
info = p.get_device_info_by_index(i)
|
||||
if info['maxOutputChannels'] > 0:
|
||||
output_devices += 1
|
||||
|
||||
p.terminate()
|
||||
|
||||
print(f"✅ PyAudio installed")
|
||||
print(f" Output devices available: {output_devices}")
|
||||
return True
|
||||
|
||||
except ImportError:
|
||||
print("❌ PyAudio not installed")
|
||||
print(" To enable playback, run:")
|
||||
print(" sudo dnf install python3-devel portaudio-devel")
|
||||
print(" pip install pyaudio")
|
||||
return False
|
||||
except Exception as e:
|
||||
print(f"❌ PyAudio error: {e}")
|
||||
return False
|
||||
|
||||
def check_dependencies():
|
||||
"""Check all required dependencies"""
|
||||
deps = {
|
||||
'PyQt5': 'PyQt5',
|
||||
'numpy': 'numpy',
|
||||
'struct': None, # Built-in
|
||||
'wave': None, # Built-in
|
||||
}
|
||||
|
||||
print("\nDependency check:")
|
||||
all_good = True
|
||||
|
||||
for module_name, pip_name in deps.items():
|
||||
try:
|
||||
__import__(module_name)
|
||||
print(f"✅ {module_name}")
|
||||
except ImportError:
|
||||
print(f"❌ {module_name} not found")
|
||||
if pip_name:
|
||||
print(f" Install with: pip install {pip_name}")
|
||||
all_good = False
|
||||
|
||||
return all_good
|
||||
|
||||
def main():
|
||||
print("DryBox Audio Setup Test")
|
||||
print("=" * 40)
|
||||
|
||||
# Change to DryBox directory if needed
|
||||
if os.path.basename(os.getcwd()) != 'DryBox':
|
||||
if os.path.exists('DryBox'):
|
||||
os.chdir('DryBox')
|
||||
print(f"Changed to DryBox directory: {os.getcwd()}")
|
||||
|
||||
print("\nChecking audio file...")
|
||||
audio_ok = check_audio_file()
|
||||
|
||||
print("\nChecking PyAudio...")
|
||||
pyaudio_ok = check_pyaudio()
|
||||
|
||||
print("\nChecking dependencies...")
|
||||
deps_ok = check_dependencies()
|
||||
|
||||
print("\n" + "=" * 40)
|
||||
if audio_ok and deps_ok:
|
||||
print("✅ Audio setup is ready!")
|
||||
if not pyaudio_ok:
|
||||
print("⚠️ Playback disabled (PyAudio not available)")
|
||||
print(" Recording will still work")
|
||||
else:
|
||||
print("❌ Audio setup needs attention")
|
||||
|
||||
print("\nUsage tips:")
|
||||
print("1. Run the UI: python UI/main.py")
|
||||
print("2. Click 'Run Automatic Test' or press Space")
|
||||
print("3. Enable playback on Phone 2 with Ctrl+2")
|
||||
print("4. You'll hear the decoded audio after handshake completes")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Loading…
Reference in New Issue
Block a user