def __find_next_mp3_frame__(cls, mp3file): from audiotools.id3 import skip_id3v2_comment # if we're starting at an ID3v2 header, skip it to save a bunch of time bytes_skipped = skip_id3v2_comment(mp3file) # then find the next mp3 frame from audiotools.bitstream import BitstreamReader reader = BitstreamReader(mp3file, False) reader.mark() try: (sync, mpeg_id, layer_description) = reader.parse("11u 2u 2u 1p") except IOError as err: reader.unmark() raise err while (not ((sync == 0x7FF) and (mpeg_id in (0, 2, 3)) and (layer_description in (1, 2, 3)))): reader.rewind() reader.unmark() reader.skip(8) bytes_skipped += 1 reader.mark() try: (sync, mpeg_id, layer_description) = reader.parse("11u 2u 2u 1p") except IOError as err: reader.unmark() raise err else: reader.rewind() reader.unmark() return bytes_skipped
def __find_next_mp3_frame__(cls, mp3file): from audiotools.id3 import skip_id3v2_comment # if we're starting at an ID3v2 header, skip it to save a bunch of time bytes_skipped = skip_id3v2_comment(mp3file) # then find the next mp3 frame from audiotools.bitstream import BitstreamReader reader = BitstreamReader(mp3file, 0) reader.mark() try: (sync, mpeg_id, layer_description) = reader.parse("11u 2u 2u 1p") except IOError as err: reader.unmark() raise err while (not ((sync == 0x7FF) and (mpeg_id in (0, 2, 3)) and (layer_description in (1, 2, 3)))): reader.rewind() reader.unmark() reader.skip(8) bytes_skipped += 1 reader.mark() try: (sync, mpeg_id, layer_description) = reader.parse("11u 2u 2u 1p") except IOError as err: reader.unmark() raise err else: reader.rewind() reader.unmark() return bytes_skipped
def __find_mp3_start__(cls, mp3file): """places mp3file at the position of the MP3 file's start""" from audiotools.id3 import skip_id3v2_comment # if we're starting at an ID3v2 header, skip it to save a bunch of time skip_id3v2_comment(mp3file) from audiotools.bitstream import BitstreamReader reader = BitstreamReader(mp3file, False) # skip over any bytes that aren't a valid MPEG header reader.mark() (frame_sync, mpeg_id, layer) = reader.parse("11u 2u 2u 1p") while (not ((frame_sync == 0x7FF) and (mpeg_id in (0, 2, 3)) and (layer in (1, 2, 3)))): reader.rewind() reader.unmark() reader.skip(8) reader.mark() reader.rewind() reader.unmark()
def __find_mp3_start__(cls, mp3file): """places mp3file at the position of the MP3 file's start""" from audiotools.id3 import skip_id3v2_comment # if we're starting at an ID3v2 header, skip it to save a bunch of time skip_id3v2_comment(mp3file) from audiotools.bitstream import BitstreamReader reader = BitstreamReader(mp3file, 0) # skip over any bytes that aren't a valid MPEG header reader.mark() (frame_sync, mpeg_id, layer) = reader.parse("11u 2u 2u 1p") while (not ((frame_sync == 0x7FF) and (mpeg_id in (0, 2, 3)) and (layer in (1, 2, 3)))): reader.rewind() reader.unmark() reader.skip(8) reader.mark() reader.rewind() reader.unmark()
class WavPackDecoder: def __init__(self, filename): self.reader = BitstreamReader(open(filename, "rb"), 1) #read initial block to populate #sample_rate, bits_per_sample, channels, and channel_mask self.reader.mark() block_header = Block_Header.read(self.reader) sub_blocks_size = block_header.block_size - 24 sub_blocks_data = self.reader.substream(sub_blocks_size) if (block_header.sample_rate != 15): self.sample_rate = [6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 192000][block_header.sample_rate] else: sub_blocks_data.mark() try: for sub_block in sub_blocks(sub_blocks_data, sub_blocks_size): if ((sub_block.metadata_function == 7) and (sub_block.nondecoder_data == 1)): self.sample_rate = sub_block.data.read( sub_block.data_size() * 8) break else: raise ValueError("invalid sample rate") finally: sub_blocks_data.rewind() sub_blocks_data.unmark() self.bits_per_sample = [8, 16, 24, 32][block_header.bits_per_sample] if (block_header.initial_block and block_header.final_block): if ((block_header.mono_output == 0) or (block_header.false_stereo == 1)): self.channels = 2 self.channel_mask = 0x3 else: self.channels = 1 self.channel_mask = 0x4 else: #look for channel mask sub block sub_blocks_data.mark() for sub_block in sub_blocks(sub_blocks_data, sub_blocks_size): if ((sub_block.metadata_function == 13) and (sub_block.nondecoder_data == 0)): self.channels = sub_block.data.read(8) self.channel_mask = sub_block.data.read( (sub_block.data_size() - 1) * 8) break else: #FIXME - handle case of no channel mask sub block raise NotImplementedError() sub_blocks_data.rewind() sub_blocks_data.unmark() self.reader.rewind() self.reader.unmark() self.pcm_finished = False self.md5_checked = False self.md5sum = md5() def read(self, bytes): 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 close(self): self.reader.close()
def __read_info__(self): from audiotools.bitstream import BitstreamReader from audiotools import ChannelMask reader = BitstreamReader(open(self.filename, "rb"), 1) reader.mark() try: (block_id, total_samples, bits_per_sample, mono_output, initial_block, final_block, sample_rate) = reader.parse( "4b 64p 32u 64p 2u 1u 8p 1u 1u 5p 5p 4u 37p") if (block_id != b"wvpk"): from audiotools.text import ERR_WAVPACK_INVALID_HEADER raise InvalidWavPack(ERR_WAVPACK_INVALID_HEADER) if (sample_rate != 0xF): self.__samplerate__ = WavPackAudio.SAMPLING_RATE[sample_rate] else: # if unknown, pull from SAMPLE_RATE sub-block for (block_id, nondecoder, data_size, data) in self.sub_blocks(reader): if ((block_id == 0x7) and nondecoder): self.__samplerate__ = data.read(data_size * 8) break else: # no SAMPLE RATE sub-block found # so pull info from FMT chunk reader.rewind() (self.__samplerate__,) = self.fmt_chunk(reader).parse( "32p 32u") self.__bitspersample__ = [8, 16, 24, 32][bits_per_sample] self.__total_frames__ = total_samples if (initial_block and final_block): if (mono_output): self.__channels__ = 1 self.__channel_mask__ = ChannelMask(0x4) else: self.__channels__ = 2 self.__channel_mask__ = ChannelMask(0x3) else: # if not mono or stereo, pull from CHANNEL INFO sub-block reader.rewind() for (block_id, nondecoder, data_size, data) in self.sub_blocks(reader): if ((block_id == 0xD) and not nondecoder): self.__channels__ = data.read(8) self.__channel_mask__ = ChannelMask( data.read((data_size - 1) * 8)) break else: # no CHANNEL INFO sub-block found # so pull info from FMT chunk reader.rewind() fmt = self.fmt_chunk(reader) compression_code = fmt.read(16) self.__channels__ = fmt.read(16) if (compression_code == 1): # this is theoretically possible # with very old .wav files, # but shouldn't happen in practice self.__channel_mask__ = \ {1: ChannelMask.from_fields(front_center=True), 2: ChannelMask.from_fields(front_left=True, front_right=True), 3: ChannelMask.from_fields(front_left=True, front_right=True, front_center=True), 4: ChannelMask.from_fields(front_left=True, front_right=True, back_left=True, back_right=True), 5: ChannelMask.from_fields(front_left=True, front_right=True, back_left=True, back_right=True, front_center=True), 6: ChannelMask.from_fields(front_left=True, front_right=True, back_left=True, back_right=True, front_center=True, low_frequency=True) }.get(self.__channels__, ChannelMask(0)) elif (compression_code == 0xFFFE): fmt.skip(128) mask = fmt.read(32) self.__channel_mask__ = ChannelMask(mask) else: from audiotools.text import ERR_WAVPACK_UNSUPPORTED_FMT raise InvalidWavPack(ERR_WAVPACK_UNSUPPORTED_FMT) finally: reader.unmark() reader.close()
def __read_info__(self): from audiotools.bitstream import BitstreamReader from audiotools import ChannelMask reader = BitstreamReader(open(self.filename, "rb"), 1) reader.mark() try: (block_id, total_samples, bits_per_sample, mono_output, initial_block, final_block, sample_rate) = reader.parse( "4b 64p 32u 64p 2u 1u 8p 1u 1u 5p 5p 4u 37p") if (block_id != 'wvpk'): from audiotools.text import ERR_WAVPACK_INVALID_HEADER raise InvalidWavPack(ERR_WAVPACK_INVALID_HEADER) if (sample_rate != 0xF): self.__samplerate__ = WavPackAudio.SAMPLING_RATE[sample_rate] else: # if unknown, pull from SAMPLE_RATE sub-block for (block_id, nondecoder, data_size, data) in self.sub_blocks(reader): if ((block_id == 0x7) and nondecoder): self.__samplerate__ = data.read(data_size * 8) break else: # no SAMPLE RATE sub-block found # so pull info from FMT chunk reader.rewind() (self.__samplerate__,) = self.fmt_chunk(reader).parse( "32p 32u") self.__bitspersample__ = [8, 16, 24, 32][bits_per_sample] self.__total_frames__ = total_samples if (initial_block and final_block): if (mono_output): self.__channels__ = 1 self.__channel_mask__ = ChannelMask(0x4) else: self.__channels__ = 2 self.__channel_mask__ = ChannelMask(0x3) else: # if not mono or stereo, pull from CHANNEL INFO sub-block reader.rewind() for (block_id, nondecoder, data_size, data) in self.sub_blocks(reader): if ((block_id == 0xD) and not nondecoder): self.__channels__ = data.read(8) self.__channel_mask__ = ChannelMask( data.read((data_size - 1) * 8)) break else: # no CHANNEL INFO sub-block found # so pull info from FMT chunk reader.rewind() fmt = self.fmt_chunk(reader) compression_code = fmt.read(16) self.__channels__ = fmt.read(16) if (compression_code == 1): # this is theoretically possible # with very old .wav files, # but shouldn't happen in practice self.__channel_mask__ = \ {1: ChannelMask.from_fields(front_center=True), 2: ChannelMask.from_fields(front_left=True, front_right=True), 3: ChannelMask.from_fields(front_left=True, front_right=True, front_center=True), 4: ChannelMask.from_fields(front_left=True, front_right=True, back_left=True, back_right=True), 5: ChannelMask.from_fields(front_left=True, front_right=True, back_left=True, back_right=True, front_center=True), 6: ChannelMask.from_fields(front_left=True, front_right=True, back_left=True, back_right=True, front_center=True, low_frequency=True) }.get(self.__channels__, ChannelMask(0)) elif (compression_code == 0xFFFE): fmt.skip(128) mask = fmt.read(32) self.__channel_mask__ = ChannelMask(mask) else: from audiotools.text import ERR_WAVPACK_UNSUPPORTED_FMT raise InvalidWavPack(ERR_WAVPACK_UNSUPPORTED_FMT) finally: reader.unmark() reader.close()
class ALACDecoder(object): def __init__(self, filename): self.reader = BitstreamReader(open(filename, "rb"), False) self.reader.mark() try: # locate the "alac" atom # which is full of required decoding parameters try: stsd = self.find_sub_atom(b"moov", b"trak", b"mdia", b"minf", b"stbl", b"stsd") except KeyError: raise ValueError("required stsd atom not found") (stsd_version, descriptions) = stsd.parse("8u 24p 32u") (alac1, alac2, self.samples_per_frame, self.bits_per_sample, self.history_multiplier, self.initial_history, self.maximum_k, self.channels, self.sample_rate) = stsd.parse( # ignore much of the stuff in the "high" ALAC atom "32p 4b 6P 16p 16p 16p 4P 16p 16p 16p 16p 4P" + # and use the attributes in the "low" ALAC atom instead "32p 4b 4P 32u 8p 8u 8u 8u 8u 8u 16p 32p 32p 32u") self.channel_mask = { 1: 0x0004, 2: 0x0003, 3: 0x0007, 4: 0x0107, 5: 0x0037, 6: 0x003F, 7: 0x013F, 8: 0x00FF }.get(self.channels, 0) if ((alac1 != b'alac') or (alac2 != b'alac')): raise ValueError("Invalid alac atom") # also locate the "mdhd" atom # which contains the stream's length in PCM frames self.reader.rewind() mdhd = self.find_sub_atom(b"moov", b"trak", b"mdia", b"mdhd") (version, ) = mdhd.parse("8u 24p") if (version == 0): (self.total_pcm_frames, ) = mdhd.parse("32p 32p 32p 32u 2P 16p") elif (version == 1): (self.total_pcm_frames, ) = mdhd.parse("64p 64p 32p 64U 2P 16p") else: raise ValueError("invalid mdhd version") # finally, set our stream to the "mdat" atom self.reader.rewind() (atom_size, atom_name) = self.reader.parse("32u 4b") while (atom_name != b"mdat"): self.reader.skip_bytes(atom_size - 8) (atom_size, atom_name) = self.reader.parse("32u 4b") finally: self.reader.unmark() def find_sub_atom(self, *atom_names): reader = self.reader for (last, next_atom) in iter_last(iter(atom_names)): try: (length, stream_atom) = reader.parse("32u 4b") while (stream_atom != next_atom): reader.skip_bytes(length - 8) (length, stream_atom) = reader.parse("32u 4b") if (last): return reader.substream(length - 8) else: reader = reader.substream(length - 8) except IOError: raise KeyError(next_atom) def read(self, pcm_frames): # if the stream is exhausted, return an empty pcm.FrameList object if (self.total_pcm_frames == 0): return empty_framelist(self.channels, self.bits_per_sample) # 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_frame(self, channel_count): """returns a list of PCM sample lists, one per channel""" # read the ALAC frame header self.reader.skip(16) has_sample_count = self.reader.read(1) uncompressed_lsb_size = self.reader.read(2) uncompressed = self.reader.read(1) if (has_sample_count): sample_count = self.reader.read(32) else: sample_count = self.samples_per_frame if (uncompressed == 1): # if the frame is uncompressed, # read the raw, interlaced samples samples = [ self.reader.read_signed(self.bits_per_sample) for i in range(sample_count * channel_count) ] return [samples[i::channel_count] for i in range(channel_count)] else: # if the frame is compressed, # read the interlacing parameters interlacing_shift = self.reader.read(8) interlacing_leftweight = self.reader.read(8) # subframe headers subframe_headers = [ self.read_subframe_header() for i in range(channel_count) ] # optional uncompressed LSB values if (uncompressed_lsb_size > 0): uncompressed_lsbs = [ self.reader.read(uncompressed_lsb_size * 8) for i in range(sample_count * channel_count) ] else: uncompressed_lsbs = [] sample_size = (self.bits_per_sample - (uncompressed_lsb_size * 8) + channel_count - 1) # and residual blocks residual_blocks = [ self.read_residuals(sample_size, sample_count) for i in range(channel_count) ] # calculate subframe samples based on # subframe header's QLP coefficients and QLP shift-needed decoded_subframes = [ self.decode_subframe(header[0], header[1], sample_size, residuals) for (header, residuals) in zip(subframe_headers, residual_blocks) ] # decorrelate channels according interlacing shift and leftweight decorrelated_channels = self.decorrelate_channels( decoded_subframes, interlacing_shift, interlacing_leftweight) # if uncompressed LSB values are present, # prepend them to each sample of each channel if (uncompressed_lsb_size > 0): channels = [] for (i, channel) in enumerate(decorrelated_channels): assert (len(channel) == len( uncompressed_lsbs[i::channel_count])) channels.append([ s << (uncompressed_lsb_size * 8) | l for (s, l) in zip( channel, uncompressed_lsbs[i::channel_count]) ]) return channels else: return decorrelated_channels def read_subframe_header(self): prediction_type = self.reader.read(4) qlp_shift_needed = self.reader.read(4) rice_modifier = self.reader.read(3) qlp_coefficients = [ self.reader.read_signed(16) for i in range(self.reader.read(5)) ] return (qlp_shift_needed, qlp_coefficients) def read_residuals(self, sample_size, sample_count): residuals = [] history = self.initial_history sign_modifier = 0 i = 0 while (i < sample_count): # get an unsigned residual based on "history" # and on "sample_size" as a lst resort k = min(log2(history // (2**9) + 3), self.maximum_k) unsigned = self.read_residual(k, sample_size) + sign_modifier # clear out old sign modifier, if any sign_modifier = 0 # change unsigned residual to signed residual if (unsigned & 1): residuals.append(-((unsigned + 1) // 2)) else: residuals.append(unsigned // 2) # update history based on unsigned residual if (unsigned <= 0xFFFF): history += ((unsigned * self.history_multiplier) - ((history * self.history_multiplier) >> 9)) else: history = 0xFFFF # if history gets too small, we may have a block of 0 samples # which can be compressed more efficiently if ((history < 128) and ((i + 1) < sample_count)): zeroes_k = min(7 - log2(history) + ((history + 16) // 64), self.maximum_k) zero_residuals = self.read_residual(zeroes_k, 16) if (zero_residuals > 0): residuals.extend([0] * zero_residuals) i += zero_residuals history = 0 if (zero_residuals <= 0xFFFF): sign_modifier = 1 i += 1 return residuals def read_residual(self, k, sample_size): msb = self.reader.read_huffman_code(RESIDUAL) if (msb == -1): return self.reader.read(sample_size) elif (k == 0): return msb else: lsb = self.reader.read(k) if (lsb > 1): return msb * ((1 << k) - 1) + (lsb - 1) elif (lsb == 1): self.reader.unread(1) return msb * ((1 << k) - 1) else: self.reader.unread(0) return msb * ((1 << k) - 1) def decode_subframe(self, qlp_shift_needed, qlp_coefficients, sample_size, residuals): # first sample is always copied verbatim samples = [residuals.pop(0)] if (len(qlp_coefficients) < 31): # the next "coefficient count" samples # are applied as differences to the previous for i in range(len(qlp_coefficients)): samples.append( truncate_bits(samples[-1] + residuals.pop(0), sample_size)) # remaining samples are processed much like LPC for residual in residuals: base_sample = samples[-len(qlp_coefficients) - 1] lpc_sum = sum([(s - base_sample) * c for (s, c) in zip(samples[-len(qlp_coefficients):], reversed(qlp_coefficients))]) outval = (1 << (qlp_shift_needed - 1)) + lpc_sum outval >>= qlp_shift_needed samples.append( truncate_bits(outval + residual + base_sample, sample_size)) buf = samples[-len(qlp_coefficients) - 2:-1] # error value then adjusts the coefficients table if (residual > 0): predictor_num = len(qlp_coefficients) - 1 while ((predictor_num >= 0) and residual > 0): val = (buf[0] - buf[len(qlp_coefficients) - predictor_num]) sign = sign_only(val) qlp_coefficients[predictor_num] -= sign val *= sign residual -= ((val >> qlp_shift_needed) * (len(qlp_coefficients) - predictor_num)) predictor_num -= 1 elif (residual < 0): # the same as above, but we break if residual goes positive predictor_num = len(qlp_coefficients) - 1 while ((predictor_num >= 0) and residual < 0): val = (buf[0] - buf[len(qlp_coefficients) - predictor_num]) sign = -sign_only(val) qlp_coefficients[predictor_num] -= sign val *= sign residual -= ((val >> qlp_shift_needed) * (len(qlp_coefficients) - predictor_num)) predictor_num -= 1 else: # residuals are encoded as simple difference values for residual in residuals: samples.append( truncate_bits(samples[-1] + residual, sample_size)) return samples def decorrelate_channels(self, channel_data, interlacing_shift, interlacing_leftweight): if (len(channel_data) != 2): return channel_data elif (interlacing_leftweight == 0): return channel_data else: left = [] right = [] for (ch1, ch2) in zip(*channel_data): right.append(ch1 - ((ch2 * interlacing_leftweight) // (2**interlacing_shift))) left.append(ch2 + right[-1]) return [left, right] def close(self): self.reader.close() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close()
class ALACDecoder: def __init__(self, filename): self.reader = BitstreamReader(open(filename, "rb"), 0) self.reader.mark() try: #locate the "alac" atom #which is full of required decoding parameters try: stsd = self.find_sub_atom("moov", "trak", "mdia", "minf", "stbl", "stsd") except KeyError: raise ValueError("required stsd atom not found") (stsd_version, descriptions) = stsd.parse("8u 24p 32u") (alac1, alac2, self.samples_per_frame, self.bits_per_sample, self.history_multiplier, self.initial_history, self.maximum_k, self.channels, self.sample_rate) = stsd.parse( #ignore much of the stuff in the "high" ALAC atom "32p 4b 6P 16p 16p 16p 4P 16p 16p 16p 16p 4P" + #and use the attributes in the "low" ALAC atom instead "32p 4b 4P 32u 8p 8u 8u 8u 8u 8u 16p 32p 32p 32u") self.channel_mask = {1: 0x0004, 2: 0x0003, 3: 0x0007, 4: 0x0107, 5: 0x0037, 6: 0x003F, 7: 0x013F, 8: 0x00FF}.get(self.channels, 0) if ((alac1 != 'alac') or (alac2 != 'alac')): raise ValueError("Invalid alac atom") #also locate the "mdhd" atom #which contains the stream's length in PCM frames self.reader.rewind() mdhd = self.find_sub_atom("moov", "trak", "mdia", "mdhd") (version, ) = mdhd.parse("8u 24p") if (version == 0): (self.total_pcm_frames,) = mdhd.parse( "32p 32p 32p 32u 2P 16p") elif (version == 1): (self.total_pcm_frames,) = mdhd.parse( "64p 64p 32p 64U 2P 16p") else: raise ValueError("invalid mdhd version") #finally, set our stream to the "mdat" atom self.reader.rewind() (atom_size, atom_name) = self.reader.parse("32u 4b") while (atom_name != "mdat"): self.reader.skip_bytes(atom_size - 8) (atom_size, atom_name) = self.reader.parse("32u 4b") finally: self.reader.unmark() def find_sub_atom(self, *atom_names): reader = self.reader for (last, next_atom) in iter_last(iter(atom_names)): try: (length, stream_atom) = reader.parse("32u 4b") while (stream_atom != next_atom): reader.skip_bytes(length - 8) (length, stream_atom) = reader.parse("32u 4b") if (last): return reader.substream(length - 8) else: reader = reader.substream(length - 8) except IOError: raise KeyError(next_atom) 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_frame(self, channel_count): """returns a list of PCM sample lists, one per channel""" #read the ALAC frame header self.reader.skip(16) has_sample_count = self.reader.read(1) uncompressed_lsb_size = self.reader.read(2) uncompressed = self.reader.read(1) if (has_sample_count): sample_count = self.reader.read(32) else: sample_count = self.samples_per_frame if (uncompressed == 1): #if the frame is uncompressed, #read the raw, interlaced samples samples = [self.reader.read_signed(self.bits_per_sample) for i in xrange(sample_count * channel_count)] return [samples[i::channel_count] for i in xrange(channel_count)] else: #if the frame is compressed, #read the interlacing parameters interlacing_shift = self.reader.read(8) interlacing_leftweight = self.reader.read(8) #subframe headers subframe_headers = [self.read_subframe_header() for i in xrange(channel_count)] #optional uncompressed LSB values if (uncompressed_lsb_size > 0): uncompressed_lsbs = [ self.reader.read(uncompressed_lsb_size * 8) for i in xrange(sample_count * channel_count)] else: uncompressed_lsbs = [] sample_size = (self.bits_per_sample - (uncompressed_lsb_size * 8) + channel_count - 1) #and residual blocks residual_blocks = [self.read_residuals(sample_size, sample_count) for i in xrange(channel_count)] #calculate subframe samples based on #subframe header's QLP coefficients and QLP shift-needed decoded_subframes = [self.decode_subframe(header[0], header[1], sample_size, residuals) for (header, residuals) in zip(subframe_headers, residual_blocks)] #decorrelate channels according interlacing shift and leftweight decorrelated_channels = self.decorrelate_channels( decoded_subframes, interlacing_shift, interlacing_leftweight) #if uncompressed LSB values are present, #prepend them to each sample of each channel if (uncompressed_lsb_size > 0): channels = [] for (i, channel) in enumerate(decorrelated_channels): assert(len(channel) == len(uncompressed_lsbs[i::channel_count])) channels.append([s << (uncompressed_lsb_size * 8) | l for (s, l) in zip(channel, uncompressed_lsbs[i::channel_count])]) return channels else: return decorrelated_channels def read_subframe_header(self): prediction_type = self.reader.read(4) qlp_shift_needed = self.reader.read(4) rice_modifier = self.reader.read(3) qlp_coefficients = [self.reader.read_signed(16) for i in xrange(self.reader.read(5))] return (qlp_shift_needed, qlp_coefficients) def read_residuals(self, sample_size, sample_count): residuals = [] history = self.initial_history sign_modifier = 0 i = 0 while (i < sample_count): #get an unsigned residual based on "history" #and on "sample_size" as a lst resort k = min(log2(history / (2 ** 9) + 3), self.maximum_k) unsigned = self.read_residual(k, sample_size) + sign_modifier #clear out old sign modifier, if any sign_modifier = 0 #change unsigned residual to signed residual if (unsigned & 1): residuals.append(-((unsigned + 1) / 2)) else: residuals.append(unsigned / 2) #update history based on unsigned residual if (unsigned <= 0xFFFF): history += ((unsigned * self.history_multiplier) - ((history * self.history_multiplier) >> 9)) else: history = 0xFFFF #if history gets too small, we may have a block of 0 samples #which can be compressed more efficiently if ((history < 128) and ((i + 1) < sample_count)): zeroes_k = min(7 - log2(history) + ((history + 16) / 64), self.maximum_k) zero_residuals = self.read_residual(zeroes_k, 16) if (zero_residuals > 0): residuals.extend([0] * zero_residuals) i += zero_residuals history = 0 if (zero_residuals <= 0xFFFF): sign_modifier = 1 i += 1 return residuals def read_residual(self, k, sample_size): msb = self.reader.limited_unary(0, 9) if (msb is None): return self.reader.read(sample_size) elif (k == 0): return msb else: lsb = self.reader.read(k) if (lsb > 1): return msb * ((1 << k) - 1) + (lsb - 1) elif (lsb == 1): self.reader.unread(1) return msb * ((1 << k) - 1) else: self.reader.unread(0) return msb * ((1 << k) - 1) def decode_subframe(self, qlp_shift_needed, qlp_coefficients, sample_size, residuals): #first sample is always copied verbatim samples = [residuals.pop(0)] if (len(qlp_coefficients) < 31): #the next "coefficient count" samples #are applied as differences to the previous for i in xrange(len(qlp_coefficients)): samples.append(truncate_bits(samples[-1] + residuals.pop(0), sample_size)) #remaining samples are processed much like LPC for residual in residuals: base_sample = samples[-len(qlp_coefficients) - 1] lpc_sum = sum([(s - base_sample) * c for (s, c) in zip(samples[-len(qlp_coefficients):], reversed(qlp_coefficients))]) outval = (1 << (qlp_shift_needed - 1)) + lpc_sum outval >>= qlp_shift_needed samples.append(truncate_bits(outval + residual + base_sample, sample_size)) buf = samples[-len(qlp_coefficients) - 2:-1] #error value then adjusts the coefficients table if (residual > 0): predictor_num = len(qlp_coefficients) - 1 while ((predictor_num >= 0) and residual > 0): val = (buf[0] - buf[len(qlp_coefficients) - predictor_num]) sign = sign_only(val) qlp_coefficients[predictor_num] -= sign val *= sign residual -= ((val >> qlp_shift_needed) * (len(qlp_coefficients) - predictor_num)) predictor_num -= 1 elif (residual < 0): #the same as above, but we break if residual goes positive predictor_num = len(qlp_coefficients) - 1 while ((predictor_num >= 0) and residual < 0): val = (buf[0] - buf[len(qlp_coefficients) - predictor_num]) sign = -sign_only(val) qlp_coefficients[predictor_num] -= sign val *= sign residual -= ((val >> qlp_shift_needed) * (len(qlp_coefficients) - predictor_num)) predictor_num -= 1 else: #residuals are encoded as simple difference values for residual in residuals: samples.append(truncate_bits(samples[-1] + residual, sample_size)) return samples def decorrelate_channels(self, channel_data, interlacing_shift, interlacing_leftweight): if (len(channel_data) != 2): return channel_data elif (interlacing_leftweight == 0): return channel_data else: left = [] right = [] for (ch1, ch2) in zip(*channel_data): right.append(ch1 - ((ch2 * interlacing_leftweight) / (2 ** interlacing_shift))) left.append(ch2 + right[-1]) return [left, right] def close(self): pass
class SHNDecoder(object): def __init__(self, filename): self.reader = BitstreamReader(open(filename, "rb"), False) (self.file_type, self.channels, self.block_length, self.max_LPC, self.number_of_means) = self.read_header() if ((1 <= self.file_type) and (self.file_type <= 2)): self.bits_per_sample = 8 self.signed_samples = (self.file_type == 1) elif ((3 <= self.file_type) and (self.file_type <= 6)): self.bits_per_sample = 16 self.signed_samples = (self.file_type in (3, 5)) else: raise ValueError("unsupported Shorten file type") self.wrapped_samples = [[0] * 3 for c in range(self.channels)] self.means = [[0] * self.number_of_means for c in range(self.channels)] self.left_shift = 0 self.stream_finished = False # try to read the first command for a wave/aiff header self.reader.mark() self.read_metadata() self.reader.rewind() self.reader.unmark() def read_metadata(self): from io import BytesIO command = self.unsigned(2) if (command == 9): # got verbatim, so read data verbatim_bytes = ints_to_bytes([self.unsigned(8) & 0xFF for i in range(self.unsigned(5))]) try: wave = BitstreamReader(BytesIO(verbatim_bytes), True) header = wave.read_bytes(12) if (header.startswith(b"RIFF") and header.endswith(b"WAVE")): # got RIFF/WAVE header, so parse wave blocks as needed total_size = len(verbatim_bytes) - 12 while (total_size > 0): (chunk_id, chunk_size) = wave.parse("4b 32u") total_size -= 8 if (chunk_id == b'fmt '): (channels, self.sample_rate, bits_per_sample, channel_mask) = parse_fmt( wave.substream(chunk_size)) self.channel_mask = int(channel_mask) return else: if (chunk_size % 2): wave.read_bytes(chunk_size + 1) total_size -= (chunk_size + 1) else: wave.read_bytes(chunk_size) total_size -= chunk_size else: # no fmt chunk, so use default metadata pass except (IOError, ValueError): pass try: aiff = BitstreamReader(BytesIO(verbatim_bytes), False) header = aiff.read_bytes(12) if (header.startswith(b"FORM") and header.endswith(b"AIFF")): # got FORM/AIFF header, so parse aiff blocks as needed total_size = len(verbatim_bytes) - 12 while (total_size > 0): (chunk_id, chunk_size) = aiff.parse("4b 32u") total_size -= 8 if (chunk_id == b'COMM'): (channels, total_sample_frames, bits_per_sample, self.sample_rate, channel_mask) = parse_comm( aiff.substream(chunk_size)) self.channel_mask = int(channel_mask) return else: if (chunk_size % 2): aiff.read_bytes(chunk_size + 1) total_size -= (chunk_size + 1) else: aiff.read_bytes(chunk_size) total_size -= chunk_size else: # no COMM chunk, so use default metadata pass except IOError: pass # got something else, so invent some PCM parameters self.sample_rate = 44100 if (self.channels == 1): self.channel_mask = 0x4 elif (self.channels == 2): self.channel_mask = 0x3 else: self.channel_mask = 0 def unsigned(self, c): MSB = self.reader.unary(1) LSB = self.reader.read(c) return MSB * 2 ** c + LSB def signed(self, c): u = self.unsigned(c + 1) if ((u % 2) == 0): return u // 2 else: return -(u // 2) - 1 def long(self): return self.unsigned(self.unsigned(2)) def skip_unsigned(self, c): self.reader.skip_unary(1) self.reader.skip(c) def read_header(self): magic = self.reader.read_bytes(4) if (magic != b"ajkg"): raise ValueError("invalid magic number") version = self.reader.read(8) if (version != 2): raise ValueError("unsupported version") file_type = self.long() channels = self.long() block_length = self.long() max_LPC = self.long() number_of_means = self.long() bytes_to_skip = self.long() self.reader.read_bytes(bytes_to_skip) return (file_type, channels, block_length, max_LPC, number_of_means) 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_diff0(self, block_length, means): offset = shnmean(means) energy = self.unsigned(3) samples = [] for i in range(block_length): residual = self.signed(energy) samples.append(residual + offset) return samples def read_diff1(self, block_length, previous_samples): samples = previous_samples[-1:] energy = self.unsigned(3) for i in range(1, block_length + 1): residual = self.signed(energy) samples.append(samples[i - 1] + residual) return samples[1:] def read_diff2(self, block_length, previous_samples): samples = previous_samples[-2:] energy = self.unsigned(3) for i in range(2, block_length + 2): residual = self.signed(energy) samples.append((2 * samples[i - 1]) - samples[i - 2] + residual) return samples[2:] def read_diff3(self, block_length, previous_samples): samples = previous_samples[-3:] energy = self.unsigned(3) for i in range(3, block_length + 3): residual = self.signed(energy) samples.append((3 * (samples[i - 1] - samples[i - 2])) + samples[i - 3] + residual) return samples[3:] def read_qlpc(self, block_length, means, previous_samples): offset = shnmean(means) energy = self.unsigned(3) LPC_count = self.unsigned(2) LPC_coeff = [self.signed(5) for i in range(LPC_count)] unoffset = [] samples = previous_samples[-LPC_count:] for i in range(block_length): residual = self.signed(energy) LPC_sum = 2 ** 5 for j in range(LPC_count): if ((i - j - 1) < 0): # apply offset to warm-up samples LPC_sum += (LPC_coeff[j] * (samples[LPC_count + (i - j - 1)] - offset)) else: LPC_sum += LPC_coeff[j] * unoffset[i - j - 1] unoffset.append(LPC_sum // 2 ** 5 + residual) return [u + offset for u in unoffset] def close(self): self.reader.close() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close()
class SHNDecoder(object): def __init__(self, filename): self.reader = BitstreamReader(open(filename, "rb"), False) (self.file_type, self.channels, self.block_length, self.max_LPC, self.number_of_means) = self.read_header() if ((1 <= self.file_type) and (self.file_type <= 2)): self.bits_per_sample = 8 self.signed_samples = (self.file_type == 1) elif ((3 <= self.file_type) and (self.file_type <= 6)): self.bits_per_sample = 16 self.signed_samples = (self.file_type in (3, 5)) else: raise ValueError("unsupported Shorten file type") self.wrapped_samples = [[0] * 3 for c in range(self.channels)] self.means = [[0] * self.number_of_means for c in range(self.channels)] self.left_shift = 0 self.stream_finished = False # try to read the first command for a wave/aiff header self.reader.mark() self.read_metadata() self.reader.rewind() self.reader.unmark() def read_metadata(self): from io import BytesIO command = self.unsigned(2) if (command == 9): # got verbatim, so read data verbatim_bytes = ints_to_bytes( [self.unsigned(8) & 0xFF for i in range(self.unsigned(5))]) try: wave = BitstreamReader(BytesIO(verbatim_bytes), True) header = wave.read_bytes(12) if (header.startswith(b"RIFF") and header.endswith(b"WAVE")): # got RIFF/WAVE header, so parse wave blocks as needed total_size = len(verbatim_bytes) - 12 while (total_size > 0): (chunk_id, chunk_size) = wave.parse("4b 32u") total_size -= 8 if (chunk_id == b'fmt '): (channels, self.sample_rate, bits_per_sample, channel_mask) = parse_fmt( wave.substream(chunk_size)) self.channel_mask = int(channel_mask) return else: if (chunk_size % 2): wave.read_bytes(chunk_size + 1) total_size -= (chunk_size + 1) else: wave.read_bytes(chunk_size) total_size -= chunk_size else: # no fmt chunk, so use default metadata pass except (IOError, ValueError): pass try: aiff = BitstreamReader(BytesIO(verbatim_bytes), False) header = aiff.read_bytes(12) if (header.startswith(b"FORM") and header.endswith(b"AIFF")): # got FORM/AIFF header, so parse aiff blocks as needed total_size = len(verbatim_bytes) - 12 while (total_size > 0): (chunk_id, chunk_size) = aiff.parse("4b 32u") total_size -= 8 if (chunk_id == b'COMM'): (channels, total_sample_frames, bits_per_sample, self.sample_rate, channel_mask) = parse_comm( aiff.substream(chunk_size)) self.channel_mask = int(channel_mask) return else: if (chunk_size % 2): aiff.read_bytes(chunk_size + 1) total_size -= (chunk_size + 1) else: aiff.read_bytes(chunk_size) total_size -= chunk_size else: # no COMM chunk, so use default metadata pass except IOError: pass # got something else, so invent some PCM parameters self.sample_rate = 44100 if (self.channels == 1): self.channel_mask = 0x4 elif (self.channels == 2): self.channel_mask = 0x3 else: self.channel_mask = 0 def unsigned(self, c): MSB = self.reader.unary(1) LSB = self.reader.read(c) return MSB * 2**c + LSB def signed(self, c): u = self.unsigned(c + 1) if ((u % 2) == 0): return u // 2 else: return -(u // 2) - 1 def long(self): return self.unsigned(self.unsigned(2)) def skip_unsigned(self, c): self.reader.skip_unary(1) self.reader.skip(c) def read_header(self): magic = self.reader.read_bytes(4) if (magic != b"ajkg"): raise ValueError("invalid magic number") version = self.reader.read(8) if (version != 2): raise ValueError("unsupported version") file_type = self.long() channels = self.long() block_length = self.long() max_LPC = self.long() number_of_means = self.long() bytes_to_skip = self.long() self.reader.read_bytes(bytes_to_skip) return (file_type, channels, block_length, max_LPC, number_of_means) 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_diff0(self, block_length, means): offset = shnmean(means) energy = self.unsigned(3) samples = [] for i in range(block_length): residual = self.signed(energy) samples.append(residual + offset) return samples def read_diff1(self, block_length, previous_samples): samples = previous_samples[-1:] energy = self.unsigned(3) for i in range(1, block_length + 1): residual = self.signed(energy) samples.append(samples[i - 1] + residual) return samples[1:] def read_diff2(self, block_length, previous_samples): samples = previous_samples[-2:] energy = self.unsigned(3) for i in range(2, block_length + 2): residual = self.signed(energy) samples.append((2 * samples[i - 1]) - samples[i - 2] + residual) return samples[2:] def read_diff3(self, block_length, previous_samples): samples = previous_samples[-3:] energy = self.unsigned(3) for i in range(3, block_length + 3): residual = self.signed(energy) samples.append((3 * (samples[i - 1] - samples[i - 2])) + samples[i - 3] + residual) return samples[3:] def read_qlpc(self, block_length, means, previous_samples): offset = shnmean(means) energy = self.unsigned(3) LPC_count = self.unsigned(2) LPC_coeff = [self.signed(5) for i in range(LPC_count)] unoffset = [] samples = previous_samples[-LPC_count:] for i in range(block_length): residual = self.signed(energy) LPC_sum = 2**5 for j in range(LPC_count): if ((i - j - 1) < 0): # apply offset to warm-up samples LPC_sum += (LPC_coeff[j] * (samples[LPC_count + (i - j - 1)] - offset)) else: LPC_sum += LPC_coeff[j] * unoffset[i - j - 1] unoffset.append(LPC_sum // 2**5 + residual) return [u + offset for u in unoffset] def close(self): self.reader.close() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close()
class WavPackDecoder(object): def __init__(self, filename): self.reader = BitstreamReader(open(filename, "rb"), 1) # read initial block to populate # sample_rate, bits_per_sample, channels, and channel_mask self.reader.mark() block_header = Block_Header.read(self.reader) sub_blocks_size = block_header.block_size - 24 sub_blocks_data = self.reader.substream(sub_blocks_size) if (block_header.sample_rate != 15): self.sample_rate = [ 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 192000 ][block_header.sample_rate] else: sub_blocks_data.mark() try: for sub_block in sub_blocks(sub_blocks_data, sub_blocks_size): if (((sub_block.metadata_function == 7) and (sub_block.nondecoder_data == 1))): self.sample_rate = sub_block.data.read( sub_block.data_size() * 8) break else: raise ValueError("invalid sample rate") finally: sub_blocks_data.rewind() sub_blocks_data.unmark() self.bits_per_sample = [8, 16, 24, 32][block_header.bits_per_sample] if (block_header.initial_block and block_header.final_block): if (((block_header.mono_output == 0) or (block_header.false_stereo == 1))): self.channels = 2 self.channel_mask = 0x3 else: self.channels = 1 self.channel_mask = 0x4 else: # look for channel mask sub block sub_blocks_data.mark() for sub_block in sub_blocks(sub_blocks_data, sub_blocks_size): if (((sub_block.metadata_function == 13) and (sub_block.nondecoder_data == 0))): self.channels = sub_block.data.read(8) self.channel_mask = sub_block.data.read( (sub_block.data_size() - 1) * 8) break else: # FIXME - handle case of no channel mask sub block raise NotImplementedError() sub_blocks_data.rewind() sub_blocks_data.unmark() self.reader.rewind() self.reader.unmark() self.pcm_finished = False self.md5_checked = False self.md5sum = md5() 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 close(self): self.reader.close()
class AiffReader(object): """a PCMReader object for reading AIFF file contents""" def __init__(self, aiff_filename): """aiff_filename is a string""" from audiotools.bitstream import BitstreamReader self.stream = BitstreamReader(open(aiff_filename, "rb"), False) # ensure FORM<size>AIFF header is ok try: (form, total_size, aiff) = self.stream.parse("4b 32u 4b") except struct.error: from audiotools.text import ERR_AIFF_INVALID_AIFF raise InvalidAIFF(ERR_AIFF_INVALID_AIFF) if (form != b'FORM'): from audiotools.text import ERR_AIFF_NOT_AIFF raise ValueError(ERR_AIFF_NOT_AIFF) elif (aiff != b'AIFF'): from audiotools.text import ERR_AIFF_INVALID_AIFF raise ValueError(ERR_AIFF_INVALID_AIFF) else: total_size -= 4 comm_chunk_read = False # walk through chunks until "SSND" chunk encountered while (total_size > 0): try: (chunk_id, chunk_size) = self.stream.parse("4b 32u") except struct.error: from audiotools.text import ERR_AIFF_INVALID_AIFF raise ValueError(ERR_AIFF_INVALID_AIFF) if (not frozenset(chunk_id).issubset(AiffAudio.PRINTABLE_ASCII)): from audiotools.text import ERR_AIFF_INVALID_CHUNK_ID raise ValueError(ERR_AIFF_INVALID_CHUNK_ID) else: total_size -= 8 if (chunk_id == b"COMM"): # when "COMM" chunk encountered, # use it to populate PCMReader attributes (self.channels, self.total_pcm_frames, self.bits_per_sample, self.sample_rate, channel_mask) = parse_comm(self.stream) self.channel_mask = int(channel_mask) self.bytes_per_pcm_frame = ((self.bits_per_sample // 8) * self.channels) self.remaining_pcm_frames = self.total_pcm_frames comm_chunk_read = True elif (chunk_id == b"SSND"): # when "SSND" chunk encountered, # strip off the "offset" and "block_size" attributes # and ready PCMReader for reading if (not comm_chunk_read): from audiotools.text import ERR_AIFF_PREMATURE_SSND_CHUNK raise ValueError(ERR_AIFF_PREMATURE_SSND_CHUNK) else: self.stream.skip_bytes(8) self.stream.mark() return else: # all other chunks are ignored self.stream.skip_bytes(chunk_size) if (chunk_size % 2): if (len(self.stream.read_bytes(1)) < 1): from audiotools.text import ERR_AIFF_INVALID_CHUNK raise ValueError(ERR_AIFF_INVALID_CHUNK) total_size -= (chunk_size + 1) else: total_size -= chunk_size else: # raise an error if no "SSND" chunk is encountered from audiotools.text import ERR_AIFF_NO_SSND_CHUNK raise ValueError(ERR_AIFF_NO_SSND_CHUNK) def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close() def __del__(self): if (self.stream.has_mark()): self.stream.unmark() def read(self, pcm_frames): """try to read a pcm.FrameList with the given number of PCM frames""" # try to read requested PCM frames or remaining frames requested_pcm_frames = min(max(pcm_frames, 1), self.remaining_pcm_frames) requested_bytes = (self.bytes_per_pcm_frame * requested_pcm_frames) pcm_data = self.stream.read_bytes(requested_bytes) # raise exception if "SSND" chunk exhausted early if (len(pcm_data) < requested_bytes): from audiotools.text import ERR_AIFF_TRUNCATED_SSND_CHUNK raise IOError(ERR_AIFF_TRUNCATED_SSND_CHUNK) else: self.remaining_pcm_frames -= requested_pcm_frames # return parsed chunk return FrameList(pcm_data, self.channels, self.bits_per_sample, True, True) def read_closed(self, pcm_frames): raise ValueError("cannot read closed stream") def seek(self, pcm_frame_offset): """tries to seek to the given PCM frame offset returns the total amount of frames actually seeked over""" if (pcm_frame_offset < 0): from audiotools.text import ERR_NEGATIVE_SEEK raise ValueError(ERR_NEGATIVE_SEEK) # ensure one doesn't walk off the end of the file pcm_frame_offset = min(pcm_frame_offset, self.total_pcm_frames) # position file in "SSND" chunk self.stream.rewind() self.stream.seek((pcm_frame_offset * self.bytes_per_pcm_frame), 1) self.remaining_pcm_frames = (self.total_pcm_frames - pcm_frame_offset) return pcm_frame_offset def seek_closed(self, pcm_frame_offset): raise ValueError("cannot seek closed stream") def close(self): """closes the stream for reading""" self.stream.close() self.read = self.read_closed self.seek = self.seek_closed
class WaveReader(object): """a PCMReader object for reading wave file contents""" def __init__(self, wave_filename): """wave_filename is a string""" from audiotools.bitstream import BitstreamReader self.stream = BitstreamReader(open(wave_filename, "rb"), True) # ensure RIFF<size>WAVE header is ok try: (riff, total_size, wave) = self.stream.parse("4b 32u 4b") except struct.error: from audiotools.text import ERR_WAV_INVALID_WAVE self.stream.close() raise ValueError(ERR_WAV_INVALID_WAVE) if (riff != b'RIFF'): from audiotools.text import ERR_WAV_NOT_WAVE self.stream.close() raise ValueError(ERR_WAV_NOT_WAVE) elif (wave != b'WAVE'): from audiotools.text import ERR_WAV_INVALID_WAVE self.stream.close() raise ValueError(ERR_WAV_INVALID_WAVE) else: total_size -= 4 fmt_chunk_read = False # walk through chunks until "data" chunk encountered while (total_size > 0): try: (chunk_id, chunk_size) = self.stream.parse("4b 32u") except struct.error: from audiotools.text import ERR_WAV_INVALID_WAVE self.stream.close() raise ValueError(ERR_WAV_INVALID_WAVE) if (not frozenset(chunk_id).issubset(WaveAudio.PRINTABLE_ASCII)): from audiotools.text import ERR_WAV_INVALID_CHUNK self.stream.close() raise ValueError(ERR_WAV_INVALID_CHUNK) else: total_size -= 8 if (chunk_id == b"fmt "): # when "fmt " chunk encountered, # use it to populate PCMReader attributes (self.channels, self.sample_rate, self.bits_per_sample, channel_mask) = parse_fmt(self.stream) self.channel_mask = int(channel_mask) self.bytes_per_pcm_frame = ((self.bits_per_sample // 8) * self.channels) fmt_chunk_read = True elif (chunk_id == b"data"): # when "data" chunk encountered, # use its size to determine total PCM frames # and ready PCMReader for reading if (not fmt_chunk_read): from audiotools.text import ERR_WAV_PREMATURE_DATA self.stream.close() raise ValueError(ERR_WAV_PREMATURE_DATA) else: self.total_pcm_frames = (chunk_size // self.bytes_per_pcm_frame) self.remaining_pcm_frames = self.total_pcm_frames self.stream.mark() return else: # all other chunks are ignored self.stream.skip_bytes(chunk_size) if (chunk_size % 2): if (len(self.stream.read_bytes(1)) < 1): from audiotools.text import ERR_WAV_INVALID_CHUNK self.stream.close() raise ValueError(ERR_WAV_INVALID_CHUNK) total_size -= (chunk_size + 1) else: total_size -= chunk_size else: # raise an error if no "data" chunk is encountered from audiotools.text import ERR_WAV_NO_DATA_CHUNK self.stream.close() raise ValueError(ERR_WAV_NO_DATA_CHUNK) def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close() def __del__(self): if (self.stream.has_mark()): self.stream.unmark() def read(self, pcm_frames): """try to read a pcm.FrameList with the given number of PCM frames""" # try to read requested PCM frames or remaining frames requested_pcm_frames = min(max(pcm_frames, 1), self.remaining_pcm_frames) requested_bytes = (self.bytes_per_pcm_frame * requested_pcm_frames) pcm_data = self.stream.read_bytes(requested_bytes) # raise exception if "data" chunk exhausted early if (len(pcm_data) < requested_bytes): from audiotools.text import ERR_WAV_TRUNCATED_DATA_CHUNK raise IOError(ERR_WAV_TRUNCATED_DATA_CHUNK) else: self.remaining_pcm_frames -= requested_pcm_frames # return parsed chunk return FrameList(pcm_data, self.channels, self.bits_per_sample, False, self.bits_per_sample != 8) def read_closed(self, pcm_frames): raise ValueError("cannot read closed stream") def seek(self, pcm_frame_offset): """tries to seek to the given PCM frame offset returns the total amount of frames actually seeked over""" if (pcm_frame_offset < 0): from audiotools.text import ERR_NEGATIVE_SEEK raise ValueError(ERR_NEGATIVE_SEEK) # ensure one doesn't walk off the end of the file pcm_frame_offset = min(pcm_frame_offset, self.total_pcm_frames) # position file in "data" chunk self.stream.rewind() self.stream.seek(pcm_frame_offset * self.bytes_per_pcm_frame, 1) self.remaining_pcm_frames = (self.total_pcm_frames - pcm_frame_offset) return pcm_frame_offset def seek_closed(self, pcm_frame_offset): raise ValueError("cannot seek closed stream") def close(self): """closes the stream for reading""" self.stream.close() self.read = self.read_closed self.seek = self.seek_closed