class VorbisAudio(AudioFile): """An Ogg Vorbis file.""" SUFFIX = "ogg" NAME = SUFFIX DEFAULT_COMPRESSION = "3" COMPRESSION_MODES = tuple([str(i) for i in range(0, 11)]) BINARIES = ("oggenc", "oggdec") REPLAYGAIN_BINARIES = ("vorbisgain", ) OGG_IDENTIFICATION = Con.Struct( "ogg_id", Con.ULInt32("vorbis_version"), Con.Byte("channels"), Con.ULInt32("sample_rate"), Con.ULInt32("bitrate_maximum"), Con.ULInt32("bitrate_nominal"), Con.ULInt32("bitrate_minimum"), Con.Embed( Con.BitStruct("flags", Con.Bits("blocksize_0", 4), Con.Bits("blocksize_1", 4))), Con.Byte("framing")) COMMENT_HEADER = Con.Struct("comment_header", Con.Byte("packet_type"), Con.String("vorbis", 6)) def __init__(self, filename): """filename is a plain string.""" AudioFile.__init__(self, filename) try: self.__read_metadata__() except IOError, msg: raise InvalidVorbis(str(msg))
class UnframedVorbisComment(VorbisComment): """An implementation of VorbisComment without the framing bit.""" VORBIS_COMMENT = Con.Struct( "vorbis_comment", Con.PascalString("vendor_string", length_field=Con.ULInt32("length")), Con.PrefixedArray(length_field=Con.ULInt32("length"), subcon=Con.PascalString( "value", length_field=Con.ULInt32("length"))))
def l_tag_value(cls, file, tag): subtype = {1: Con.Byte("data"), 2: Con.CString("data"), 3: Con.ULInt16("data"), 4: Con.ULInt32("data"), 5: Con.Struct("data", Con.ULInt32("high"), Con.ULInt32("low"))}[tag.type] data = Con.StrictRepeater(tag.count, subtype) if ((tag.type != 2) and (data.sizeof() <= 4)): return tag.offset else: file.seek(tag.offset, 0) return data.parse_stream(file)
class MusepackAudio(ApeTaggedAudio, AudioFile): """A Musepack audio file.""" SUFFIX = "mpc" NAME = SUFFIX DEFAULT_COMPRESSION = "standard" COMPRESSION_MODES = ("thumb", "radio", "standard", "extreme", "insane") ###Musepack SV7### #BINARIES = ('mppdec','mppenc') ###Musepack SV8### BINARIES = ('mpcdec', 'mpcenc') MUSEPACK8_HEADER = Con.Struct('musepack8_header', Con.UBInt32('crc32'), Con.Byte('bitstream_version'), NutValue('sample_count'), NutValue('beginning_silence'), Con.Embed(Con.BitStruct( 'flags', Con.Bits('sample_frequency', 3), Con.Bits('max_used_bands', 5), Con.Bits('channel_count', 4), Con.Flag('mid_side_used'), Con.Bits('audio_block_frames', 3)))) #not sure about some of the flag locations #Musepack 7's header is very unusual MUSEPACK7_HEADER = Con.Struct('musepack7_header', Con.Const(Con.String('signature', 3), 'MP+'), Con.Byte('version'), Con.ULInt32('frame_count'), Con.ULInt16('max_level'), Con.Embed( Con.BitStruct('flags', Con.Bits('profile', 4), Con.Bits('link', 2), Con.Bits('sample_frequency', 2), Con.Flag('intensity_stereo'), Con.Flag('midside_stereo'), Con.Bits('maxband', 6))), Con.ULInt16('title_gain'), Con.ULInt16('title_peak'), Con.ULInt16('album_gain'), Con.ULInt16('album_peak'), Con.Embed( Con.BitStruct('more_flags', Con.Bits('unused1', 16), Con.Bits('last_frame_length_low', 4), Con.Flag('true_gapless'), Con.Bits('unused2', 3), Con.Flag('fast_seeking'), Con.Bits('last_frame_length_high', 7))), Con.Bytes('unknown', 3), Con.Byte('encoder_version')) def __init__(self, filename): """filename is a plain string.""" AudioFile.__init__(self, filename) f = file(filename, 'rb') try: if (f.read(4) == 'MPCK'): # a Musepack 8 stream for (key, packet) in Musepack8StreamReader(f).packets(): if (key == 'SH'): header = MusepackAudio.MUSEPACK8_HEADER.parse(packet) self.__sample_rate__ = (44100, 48000, 37800, 32000)[ header.sample_frequency] self.__total_frames__ = header.sample_count self.__channels__ = header.channel_count + 1 break elif (key == 'SE'): raise InvalidFile(_(u'No Musepack header found')) else: # a Musepack 7 stream f.seek(0, 0) try: header = MusepackAudio.MUSEPACK7_HEADER.parse_stream(f) except Con.ConstError: raise InvalidFile(_(u'Musepack signature incorrect')) header.last_frame_length = \ (header.last_frame_length_high << 4) | \ header.last_frame_length_low self.__sample_rate__ = (44100, 48000, 37800, 32000)[header.sample_frequency] self.__total_frames__ = (((header.frame_count - 1) * 1152) + header.last_frame_length) self.__channels__ = 2 finally: f.close() @classmethod def from_pcm(cls, filename, pcmreader, compression=None): """Encodes a new file from PCM data. Takes a filename string, PCMReader object and optional compression level string. Encodes a new audio file from pcmreader's data at the given filename with the specified compression level and returns a new MusepackAudio object.""" import tempfile import bisect if (str(compression) not in cls.COMPRESSION_MODES): compression = cls.DEFAULT_COMPRESSION if ((pcmreader.channels > 2) or (pcmreader.sample_rate not in (44100, 48000, 37800, 32000)) or (pcmreader.bits_per_sample != 16)): pcmreader = PCMConverter( pcmreader, sample_rate=[32000, 32000, 37800, 44100, 48000][bisect.bisect( [32000, 37800, 44100, 48000], pcmreader.sample_rate)], channels=min(pcmreader.channels, 2), bits_per_sample=16) f = tempfile.NamedTemporaryFile(suffix=".wav") w = WaveAudio.from_pcm(f.name, pcmreader) try: return cls.__from_wave__(filename, f.name, compression) finally: del(w) f.close() #While Musepack needs to pipe things through WAVE, #not all WAVEs are acceptable. #Use the *_pcm() methods first. def __to_wave__(self, wave_filename): devnull = file(os.devnull, "wb") try: sub = subprocess.Popen([BIN['mpcdec'], self.filename, wave_filename], stdout=devnull, stderr=devnull) #FIXME - small files (~5 seconds) result in an error by mpcdec, #even if they decode correctly. #Not much we can do except try to workaround its bugs. if (sub.wait() not in [0, 250]): raise DecodingError() finally: devnull.close() @classmethod def __from_wave__(cls, filename, wave_filename, compression=None): if (str(compression) not in cls.COMPRESSION_MODES): compression = cls.DEFAULT_COMPRESSION #mppenc requires files to end with .mpc for some reason if (not filename.endswith(".mpc")): import tempfile actual_filename = filename tempfile = tempfile.NamedTemporaryFile(suffix=".mpc") filename = tempfile.name else: actual_filename = tempfile = None ###Musepack SV7### #sub = subprocess.Popen([BIN['mppenc'], # "--silent", # "--overwrite", # "--%s" % (compression), # wave_filename, # filename], # preexec_fn=ignore_sigint) ###Musepack SV8### sub = subprocess.Popen([BIN['mpcenc'], "--silent", "--overwrite", "--%s" % (compression), wave_filename, filename]) if (sub.wait() == 0): if (tempfile is not None): filename = actual_filename f = file(filename, 'wb') tempfile.seek(0, 0) transfer_data(tempfile.read, f.write) f.close() tempfile.close() return MusepackAudio(filename) else: if (tempfile is not None): tempfile.close() raise EncodingError(u"error encoding file with mpcenc") @classmethod def is_type(cls, file): """Returns True if the given file object describes this format. Takes a seekable file pointer rewound to the start of the file.""" header = file.read(4) ###Musepack SV7### #return header == 'MP+\x07' ###Musepack SV8### return (header == 'MP+\x07') or (header == 'MPCK') def sample_rate(self): """Returns the rate of the track's audio as an integer number of Hz.""" return self.__sample_rate__ def total_frames(self): """Returns the total PCM frames of the track as an integer.""" return self.__total_frames__ def channels(self): """Returns an integer number of channels this track contains.""" return self.__channels__ def bits_per_sample(self): """Returns an integer number of bits-per-sample this track contains.""" return 16 def lossless(self): """Returns False.""" return False
class SpeexAudio(VorbisAudio): """An Ogg Speex audio file.""" SUFFIX = "spx" NAME = SUFFIX DEFAULT_COMPRESSION = "8" COMPRESSION_MODES = tuple([str(i) for i in range(0, 11)]) BINARIES = ("speexenc", "speexdec") REPLAYGAIN_BINARIES = tuple() SPEEX_HEADER = Con.Struct('speex_header', Con.String('speex_string', 8), Con.String('speex_version', 20), Con.ULInt32('speex_version_id'), Con.ULInt32('header_size'), Con.ULInt32('sampling_rate'), Con.ULInt32('mode'), Con.ULInt32('mode_bitstream_version'), Con.ULInt32('channels'), Con.ULInt32('bitrate'), Con.ULInt32('frame_size'), Con.ULInt32('vbr'), Con.ULInt32('frame_per_packet'), Con.ULInt32('extra_headers'), Con.ULInt32('reserved1'), Con.ULInt32('reserved2')) def __init__(self, filename): """filename is a plain string.""" AudioFile.__init__(self, filename) try: self.__read_metadata__() except IOError, msg: raise InvalidSpeex(str(msg))
class __TIFF__(ImageMetrics): HEADER = Con.Struct('header', Con.String('byte_order', 2), Con.Switch('order', lambda ctx: ctx['byte_order'], {"II": Con.Embed( Con.Struct('little_endian', Con.Const(Con.ULInt16('version'), 42), Con.ULInt32('offset'))), "MM": Con.Embed( Con.Struct('big_endian', Con.Const(Con.UBInt16('version'), 42), Con.UBInt32('offset')))})) L_IFD = Con.Struct('ifd', Con.PrefixedArray( length_field=Con.ULInt16('length'), subcon=Con.Struct('tags', Con.ULInt16('id'), Con.ULInt16('type'), Con.ULInt32('count'), Con.ULInt32('offset'))), Con.ULInt32('next')) B_IFD = Con.Struct('ifd', Con.PrefixedArray( length_field=Con.UBInt16('length'), subcon=Con.Struct('tags', Con.UBInt16('id'), Con.UBInt16('type'), Con.UBInt32('count'), Con.UBInt32('offset'))), Con.UBInt32('next')) def __init__(self, width, height, bits_per_pixel, color_count): ImageMetrics.__init__(self, width, height, bits_per_pixel, color_count, u'image/tiff') @classmethod def b_tag_value(cls, file, tag): subtype = {1: Con.Byte("data"), 2: Con.CString("data"), 3: Con.UBInt16("data"), 4: Con.UBInt32("data"), 5: Con.Struct("data", Con.UBInt32("high"), Con.UBInt32("low"))}[tag.type] data = Con.StrictRepeater(tag.count, subtype) if ((tag.type != 2) and (data.sizeof() <= 4)): return tag.offset else: file.seek(tag.offset, 0) return data.parse_stream(file) @classmethod def l_tag_value(cls, file, tag): subtype = {1: Con.Byte("data"), 2: Con.CString("data"), 3: Con.ULInt16("data"), 4: Con.ULInt32("data"), 5: Con.Struct("data", Con.ULInt32("high"), Con.ULInt32("low"))}[tag.type] data = Con.StrictRepeater(tag.count, subtype) if ((tag.type != 2) and (data.sizeof() <= 4)): return tag.offset else: file.seek(tag.offset, 0) return data.parse_stream(file) @classmethod def parse(cls, file): width = 0 height = 0 bits_per_sample = 0 color_count = 0 try: header = cls.HEADER.parse_stream(file) if (header.byte_order == 'II'): IFD = cls.L_IFD tag_value = cls.l_tag_value elif (header.byte_order == 'MM'): IFD = cls.B_IFD tag_value = cls.b_tag_value else: raise InvalidTIFF(_(u'Invalid byte order')) file.seek(header.offset, 0) ifd = IFD.parse_stream(file) while (True): for tag in ifd.tags: if (tag.id == 0x0100): width = tag_value(file, tag) elif (tag.id == 0x0101): height = tag_value(file, tag) elif (tag.id == 0x0102): try: bits_per_sample = sum(tag_value(file, tag)) except TypeError: bits_per_sample = tag_value(file, tag) elif (tag.id == 0x0140): color_count = tag.count / 3 else: pass if (ifd.next == 0x00): break else: file.seek(ifd.next, 0) ifd = IFD.parse_stream(file) return __TIFF__(width, height, bits_per_sample, color_count) except Con.ConstError: raise InvalidTIFF(_(u'Invalid TIFF'))
class __BMP__(ImageMetrics): HEADER = Con.Struct('bmp_header', Con.Const(Con.String('magic_number', 2), 'BM'), Con.ULInt32('file_size'), Con.ULInt16('reserved1'), Con.ULInt16('reserved2'), Con.ULInt32('bitmap_data_offset')) INFORMATION = Con.Struct('bmp_information', Con.ULInt32('header_size'), Con.ULInt32('width'), Con.ULInt32('height'), Con.ULInt16('color_planes'), Con.ULInt16('bits_per_pixel'), Con.ULInt32('compression_method'), Con.ULInt32('image_size'), Con.ULInt32('horizontal_resolution'), Con.ULInt32('vertical_resolution'), Con.ULInt32('colors_used'), Con.ULInt32('important_colors_used')) def __init__(self, width, height, bits_per_pixel, color_count): ImageMetrics.__init__(self, width, height, bits_per_pixel, color_count, u'image/x-ms-bmp') @classmethod def parse(cls, file): try: header = cls.HEADER.parse_stream(file) information = cls.INFORMATION.parse_stream(file) return __BMP__(information.width, information.height, information.bits_per_pixel, information.colors_used) except Con.ConstError: raise InvalidBMP(_(u'Invalid BMP'))
class VorbisComment(MetaData, dict): """A complete Vorbis Comment tag.""" VORBIS_COMMENT = Con.Struct( "vorbis_comment", Con.PascalString("vendor_string", length_field=Con.ULInt32("length")), Con.PrefixedArray(length_field=Con.ULInt32("length"), subcon=Con.PascalString( "value", length_field=Con.ULInt32("length"))), Con.Const(Con.Byte("framing"), 1)) ATTRIBUTE_MAP = { 'track_name': 'TITLE', 'track_number': 'TRACKNUMBER', 'track_total': 'TRACKTOTAL', 'album_name': 'ALBUM', 'artist_name': 'ARTIST', 'performer_name': 'PERFORMER', 'composer_name': 'COMPOSER', 'conductor_name': 'CONDUCTOR', 'media': 'SOURCE MEDIUM', 'ISRC': 'ISRC', 'catalog': 'CATALOG', 'copyright': 'COPYRIGHT', 'publisher': 'PUBLISHER', 'year': 'DATE', 'album_number': 'DISCNUMBER', 'album_total': 'DISCTOTAL', 'comment': 'COMMENT' } ITEM_MAP = dict(map(reversed, ATTRIBUTE_MAP.items())) def __init__(self, vorbis_data, vendor_string=u""): """Initialized with a key->[value1,value2] dict. keys are generally upper case. values are unicode string. vendor_string is an optional unicode string.""" dict.__init__(self, [(key.upper(), values) for (key, values) in vorbis_data.items()]) self.vendor_string = vendor_string def __setitem__(self, key, value): dict.__setitem__(self, key.upper(), value) def __getattr__(self, key): if (key == 'track_number'): match = re.match(r'^\d+$', self.get('TRACKNUMBER', [u''])[0]) if (match): return int(match.group(0)) else: match = re.match('^(\d+)/\d+$', self.get('TRACKNUMBER', [u''])[0]) if (match): return int(match.group(1)) else: return 0 elif (key == 'track_total'): match = re.match(r'^\d+$', self.get('TRACKTOTAL', [u''])[0]) if (match): return int(match.group(0)) else: match = re.match('^\d+/(\d+)$', self.get('TRACKNUMBER', [u''])[0]) if (match): return int(match.group(1)) else: return 0 elif (key == 'album_number'): match = re.match(r'^\d+$', self.get('DISCNUMBER', [u''])[0]) if (match): return int(match.group(0)) else: match = re.match('^(\d+)/\d+$', self.get('DISCNUMBER', [u''])[0]) if (match): return int(match.group(1)) else: return 0 elif (key == 'album_total'): match = re.match(r'^\d+$', self.get('DISCTOTAL', [u''])[0]) if (match): return int(match.group(0)) else: match = re.match('^\d+/(\d+)$', self.get('DISCNUMBER', [u''])[0]) if (match): return int(match.group(1)) else: return 0 elif (key in self.ATTRIBUTE_MAP): return self.get(self.ATTRIBUTE_MAP[key], [u''])[0] elif (key in MetaData.__FIELDS__): return u'' else: try: return self.__dict__[key] except KeyError: raise AttributeError(key) def __delattr__(self, key): if (key == 'track_number'): track_number = self.get('TRACKNUMBER', [u''])[0] if (re.match(r'^\d+$', track_number)): del (self['TRACKNUMBER']) elif (re.match('^\d+/(\d+)$', track_number)): self['TRACKNUMBER'] = u"0/%s" % (re.match( '^\d+/(\d+)$', track_number).group(1)) elif (key == 'track_total'): track_number = self.get('TRACKNUMBER', [u''])[0] if (re.match('^(\d+)/\d+$', track_number)): self['TRACKNUMBER'] = u"%s" % (re.match( '^(\d+)/\d+$', track_number).group(1)) if ('TRACKTOTAL' in self): del (self['TRACKTOTAL']) elif (key == 'album_number'): album_number = self.get('DISCNUMBER', [u''])[0] if (re.match(r'^\d+$', album_number)): del (self['DISCNUMBER']) elif (re.match('^\d+/(\d+)$', album_number)): self['DISCNUMBER'] = u"0/%s" % (re.match( '^\d+/(\d+)$', album_number).group(1)) elif (key == 'album_total'): album_number = self.get('DISCNUMBER', [u''])[0] if (re.match('^(\d+)/\d+$', album_number)): self['DISCNUMBER'] = u"%s" % (re.match('^(\d+)/\d+$', album_number).group(1)) if ('DISCTOTAL' in self): del (self['DISCTOTAL']) elif (key in self.ATTRIBUTE_MAP): if (self.ATTRIBUTE_MAP[key] in self): del (self[self.ATTRIBUTE_MAP[key]]) elif (key in MetaData.__FIELDS__): pass else: try: del (self.__dict__[key]) except KeyError: raise AttributeError(key) @classmethod def supports_images(cls): """Returns False.""" #There's actually a (proposed?) standard to add embedded covers #to Vorbis Comments by base64 encoding them. #This strikes me as messy and convoluted. #In addition, I'd have to perform a special case of #image extraction and re-insertion whenever converting #to FlacMetaData. The whole thought gives me a headache. return False def images(self): """Returns an empty list of Image objects.""" return list() #if an attribute is updated (e.g. self.track_name) #make sure to update the corresponding dict pair def __setattr__(self, key, value): if (key in self.ATTRIBUTE_MAP): if (key not in MetaData.__INTEGER_FIELDS__): self[self.ATTRIBUTE_MAP[key]] = [value] else: self[self.ATTRIBUTE_MAP[key]] = [unicode(value)] else: self.__dict__[key] = value @classmethod def converted(cls, metadata): """Converts a MetaData object to a VorbisComment object.""" if ((metadata is None) or (isinstance(metadata, VorbisComment))): return metadata elif (metadata.__class__.__name__ == 'FlacMetaData'): return cls(vorbis_data=dict(metadata.vorbis_comment.items()), vendor_string=metadata.vorbis_comment.vendor_string) else: values = {} for key in cls.ATTRIBUTE_MAP.keys(): if (key in cls.__INTEGER_FIELDS__): if (getattr(metadata, key) != 0): values[cls.ATTRIBUTE_MAP[key]] = \ [unicode(getattr(metadata, key))] elif (getattr(metadata, key) != u""): values[cls.ATTRIBUTE_MAP[key]] = \ [unicode(getattr(metadata, key))] return VorbisComment(values) def merge(self, metadata): """Updates any currently empty entries from metadata's values.""" metadata = self.__class__.converted(metadata) if (metadata is None): return for (key, values) in metadata.items(): if ((len(values) > 0) and (len(self.get(key, [])) == 0)): self[key] = values def __comment_name__(self): return u'Vorbis' #takes two (key,value) vorbiscomment pairs #returns cmp on the weighted set of them #(title first, then artist, album, tracknumber, ... , replaygain) @classmethod def __by_pair__(cls, pair1, pair2): KEY_MAP = { "TITLE": 1, "ALBUM": 2, "TRACKNUMBER": 3, "TRACKTOTAL": 4, "DISCNUMBER": 5, "DISCTOTAL": 6, "ARTIST": 7, "PERFORMER": 8, "COMPOSER": 9, "CONDUCTOR": 10, "CATALOG": 11, "PUBLISHER": 12, "ISRC": 13, "SOURCE MEDIUM": 14, #"YEAR": 15, "DATE": 16, "COPYRIGHT": 17, "REPLAYGAIN_ALBUM_GAIN": 19, "REPLAYGAIN_ALBUM_PEAK": 19, "REPLAYGAIN_TRACK_GAIN": 19, "REPLAYGAIN_TRACK_PEAK": 19, "REPLAYGAIN_REFERENCE_LOUDNESS": 20 } return cmp( (KEY_MAP.get(pair1[0].upper(), 18), pair1[0].upper(), pair1[1]), (KEY_MAP.get(pair2[0].upper(), 18), pair2[0].upper(), pair2[1])) def __comment_pairs__(self): pairs = [] for (key, values) in self.items(): for value in values: pairs.append((key, value)) pairs.sort(VorbisComment.__by_pair__) return pairs def build(self): """Returns this VorbisComment as a binary string.""" comment = Con.Container(vendor_string=self.vendor_string, framing=1, value=[]) for (key, values) in self.items(): for value in values: if ((value != u"") and not ((key in ("TRACKNUMBER", "TRACKTOTAL", "DISCNUMBER", "DISCTOTAL")) and (value == u"0"))): comment.value.append("%s=%s" % (key, value.encode('utf-8'))) return self.VORBIS_COMMENT.build(comment)
class OggStreamReader: """A class for walking through an Ogg stream.""" OGGS = Con.Struct( "oggs", Con.Const(Con.String("magic_number", 4), "OggS"), Con.Byte("version"), Con.Byte("header_type"), Con.SLInt64("granule_position"), Con.ULInt32("bitstream_serial_number"), Con.ULInt32("page_sequence_number"), Con.ULInt32("checksum"), Con.Byte("segments"), Con.MetaRepeater(lambda ctx: ctx["segments"], Con.Byte("segment_lengths"))) def __init__(self, stream): """stream is a file-like object with read() and close() methods.""" self.stream = stream def close(self): """Closes the sub-stream.""" self.stream.close() def packets(self, from_beginning=True): """Yields one fully reassembled Ogg packet per pass. Packets are returned as binary strings.""" if (from_beginning): self.stream.seek(0, 0) segment = cStringIO.StringIO() while (True): try: page = OggStreamReader.OGGS.parse_stream(self.stream) for length in page.segment_lengths: if (length == 255): segment.write(self.stream.read(length)) else: segment.write(self.stream.read(length)) yield segment.getvalue() segment = cStringIO.StringIO() except Con.core.FieldError: break except Con.ConstError: break def pages(self, from_beginning=True): """Yields a (Container,string) tuple per pass. Container is parsed from OggStreamReader.OGGS. string is a binary string of combined segments (which may not be a complete packet).""" if (from_beginning): self.stream.seek(0, 0) while (True): try: page = OggStreamReader.OGGS.parse_stream(self.stream) yield (page, self.stream.read(sum(page.segment_lengths))) except Con.core.FieldError: break except Con.ConstError: break @classmethod def pages_to_packet(cls, pages_iter): """Returns a complete packet as a list of (Container,string) tuples. pages_iter should be an iterator of (Container,string) tuples as returned from the pages() method. """ packet = [pages_iter.next()] while (packet[-1][0].segment_lengths[-1] == 255): packet.append(pages_iter.next()) return packet CRC_LOOKUP = ( 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4) @classmethod def calculate_ogg_checksum(cls, page_header, page_data): """Calculates an Ogg checksum integer. page_header is a Container object parsed through OGGS. page_data is a string of data contained by the page. """ old_checksum = page_header.checksum try: page_header.checksum = 0 sum = 0 for c in cls.OGGS.build(page_header) + page_data: sum = ((sum << 8) ^ \ cls.CRC_LOOKUP[((sum >> 24) & 0xFF) ^ ord(c)]) \ & 0xFFFFFFFF return sum finally: page_header.checksum = old_checksum
class WavPackAudio(ApeTaggedAudio, AudioFile): """A WavPack audio file.""" SUFFIX = "wv" NAME = SUFFIX DEFAULT_COMPRESSION = "standard" COMPRESSION_MODES = ("veryfast", "fast", "standard", "high", "veryhigh") APE_TAG_CLASS = WavPackAPEv2 HEADER = Con.Struct( "wavpackheader", Con.Const(Con.String("id", 4), 'wvpk'), Con.ULInt32("block_size"), Con.ULInt16("version"), Con.ULInt8("track_number"), Con.ULInt8("index_number"), Con.ULInt32("total_samples"), Con.ULInt32("block_index"), Con.ULInt32("block_samples"), Con.Embed( Con.BitStruct("flags", Con.Flag("floating_point_data"), Con.Flag("hybrid_noise_shaping"), Con.Flag("cross_channel_decorrelation"), Con.Flag("joint_stereo"), Con.Flag("hybrid_mode"), Con.Flag("mono_output"), Con.Bits("bits_per_sample", 2), Con.Bits("left_shift_data_low", 3), Con.Flag("final_block_in_sequence"), Con.Flag("initial_block_in_sequence"), Con.Flag("hybrid_noise_balanced"), Con.Flag("hybrid_mode_control_bitrate"), Con.Flag("extended_size_integers"), Con.Bit("sampling_rate_low"), Con.Bits("maximum_magnitude", 5), Con.Bits("left_shift_data_high", 2), Con.Flag("reserved2"), Con.Flag("false_stereo"), Con.Flag("use_IIR"), Con.Bits("reserved1", 2), Con.Bits("sampling_rate_high", 3))), Con.ULInt32("crc")) SUB_HEADER = Con.Struct( "wavpacksubheader", Con.Embed( Con.BitStruct("flags", Con.Flag("large_block"), Con.Flag("actual_size_1_less"), Con.Flag("nondecoder_data"), Con.Bits("metadata_function", 5))), Con.IfThenElse('size', lambda ctx: ctx['large_block'], ULInt24('s'), Con.Byte('s'))) BITS_PER_SAMPLE = (8, 16, 24, 32) SAMPLING_RATE = (6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 192000, 0) __options__ = { "veryfast": { "block_size": 44100, "joint_stereo": True, "false_stereo": True, "wasted_bits": True, "decorrelation_passes": 1 }, "fast": { "block_size": 44100, "joint_stereo": True, "false_stereo": True, "wasted_bit": True, "decorrelation_passes": 2 }, "standard": { "block_size": 44100, "joint_stereo": True, "false_stereo": True, "wasted_bits": True, "decorrelation_passes": 5 }, "high": { "block_size": 44100, "joint_stereo": True, "false_stereo": True, "wasted_bits": True, "decorrelation_passes": 10 }, "veryhigh": { "block_size": 44100, "joint_stereo": True, "false_stereo": True, "wasted_bits": True, "decorrelation_passes": 16 } } def __init__(self, filename): """filename is a plain string.""" self.filename = filename self.__samplerate__ = 0 self.__channels__ = 0 self.__bitspersample__ = 0 self.__total_frames__ = 0 try: self.__read_info__() except IOError, msg: raise InvalidWavPack(str(msg))