def test_ulaw2lin(self): encoded = b"\x00\x0e\x28\x3f\x57\x6a\x76\x7c\x7e\x7f" b"\x80\x8e\xa8\xbf\xd7\xea\xf6\xfc\xfe\xff" src = [-8031, -4447, -1471, -495, -163, -53, -18, -6, -2, 0, 8031, 4447, 1471, 495, 163, 53, 18, 6, 2, 0] for w in 1, 2, 4: self.assertEqual(audioop.ulaw2lin(encoded, w), packs[w](*(x << (w * 8) >> 14 for x in src))) # Current u-law implementation has two codes fo 0: 0x7f and 0xff. encoded = bytes(range(127)) + bytes(range(128, 256)) for w in 2, 4: decoded = audioop.ulaw2lin(encoded, w) self.assertEqual(audioop.lin2ulaw(decoded, w), encoded)
def decode(self, bytes): if len(bytes) != 160: log.msg("mulaw: short read on decode, %d != 160" % len(bytes), system="codec") if 0: bytes = audioop.ulaw2lin(bytes, 2) self.buf += bytes if len(self.buf) > 159: out, self.buf = self.buf[:160], self.buf[160:] return out else: return audioop.ulaw2lin(bytes, 2)
def decode(self, bytes): if len(bytes) != 160: log.msg("mulaw: short read on decode, %d != 160"%len(bytes), system="codec") if 0: bytes = audioop.ulaw2lin(bytes, 2) self.buf += bytes if len(self.buf) > 159: out, self.buf = self.buf[:160], self.buf[160:] return out else: return audioop.ulaw2lin(bytes, 2)
def test_ulaw2lin(self): encoded = b'\x00\x0e\x28\x3f\x57\x6a\x76\x7c\x7e\x7f'\ b'\x80\x8e\xa8\xbf\xd7\xea\xf6\xfc\xfe\xff' src = [-8031, -4447, -1471, -495, -163, -53, -18, -6, -2, 0, 8031, 4447, 1471, 495, 163, 53, 18, 6, 2, 0] for w in 1, 2, 4: self.assertEqual(audioop.ulaw2lin(encoded, w), packs[w](*(x << (w * 8) >> 14 for x in src))) # Current u-law implementation has two codes fo 0: 0x7f and 0xff. encoded = ''.join(chr(x) for x in range(127) + range(128, 256)) for w in 2, 4: decoded = audioop.ulaw2lin(encoded, w) self.assertEqual(audioop.lin2ulaw(decoded, w), encoded)
def test_ulaw2lin(self): # Cursory d = audioop.lin2ulaw(data[0], 1) self.assertEqual(audioop.ulaw2lin(d, 1), data[0]) if endian == 'big': self.assertEqual(audioop.ulaw2lin(d, 2), b'\x00\x00\x01\x04\x02\x0c') self.assertEqual(audioop.ulaw2lin(d, 4), b'\x00\x00\x00\x00\x01\x04\x00\x00\x02\x0c\x00\x00') else: self.assertEqual(audioop.ulaw2lin(d, 2), b'\x00\x00\x04\x01\x0c\x02') self.assertEqual(audioop.ulaw2lin(d, 4), b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x0c\x02')
def bytes_to_channels(fmtChunk: FmtChunk, raw_samples: bytes, size) -> list: if int(fmtChunk.data.bits_per_sample / 8) > 0: sample_len = int(fmtChunk.data.bits_per_sample / 8) else: sample_len = 0 samples = [] if sample_len > 0: for i in range(int(size / sample_len)): sample = raw_samples[i * sample_len:i * sample_len + sample_len] if fmtChunk.data.audio_format == 1: if sample_len == 1: converted_sample = int.from_bytes( sample, byteorder="little", signed=False) else: converted_sample = int.from_bytes( sample, byteorder="little", signed=True) elif fmtChunk.data.audio_format == 3: if sample_len == 4: converted_sample = struct.unpack("f", sample)[0] else: converted_sample = struct.unpack("d", sample)[0] elif fmtChunk.data.audio_format == 6: converted_sample = int.from_bytes(audioop.alaw2lin( sample, sample_len), byteorder="little", signed=True) elif fmtChunk.data.audio_format == 7: converted_sample = int.from_bytes(audioop.ulaw2lin( sample, sample_len), byteorder="little", signed=True) else: print( "Format zapisu danych w pliku nie jest wspierany") raise Exception samples.append(converted_sample) else: if fmtChunk.data.audio_format == 2: ret = audioop.adpcm2lin(raw_samples, fmtChunk.data.bits_per_sample, None) samples_lin = ret[0] for i in range(int(len(samples_lin) / 8)): sample = samples_lin[i * 8:i * 8 + 8] converted_sample = int.from_bytes(sample, byteorder="little", signed=True) samples.append(converted_sample) else: print("Format zapisu danych w pliku nie jest wspierany") raise Exception channels = [] for c in range(fmtChunk.data.num_channels): channels.append(samples[c::fmtChunk.data.num_channels]) return channels
def _inout(self, linear, stream_time, userdata): # logger.debug('audio capture %d', len(linear)) self._ts += 160 if self.media and (self.media.hasYourFormat(self._pcmu) or self.media.hasYourFormat(self._pcma)): linear8, self._resample1 = audiospeex.resample( linear, input_rate=44100, output_rate=8000, state=self._resample1 ) if self.media.hasYourFormat(self._pcmu): fmt, payload = self._pcmu, audioop.lin2ulaw(linear8, 2) elif self.media.hasYourFormat(self._pcma): fmt, payload = self._pcma, audioop.lin2alaw(linear8, 2) self.media.send(payload=payload, ts=self._ts, marker=False, fmt=fmt) if self._queue: fmt, packet = self._queue.pop(0) linear8 = None if str(fmt.name).lower() == "pcmu" and fmt.rate == 8000 or fmt.pt == 0: linear8 = audioop.ulaw2lin(packet.payload, 2) elif str(fmt.name).lower() == "pcma" and fmt.rate == 8000 or fmt.pt == 8: linear8 = audioop.alaw2lin(packet.payload, 2) if linear8: linear, self._resample2 = audiospeex.resample( linear8, input_rate=8000, output_rate=44100, state=self._resample2 ) # logger.debug('audio play %d', len(linear)) return linear return ""
def write(self, audio): if self._user_resample: # The user can also specify to have ULAW encoded source audio # converted to linear encoding upon being written. if self._user_resample.ulaw2lin: # Possibly skip downsampling if this was triggered, as # while ULAW encoded audio can be sampled at rates other # than 8KHz, since this is telephony related, it's unlikely. audio = audioop.ulaw2lin(audio, 2) # If the audio isn't already sampled at 8KHz, # then it needs to be downsampled first if self._user_resample.rate != 8000: audio, self._user_resample.ratecv_state = audioop.ratecv( audio, 2, self._user_resample.channels, self._user_resample.rate, 8000, self._user_resample.ratecv_state, ) # If the audio isn't already in mono, then # it needs to be downmixed as well if self._user_resample.channels == 2: audio = audioop.tomono(audio, 2, 1, 1) self._tx_q.put(audio)
def compress(self): read = wave.open(self.create_wave(), 'rb') string_wav = np.fromstring(read.readframes(-1), 'Int16') if (self.compression_mod == "a-LAW"): compressed_string = audioop.lin2alaw(string_wav, read.getsampwidth()) compressed_string = audioop.alaw2lin(compressed_string, read.getsampwidth()) self.working_signal = np.frombuffer(compressed_string, dtype='Int16') if (self.compression_mod == "u-LAW"): compressed_string = audioop.lin2ulaw(string_wav, read.getsampwidth()) compressed_string = audioop.ulaw2lin(compressed_string, read.getsampwidth()) self.working_signal = np.frombuffer(compressed_string, dtype='Int16') if (self.compression_mod == "ADPCM"): compressed_string = audioop.lin2adpcm(string_wav, read.getsampwidth(), None) compressed_string = audioop.adpcm2lin(compressed_string[0], read.getsampwidth(), None) self.working_signal = np.frombuffer(compressed_string[0], dtype='Int16')
def decode(self, encoded_frame): return [ AudioFrame(channels=1, data=audioop.ulaw2lin(encoded_frame.data, 2), sample_rate=8000, timestamp=encoded_frame.timestamp) ]
def _inout(self, linear, stream_time, userdata): # logger.debug('audio capture %d', len(linear)) self._ts += 160 if self.media and (self.media.hasYourFormat(self._pcmu) or self.media.hasYourFormat(self._pcma)): if self._outqueue: # logger.debug('sending packet from out queue, not mic') linear8 = self._outqueue.pop(0) else: linear8, self._resample1 = audiospeex.resample(linear, input_rate=self.sample_rate, output_rate=8000, state=self._resample1) if self.media.hasYourFormat(self._pcmu): fmt, payload = self._pcmu, audioop.lin2ulaw(linear8, 2) elif self.media.hasYourFormat(self._pcma): fmt, payload = self._pcma, audioop.lin2alaw(linear8, 2) self.media.send(payload=payload, ts=self._ts, marker=False, fmt=fmt) if self._queue: fmt, packet = self._queue.pop(0) linear8 = None if str(fmt.name).lower() == 'pcmu' and fmt.rate == 8000 or fmt.pt == 0: linear8 = audioop.ulaw2lin(packet.payload, 2) elif str(fmt.name).lower() == 'pcma' and fmt.rate == 8000 or fmt.pt == 8: linear8 = audioop.alaw2lin(packet.payload, 2) if linear8: self._record.write(linear8) if self._thqueue is not None: self._thqueue.put(linear8) linear, self._resample2 = audiospeex.resample(linear8, input_rate=8000, output_rate=self.sample_rate, state=self._resample2) # logger.debug('audio play %d', len(linear)) return linear return ''
def test_ulaw2lin(self): encoded = ( b'\x00\x0e(?Wjv|~\x7f\x80\x8e\xa8\xbf\xd7\xea\xf6\xfc\xfe\xff') src = [ -8031, -4447, -1471, -495, -163, -53, -18, -6, -2, 0, 8031, 4447, 1471, 495, 163, 53, 18, 6, 2, 0 ] for w in (1, 2, 3, 4): decoded = packs[w](*(x << w * 8 >> 14 for x in src)) self.assertEqual(audioop.ulaw2lin(encoded, w), decoded) self.assertEqual(audioop.ulaw2lin(bytearray(encoded), w), decoded) self.assertEqual(audioop.ulaw2lin(memoryview(encoded), w), decoded) encoded = bytes(range(127)) + bytes(range(128, 256)) for w in (2, 3, 4): decoded = audioop.ulaw2lin(encoded, w) self.assertEqual(audioop.lin2ulaw(decoded, w), encoded)
def recv_msg_symm(sock): while True: data, addr = sock.recvfrom(1024) if addr == self.master: # sys.stdout.write(data) data = audioop.ulaw2lin(data, 2) stream.write(data)
def testulaw2lin(data): if verbose: print 'ulaw2lin' # Cursory d = audioop.lin2ulaw(data[0], 1) if audioop.ulaw2lin(d, 1) != data[0]: return 0 return 1
def decode(self, bytes): if not bytes: return elif len(bytes) != 160: log.msg("mulaw: short read on decode, %d != 160"%len(bytes), system="codec") # Pad with silence. extra = (160 - len(bytes)) * bytes[-1] bytes += extra if 0: bytes = audioop.ulaw2lin(bytes, 2) self.buf += bytes if len(self.buf) > 159: out, self.buf = self.buf[:160], self.buf[160:] return out else: return audioop.ulaw2lin(bytes, 2)
def decode(self, bytes): if not bytes: return elif len(bytes) != 160: log.msg("mulaw: short read on decode, %d != 160" % len(bytes), system="codec") # Pad with silence. extra = (160 - len(bytes)) * bytes[-1] bytes += extra if 0: bytes = audioop.ulaw2lin(bytes, 2) self.buf += bytes if len(self.buf) > 159: out, self.buf = self.buf[:160], self.buf[160:] return out else: return audioop.ulaw2lin(bytes, 2)
def testulaw2lin(data): if verbose: print 'ulaw2lin' # Cursory d = audioop.lin2ulaw(data[0], 1) if audioop.ulaw2lin(d, 1) <> data[0]: return 0 return 1
def decode(self, encoded_frame): frame = AudioFrame( channels=1, data=audioop.ulaw2lin(encoded_frame.data, 2), sample_rate=SAMPLE_RATE) frame.pts = encoded_frame.timestamp frame.time_base = TIME_BASE return [frame]
def messageHandler(conn): # this is to deal with a single incoming TCP or UDP message global fifo, previous, missed, state # the actual packet length will not be 2048 bytes, but depends on the format and number of audio samples buf = sock.recv(2048) if len(buf) < 12: return # see https://en.wikipedia.org/wiki/RTP_payload_formats (version, type, counter, timestamp, id) = struct.unpack('BBHII', buf[0:12]) if version != 128: raise RuntimeError('unsupported packet version') fragment = bytearray(buf[12:]) with fifolock: if not id in fifo: fifo[id] = RingBuffer( id, rate) # make a buffer that can hold one second of audio previous[id] = None state[id] = None missed[id] = 0 if type == 0: # type=0 PCMU audio 1 8000 any 20 ITU-T G.711 PCM μ-Law audio 64 kbit/s RFC 3551 fragment = audioop.ulaw2lin(fragment, 2) fragment, state[id] = audioop.ratecv(fragment, 2, 1, 8000, 44100, state[id]) dat = np.frombuffer(fragment, np.int16) elif type == 1: # type=8 PCMA audio 1 8000 any 20 ITU-T G.711 PCM A-Law audio 64 kbit/s RFC 3551 fragment = audioop.alaw2lin(fragment, 2) fragment, state[id] = audioop.ratecv(fragment, 2, 1, 8000, 44100, state[id]) dat = np.frombuffer(fragment, np.int16) elif type == 11: # type=11 L16 audio 1 44100 any 20 Linear PCM 16-bit audio 705.6 kbit/s, uncompressed RFC 3551, Page 27 dat = np.frombuffer(fragment, np.int16) else: raise RuntimeError('unsupported RTP packet type') if not previous[id] == None: for missing in range(previous[id] + 1 - counter, 0): logger.debug('missed packet from %d' % (id)) # See https://en.wikipedia.org/wiki/Comfort_noise missing_dat = np.random.random( len(dat)) # FIXME these are only positive missing_dat *= np.linalg.norm(dat) / np.linalg.norm( missing_dat) missing_timestamp = timestamp + missing * len( dat) * 1000 / 44100 missed[id] += 1 fifo[id].push(missing_dat.astype(np.int16), missing_timestamp) previous[id] = counter fifo[id].push(dat, timestamp)
def stream_to_lex(self, base_64_encoded_data): if self.stop_data_processing.is_set(): self.logger.warn( "discarding the passed in data, as underlying lex stream has been stopped" ) return data = self.__decode_data(base_64_encoded_data) raw_audio_data = audioop.ulaw2lin(data, self.width) #raw_audio_data, state = audioop.lin2adpcm(raw_audio_data, self.width, None) # raw_audio_data, state = audioop.ratecv(raw_audio_data, # self.width, # self.channels, # self.twilio_rate, # self.lex_rate, # None) rms = audioop.rms(raw_audio_data, self.width) #self.logger.info("RMS value is {0}".format(rms)) self.rms_values.append(rms) if rms > self.voice_threshold: #self.logger.debug("voice detected in input data") self.rms_graph.append("^") if self.last_detected_voice_time is None: # voice detected for first time self.logger.debug("voice detected for first time") self.voice_detected() self.last_detected_voice_time = datetime.now() self.lex_client.add_to_stream(raw_audio_data) else: self.rms_graph.append(".") #self.logger.debug("silence detected in input data") if self.last_detected_voice_time: # check if elapsed time is greater than configured time for silence self.lex_client.add_to_stream(raw_audio_data) silence_time = (datetime.now() - self.last_detected_voice_time).total_seconds() if silence_time >= self.silence_duration_time: self.logger.debug( "elapsed time {0} seconds since last detected voice time {1} is higher than configured time for silence {2} seconds. closing connection to lex." .format(silence_time, self.last_detected_voice_time, self.silence_duration_time)) # stop lex client now self.lex_client.stop() self.stop_data_processing.set() self.logger.info("Voice activity graph {0}".format("".join( self.rms_graph))) self.logger.info("RMS values {0}".format(self.rms_values)) self.silence_detected()
def readframes(self, nframes): if self._encoding in _simple_encodings: if nframes == AUDIO_UNKNOWN_SIZE: data = self._file.read() else: data = self._file.read(nframes*self._framesize) if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: import audioop data = audioop.ulaw2lin(data, self._sampwidth) return data
def decode(self, payload): assert isinstance(payload, bytes), "payload is not an instance of bytes" if not payload: return elif len(payload) != 160: log.msg("mulaw: short read on decode, %d != 160" % len(payload), system="codec") # Pad with silence. extra = (160 - len(payload)) * payload[-1] payload += extra if 0: payload = audioop.ulaw2lin(payload, 2) self.buf += payload if len(self.buf) > 159: out, self.buf = self.buf[:160], self.buf[160:] return out else: return audioop.ulaw2lin(payload, 2)
def sendPacket(packetsize): previousend = 0; singleByte = b'\x00' replacement = singleByte newEnd = 0 for i in range (1, packetsize): replacement+=singleByte for i in range (0, nframes, packetsize): randnum = random.random() for i in range(0,6): if (randnum<lossratio[i]): J[i].writeframes(audioop.ulaw2lin(encodedaudio[previousend-packetsize:newEnd],1)) K[i].writeframes(replacement) previousend = previousend+packetsize else: newEnd = previousend+packetsize J[i].writeframes(audioop.ulaw2lin(encodedaudio[previousend:newEnd],1)) K[i].writeframes(audioop.ulaw2lin(encodedaudio[previousend:newEnd],1)) previousend = previousend+packetsize
def readframes(self, nframes): if self._encoding in sunau._simple_encodings: if nframes == sunau.AUDIO_UNKNOWN_SIZE: data = self._file.read() else: data = self._file.read(nframes * self._framesize * self._nchannels) if self._encoding == sunau.AUDIO_FILE_ENCODING_MULAW_8: import audioop data = audioop.ulaw2lin(data, self._sampwidth) return data return None # XXX--not implemented yet
def speech_to_text(self): stt_config = CONFIG['stt_config'] models_folder = Path(stt_config['folder']) model_path = str(models_folder / stt_config['model']) scorer_path = str(models_folder / stt_config['scorer']) self.deep_speech = Model(model_path) self.deep_speech.enableExternalScorer(scorer_path) stream = self.deep_speech.createStream() while True: speech = self.audio_in_queue.get() while not self.audio_in_queue.empty(): speech += self.audio_in_queue.get() lin_speech = audioop.ulaw2lin(speech, 2) ds_speech, _ = audioop.ratecv(lin_speech, 2, 1, self.IN_AUDIO_RATE, self.DS_AUDIO_RATE, None) lin_speech_arr = np.frombuffer(lin_speech, np.int16) ds_speech_arr = np.frombuffer(ds_speech, np.int16) stream.feedAudioContent(ds_speech_arr) self.caller_audio_chunk = np.concatenate( (self.caller_audio_chunk, lin_speech_arr)) chunk_idx = max(0, len(self.caller_audio_chunk) - self.QUIET_LENGTH) quiet_chunk = self.caller_audio_chunk[chunk_idx:] if (quiet_chunk < self.QUIET_THRESH).all() and ( self.caller_audio_chunk > self.QUIET_THRESH).any(): text = stream.intermediateDecode() if text.strip(): self.stt_to_chatbot_queue.put(text) idx = len(self.transcript ) # insert to avoid race conditions with indexes self.transcript.insert( idx, { "speaker": "caller", "text": text, "datetime": dt.datetime.now().isoformat() }) self.stt_to_classification_queue.put(idx) stream.finishStream() stream = self.deep_speech.createStream() self.caller_audio_chunk = np.array([], dtype='int16')
def read_sound_file(path): with open(path, 'rb') as fp: au = sunau.open(fp) rate = au.getframerate() nchannels = au.getnchannels() encoding = au._encoding fp.seek(0) data = fp.read() if encoding != sunau.AUDIO_FILE_ENCODING_MULAW_8: raise RuntimeError('Expect .au file with 8-bit mu-law samples') data = audioop.ulaw2lin(data, 2) return data, rate, 16, nchannels
def readframes(self, nframes): if self._encoding in _simple_encodings: if nframes == AUDIO_UNKNOWN_SIZE: data = self._file.read() else: data = self._file.read(nframes * self._framesize) self._soundpos += len(data) // self._framesize if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: import audioop data = audioop.ulaw2lin(data, self._sampwidth) return data return None # XXX--not implemented yet
def RTP_Rx_Thread(self, threadName): #print(threadName, "RTP_Rx_Thread started") while True: data, addr = self.RTP_Sock.recvfrom(1024) #print(threadName, "RTP_Rx_Thread: received message:", data) if data[0:2] == bytes.fromhex('9000'): buffer = audioop.ulaw2lin(data[28:], 2) if RepeaterVolume != 1: buffer = audioop.mul(buffer, 2, RepeaterVolume) buffer, newstate = audioop.ratecv(buffer, 2, 1, self.PCMSAMPLERATE, 48000, None) mumble.sound_output.add_sound(buffer)
def read_sound_file(path): fp = open(path, 'rb') size, enc, rate, nchannels, extra = sunaudio.gethdr(fp) data = fp.read() fp.close() if enc != SND_FORMAT_MULAW_8: print "Expect .au file with 8-bit mu-law samples" return # Convert the data to 16-bit signed. data = audioop.ulaw2lin(data, 2) return (data, rate, 16, nchannels)
def save_output(data, filename): # data is the u-law quantized sample u_law = data u_law = [chr(x) for x in u_law] u_law = ''.join(u_law) original = audioop.ulaw2lin(u_law, input_sample_width) print "output data size: " + str(len(original)) output = wave.open(filename, 'w') output.setparams((input_num_channels, input_sample_width, SAMPLE_RATE, 0, 'NONE', 'not compressed')) output.writeframes(original) output.close()
def readframes(self, nframes): if self._encoding in _simple_encodings: if nframes == AUDIO_UNKNOWN_SIZE: data = self._file.read() else: data = self._file.read(nframes * self._framesize) self._soundpos += len(data) // self._framesize if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: with warnings.catch_warnings(): warnings.simplefilter('ignore', category=DeprecationWarning) import audioop data = audioop.ulaw2lin(data, self._sampwidth) return data return None # XXX--not implemented yet
def read_sound_file(path): with open(path, 'rb') as fp: au = sunau.open(fp) rate = au.getframerate() nchannels = au.getnchannels() encoding = au._encoding fp.seek(0) data = fp.read() if encoding != sunau.AUDIO_FILE_ENCODING_MULAW_8: raise RuntimeError("Expect .au file with 8-bit mu-law samples") # Convert the data to 16-bit signed. data = audioop.ulaw2lin(data, 2) return (data, rate, 16, nchannels)
def load_sph(file_name): """ Load NIST SPH audio file file_name: sph full path """ fsph = sphfile.SPHFile(file_name) # u-law encoding and uint8 sample width assert fsph.format['sample_coding'] == 'ulaw' # transform to pcm16 and [-1, 1] buf = audioop.ulaw2lin(fsph.content, 2) y = np.frombuffer(buf, np.int16) / float(np.iinfo(np.int16).max) ych = [] for ch in range(fsph.format['channel_count']): ych.append(y[ch::2]) ych = np.vstack(ych).T return ych, fsph.format['sample_rate']
def run(self): while 1: olddata = data = self.iport.readsamps(600) if self.do_ulaw: data = audioop.lin2ulaw(data, 2) data = audioop.ulaw2lin(data, 2) if self.do_adpcm: data, nacstate = audioop.lin2adpcm(data, 2, \ self.acstate) data, dummy = audioop.adpcm2lin(data, 2, \ self.acstate) self.acstate = nacstate if self.do_diff: olddata = audioop.mul(olddata, 2, -1) data = audioop.add(olddata, data, 2) self.oport.writesamps(data) fl.check_forms()
def on_data_received(self, data): self._global_data += audioop.ulaw2lin(RTP(data).load, 2) # data.decode() audio_regions = auditok.split( self._global_data, audio_format='bytes', sampling_rate=8000, sample_width=2, channels=1, min_dur=0.3, # minimum duration of a valid audio event in seconds max_dur=6, # maximum duration of an event max_silence= 0.3, # maximum duration of tolerated continuous silence within an event energy_threshold=50 # threshold of detection ) if len(list(audio_regions)) > 1: self.queue_audio.put(self._global_data) self._global_data = b''
def avs_play_audio(queue_data, stream): # Get data from queue try: data = queue_data.get(block=True, timeout=1) if len(data) == 0: return False except: return False #print("queue_data.get {}".format(len(data))) # Decompress and play data if CONF_AUDIO_RECV_BITDEPTH == DEVICE_CAPABILITIES_BITDEPTH_8: data = audioop.ulaw2lin(data, 2) stream.write(data) queue_data.task_done() return True
def analyze(self, bytes_data): ## Отправка в декодер # Декомпрессия из формата u-LAW (PCMU) data = audioop.ulaw2lin(bytes_data, 2) samples = np.frombuffer(data, dtype=np.int16) for s in samples: self.detector.goertzel(s) # Результатом алгоритма декодирования является characters -- список # пар значений (нажатая клавиша, время нажатия в секундах от запуска скрипта) if (self.detector.characters): self.transformInput(self.detector.characters) self.last_sound_time = int(round(time() * 1000)) # В случае, когда звука нет больше 100 мс, камера останавливается elapsed = int(round(time() * 1000)) - self.last_sound_time if elapsed > 100: self.camera.stop() self.detector.characters = []
def RTP_Rx_Thread(self, threadName): #print(threadName, "RTP_Rx_Thread started") self.flushWave() LastWaveSegmentChangeTime = -MAX_SEC_PER_WAVEFILE while True: data, addr = self.RTP_Sock.recvfrom(1024) #print(threadName, "RTP_Rx_Thread: received message:", data) if time.time() - LastWaveSegmentChangeTime >= MAX_SEC_PER_WAVEFILE: self.flushWave() self.WaveSegmentName = WAVE_PATH + 'rec-' + threadName + '-' + time.strftime( '%Y%m%d-%H%M') + '.wav' print( threadName, ':', 'Beginning new segment \"' + self.WaveSegmentName + '\"...') self.wavefile = wave.open(self.WaveSegmentName + '.tmp', 'wb') self.wavefile.setparams( (1, 2, self.PCMSAMPLERATE, 0, 'NONE', 'not compressed')) LastWaveSegmentChangeTime = time.time() if data[0:2] == bytes.fromhex('9000'): self.wavefile.writeframes(audioop.ulaw2lin(data[28:], 2)) self.WaveDataWritten = True
def test_play_sound_file(self): path = findfile("audiotest.au") fp = open(path, 'r') size, enc, rate, nchannels, extra = sunaudio.gethdr(fp) data = fp.read() fp.close() if enc != SND_FORMAT_MULAW_8: self.fail("Expect .au file with 8-bit mu-law samples") # convert the data to 16-bit signed data = audioop.ulaw2lin(data, 2) # set the data format if sys.byteorder == 'little': fmt = linuxaudiodev.AFMT_S16_LE else: fmt = linuxaudiodev.AFMT_S16_BE # set parameters based on .au file headers self.dev.setparameters(rate, 16, nchannels, fmt) self.dev.write(data) self.dev.flush()
"""Stuff to parse AIFF-C and AIFF files.
def _ulaw2lin(self, data): import audioop return audioop.ulaw2lin(data, 2)
"""Stuff to parse Sun and NeXT audio files.
from test_support import verbose, findfile, TestFailed, TestSkipped import errno import fcntl import linuxaudiodev import os import sys import select import sunaudio import time import audioop SND_FORMAT_MULAW_8 = 1 def play_sound_file(path): fp = open(path, 'r') size, enc, rate, nchannels, extra = sunaudio.gethdr(fp) data = fp.read() fp.close() if enc != SND_FORMAT_MULAW_8: print "Expect .au file with 8-bit mu-law samples" return try: a = linuxaudiodev.open('w') except linuxaudiodev.error, msg: if msg[0] in (errno.EACCES, errno.ENODEV): raise TestSkipped, msg raise TestFailed, msg # convert the data to 16-bit signed data = audioop.ulaw2lin(data, 2) # set the data format if sys.byteorder == 'little': fmt = linuxaudiodev.AFMT_S16_LE
def test_ulaw2lin(self): # Cursory d = audioop.lin2ulaw(data[0], 1) self.assertEqual(audioop.ulaw2lin(d, 1), data[0])
# Compare different audio compression schemes.
data = fp.read() fp.close() if enc != SND_FORMAT_MULAW_8: print "Expect .au file with 8-bit mu-law samples" return try: a = linuxaudiodev.open('w') except linuxaudiodev.error, msg: if msg[0] in (errno.EACCES, errno.ENODEV, errno.EBUSY): raise TestSkipped, msg raise TestFailed, msg # convert the data to 16-bit signed data = audioop.ulaw2lin(data, 2) # set the data format if sys.byteorder == 'little': fmt = linuxaudiodev.AFMT_S16_LE else: fmt = linuxaudiodev.AFMT_S16_BE # at least check that these methods can be invoked a.bufsize() a.obufcount() a.obuffree() a.getptr() a.fileno() # set parameters based on .au file headers
def testulaw2lin(data): # Cursory d = audioop.lin2ulaw(data[0], 1) if audioop.ulaw2lin(d, 1) <> data[0]: return 0 return 1
QSIZE = 100000
K.append(sunau.open("soundfiles/whatYouFeel1g.au","w")) k= sunau.open("soundfiles/whatYouFeel1.au","w") currentIndex = 0; replacement = b'\x00' packetsize = 256 prev=0 lossratio = [.1,.2,.35,.5,.7,100] zeroes = False; nframes = math.floor(w.getnframes()) audiostring = w.readframes(nframes) encodedaudio = audioop.lin2ulaw(audiostring, 1) recodedaudio = audioop.ulaw2lin(encodedaudio, 1) for item in J: item.setsampwidth(w.getsampwidth()) item.setframerate(w.getframerate()) item.setcomptype(w.getcomptype(),w.getcompname()) item.setnchannels(w.getnchannels()) for item in K: item.setsampwidth(w.getsampwidth()) item.setframerate(w.getframerate()) item.setcomptype(w.getcomptype(),w.getcompname()) item.setnchannels(w.getnchannels()) '''for i in range (0, packetsize): replacement+=b'\x00'
serv.bind((socket.gethostname(),777)) print '\n'*90,"*"*80,"\n",' '*30,'VoIP Rxer by Godson','\n\n','*'*80,'\n'*17 ip=raw_input("\nEnter the IP of other machine \t") comp=raw_input("\n Select one of the compression technique from the following \n\t1.mue law\n\t2.ADPCM\n") #constants rate=33000 # these things mean nothing. i forgot to remove them(used for some experimentation) bits=8 channels=1 data=[] def recv(bytes): global channels,bits,rate #I used these constants for debugging, they are not used in present code sou=pySonic.Source() print "Received amount of data",len(bytes) sou.Sound=pySonic.MemorySample(bytes,channels,16,44000) #It simply forms a chunk of audio from the received samples sou.Play() print "Playing..." while sou.IsPlaying(): time.sleep(0) #Lol do we need this line!!!!! while True: #A continuous loop which keeps on receving,decompressing & playing the audio data. sample,client=serv.recvfrom(100000) #dont be scared by that number data.append(sample) #All samples were joined together to make a meaningful audio. bytes=''.join(data) # usually this called buffering. This one considerably slows down the program data=[] print "decoding..." if comp=='1': ulaw=audioop.ulaw2lin(bytes,4) #recovering original samples recv(ulaw) else: k=audioop.adpcm2lin(bytes,4,None) recv(k[0])
"""Classes for manipulating audio devices (currently only for Sun and SGI)"""