def test_adpcm2lin(self):
# Very cursory test
self.assertEqual(audioop.adpcm2lin(b'\0\0', 1, None),
(b'\0' * 4, (0, 0)))
self.assertEqual(audioop.adpcm2lin(b'\0\0', 2, None),
(b'\0' * 8, (0, 0)))
self.assertEqual(audioop.adpcm2lin(b'\0\0', 4, None),
(b'\0' * 16, (0, 0)))
def test_adpcm2lin(self):
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 1, None),
(b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 2, None),
(packs[2](0, 0xb, 0x29, -0x16, 0x72, -0xb3), (-179, 40)))
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 4, None),
(packs[4](0, 0xb0000, 0x290000, -0x160000, 0x720000,
-0xb30000), (-179, 40)))
# Very cursory test
for w in 1, 2, 4:
self.assertEqual(audioop.adpcm2lin(b'\0' * 5, w, None),
(b'\0' * w * 10, (0, 0)))
def test_adpcm2lin(self):
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 1, None),
(b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 2, None),
(packs[2](0, 0xb, 0x29, -0x16, 0x72, -0xb3), (-179, 40)))
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 4, None),
(packs[4](0, 0xb0000, 0x290000, -0x160000, 0x720000,
-0xb30000), (-179, 40)))
# Very cursory test
for w in 1, 2, 4:
self.assertEqual(audioop.adpcm2lin(b'\0' * 5, w, None),
(b'\0' * w * 10, (0, 0)))
def test_adpcm2lin(self):
self.assertEqual(audioop.adpcm2lin(b"\x07\x7f\x7f", 1, None), (b"\x00\x00\x00\xff\x00\xff", (-179, 40)))
self.assertEqual(
audioop.adpcm2lin(b"\x07\x7f\x7f", 2, None), (packs[2](0, 0xB, 0x29, -0x16, 0x72, -0xB3), (-179, 40))
)
self.assertEqual(
audioop.adpcm2lin(b"\x07\x7f\x7f", 4, None),
(packs[4](0, 0xB0000, 0x290000, -0x160000, 0x720000, -0xB30000), (-179, 40)),
)
# Very cursory test
for w in 1, 2, 4:
self.assertEqual(audioop.adpcm2lin(b"\0" * 5, w, None), (b"\0" * w * 10, (0, 0)))
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 GetSound(
self,
index,
outputpath=None
): #index 0 is BGM. 1, 2 and 3 is SFX. if outputpath is None, the raw mono PCM @ 8184Hz is returned instead
if self.Loaded[2]:
if self.SoundData[index]:
#reverse nibbles:
data = []
for i in map(ord, self.SoundData[index]):
data.append(chr((i & 0xF) << 4 | (i >> 4)))
data = "".join(data)
#4bit ADPCM decode
decoded = audioop.adpcm2lin(data, 2, None)[0]
#write to wav:
if outputpath:
f = wave.open(outputpath, "wb")
f.setnchannels(1)
f.setsampwidth(2)
f.setframerate(
8192
) #possibly 8184, but not a noticable difference anyway
f.writeframes(decoded)
#f.writeframes("".join(out))
f.close()
return True
else:
return decoded
else:
return False
def _adpcm2lin(self, data):
import audioop
if not hasattr(self, '_adpcmstate'):
# first time
self._adpcmstate = None
data, self._adpcmstate = audioop.adpcm2lin(data, 2, self._adpcmstate)
return data
def GetSound(self, index, outputpath=None):#index 0 is BGM. 1, 2 and 3 is SFX. if outputpath is None, the raw mono PCM @ 8184Hz is returned instead
if self.Loaded[2]:
if self.SoundData[index]:
#reverse nibbles:
data = []
for i in map(ord,self.SoundData[index]):
data.append(chr((i&0xF)<< 4 | (i>>4)))
data = "".join(data)
#4bit ADPCM decode
decoded = audioop.adpcm2lin(data, 2, None)[0]
#write to wav:
if outputpath:
f = wave.open(outputpath, "wb")
f.setnchannels(1)
f.setsampwidth(2)
f.setframerate(8192)#possibly 8184, but not a noticable difference anyway
f.writeframes(decoded)
#f.writeframes("".join(out))
f.close()
return True
else:
return decoded
else:
return False
def datagram_received(self, data, addr):
message = audioop.adpcm2lin(zlib.decompress(data), 2, None)
buffer.put(message[0])
if buffer_response.empty():
self.transport.sendto(b'', addr)
else:
self.transport.sendto(buffer_response.get().encode(), addr)
def handleNotification(self, cHandle, data):
#pcm = adpcm_decode(data)
pcm2, self.state = audioop.adpcm2lin(data, 2, self.state)
# p1 = Struct('< 40h').unpack(pcm)
# p2 = Struct('< 40h').unpack(pcm2)
byteorder = '<'
rawbytes = pcm2
b = struct.unpack(byteorder + str(len(rawbytes) // 2) + "h", rawbytes)
# for frame in b:
# # print(frame)
# m = Struct('< h').pack(frame)
# # print(m)
# self.frames.append(m)
# time_old = np.linspace(0, , len(pcm2))
# time_new = np.linspace(0, duration, len(pcm2)*4)
x = np.arange(0, len(b))
y = np.array(b)
# yn = y - 180
f = interpolate.interp1d(x, y)
xnew = np.arange(0, len(b)-1, 0.1523)
new_pcm = f(xnew)
self.frames.append(new_pcm.tobytes())
self.numframes += 1
def handleNotification(self, cHandle, data):
#pcm = adpcm_decode(data)
pcm2, self.state = audioop.adpcm2lin(data, 2, self.state)
# p1 = Struct('< 40h').unpack(pcm)
# p2 = Struct('< 40h').unpack(pcm2)
byteorder = '<'
rawbytes = pcm2
b = struct.unpack(byteorder + str(len(rawbytes) // 2) + "h", rawbytes)
self.frames.append(pcm2)
import numpy as np
from scipy import interpolate
# time_old = np.linspace(0, , len(pcm2))
# time_new = np.linspace(0, duration, len(pcm2)*4)
x = np.arange(0, len(b))
y = np.array(b)
yn = y - 180
f = interpolate.interp1d(x, yn)
xnew = np.arange(0, len(b)-1, 0.5)
new_pcm = f(xnew)
# self.frames.append(new_pcm)
self.numframes += 1
def _adpcm2lin(self, data):
import audioop
if not hasattr(self, '_adpcmstate'):
# first time
self._adpcmstate = None
data, self._adpcmstate = audioop.adpcm2lin(data, 2, self._adpcmstate)
return data
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 _adpcm2lin(self, data):
with warnings.catch_warnings():
warnings.simplefilter('ignore', category=DeprecationWarning)
import audioop
if not hasattr(self, '_adpcmstate'):
# first time
self._adpcmstate = None
data, self._adpcmstate = audioop.adpcm2lin(data, 2, self._adpcmstate)
return data
def datagram_received(self, data, addr):
message = audioop.adpcm2lin(zlib.decompress(data), 2, None)
pair = self.socket_pair(host=addr[0], port=addr[1])
if addr in self.connection_dict:
self.connection_dict[addr].put_buffer(message[0])
resp = self.connection_dict[addr].get_buffer()
self.transport.sendto(resp, addr)
else:
self.connection_dict[addr] = VoiceTranscription()
self.connection_dict[addr].put_buffer(message[0])
def handle(self, data):
# Strip the header at the beginning of the data
data = data[KaicongAudio.HEADER_SIZE:]
# Decompress from ADPCM (differential) to PCM-16L (WAV) format
result = ""
state = None
for i in xrange(0, len(data) - 5, 2): #TODO: No magic numbers
adpcmfragment = data[i:i + 2]
(sample, state) = audioop.adpcm2lin(adpcmfragment, 2, state)
result += sample
return result
def handleNotification(self, cHandle, data):
# print(self.stream.get_write_available())
pcm, self.state = audioop.adpcm2lin(data, 2, self.state)
b = Struct('< 40h').unpack(pcm)
# self.frames.append(pcm)
self.stream.write(pcm)
free = self.stream.get_write_available()
# print(len(pcm)//2, free)
m = Struct('< {}h'.format(free//2)).pack(*[b[-1]]*(free//2))
self.stream.write(m)
# print(self.stream.get_write_available())
self.numframes += 1
def handle(self, data):
# Strip the header at the beginning of the data
data = data[KaicongAudio.HEADER_SIZE:]
# Decompress from ADPCM (differential) to PCM-16L (WAV) format
result = ""
state = None
for i in xrange(0, len(data)-5, 2): #TODO: No magic numbers
adpcmfragment = data[i:i+2]
(sample, state) = audioop.adpcm2lin(adpcmfragment, 2, state)
result += sample
return result
def finish(self):
self.adpcmfile.close()
print("* done recording", self.numframes, "frames")
with open('recording.adpcm', 'rb') as f:
adpcm = f.read()
print(len(adpcm))
pcm, _ = audioop.adpcm2lin(adpcm, 2, None)
print(len(pcm))
# data length is 20 bytes, pcm length is 80 bytes
self.wavfile = wave.open(self.audio_filename, 'wb')
self.wavfile.setparams((1, 2, 8000, self.numframes*40, 'NONE', 'NONE'))
self.wavfile.writeframes(pcm)
self.wavfile.close()
def handle(self, data):
# Strip the header at the beginning of the data
data = data[KaicongAudio.HEADER_SZ:]
# Decompress from ADPCM (differential) to PCM-16L (WAV) format
result = ""
state = None
for i in range(0, len(data), KaicongAudio.SAMPLE_SZ):
adpcmfragment = data[i:i + KaicongAudio.SAMPLE_SZ]
(sample, state) = audioop.adpcm2lin(adpcmfragment,
KaicongAudio.SAMPLE_SZ, state)
result += sample
print(len(result))
return result
def handle(self, data):
# Strip the header at the beginning of the data
data = data[KaicongAudio.HEADER_SZ:]
# Decompress from ADPCM (differential) to PCM-16L (WAV) format
result = ""
state = None
for i in xrange(0, len(data), KaicongAudio.SAMPLE_SZ):
adpcmfragment = data[i:i+KaicongAudio.SAMPLE_SZ]
(sample, state) = audioop.adpcm2lin(
adpcmfragment,
KaicongAudio.SAMPLE_SZ,
state)
result += sample
print len(result)
return result
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 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 test_adpcm2lin(self):
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 1, None),
(b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
self.assertEqual(
audioop.adpcm2lin(bytearray(b'\x07\x7f\x7f'), 1, None),
(b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
self.assertEqual(
audioop.adpcm2lin(memoryview(b'\x07\x7f\x7f'), 1, None),
(b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 2, None),
(packs[2](0, 11, 41, -22, 114, -179), (-179, 40)))
self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 3, None),
(packs[3](0, 2816, 10496, -5632, 29184, -45824),
(-179, 40)))
self.assertEqual(
audioop.adpcm2lin(b'\x07\x7f\x7f', 4, None),
(packs[4](0, 720896, 2686976, -1441792, 7471104, -11730944),
(-179, 40)))
for w in (1, 2, 3, 4):
self.assertEqual(audioop.adpcm2lin(b'\x00' * 5, w, None),
(b'\x00' * w * 10, (0, 0)))
def read_wav(songname, mark_1=0, mark_2=0):
file = wave.open(songname, 'r')
chanl = file.getnchannels()
smwid = file.getsampwidth()
smfreq = file.getframerate()
global tframe
tframe = file.getnframes()
if mark_2 == 0:
mark_2 = tframe
#print "Channels: "+str(chanl)
#print "Sample Width: "+str(smwid)
#print "Sample Freq: "+str(smfreq)
#print "Total Frames: "+str(tframe)
frames = []
songdata = file.readframes(mark_2)
mark_toread = mark_2-mark_1
for mark in range(0, mark_toread):
pcm = audioop.adpcm2lin(songdata[mark+mark_1],2,None)
value = struct.unpack('l', pcm[0])
frames.append(value[0])
#progress(mark+1, mark_toread)
file.close()
return frames
# Compare different audio compression schemes.
def readframes(self, nframes=-1):
import audioop
data, nframes = self._rdr.readframes(nframes)
data, self.__state = audioop.adpcm2lin(data, self.__width,
self.__state)
return data, nframes
def test_adpcm2lin(self):
# Very cursory test
self.assertEqual(audioop.adpcm2lin('\0\0', 1, None),
('\0\0\0\0', (0, 0)))
def decode(self, data):
data, self.state = audioop.adpcm2lin(data, self.width, self.state)
return data
def testadpcm2lin(data):
# Very cursory test
if audioop.adpcm2lin('\0\0', 1, None) <> ('\0\0\0\0', (0,0)):
return 0
return 1
def test_adpcm2lin(self):
# Very cursory test
self.assertEqual(audioop.adpcm2lin('\0\0', 1, None), ('\0\0\0\0', (0,0)))
def callback(input_data, frame_count, time_info, status):
message = audioop.lin2adpcm(input_data, 2, None)
message = audioop.adpcm2lin(message[0], 2, None)
return (message[0], pyaudio.paContinue)
def test_adpcm2lin(self):
# Very cursory test
self.assertEqual(audioop.adpcm2lin(b'\0\0', 1, None), (b'\0' * 4, (0,0)))
self.assertEqual(audioop.adpcm2lin(b'\0\0', 2, None), (b'\0' * 8, (0,0)))
self.assertEqual(audioop.adpcm2lin(b'\0\0', 4, None), (b'\0' * 16, (0,0)))
import audioop
import wave
data = []
with open('output.adpcm', 'rb') as f:
state = (None, None)
byte = f.read(1)
while byte != b'':
state = audioop.adpcm2lin(byte, 4, state[1])
data.append(state[0])
byte = f.read(1)
wf = wave.open('output.wav', 'wb')
wf.setnchannels(2)
wf.setsampwidth(4)
wf.setframerate(44100)
wf.writeframes(b''.join(data))
wf.close()
def adpcm_compress(np_array, sample_width):
compressed = audioop.lin2adpcm(np_array, sample_width, None)
return np.frombuffer(audioop.adpcm2lin(compressed[0], sample_width,
None)[0],
dtype=np.int16)
def datagram_received(self, data, addr):
buffer.put_nowait(audioop.adpcm2lin(zlib.decompress(data), 2, None))
if response.empty():
self.transport.sendto(b'', addr)
else:
self.transport.sendto(response.get().encode(), addr)
"""Stuff to parse AIFF-C and AIFF files.
# Compare different audio compression schemes.
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])
def _decode_adpcm(sounddata, width, step=None):
return sounddata
return audioop.adpcm2lin(sounddata, width, step)
