def test_callback() -> None:
# Calculate expected number of samples
frame_size_ms = 10
samples_per_second = 48000
expected_samples = (frame_size_ms * samples_per_second // 1000)
# Calculate the expected length of the decoded packet
bytes_per_sample = 2
channels = 2
expected_pcm_length = (expected_samples * bytes_per_sample * channels)
# Create a decoder to test that the encoded packets are valid
decoder = pyogg.OpusDecoder()
decoder.set_sampling_frequency(samples_per_second)
decoder.set_channels(channels)
# Specify the callback that will receive the encoded packets
index = 0
def callback(encoded_packet: memoryview, samples: int,
end_of_stream: bool) -> None:
assert len(encoded_packet) > 0
assert samples == expected_samples
# Check encoded packet is valid
pcm = decoder.decode(encoded_packet)
assert len(pcm) == expected_pcm_length
# Ignore the end of stream; it's tested below
# Create the encoder
encoder = init_encoder(channels=channels,
frame_size=frame_size_ms,
duration_ms=60,
callback=callback)
def test_callback():
# Calculate expected number of samples
frame_size_ms = 10
samples_per_second = 48000
expected_samples = (frame_size_ms * samples_per_second // 1000)
# Calculate the expected length of the decoded packet
bytes_per_sample = 2
channels = 2
expected_pcm_length = (expected_samples * bytes_per_sample * channels)
# Create a decoder to test that the encoded packets are valid
decoder = pyogg.OpusDecoder()
decoder.set_sampling_frequency(samples_per_second)
decoder.set_channels(channels)
# Specify the callback that will receive the encoded packets
def callback(encoded_packet, samples):
assert len(encoded_packet) > 0
assert samples == expected_samples
# Check encoded packet is valid
pcm = decoder.decode(encoded_packet)
assert len(pcm) == expected_pcm_length
# Create the encoder
encoder = init_encoder(channels=channels,
frame_size=frame_size_ms,
callback=callback)
def init_decoder(encoded_packet=None,
samples_per_second=48000,
channels=1,
set_sampling_frequency=True,
set_channels=True,
decode_packet=True) -> pyogg.OpusDecoder:
decoder = pyogg.OpusDecoder()
if set_sampling_frequency:
decoder.set_sampling_frequency(samples_per_second)
if set_channels:
decoder.set_channels(channels)
if decode_packet:
# Decode the encoded packet
decoder.decode(encoded_packet)
return decoder
def test_pcm_buffer_not_configured() -> None:
decoder = pyogg.OpusDecoder()
decoder._decoder = "invalid"
with pytest.raises(pyogg.PyOggError):
decoder.decode(memoryview(bytearray(b"")))
def test_pcm_buffer_not_configured():
decoder = pyogg.OpusDecoder()
decoder._decoder = "invalid"
with pytest.raises(pyogg.PyOggError):
decoder.decode(b"")
def datagramReceived(self, data, addr):
#print("Received UDP packet from", addr)
# If we haven't already seen this address, create a new
# UDPPacketizer for it, otherwise get the appropriate instance
if addr not in self._connections:
packets_to_buffer = 3
self._connections[addr] = {
"udp_packetizer": UDPPacketizer(self.transport, addr),
# Initialise the jitter buffer
"jitter_buffer": JitterBuffer(packets_to_buffer)
}
udp_packetizer = self._connections[addr]["udp_packetizer"]
jitter_buffer = self._connections[addr]["jitter_buffer"]
# Extract the timestamp (4 bytes), sequence number (2 bytes),
# and encoded frame (remainder)
timestamp, seq_no, encoded_packet = udp_packetizer.decode(data)
jitter_buffer.put_packet(seq_no, encoded_packet)
return
# !!!!!!!!!!! FIXME !!!!!!!!!!!
# Doesn't use the jitter buffer's packet
# Fake high data loss
reliability = 1.0
if random.random() < reliability:
self.transport.write(data, addr)
else:
self._dropped_packets += 1
print(
f"TEST: DROPPING PACKET! Dropped a total of {self._dropped_packets} packets."
)
return
seq_no = int.from_bytes(seq_no, "big")
print("\n", seq_no)
# Get OpusDecoder for this client
try:
opus_decoder = self._opus_decoders[addr]
except KeyError:
# Didn't find an OpusDecoder for this connection, create
# one and store it in the dictionary
opus_decoder = pyogg.OpusDecoder()
self._opus_decoders[addr] = opus_decoder
# Initialise the decoder
opus_decoder.set_channels(1) # Mono
opus_decoder.set_sampling_frequency(48000)
# Decode the encoded packet
pcm = opus_decoder.decode(encoded_packet)
# Get the wave_write for this client
try:
wave_write = self._wave_writes[addr]
except KeyError:
# Didn't find a wave_write for this connection, create one
# and store it in the dictionary
filename = f"{addr[0]}_{addr[1]}.wav"
wave_write = wave.open(filename, "wb")
self._wave_writes[addr] = wave_write
# Initialise the wave_write
wave_write.setnchannels(1)
wave_write.setsampwidth(2)
wave_write.setframerate(48000)
# Write the PCM to the wav file
wave_write.writeframes(pcm)
