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)