def read(self, pcm_frames):
# if the stream is exhausted, return an empty pcm.FrameList object
if (self.total_pcm_frames == 0):
return from_list([], self.channels, self.bits_per_sample, True)
# otherwise, read one ALAC frameset's worth of frame data
frameset_data = []
frame_channels = self.reader.read(3) + 1
while (frame_channels != 0x8):
frameset_data.extend(self.read_frame(frame_channels))
frame_channels = self.reader.read(3) + 1
self.reader.byte_align()
# reorder the frameset to Wave order, depending on channel count
if ((self.channels == 1) or (self.channels == 2)):
pass
elif (self.channels == 3):
frameset_data = [
frameset_data[1], frameset_data[2], frameset_data[0]
]
elif (self.channels == 4):
frameset_data = [
frameset_data[1], frameset_data[2], frameset_data[0],
frameset_data[3]
]
elif (self.channels == 5):
frameset_data = [
frameset_data[1], frameset_data[2], frameset_data[0],
frameset_data[3], frameset_data[4]
]
elif (self.channels == 6):
frameset_data = [
frameset_data[1], frameset_data[2], frameset_data[0],
frameset_data[5], frameset_data[3], frameset_data[4]
]
elif (self.channels == 7):
frameset_data = [
frameset_data[1], frameset_data[2], frameset_data[0],
frameset_data[6], frameset_data[3], frameset_data[4],
frameset_data[5]
]
elif (self.channels == 8):
frameset_data = [
frameset_data[3], frameset_data[4], frameset_data[0],
frameset_data[7], frameset_data[5], frameset_data[6],
frameset_data[1], frameset_data[2]
]
else:
raise ValueError("unsupported channel count")
framelist = from_channels([
from_list(channel, 1, self.bits_per_sample, True)
for channel in frameset_data
])
# deduct PCM frames from remainder
self.total_pcm_frames -= framelist.frames
# return samples as a pcm.FrameList object
return framelist
def read(self, pcm_frames):
if (self.pcm_finished):
if (not self.md5_checked):
self.reader.mark()
try:
try:
header = Block_Header.read(self.reader)
sub_blocks_size = header.block_size - 24
sub_blocks_data = \
self.reader.substream(sub_blocks_size)
for sub_block in sub_blocks(sub_blocks_data,
sub_blocks_size):
if (((sub_block.metadata_function == 6) and
(sub_block.nondecoder_data == 1))):
if ((sub_block.data.read_bytes(16) !=
self.md5sum.digest())):
raise ValueError("invalid stream MD5 sum")
except (IOError, ValueError):
#no error if a block isn't found
pass
finally:
self.reader.rewind()
self.reader.unmark()
return from_list([], self.channels, self.bits_per_sample, True)
channels = []
while (True): # in place of a do-while loop
try:
block_header = Block_Header.read(self.reader)
except (ValueError, IOError):
self.pcm_finished = True
return from_list([], self.channels, self.bits_per_sample, True)
sub_blocks_size = block_header.block_size - 24
sub_blocks_data = self.reader.substream(sub_blocks_size)
channels.extend(read_block(block_header,
sub_blocks_size,
sub_blocks_data))
if (block_header.final_block == 1):
break
if ((block_header.block_index +
block_header.block_samples) >= block_header.total_samples):
self.pcm_finished = True
#combine channels of audio data into single block
block = from_channels([from_list(ch, 1, self.bits_per_sample, True)
for ch in channels])
#update MD5 sum
self.md5sum.update(block.to_bytes(False, self.bits_per_sample > 8))
#return single block of audio data
return block
def read(self, pcm_frames):
if (self.pcm_finished):
if (not self.md5_checked):
self.reader.mark()
try:
try:
header = Block_Header.read(self.reader)
sub_blocks_size = header.block_size - 24
sub_blocks_data = \
self.reader.substream(sub_blocks_size)
for sub_block in sub_blocks(sub_blocks_data,
sub_blocks_size):
if (((sub_block.metadata_function == 6) and
(sub_block.nondecoder_data == 1))):
if ((sub_block.data.read_bytes(16) !=
self.md5sum.digest())):
raise ValueError("invalid stream MD5 sum")
except (IOError, ValueError):
#no error if a block isn't found
pass
finally:
self.reader.rewind()
self.reader.unmark()
return from_list([], self.channels, self.bits_per_sample, True)
channels = []
while (True): # in place of a do-while loop
try:
block_header = Block_Header.read(self.reader)
except (ValueError, IOError):
self.pcm_finished = True
return from_list([], self.channels, self.bits_per_sample, True)
sub_blocks_size = block_header.block_size - 24
sub_blocks_data = self.reader.substream(sub_blocks_size)
channels.extend(read_block(block_header,
sub_blocks_size,
sub_blocks_data))
if (block_header.final_block == 1):
break
if ((block_header.block_index +
block_header.block_samples) >= block_header.total_samples):
self.pcm_finished = True
#combine channels of audio data into single block
block = from_channels([from_list(ch, 1, self.bits_per_sample, True)
for ch in channels])
#update MD5 sum
self.md5sum.update(block.to_bytes(False, self.bits_per_sample > 8))
#return single block of audio data
return block
def set_format(self, sample_rate, channels, channel_mask, bits_per_sample):
"""sets the output stream to the given format
if the stream hasn't been initialized, this method initializes it
if the stream has been initialized to a different format,
this method closes and reopens the stream to the new format
if the stream has been initialized to the same format,
this method does nothing"""
if (self.__ossaudio__ is None):
# output hasn't been initialized
import ossaudiodev
AudioOutput.set_format(self, sample_rate, channels, channel_mask,
bits_per_sample)
# initialize audio output device and setup framelist converter
self.__ossaudio__ = ossaudiodev.open('w')
self.__ossmixer__ = ossaudiodev.openmixer()
if (self.bits_per_sample == 8):
self.__ossaudio__.setfmt(ossaudiodev.AFMT_S8_LE)
self.__converter__ = lambda f: f.to_bytes(False, True)
elif (self.bits_per_sample == 16):
self.__ossaudio__.setfmt(ossaudiodev.AFMT_S16_LE)
self.__converter__ = lambda f: f.to_bytes(False, True)
elif (self.bits_per_sample == 24):
from audiotools.pcm import from_list
self.__ossaudio__.setfmt(ossaudiodev.AFMT_S16_LE)
self.__converter__ = lambda f: from_list([
i >> 8 for i in list(f)
], self.channels, 16, True).to_bytes(False, True)
else:
raise ValueError("Unsupported bits-per-sample")
self.__ossaudio__.channels(channels)
self.__ossaudio__.speed(sample_rate)
elif (not self.compatible(sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)):
# output has been initialized to a different format
self.close()
self.set_format(sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)
def set_format(self, sample_rate, channels, channel_mask, bits_per_sample):
"""sets the output stream to the given format
if the stream hasn't been initialized, this method initializes it
if the stream has been initialized to a different format,
this method closes and reopens the stream to the new format
if the stream has been initialized to the same format,
this method does nothing"""
if (self.__ossaudio__ is None):
# output hasn't been initialized
import ossaudiodev
AudioOutput.set_format(self, sample_rate, channels,
channel_mask, bits_per_sample)
# initialize audio output device and setup framelist converter
self.__ossaudio__ = ossaudiodev.open('w')
self.__ossmixer__ = ossaudiodev.openmixer()
if (self.bits_per_sample == 8):
self.__ossaudio__.setfmt(ossaudiodev.AFMT_S8_LE)
self.__converter__ = lambda f: f.to_bytes(False, True)
elif (self.bits_per_sample == 16):
self.__ossaudio__.setfmt(ossaudiodev.AFMT_S16_LE)
self.__converter__ = lambda f: f.to_bytes(False, True)
elif (self.bits_per_sample == 24):
from audiotools.pcm import from_list
self.__ossaudio__.setfmt(ossaudiodev.AFMT_S16_LE)
self.__converter__ = lambda f: from_list(
[i >> 8 for i in list(f)],
self.channels, 16, True).to_bytes(False, True)
else:
raise ValueError("Unsupported bits-per-sample")
self.__ossaudio__.channels(channels)
self.__ossaudio__.speed(sample_rate)
elif (not self.compatible(sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)):
# output has been initialized to a different format
self.close()
self.set_format(sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)
def encode_compressed_frame(writer, pcmreader, options, channels):
if pcmreader.bits_per_sample <= 16:
uncompressed_LSBs = 0
LSBs = []
else:
from audiotools.pcm import from_list
# extract uncompressed LSBs
uncompressed_LSBs = (pcmreader.bits_per_sample - 16) // 8
LSBs = []
for i in range(len(channels[0])):
for c in range(len(channels)):
LSBs.append(channels[c][i] %
(2 ** (pcmreader.bits_per_sample - 16)))
channels = [from_list([i >> (pcmreader.bits_per_sample - 16)
for i in channel], 1, 16, True)
for channel in channels]
if len(channels) == 1:
encode_non_interlaced_frame(writer,
pcmreader,
options,
uncompressed_LSBs,
LSBs,
channels)
else:
interlaced_frames = [BitstreamRecorder(0) for i in
range(options.min_interlacing_leftweight,
options.max_interlacing_leftweight + 1)]
for (leftweight,
frame) in zip(range(options.min_interlacing_leftweight,
options.max_interlacing_leftweight + 1),
interlaced_frames):
encode_interlaced_frame(frame,
pcmreader,
options,
uncompressed_LSBs,
LSBs,
options.interlacing_shift,
leftweight,
channels)
for i in range(len(interlaced_frames) - 1):
if ((interlaced_frames[i].bits() <
min([f.bits() for f in interlaced_frames[i + 1:]]))):
interlaced_frames[i].copy(writer)
break
else:
interlaced_frames[0].copy(writer)
def read(self, pcm_frames):
#if the stream is exhausted,
#verify its MD5 sum and return an empty pcm.FrameList object
if (self.total_frames < 1):
if (self.md5sum == self.current_md5sum.digest()):
return from_list([], self.channels, self.bits_per_sample, True)
else:
raise ValueError("MD5 checksum mismatch")
crc16 = CRC16()
self.reader.add_callback(crc16.update)
#fetch the decoding parameters from the frame header
(block_size,
channel_assignment,
bits_per_sample) = self.read_frame_header()
channel_count = self.CHANNEL_COUNT[channel_assignment]
if (channel_count is None):
raise ValueError("invalid channel assignment")
#channel data will be a list of signed sample lists, one per channel
#such as [[1, 2, 3, ...], [4, 5, 6, ...]] for a 2 channel stream
channel_data = []
for channel_number in xrange(channel_count):
if ((channel_assignment == 0x8) and (channel_number == 1)):
#for left-difference assignment
#the difference channel has 1 additional bit
channel_data.append(self.read_subframe(block_size,
bits_per_sample + 1))
elif ((channel_assignment == 0x9) and (channel_number == 0)):
#for difference-right assignment
#the difference channel has 1 additional bit
channel_data.append(self.read_subframe(block_size,
bits_per_sample + 1))
elif ((channel_assignment == 0xA) and (channel_number == 1)):
#for mid-side assignment
#the side channel has 1 additional bit
channel_data.append(self.read_subframe(block_size,
bits_per_sample + 1))
else:
#otherwise, use the frame's bits-per-sample value
channel_data.append(self.read_subframe(block_size,
bits_per_sample))
#one all the subframes have been decoded,
#reconstruct them depending on the channel assignment
if (channel_assignment == 0x8):
#left-difference
samples = []
for (left, difference) in zip(*channel_data):
samples.append(left)
samples.append(left - difference)
elif (channel_assignment == 0x9):
#difference-right
samples = []
for (difference, right) in zip(*channel_data):
samples.append(difference + right)
samples.append(right)
elif (channel_assignment == 0xA):
#mid-side
samples = []
for (mid, side) in zip(*channel_data):
samples.append((((mid * 2) + (side % 2)) + side) / 2)
samples.append((((mid * 2) + (side % 2)) - side) / 2)
else:
#independent
samples = [0] * block_size * channel_count
for (i, channel) in enumerate(channel_data):
samples[i::channel_count] = channel
self.reader.byte_align()
#read and verify the frame's trailing CRC-16 footer
self.reader.read(16)
self.reader.pop_callback()
if (int(crc16) != 0):
raise ValueError("CRC16 mismatch in frame footer")
#deduct the amount of PCM frames from the remaining amount
self.total_frames -= block_size
#build a pcm.FrameList object from the combined samples
framelist = from_list(samples, channel_count, bits_per_sample, True)
#update the running MD5 sum calculation with the frame's data
self.current_md5sum.update(framelist.to_bytes(0, 1))
#and finally return the frame data
return framelist
def read(self, pcm_frames):
#if the stream is exhausted, return an empty pcm.FrameList object
if (self.total_pcm_frames == 0):
return from_list([], self.channels, self.bits_per_sample, True)
#otherwise, read one ALAC frameset's worth of frame data
frameset_data = []
frame_channels = self.reader.read(3) + 1
while (frame_channels != 0x8):
frameset_data.extend(self.read_frame(frame_channels))
frame_channels = self.reader.read(3) + 1
self.reader.byte_align()
#reorder the frameset to Wave order, depending on channel count
if ((self.channels == 1) or (self.channels == 2)):
pass
elif (self.channels == 3):
frameset_data = [frameset_data[1],
frameset_data[2],
frameset_data[0]]
elif (self.channels == 4):
frameset_data = [frameset_data[1],
frameset_data[2],
frameset_data[0],
frameset_data[3]]
elif (self.channels == 5):
frameset_data = [frameset_data[1],
frameset_data[2],
frameset_data[0],
frameset_data[3],
frameset_data[4]]
elif (self.channels == 6):
frameset_data = [frameset_data[1],
frameset_data[2],
frameset_data[0],
frameset_data[5],
frameset_data[3],
frameset_data[4]]
elif (self.channels == 7):
frameset_data = [frameset_data[1],
frameset_data[2],
frameset_data[0],
frameset_data[6],
frameset_data[3],
frameset_data[4],
frameset_data[5]]
elif (self.channels == 8):
frameset_data = [frameset_data[3],
frameset_data[4],
frameset_data[0],
frameset_data[7],
frameset_data[5],
frameset_data[6],
frameset_data[1],
frameset_data[2]]
else:
raise ValueError("unsupported channel count")
framelist = from_channels([from_list(channel,
1,
self.bits_per_sample,
True)
for channel in frameset_data])
#deduct PCM frames from remainder
self.total_pcm_frames -= framelist.frames
#return samples as a pcm.FrameList object
return framelist
def read(self, pcm_frames):
if (self.total_pcm_frames == 0):
return FrameList("", self.channels, self.bits_per_sample, True,
True)
pcm_frames = min(self.pcm_frames_per_tta_frame, self.total_pcm_frames)
frame_reader = self.reader.substream(
self.frame_sizes[self.current_tta_frame])
crc = CRC32()
frame_reader.add_callback(crc.update)
self.total_pcm_frames -= pcm_frames
self.current_tta_frame += 1
# setup Rice parameters for each channel
k0 = [10] * self.channels
k1 = [10] * self.channels
sum0 = [2**14] * self.channels
sum1 = [2**14] * self.channels
# list of unfiltered output for each channel
unfiltered = [[] for i in range(self.channels)]
for f in range(pcm_frames):
correlated = []
for (c, ch_output) in enumerate(unfiltered):
# read most-significant bits
MSB = frame_reader.unary(0)
if (MSB == 0):
# read least-significant bits
unsigned = frame_reader.read(k0[c])
else:
# read least-significant bits
LSB = frame_reader.read(k1[c])
unshifted = ((MSB - 1) << k1[c]) + LSB
unsigned = unshifted + (1 << k0[c])
# adjust sum1 and k1
sum1[c] += (unshifted - (sum1[c] >> 4))
if (sum1[c] < (2**(k1[c] + 4))):
k1[c] = max(k1[c] - 1, 0)
elif (sum1[c] > (2**(k1[c] + 5))):
k1[c] += 1
# adjust sum0 and k0
sum0[c] += (unsigned - (sum0[c] >> 4))
if (sum0[c] < (2**(k0[c] + 4))):
k0[c] = max(k0[c] - 1, 0)
elif (sum0[c] > (2**(k0[c] + 5))):
k0[c] += 1
# apply sign bit
if ((unsigned % 2) == 1):
# positive
ch_output.append((unsigned + 1) // 2)
else:
# negative
ch_output.append(-(unsigned // 2))
# check frame's trailing CRC32 now that reading is finished
frame_reader.byte_align()
frame_reader.pop_callback()
frame_crc = frame_reader.read(32)
if (int(crc) != frame_crc):
raise ValueError("CRC32 mismatch in frame (0x%8.8X != 0x%8.8X)" %
(frame_crc, int(crc)))
# run hybrid filter on each channel
filtered = []
for unfiltered_ch in unfiltered:
filtered.append(tta_filter(self.bits_per_sample, unfiltered_ch))
# run fixed order prediction on each channel
predicted = []
for filtered_ch in filtered:
predicted.append(fixed_predictor(self.bits_per_sample,
filtered_ch))
if (self.channels == 1):
# send channel as-is
return from_list(predicted[0], 1, self.bits_per_sample, True)
else:
# decorrelate channels
decorrelated = decorrelate(predicted)
# return all channels as single FrameList
return from_channels([
from_list(decorrelated_ch, 1, self.bits_per_sample, True)
for decorrelated_ch in decorrelated
])
def read(self, pcm_frames):
if self.stream_finished:
return from_channels([empty_framelist(1, self.bits_per_sample)
for channel in range(self.channels)])
c = 0
samples = []
unshifted = []
while True:
command = self.unsigned(2)
if (((0 <= command) and (command <= 3) or
(7 <= command) and (command <= 8))):
# audio data commands
if command == 0: # DIFF0
samples.append(self.read_diff0(self.block_length,
self.means[c]))
elif command == 1: # DIFF1
samples.append(self.read_diff1(self.block_length,
self.wrapped_samples[c]))
elif command == 2: # DIFF2
samples.append(self.read_diff2(self.block_length,
self.wrapped_samples[c]))
elif command == 3: # DIFF3
samples.append(self.read_diff3(self.block_length,
self.wrapped_samples[c]))
elif command == 7: # QLPC
samples.append(self.read_qlpc(self.block_length,
self.means[c],
self.wrapped_samples[c]))
elif command == 8: # ZERO
samples.append([0] * self.block_length)
# update means for channel
self.means[c].append(shnmean(samples[c]))
self.means[c] = self.means[c][1:]
# wrap samples for next command in channel
self.wrapped_samples[c] = samples[c][-(max(3, self.max_LPC)):]
# apply left shift to samples
if self.left_shift > 0:
unshifted.append([s << self.left_shift
for s in samples[c]])
else:
unshifted.append(samples[c])
c += 1
if c == self.channels:
# return a FrameList from shifted data
return from_channels([from_list(channel, 1,
self.bits_per_sample,
self.signed_samples)
for channel in unshifted])
else:
# non audio commands
if command == 4: # QUIT
self.stream_finished = True
return from_channels(
[empty_framelist(1, self.bits_per_sample)
for channel in range(self.channels)])
elif command == 5: # BLOCKSIZE
self.block_length = self.long()
elif command == 6: # BITSHIFT
self.left_shift = self.unsigned(2)
elif command == 9: # VERBATIM
# skip this command during reading
size = self.unsigned(5)
for i in range(size):
self.skip_unsigned(8)
else:
raise ValueError("unsupported Shorten command")
def read(self, pcm_frames):
if (self.total_pcm_frames == 0):
return FrameList("",
self.channels,
self.bits_per_sample,
True,
True)
pcm_frames = min(self.pcm_frames_per_tta_frame, self.total_pcm_frames)
frame_reader = self.reader.substream(
self.frame_sizes[self.current_tta_frame])
crc = CRC32()
frame_reader.add_callback(crc.update)
self.total_pcm_frames -= pcm_frames
self.current_tta_frame += 1
#setup Rice parameters for each channel
k0 = [10] * self.channels
k1 = [10] * self.channels
sum0 = [2 ** 14] * self.channels
sum1 = [2 ** 14] * self.channels
#list of unfiltered output for each channel
unfiltered = [[] for i in xrange(self.channels)]
for f in xrange(pcm_frames):
correlated = []
for (c, ch_output) in enumerate(unfiltered):
#read most-significant bits
MSB = frame_reader.unary(0)
if (MSB == 0):
#read least-significant bits
unsigned = frame_reader.read(k0[c])
else:
#read least-significant bits
LSB = frame_reader.read(k1[c])
unshifted = ((MSB - 1) << k1[c]) + LSB
unsigned = unshifted + (1 << k0[c])
#adjust sum1 and k1
sum1[c] += (unshifted - (sum1[c] >> 4))
if (sum1[c] < (2 ** (k1[c] + 4))):
k1[c] = max(k1[c] - 1, 0)
elif (sum1[c] > (2 ** (k1[c] + 5))):
k1[c] += 1
#adjust sum0 and k0
sum0[c] += (unsigned - (sum0[c] >> 4))
if (sum0[c] < (2 ** (k0[c] + 4))):
k0[c] = max(k0[c] - 1, 0)
elif (sum0[c] > (2 ** (k0[c] + 5))):
k0[c] += 1
#apply sign bit
if ((unsigned % 2) == 1):
#positive
ch_output.append((unsigned + 1) / 2)
else:
#negative
ch_output.append(-(unsigned / 2))
#check frame's trailing CRC32 now that reading is finished
frame_reader.byte_align()
frame_reader.pop_callback()
frame_crc = frame_reader.read(32)
if (int(crc) != frame_crc):
raise ValueError("CRC32 mismatch in frame (0x%8.8X != 0x%8.8X)" %
(frame_crc, int(crc)))
#run hybrid filter on each channel
filtered = []
for unfiltered_ch in unfiltered:
filtered.append(
tta_filter(self.bits_per_sample, unfiltered_ch))
#run fixed order prediction on each channel
predicted = []
for filtered_ch in filtered:
predicted.append(
fixed_predictor(self.bits_per_sample, filtered_ch))
if (self.channels == 1):
#send channel as-is
return from_list(predicted[0],
1,
self.bits_per_sample,
True)
else:
#decorrelate channels
decorrelated = decorrelate(predicted)
#return all channels as single FrameList
return from_channels([from_list(decorrelated_ch,
1,
self.bits_per_sample,
True)
for decorrelated_ch in decorrelated])
def read(self, pcm_frames):
# if the stream is exhausted,
# verify its MD5 sum and return an empty pcm.FrameList object
if (self.total_frames < 1):
if (self.md5sum == self.current_md5sum.digest()):
return empty_framelist(self.channels, self.bits_per_sample)
else:
raise ValueError("MD5 checksum mismatch")
crc16 = CRC16()
self.reader.add_callback(crc16.update)
# fetch the decoding parameters from the frame header
(block_size, channel_assignment,
bits_per_sample) = self.read_frame_header()
channel_count = self.CHANNEL_COUNT[channel_assignment]
if (channel_count is None):
raise ValueError("invalid channel assignment")
# channel data will be a list of signed sample lists, one per channel
# such as [[1, 2, 3, ...], [4, 5, 6, ...]] for a 2 channel stream
channel_data = []
for channel_number in range(channel_count):
if ((channel_assignment == 0x8) and (channel_number == 1)):
# for left-difference assignment
# the difference channel has 1 additional bit
channel_data.append(
self.read_subframe(block_size, bits_per_sample + 1))
elif ((channel_assignment == 0x9) and (channel_number == 0)):
# for difference-right assignment
# the difference channel has 1 additional bit
channel_data.append(
self.read_subframe(block_size, bits_per_sample + 1))
elif ((channel_assignment == 0xA) and (channel_number == 1)):
# for average-difference assignment
# the difference channel has 1 additional bit
channel_data.append(
self.read_subframe(block_size, bits_per_sample + 1))
else:
# otherwise, use the frame's bits-per-sample value
channel_data.append(
self.read_subframe(block_size, bits_per_sample))
# one all the subframes have been decoded,
# reconstruct them depending on the channel assignment
if (channel_assignment == 0x8):
# left-difference
samples = []
for (left, difference) in zip(*channel_data):
samples.append(left)
samples.append(left - difference)
elif (channel_assignment == 0x9):
# difference-right
samples = []
for (difference, right) in zip(*channel_data):
samples.append(difference + right)
samples.append(right)
elif (channel_assignment == 0xA):
# mid-side
samples = []
for (mid, side) in zip(*channel_data):
samples.append((((mid * 2) + (side % 2)) + side) // 2)
samples.append((((mid * 2) + (side % 2)) - side) // 2)
else:
# independent
samples = [0] * block_size * channel_count
for (i, channel) in enumerate(channel_data):
samples[i::channel_count] = channel
self.reader.byte_align()
# read and verify the frame's trailing CRC-16 footer
self.reader.read(16)
self.reader.pop_callback()
if (int(crc16) != 0):
raise ValueError("CRC16 mismatch in frame footer")
# deduct the amount of PCM frames from the remaining amount
self.total_frames -= block_size
# build a pcm.FrameList object from the combined samples
framelist = from_list(samples, channel_count, bits_per_sample, True)
# update the running MD5 sum calculation with the frame's data
self.current_md5sum.update(framelist.to_bytes(0, 1))
# and finally return the frame data
return framelist
def read(self, pcm_frames):
if (self.stream_finished):
return from_channels([
empty_framelist(1, self.bits_per_sample)
for channel in range(self.channels)
])
c = 0
samples = []
unshifted = []
while (True):
command = self.unsigned(2)
if (((0 <= command) and (command <= 3)
or (7 <= command) and (command <= 8))):
# audio data commands
if (command == 0): # DIFF0
samples.append(
self.read_diff0(self.block_length, self.means[c]))
elif (command == 1): # DIFF1
samples.append(
self.read_diff1(self.block_length,
self.wrapped_samples[c]))
elif (command == 2): # DIFF2
samples.append(
self.read_diff2(self.block_length,
self.wrapped_samples[c]))
elif (command == 3): # DIFF3
samples.append(
self.read_diff3(self.block_length,
self.wrapped_samples[c]))
elif (command == 7): # QLPC
samples.append(
self.read_qlpc(self.block_length, self.means[c],
self.wrapped_samples[c]))
elif (command == 8): # ZERO
samples.append([0] * self.block_length)
# update means for channel
self.means[c].append(shnmean(samples[c]))
self.means[c] = self.means[c][1:]
# wrap samples for next command in channel
self.wrapped_samples[c] = samples[c][-(max(3, self.max_LPC)):]
# apply left shift to samples
if (self.left_shift > 0):
unshifted.append(
[s << self.left_shift for s in samples[c]])
else:
unshifted.append(samples[c])
c += 1
if (c == self.channels):
# return a FrameList from shifted data
return from_channels([
from_list(channel, 1, self.bits_per_sample,
self.signed_samples) for channel in unshifted
])
else:
# non audio commands
if (command == 4): # QUIT
self.stream_finished = True
return from_channels([
empty_framelist(1, self.bits_per_sample)
for channel in range(self.channels)
])
elif (command == 5): # BLOCKSIZE
self.block_length = self.long()
elif (command == 6): # BITSHIFT
self.left_shift = self.unsigned(2)
elif (command == 9): # VERBATIM
# skip this command during reading
size = self.unsigned(5)
for i in range(size):
self.skip_unsigned(8)
else:
raise ValueError("unsupported Shorten command")