mirror-github-bspeice
/
Melodia
mirror of https://github.com/bspeice/Melodia
1
0
Fork 0
Code Issues Releases Wiki Activity

Add in the audiotools resources

master
Bradlee Speice 2012-12-10 12:55:06 -05:00
parent 51a861abe1
commit 48906a5513
48 changed files with 26321 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Melodia/resources/__init__.py Normal file
View File

@ -0,0 +1,6 @@
import os, sys
def get_resource_dir():
return os.path.dirname(
os.path.abspath(__file__)
)

751
Melodia/resources/audiotools/__aiff__.py Normal file
View File

@ -0,0 +1,751 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, InvalidFile, Con, PCMReader,
__capped_stream_reader__, PCMReaderError,
transfer_data, DecodingError, EncodingError,
ID3v22Comment, BUFFER_SIZE, ChannelMask,
ReorderedPCMReader, pcm,
cStringIO, os, AiffContainer, to_pcm_progress)
import gettext
gettext.install("audiotools", unicode=True)
_HUGE_VAL = 1.79769313486231e+308
class IEEE_Extended(Con.Adapter):
"""A construct for handling 80-bit IEEE-extended values."""
def __init__(self, name):
Con.Adapter.__init__(
self,
Con.Struct(name,
Con.Embed(Con.BitStruct(None,
Con.Flag("signed"),
Con.Bits("exponent", 15))),
Con.UBInt64("mantissa")))
def _encode(self, value, context):
import math
if (value < 0):
signed = True
value *= -1
else:
signed = False
(fmant, exponent) = math.frexp(value)
if ((exponent > 16384) or (fmant >= 1)):
exponent = 0x7FFF
mantissa = 0
else:
exponent += 16382
mantissa = fmant * (2 ** 64)
return Con.Container(signed=signed,
exponent=exponent,
mantissa=mantissa)
def _decode(self, obj, context):
if ((obj.exponent == 0) and (obj.mantissa == 0)):
return 0
else:
if (obj.exponent == 0x7FFF):
return _HUGE_VAL
else:
f = obj.mantissa * (2.0 ** (obj.exponent - 16383 - 63))
return f if not obj.signed else -f
#######################
#AIFF
#######################
class AiffReader(PCMReader):
"""A subclass of PCMReader for reading AIFF file contents."""
def __init__(self, aiff_file,
sample_rate, channels, channel_mask, bits_per_sample,
chunk_length, process=None):
"""aiff_file should be rewound to the start of the SSND chunk."""
alignment = AiffAudio.SSND_ALIGN.parse_stream(aiff_file)
PCMReader.__init__(self,
file=__capped_stream_reader__(
aiff_file,
chunk_length - AiffAudio.SSND_ALIGN.sizeof()),
sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample,
process=process,
signed=True,
big_endian=True)
self.ssnd_chunk_length = chunk_length - 8
standard_channel_mask = ChannelMask(self.channel_mask)
aiff_channel_mask = AIFFChannelMask(standard_channel_mask)
if (channels in (3, 4, 6)):
self.channel_order = [aiff_channel_mask.channels().index(channel)
for channel in
standard_channel_mask.channels()]
else:
self.channel_order = None
def read(self, bytes):
"""Try to read a pcm.FrameList of size "bytes"."""
#align bytes downward if an odd number is read in
bytes -= (bytes % (self.channels * self.bits_per_sample / 8))
pcm_data = self.file.read(
max(bytes, self.channels * self.bits_per_sample / 8))
if ((len(pcm_data) == 0) and (self.ssnd_chunk_length > 0)):
raise IOError("ssnd chunk ends prematurely")
else:
self.ssnd_chunk_length -= len(pcm_data)
try:
framelist = pcm.FrameList(pcm_data,
self.channels,
self.bits_per_sample,
True, True)
if (self.channel_order is not None):
return pcm.from_channels([framelist.channel(channel)
for channel in self.channel_order])
else:
return framelist
except ValueError:
raise IOError("ssnd chunk ends prematurely")
class InvalidAIFF(InvalidFile):
"""Raised if some problem occurs parsing AIFF chunks."""
pass
class AiffAudio(AiffContainer):
"""An AIFF audio file."""
SUFFIX = "aiff"
NAME = SUFFIX
AIFF_HEADER = Con.Struct("aiff_header",
Con.Const(Con.Bytes("aiff_id", 4), "FORM"),
Con.UBInt32("aiff_size"),
Con.Const(Con.Bytes("aiff_type", 4), "AIFF"))
CHUNK_HEADER = Con.Struct("chunk_header",
Con.Bytes("chunk_id", 4),
Con.UBInt32("chunk_length"))
COMM_CHUNK = Con.Struct("comm",
Con.UBInt16("channels"),
Con.UBInt32("total_sample_frames"),
Con.UBInt16("sample_size"),
IEEE_Extended("sample_rate"))
SSND_ALIGN = Con.Struct("ssnd",
Con.UBInt32("offset"),
Con.UBInt32("blocksize"))
PRINTABLE_ASCII = set([chr(i) for i in xrange(0x20, 0x7E + 1)])
def __init__(self, filename):
"""filename is a plain string."""
self.filename = filename
comm_found = False
ssnd_found = False
try:
f = open(self.filename, 'rb')
for (chunk_id, chunk_length, chunk_offset) in self.chunks():
if (chunk_id == 'COMM'):
f.seek(chunk_offset, 0)
comm = self.COMM_CHUNK.parse(f.read(chunk_length))
self.__channels__ = comm.channels
self.__total_sample_frames__ = comm.total_sample_frames
self.__sample_size__ = comm.sample_size
self.__sample_rate__ = int(comm.sample_rate)
comm_found = True
elif (chunk_id == 'SSND'):
f.seek(chunk_offset, 0)
ssnd = self.SSND_ALIGN.parse_stream(f)
ssnd_found = True
elif (not set(chunk_id).issubset(self.PRINTABLE_ASCII)):
raise InvalidAIFF(_("chunk header not ASCII"))
if (not comm_found):
raise InvalidAIFF(_("no COMM chunk found"))
if (not ssnd_found):
raise InvalidAIFF(_("no SSND chunk found"))
f.close()
except IOError, msg:
raise InvalidAIFF(str(msg))
except Con.FieldError:
raise InvalidAIFF(_("invalid COMM or SSND chunk"))
def bits_per_sample(self):
"""Returns an integer number of bits-per-sample this track contains."""
return self.__sample_size__
def channels(self):
"""Returns an integer number of channels this track contains."""
return self.__channels__
def channel_mask(self):
"""Returns a ChannelMask object of this track's channel layout."""
#this unusual arrangement is taken from the AIFF specification
if (self.channels() <= 2):
return ChannelMask.from_channels(self.channels())
elif (self.channels() == 3):
return ChannelMask.from_fields(
front_left=True, front_right=True, front_center=True)
elif (self.channels() == 4):
return ChannelMask.from_fields(
front_left=True, front_right=True,
back_left=True, back_right=True)
elif (self.channels() == 6):
return ChannelMask.from_fields(
front_left=True, side_left=True,
front_center=True, front_right=True,
side_right=True, back_center=True)
else:
return ChannelMask(0)
def lossless(self):
"""Returns True."""
return True
def total_frames(self):
"""Returns the total PCM frames of the track as an integer."""
return self.__total_sample_frames__
def sample_rate(self):
"""Returns the rate of the track's audio as an integer number of Hz."""
return self.__sample_rate__
@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(12)
return ((header[0:4] == 'FORM') and
(header[8:12] == 'AIFF'))
def chunks(self):
"""Yields a (chunk_id, length, offset) per AIFF chunk."""
f = open(self.filename, 'rb')
try:
aiff_header = self.AIFF_HEADER.parse_stream(f)
except Con.ConstError:
raise InvalidAIFF(_(u"Not an AIFF file"))
except Con.core.FieldError:
raise InvalidAIFF(_(u"Invalid AIFF file"))
total_size = aiff_header.aiff_size - 4
while (total_size > 0):
chunk_header = self.CHUNK_HEADER.parse_stream(f)
total_size -= 8
yield (chunk_header.chunk_id,
chunk_header.chunk_length,
f.tell())
f.seek(chunk_header.chunk_length, 1)
total_size -= chunk_header.chunk_length
f.close()
def comm_chunk(self):
"""Returns (channels, pcm_frames, bits_per_sample, sample_rate) ."""
try:
for (chunk_id, chunk_length, chunk_offset) in self.chunks():
if (chunk_id == 'COMM'):
f = open(self.filename, 'rb')
f.seek(chunk_offset, 0)
comm = self.COMM_CHUNK.parse(f.read(chunk_length))
f.close()
return (comm.channels,
comm.total_sample_frames,
comm.sample_size,
int(comm.sample_rate))
else:
raise InvalidAIFF(_(u"COMM chunk not found"))
except IOError, msg:
raise InvalidAIFF(str(msg))
except Con.FieldError:
raise InvalidAIFF(_(u"invalid COMM chunk"))
def chunk_files(self):
"""Yields a (chunk_id,length,file) per AIFF chunk.
The file object is capped to read only its chunk data."""
f = open(self.filename, 'rb')
try:
aiff_header = self.AIFF_HEADER.parse_stream(f)
except Con.ConstError:
raise InvalidAIFF(_(u"Not an AIFF file"))
except Con.core.FieldError:
raise InvalidAIFF(_(u"Invalid AIFF file"))
total_size = aiff_header.aiff_size - 4
while (total_size > 0):
chunk_header = self.CHUNK_HEADER.parse_stream(f)
total_size -= 8
yield (chunk_header.chunk_id,
chunk_header.chunk_length,
__capped_stream_reader__(f, chunk_header.chunk_length))
total_size -= chunk_header.chunk_length
f.close()
def get_metadata(self):
"""Returns a MetaData object, or None.
Raises IOError if unable to read the file."""
for (chunk_id, chunk_length, chunk_offset) in self.chunks():
if (chunk_id == 'ID3 '):
f = open(self.filename, 'rb')
f.seek(chunk_offset, 0)
id3 = ID3v22Comment.parse(f)
f.close()
return id3
else:
return None
def set_metadata(self, metadata):
"""Takes a MetaData object and sets this track's metadata.
This metadata includes track name, album name, and so on.
Raises IOError if unable to write the file."""
if (metadata is None):
return
import tempfile
id3_chunk = ID3v22Comment.converted(metadata).build()
new_aiff = tempfile.TemporaryFile()
new_aiff.seek(12, 0)
id3_found = False
for (chunk_id, chunk_length, chunk_file) in self.chunk_files():
if (chunk_id != 'ID3 '):
new_aiff.write(self.CHUNK_HEADER.build(
Con.Container(chunk_id=chunk_id,
chunk_length=chunk_length)))
transfer_data(chunk_file.read, new_aiff.write)
else:
new_aiff.write(self.CHUNK_HEADER.build(
Con.Container(chunk_id='ID3 ',
chunk_length=len(id3_chunk))))
new_aiff.write(id3_chunk)
id3_found = True
if (not id3_found):
new_aiff.write(self.CHUNK_HEADER.build(
Con.Container(chunk_id='ID3 ',
chunk_length=len(id3_chunk))))
new_aiff.write(id3_chunk)
header = Con.Container(
aiff_id='FORM',
aiff_size=new_aiff.tell() - 8,
aiff_type='AIFF')
new_aiff.seek(0, 0)
new_aiff.write(self.AIFF_HEADER.build(header))
new_aiff.seek(0, 0)
f = open(self.filename, 'wb')
transfer_data(new_aiff.read, f.write)
new_aiff.close()
f.close()
def delete_metadata(self):
"""Deletes the track's MetaData.
This removes or unsets tags as necessary in order to remove all data.
Raises IOError if unable to write the file."""
import tempfile
new_aiff = tempfile.TemporaryFile()
new_aiff.seek(12, 0)
for (chunk_id, chunk_length, chunk_file) in self.chunk_files():
if (chunk_id != 'ID3 '):
new_aiff.write(self.CHUNK_HEADER.build(
Con.Container(chunk_id=chunk_id,
chunk_length=chunk_length)))
transfer_data(chunk_file.read, new_aiff.write)
header = Con.Container(
aiff_id='FORM',
aiff_size=new_aiff.tell() - 8,
aiff_type='AIFF')
new_aiff.seek(0, 0)
new_aiff.write(self.AIFF_HEADER.build(header))
new_aiff.seek(0, 0)
f = open(self.filename, 'wb')
transfer_data(new_aiff.read, f.write)
new_aiff.close()
f.close()
def to_pcm(self):
"""Returns a PCMReader object containing the track's PCM data."""
for (chunk_id, chunk_length, chunk_offset) in self.chunks():
if (chunk_id == 'SSND'):
f = open(self.filename, 'rb')
f.seek(chunk_offset, 0)
return AiffReader(f,
self.sample_rate(),
self.channels(),
int(self.channel_mask()),
self.bits_per_sample(),
chunk_length)
else:
return PCMReaderError(u"no SSND chunk found",
self.sample_rate(),
self.channels(),
int(self.channel_mask()),
self.bits_per_sample)
@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 AiffAudio object."""
try:
f = open(filename, 'wb')
except IOError, msg:
raise EncodingError(str(msg))
if (int(pcmreader.channel_mask) in
(0x4, # FC
0x3, # FL, FR
0x7, # FL, FR, FC
0x33, # FL, FR, BL, BR
0x707)): # FL, SL, FC, FR, SR, BC
standard_channel_mask = ChannelMask(pcmreader.channel_mask)
aiff_channel_mask = AIFFChannelMask(standard_channel_mask)
pcmreader = ReorderedPCMReader(
pcmreader,
[standard_channel_mask.channels().index(channel)
for channel in aiff_channel_mask.channels()])
try:
aiff_header = Con.Container(aiff_id='FORM',
aiff_size=4,
aiff_type='AIFF')
comm_chunk = Con.Container(
channels=pcmreader.channels,
total_sample_frames=0,
sample_size=pcmreader.bits_per_sample,
sample_rate=float(pcmreader.sample_rate))
ssnd_header = Con.Container(chunk_id='SSND',
chunk_length=0)
ssnd_alignment = Con.Container(offset=0,
blocksize=0)
#skip ahead to the start of the SSND chunk
f.seek(cls.AIFF_HEADER.sizeof() +
cls.CHUNK_HEADER.sizeof() +
cls.COMM_CHUNK.sizeof() +
cls.CHUNK_HEADER.sizeof(), 0)
#write the SSND alignment info
f.write(cls.SSND_ALIGN.build(ssnd_alignment))
#write big-endian samples to SSND chunk from pcmreader
try:
framelist = pcmreader.read(BUFFER_SIZE)
except (ValueError, IOError), err:
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
cls.__unlink__(filename)
raise err
total_pcm_frames = 0
while (len(framelist) > 0):
f.write(framelist.to_bytes(True, True))
total_pcm_frames += framelist.frames
try:
framelist = pcmreader.read(BUFFER_SIZE)
except (ValueError, IOError), err:
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
cls.__unlink__(filename)
raise err
total_size = f.tell()
#return to the start of the file
f.seek(0, 0)
#write AIFF header
aiff_header.aiff_size = total_size - 8
f.write(cls.AIFF_HEADER.build(aiff_header))
#write COMM chunk
comm_chunk.total_sample_frames = total_pcm_frames
comm_chunk = cls.COMM_CHUNK.build(comm_chunk)
f.write(cls.CHUNK_HEADER.build(Con.Container(
chunk_id='COMM',
chunk_length=len(comm_chunk))))
f.write(comm_chunk)
#write SSND chunk header
f.write(cls.CHUNK_HEADER.build(Con.Container(
chunk_id='SSND',
chunk_length=(total_pcm_frames *
(pcmreader.bits_per_sample / 8) *
pcmreader.channels) +
cls.SSND_ALIGN.sizeof())))
try:
pcmreader.close()
except DecodingError, err:
raise EncodingError(err.error_message)
finally:
f.close()
return cls(filename)
def to_aiff(self, aiff_filename, progress=None):
"""Writes the contents of this file to the given .aiff filename string.
Raises EncodingError if some error occurs during decoding."""
try:
self.verify()
except InvalidAiff, err:
raise EncodingError(str(err))
try:
output = file(aiff_filename, 'wb')
input = file(self.filename, 'rb')
except IOError, msg:
raise EncodingError(str(msg))
try:
transfer_data(input.read, output.write)
finally:
input.close()
output.close()
@classmethod
def from_aiff(cls, filename, aiff_filename, compression=None,
progress=None):
try:
cls(aiff_filename).verify()
except InvalidAiff, err:
raise EncodingError(unicode(err))
try:
input = file(aiff_filename, 'rb')
output = file(filename, 'wb')
except IOError, err:
raise EncodingError(str(err))
try:
total_bytes = os.path.getsize(aiff_filename)
current_bytes = 0
s = input.read(4096)
while (len(s) > 0):
current_bytes += len(s)
output.write(s)
if (progress is not None):
progress(current_bytes, total_bytes)
s = input.read(4096)
output.flush()
try:
return AiffAudio(filename)
except InvalidFile:
cls.__unlink__(filename)
raise EncodingError(u"invalid AIFF source file")
finally:
input.close()
output.close()
def convert(self, target_path, target_class, compression=None,
progress=None):
"""Encodes a new AudioFile from existing AudioFile.
Take a filename string, target class and optional compression string.
Encodes a new AudioFile in the target class and returns
the resulting object.
May raise EncodingError if some problem occurs during encoding."""
if (hasattr(target_class, "from_aiff")):
return target_class.from_aiff(target_path,
self.filename,
compression=compression,
progress=progress)
else:
return target_class.from_pcm(target_path,
to_pcm_progress(self, progress),
compression)
def pcm_split(self):
"""Returns a pair of data strings before and after PCM data.
The first contains all data before the PCM content of the data chunk.
The second containing all data after the data chunk.
"""
head = cStringIO.StringIO()
tail = cStringIO.StringIO()
current_block = head
aiff_file = open(self.filename, 'rb')
try:
try:
#transfer the 12-bite FORMsizeAIFF header
header = AiffAudio.AIFF_HEADER.parse(aiff_file.read(12))
total_size = header.aiff_size - 4
current_block.write(AiffAudio.AIFF_HEADER.build(header))
except Con.ConstError:
raise InvalidAIFF(_(u"Not an AIFF file"))
except Con.core.FieldError:
raise InvalidAIFF(_(u"Invalid AIFF file"))
while (total_size > 0):
try:
#transfer each chunk header
chunk_header = AiffAudio.CHUNK_HEADER.parse(
aiff_file.read(8))
current_block.write(AiffAudio.CHUNK_HEADER.build(
chunk_header))
total_size -= 8
except Con.core.FieldError:
raise InvalidAiff(_(u"Invalid AIFF file"))
#and transfer the full content of non-ssnd chunks
if (chunk_header.chunk_id != "SSND"):
current_block.write(
aiff_file.read(chunk_header.chunk_length))
else:
#or, the top 8 align bytes of the ssnd chunk
try:
align = AiffAudio.SSND_ALIGN.parse(
aiff_file.read(8))
current_block.write(AiffAudio.SSND_ALIGN.build(
align))
aiff_file.seek(chunk_header.chunk_length - 8,
os.SEEK_CUR)
current_block = tail
except Con.core.FieldError:
raise InvalidAiff(_(u"Invalid AIFF file"))
total_size -= chunk_header.chunk_length
return (head.getvalue(), tail.getvalue())
finally:
aiff_file.close()
@classmethod
def aiff_from_chunks(cls, filename, chunk_iter):
"""Builds a new AIFF file from a chunk data iterator.
filename is the path to the wave file to build.
chunk_iter should yield (chunk_id, chunk_data) tuples.
"""
f = file(filename, 'wb')
header = Con.Container()
header.aiff_id = 'FORM'
header.aiff_type = 'AIFF'
header.aiff_size = 4
#write an unfinished header with an invalid size (for now)
f.write(cls.AIFF_HEADER.build(header))
for (chunk_id, chunk_data) in chunk_iter:
#not sure if I need to fix chunk sizes
#to fall on 16-bit boundaries
chunk_header = cls.CHUNK_HEADER.build(
Con.Container(chunk_id=chunk_id,
chunk_length=len(chunk_data)))
f.write(chunk_header)
header.aiff_size += len(chunk_header)
f.write(chunk_data)
header.aiff_size += len(chunk_data)
#now that the chunks are done, go back and re-write the header
f.seek(0, 0)
f.write(cls.AIFF_HEADER.build(header))
f.close()
def has_foreign_aiff_chunks(self):
return (set(['COMM', 'SSND']) !=
set([chunk[0] for chunk in self.chunks()]))
class AIFFChannelMask(ChannelMask):
"""The AIFF-specific channel mapping."""
def __repr__(self):
return "AIFFChannelMask(%s)" % \
",".join(["%s=%s" % (field, getattr(self, field))
for field in self.SPEAKER_TO_MASK.keys()
if (getattr(self, field))])
def channels(self):
"""Returns a list of speaker strings this mask contains.
Returned in the order in which they should appear
in the PCM stream.
"""
count = len(self)
if (count == 1):
return ["front_center"]
elif (count == 2):
return ["front_left", "front_right"]
elif (count == 3):
return ["front_left", "front_right", "front_center"]
elif (count == 4):
return ["front_left", "front_right",
"back_left", "back_right"]
elif (count == 6):
return ["front_left", "side_left", "front_center",
"front_right", "side_right", "back_center"]
else:
return []

808
Melodia/resources/audiotools/__ape__.py Normal file
View File

@ -0,0 +1,808 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, WaveAudio, InvalidFile, PCMReader,
Con, transfer_data, subprocess, BIN, MetaData,
os, re, TempWaveReader, Image, cStringIO)
import gettext
gettext.install("audiotools", unicode=True)
#takes a pair of integers for the current and total values
#returns a unicode string of their combined pair
#for example, __number_pair__(2,3) returns u"2/3"
#whereas __number_pair__(4,0) returns u"4"
def __number_pair__(current, total):
if (total == 0):
return u"%d" % (current)
else:
return u"%d/%d" % (current, total)
#######################
#MONKEY'S AUDIO
#######################
class ApeTagItem:
"""A container for APEv2 tag items."""
APEv2_FLAGS = Con.BitStruct("APEv2_FLAGS",
Con.Bits("undefined1", 5),
Con.Flag("read_only"),
Con.Bits("encoding", 2),
Con.Bits("undefined2", 16),
Con.Flag("contains_header"),
Con.Flag("contains_no_footer"),
Con.Flag("is_header"),
Con.Bits("undefined3", 5))
APEv2_TAG = Con.Struct("APEv2_TAG",
Con.ULInt32("length"),
Con.Embed(APEv2_FLAGS),
Con.CString("key"),
Con.MetaField("value",
lambda ctx: ctx["length"]))
def __init__(self, item_type, read_only, key, data):
"""Fields are as follows:
item_type is 0 = UTF-8, 1 = binary, 2 = external, 3 = reserved.
read_only is True if the item is read only.
key is an ASCII string.
data is a binary string of the data itself.
"""
self.type = item_type
self.read_only = read_only
self.key = key
self.data = data
def __repr__(self):
return "ApeTagItem(%s,%s,%s,%s)" % \
(repr(self.type),
repr(self.read_only),
repr(self.key),
repr(self.data))
def __str__(self):
return self.data
def __unicode__(self):
return self.data.rstrip(chr(0)).decode('utf-8', 'replace')
def build(self):
"""Returns this tag as a binary string of data."""
return self.APEv2_TAG.build(
Con.Container(key=self.key,
value=self.data,
length=len(self.data),
encoding=self.type,
undefined1=0,
undefined2=0,
undefined3=0,
read_only=self.read_only,
contains_header=False,
contains_no_footer=False,
is_header=False))
@classmethod
def binary(cls, key, data):
"""Returns an ApeTagItem of binary data.
key is an ASCII string, data is a binary string."""
return cls(1, False, key, data)
@classmethod
def external(cls, key, data):
"""Returns an ApeTagItem of external data.
key is an ASCII string, data is a binary string."""
return cls(2, False, key, data)
@classmethod
def string(cls, key, data):
"""Returns an ApeTagItem of text data.
key is an ASCII string, data is a UTF-8 binary string."""
return cls(0, False, key, data.encode('utf-8', 'replace'))
class ApeTag(MetaData):
"""A complete APEv2 tag."""
ITEM = ApeTagItem
APEv2_FLAGS = Con.BitStruct("APEv2_FLAGS",
Con.Bits("undefined1", 5),
Con.Flag("read_only"),
Con.Bits("encoding", 2),
Con.Bits("undefined2", 16),
Con.Flag("contains_header"),
Con.Flag("contains_no_footer"),
Con.Flag("is_header"),
Con.Bits("undefined3", 5))
APEv2_FOOTER = Con.Struct("APEv2",
Con.String("preamble", 8),
Con.ULInt32("version_number"),
Con.ULInt32("tag_size"),
Con.ULInt32("item_count"),
Con.Embed(APEv2_FLAGS),
Con.ULInt64("reserved"))
APEv2_HEADER = APEv2_FOOTER
APEv2_TAG = ApeTagItem.APEv2_TAG
ATTRIBUTE_MAP = {'track_name': 'Title',
'track_number': 'Track',
'track_total': 'Track',
'album_number': 'Media',
'album_total': 'Media',
'album_name': 'Album',
'artist_name': 'Artist',
#"Performer" is not a defined APEv2 key
#it would be nice to have, yet would not be standard
'performer_name': 'Performer',
'composer_name': 'Composer',
'conductor_name': 'Conductor',
'ISRC': 'ISRC',
'catalog': 'Catalog',
'copyright': 'Copyright',
'publisher': 'Publisher',
'year': 'Year',
'date': 'Record Date',
'comment': 'Comment'}
INTEGER_ITEMS = ('Track', 'Media')
def __init__(self, tags, tag_length=None):
"""Constructs an ApeTag from a list of ApeTagItem objects.
tag_length is an optional total length integer."""
for tag in tags:
if (not isinstance(tag, ApeTagItem)):
raise ValueError("%s is not ApeTag" % (repr(tag)))
self.__dict__["tags"] = tags
self.__dict__["tag_length"] = tag_length
def __eq__(self, metadata):
if (isinstance(metadata, ApeTag)):
if (set(self.keys()) != set(metadata.keys())):
return False
for tag in self.tags:
try:
if (tag.data != metadata[tag.key].data):
return False
except KeyError:
return False
else:
return True
elif (isinstance(metadata, MetaData)):
return MetaData.__eq__(self, metadata)
else:
return False
def keys(self):
return [tag.key for tag in self.tags]
def __getitem__(self, key):
for tag in self.tags:
if (tag.key == key):
return tag
else:
raise KeyError(key)
def get(self, key, default):
try:
return self[key]
except KeyError:
return default
def __setitem__(self, key, value):
for i in xrange(len(self.tags)):
if (self.tags[i].key == key):
self.tags[i] = value
return
else:
self.tags.append(value)
def index(self, key):
for (i, tag) in enumerate(self.tags):
if (tag.key == key):
return i
else:
raise ValueError(key)
def __delitem__(self, key):
for i in xrange(len(self.tags)):
if (self.tags[i].key == key):
del(self.tags[i])
return
#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 == 'track_number'):
self['Track'] = self.ITEM.string(
'Track', __number_pair__(value, self.track_total))
elif (key == 'track_total'):
self['Track'] = self.ITEM.string(
'Track', __number_pair__(self.track_number, value))
elif (key == 'album_number'):
self['Media'] = self.ITEM.string(
'Media', __number_pair__(value, self.album_total))
elif (key == 'album_total'):
self['Media'] = self.ITEM.string(
'Media', __number_pair__(self.album_number, value))
else:
self[self.ATTRIBUTE_MAP[key]] = self.ITEM.string(
self.ATTRIBUTE_MAP[key], value)
else:
self.__dict__[key] = value
def __getattr__(self, key):
if (key == 'track_number'):
try:
return int(re.findall('\d+',
unicode(self.get("Track", u"0")))[0])
except IndexError:
return 0
elif (key == 'track_total'):
try:
return int(re.findall('\d+/(\d+)',
unicode(self.get("Track", u"0")))[0])
except IndexError:
return 0
elif (key == 'album_number'):
try:
return int(re.findall('\d+',
unicode(self.get("Media", u"0")))[0])
except IndexError:
return 0
elif (key == 'album_total'):
try:
return int(re.findall('\d+/(\d+)',
unicode(self.get("Media", u"0")))[0])
except IndexError:
return 0
elif (key in self.ATTRIBUTE_MAP):
return unicode(self.get(self.ATTRIBUTE_MAP[key], u''))
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'):
setattr(self, 'track_number', 0)
if ((self.track_number == 0) and (self.track_total == 0)):
del(self['Track'])
elif (key == 'track_total'):
setattr(self, 'track_total', 0)
if ((self.track_number == 0) and (self.track_total == 0)):
del(self['Track'])
elif (key == 'album_number'):
setattr(self, 'album_number', 0)
if ((self.album_number == 0) and (self.album_total == 0)):
del(self['Media'])
elif (key == 'album_total'):
setattr(self, 'album_total', 0)
if ((self.album_number == 0) and (self.album_total == 0)):
del(self['Media'])
elif (key in self.ATTRIBUTE_MAP):
try:
del(self[self.ATTRIBUTE_MAP[key]])
except ValueError:
pass
elif (key in MetaData.__FIELDS__):
pass
else:
try:
del(self.__dict__[key])
except KeyError:
raise AttributeError(key)
@classmethod
def converted(cls, metadata):
"""Converts a MetaData object to an ApeTag object."""
if ((metadata is None) or (isinstance(metadata, ApeTag))):
return metadata
else:
tags = cls([])
for (field, key) in cls.ATTRIBUTE_MAP.items():
if (field not in cls.__INTEGER_FIELDS__):
field = unicode(getattr(metadata, field))
if (len(field) > 0):
tags[key] = cls.ITEM.string(key, field)
if ((metadata.track_number != 0) or
(metadata.track_total != 0)):
tags["Track"] = cls.ITEM.string(
"Track", __number_pair__(metadata.track_number,
metadata.track_total))
if ((metadata.album_number != 0) or
(metadata.album_total != 0)):
tags["Media"] = cls.ITEM.string(
"Media", __number_pair__(metadata.album_number,
metadata.album_total))
for image in metadata.images():
tags.add_image(image)
return tags
def merge(self, metadata):
"""Updates any currently empty entries from metadata's values."""
metadata = self.__class__.converted(metadata)
if (metadata is None):
return
for tag in metadata.tags:
if ((tag.key not in ('Track', 'Media')) and
(len(str(tag)) > 0) and
(len(str(self.get(tag.key, ""))) == 0)):
self[tag.key] = tag
for attr in ("track_number", "track_total",
"album_number", "album_total"):
if ((getattr(self, attr) == 0) and
(getattr(metadata, attr) != 0)):
setattr(self, attr, getattr(metadata, attr))
def __comment_name__(self):
return u'APEv2'
#takes two (key,value) apetag pairs
#returns cmp on the weighted set of them
#(title first, then artist, album, tracknumber)
@classmethod
def __by_pair__(cls, pair1, pair2):
KEY_MAP = {"Title": 1,
"Album": 2,
"Track": 3,
"Media": 4,
"Artist": 5,
"Performer": 6,
"Composer": 7,
"Conductor": 8,
"Catalog": 9,
"Publisher": 10,
"ISRC": 11,
#"Media": 12,
"Year": 13,
"Record Date": 14,
"Copyright": 15}
return cmp((KEY_MAP.get(pair1[0], 16), pair1[0], pair1[1]),
(KEY_MAP.get(pair2[0], 16), pair2[0], pair2[1]))
def __comment_pairs__(self):
items = []
for tag in self.tags:
if (tag.key in ('Cover Art (front)', 'Cover Art (back)')):
pass
elif (tag.type == 0):
items.append((tag.key, unicode(tag)))
else:
if (len(str(tag)) <= 20):
items.append((tag.key, str(tag).encode('hex')))
else:
items.append((tag.key,
str(tag).encode('hex')[0:39].upper() +
u"\u2026"))
return sorted(items, ApeTag.__by_pair__)
@classmethod
def supports_images(cls):
"""Returns True."""
return True
def __parse_image__(self, key, type):
data = cStringIO.StringIO(str(self[key]))
description = Con.CString(None).parse_stream(data).decode('utf-8',
'replace')
data = data.read()
return Image.new(data, description, type)
def add_image(self, image):
"""Embeds an Image object in this metadata."""
if (image.type == 0):
self['Cover Art (front)'] = self.ITEM.external(
'Cover Art (front)',
Con.CString(None).build(image.description.encode(
'utf-8', 'replace')) + image.data)
elif (image.type == 1):
self['Cover Art (back)'] = self.ITEM.binary(
'Cover Art (back)',
Con.CString(None).build(image.description.encode(
'utf-8', 'replace')) + image.data)
def delete_image(self, image):
"""Deletes an Image object from this metadata."""
if ((image.type == 0) and 'Cover Art (front)' in self.keys()):
del(self['Cover Art (front)'])
elif ((image.type == 1) and 'Cover Art (back)' in self.keys()):
del(self['Cover Art (back)'])
def images(self):
"""Returns a list of embedded Image objects."""
#APEv2 supports only one value per key
#so a single front and back cover are all that is possible
img = []
if ('Cover Art (front)' in self.keys()):
img.append(self.__parse_image__('Cover Art (front)', 0))
if ('Cover Art (back)' in self.keys()):
img.append(self.__parse_image__('Cover Art (back)', 1))
return img
@classmethod
def read(cls, apefile):
"""Returns an ApeTag object from an APEv2 tagged file object.
May return None if the file object has no tag."""
apefile.seek(-32, 2)
footer = cls.APEv2_FOOTER.parse(apefile.read(32))
if (footer.preamble != 'APETAGEX'):
return None
apefile.seek(-(footer.tag_size), 2)
return cls([ApeTagItem(item_type=tag.encoding,
read_only=tag.read_only,
key=tag.key,
data=tag.value)
for tag in Con.StrictRepeater(
footer.item_count,
cls.APEv2_TAG).parse(apefile.read())],
tag_length=footer.tag_size + ApeTag.APEv2_FOOTER.sizeof()
if footer.contains_header else
footer.tag_size)
def build(self):
"""Returns an APEv2 tag as a binary string."""
header = Con.Container(preamble='APETAGEX',
version_number=2000,
tag_size=0,
item_count=len(self.tags),
undefined1=0,
undefined2=0,
undefined3=0,
read_only=False,
encoding=0,
contains_header=True,
contains_no_footer=False,
is_header=True,
reserved=0l)
footer = Con.Container(preamble=header.preamble,
version_number=header.version_number,
tag_size=0,
item_count=len(self.tags),
undefined1=0,
undefined2=0,
undefined3=0,
read_only=False,
encoding=0,
contains_header=True,
contains_no_footer=False,
is_header=False,
reserved=0l)
tags = "".join([tag.build() for tag in self.tags])
footer.tag_size = header.tag_size = \
len(tags) + len(ApeTag.APEv2_FOOTER.build(footer))
return ApeTag.APEv2_FOOTER.build(header) + \
tags + \
ApeTag.APEv2_FOOTER.build(footer)
class ApeTaggedAudio:
"""A class for handling audio formats with APEv2 tags.
This class presumes there will be a filename attribute which
can be opened and checked for tags, or written if necessary."""
APE_TAG_CLASS = ApeTag
def get_metadata(self):
"""Returns an ApeTag object, or None.
Raises IOError if unable to read the file."""
f = file(self.filename, 'rb')
try:
return self.APE_TAG_CLASS.read(f)
finally:
f.close()
def set_metadata(self, metadata):
"""Takes a MetaData object and sets this track's metadata.
Raises IOError if unable to write the file."""
apetag = self.APE_TAG_CLASS.converted(metadata)
if (apetag is None):
return
current_metadata = self.get_metadata()
if (current_metadata is not None): # there's existing tags to delete
f = file(self.filename, "rb")
untagged_data = f.read()[0:-current_metadata.tag_length]
f.close()
f = file(self.filename, "wb")
f.write(untagged_data)
f.write(apetag.build())
f.close()
else: # no existing tags
f = file(self.filename, "ab")
f.write(apetag.build())
f.close()
def delete_metadata(self):
"""Deletes the track's MetaData.
Raises IOError if unable to write the file."""
current_metadata = self.get_metadata()
if (current_metadata is not None): # there's existing tags to delete
f = file(self.filename, "rb")
untagged_data = f.read()[0:-current_metadata.tag_length]
f.close()
f = file(self.filename, "wb")
f.write(untagged_data)
f.close()
class ApeAudio(ApeTaggedAudio, AudioFile):
"""A Monkey's Audio file."""
SUFFIX = "ape"
NAME = SUFFIX
DEFAULT_COMPRESSION = "5000"
COMPRESSION_MODES = tuple([str(x * 1000) for x in range(1, 6)])
BINARIES = ("mac",)
FILE_HEAD = Con.Struct("ape_head",
Con.String('id', 4),
Con.ULInt16('version'))
#version >= 3.98
APE_DESCRIPTOR = Con.Struct("ape_descriptor",
Con.ULInt16('padding'),
Con.ULInt32('descriptor_bytes'),
Con.ULInt32('header_bytes'),
Con.ULInt32('seektable_bytes'),
Con.ULInt32('header_data_bytes'),
Con.ULInt32('frame_data_bytes'),
Con.ULInt32('frame_data_bytes_high'),
Con.ULInt32('terminating_data_bytes'),
Con.String('md5', 16))
APE_HEADER = Con.Struct("ape_header",
Con.ULInt16('compression_level'),
Con.ULInt16('format_flags'),
Con.ULInt32('blocks_per_frame'),
Con.ULInt32('final_frame_blocks'),
Con.ULInt32('total_frames'),
Con.ULInt16('bits_per_sample'),
Con.ULInt16('number_of_channels'),
Con.ULInt32('sample_rate'))
#version <= 3.97
APE_HEADER_OLD = Con.Struct("ape_header_old",
Con.ULInt16('compression_level'),
Con.ULInt16('format_flags'),
Con.ULInt16('number_of_channels'),
Con.ULInt32('sample_rate'),
Con.ULInt32('header_bytes'),
Con.ULInt32('terminating_bytes'),
Con.ULInt32('total_frames'),
Con.ULInt32('final_frame_blocks'))
def __init__(self, filename):
"""filename is a plain string."""
AudioFile.__init__(self, filename)
(self.__samplespersec__,
self.__channels__,
self.__bitspersample__,
self.__totalsamples__) = ApeAudio.__ape_info__(filename)
@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."""
return file.read(4) == "MAC "
def lossless(self):
"""Returns True."""
return True
@classmethod
def supports_foreign_riff_chunks(cls):
"""Returns True."""
return True
def has_foreign_riff_chunks(self):
"""Returns True."""
#FIXME - this isn't strictly true
#I'll need a way to detect foreign chunks in APE's stream
#without decoding it first,
#but since I'm not supporting APE anyway, I'll take the lazy way out
return True
def bits_per_sample(self):
"""Returns an integer number of bits-per-sample this track contains."""
return self.__bitspersample__
def channels(self):
"""Returns an integer number of channels this track contains."""
return self.__channels__
def total_frames(self):
"""Returns the total PCM frames of the track as an integer."""
return self.__totalsamples__
def sample_rate(self):
"""Returns the rate of the track's audio as an integer number of Hz."""
return self.__samplespersec__
@classmethod
def __ape_info__(cls, filename):
f = file(filename, 'rb')
try:
file_head = cls.FILE_HEAD.parse_stream(f)
if (file_head.id != 'MAC '):
raise InvalidFile(_(u"Invalid Monkey's Audio header"))
if (file_head.version >= 3980): # the latest APE file type
descriptor = cls.APE_DESCRIPTOR.parse_stream(f)
header = cls.APE_HEADER.parse_stream(f)
return (header.sample_rate,
header.number_of_channels,
header.bits_per_sample,
((header.total_frames - 1) * \
header.blocks_per_frame) + \
header.final_frame_blocks)
else: # old-style APE file (obsolete)
header = cls.APE_HEADER_OLD.parse_stream(f)
if (file_head.version >= 3950):
blocks_per_frame = 0x48000
elif ((file_head.version >= 3900) or
((file_head.version >= 3800) and
(header.compression_level == 4000))):
blocks_per_frame = 0x12000
else:
blocks_per_frame = 0x2400
if (header.format_flags & 0x01):
bits_per_sample = 8
elif (header.format_flags & 0x08):
bits_per_sample = 24
else:
bits_per_sample = 16
return (header.sample_rate,
header.number_of_channels,
bits_per_sample,
((header.total_frames - 1) * \
blocks_per_frame) + \
header.final_frame_blocks)
finally:
f.close()
def to_wave(self, wave_filename):
"""Writes the contents of this file to the given .wav filename string.
Raises EncodingError if some error occurs during decoding."""
if (self.filename.endswith(".ape")):
devnull = file(os.devnull, "wb")
sub = subprocess.Popen([BIN['mac'],
self.filename,
wave_filename,
'-d'],
stdout=devnull,
stderr=devnull)
sub.wait()
devnull.close()
else:
devnull = file(os.devnull, 'ab')
import tempfile
ape = tempfile.NamedTemporaryFile(suffix='.ape')
f = file(self.filename, 'rb')
transfer_data(f.read, ape.write)
f.close()
ape.flush()
sub = subprocess.Popen([BIN['mac'],
ape.name,
wave_filename,
'-d'],
stdout=devnull,
stderr=devnull)
sub.wait()
ape.close()
devnull.close()
@classmethod
def from_wave(cls, filename, wave_filename, compression=None):
"""Encodes a new AudioFile from an existing .wav file.
Takes a filename string, wave_filename string
of an existing WaveAudio file
and an optional compression level string.
Encodes a new audio file from the wave's data
at the given filename with the specified compression level
and returns a new ApeAudio object."""
if (str(compression) not in cls.COMPRESSION_MODES):
compression = cls.DEFAULT_COMPRESSION
devnull = file(os.devnull, "wb")
sub = subprocess.Popen([BIN['mac'],
wave_filename,
filename,
"-c%s" % (compression)],
stdout=devnull,
stderr=devnull)
sub.wait()
devnull.close()
return ApeAudio(filename)

256
Melodia/resources/audiotools/__au__.py Normal file
View File

@ -0,0 +1,256 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, InvalidFile, PCMReader, Con,
transfer_data, InvalidFormat,
__capped_stream_reader__, BUFFER_SIZE,
FILENAME_FORMAT, EncodingError, DecodingError,
ChannelMask)
import audiotools.pcm
import gettext
gettext.install("audiotools", unicode=True)
class InvalidAU(InvalidFile):
pass
#######################
#Sun AU
#######################
class AuReader(PCMReader):
"""A subclass of PCMReader for reading Sun AU file contents."""
def __init__(self, au_file, data_size,
sample_rate, channels, channel_mask, bits_per_sample):
"""au_file is a file, data_size is an integer byte count.
sample_rate, channels, channel_mask and bits_per_sample are ints.
"""
PCMReader.__init__(self,
file=au_file,
sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)
self.data_size = data_size
def read(self, bytes):
"""Try to read a pcm.FrameList of size "bytes"."""
#align bytes downward if an odd number is read in
bytes -= (bytes % (self.channels * self.bits_per_sample / 8))
bytes = max(bytes, self.channels * self.bits_per_sample / 8)
pcm_data = self.file.read(bytes)
if ((len(pcm_data) == 0) and (self.data_size > 0)):
raise IOError("data ends prematurely")
else:
self.data_size -= len(pcm_data)
try:
return audiotools.pcm.FrameList(pcm_data,
self.channels,
self.bits_per_sample,
True,
True)
except ValueError:
raise IOError("data ends prematurely")
class AuAudio(AudioFile):
"""A Sun AU audio file."""
SUFFIX = "au"
NAME = SUFFIX
AU_HEADER = Con.Struct('header',
Con.Const(Con.String('magic_number', 4), '.snd'),
Con.UBInt32('data_offset'),
Con.UBInt32('data_size'),
Con.UBInt32('encoding_format'),
Con.UBInt32('sample_rate'),
Con.UBInt32('channels'))
def __init__(self, filename):
AudioFile.__init__(self, filename)
try:
f = file(filename, 'rb')
except IOError, msg:
raise InvalidAU(str(msg))
try:
header = AuAudio.AU_HEADER.parse_stream(f)
if (header.encoding_format not in (2, 3, 4)):
raise InvalidFile(_(u"Unsupported Sun AU encoding format"))
self.__bits_per_sample__ = {2: 8, 3: 16, 4: 24}[
header.encoding_format]
self.__channels__ = header.channels
self.__sample_rate__ = header.sample_rate
self.__total_frames__ = header.data_size / \
(self.__bits_per_sample__ / 8) / \
self.__channels__
self.__data_offset__ = header.data_offset
self.__data_size__ = header.data_size
except Con.ConstError:
raise InvalidFile(_(u"Invalid Sun AU header"))
except Con.FieldError:
raise InvalidAU(_(u"Invalid Sun AU header"))
@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."""
return file.read(4) == ".snd"
def lossless(self):
"""Returns True."""
return True
def bits_per_sample(self):
"""Returns an integer number of bits-per-sample this track contains."""
return self.__bits_per_sample__
def channels(self):
"""Returns an integer number of channels this track contains."""
return self.__channels__
def channel_mask(self):
"""Returns a ChannelMask object of this track's channel layout."""
if (self.channels() <= 2):
return ChannelMask.from_channels(self.channels())
else:
return ChannelMask(0)
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 to_pcm(self):
"""Returns a PCMReader object containing the track's PCM data."""
f = file(self.filename, 'rb')
f.seek(self.__data_offset__, 0)
return AuReader(au_file=f,
data_size=self.__data_size__,
sample_rate=self.sample_rate(),
channels=self.channels(),
channel_mask=int(self.channel_mask()),
bits_per_sample=self.bits_per_sample())
@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 AuAudio object."""
if (pcmreader.bits_per_sample not in (8, 16, 24)):
raise InvalidFormat(
_(u"Unsupported bits per sample %s") % (
pcmreader.bits_per_sample))
bytes_per_sample = pcmreader.bits_per_sample / 8
header = Con.Container(magic_number='.snd',
data_offset=0,
data_size=0,
encoding_format={8: 2, 16: 3, 24: 4}[
pcmreader.bits_per_sample],
sample_rate=pcmreader.sample_rate,
channels=pcmreader.channels)
try:
f = file(filename, 'wb')
except IOError, err:
raise EncodingError(str(err))
try:
#send out a dummy header
f.write(AuAudio.AU_HEADER.build(header))
header.data_offset = f.tell()
#send our big-endian PCM data
#d will be a list of ints, so we can't use transfer_data
try:
framelist = pcmreader.read(BUFFER_SIZE)
while (len(framelist) > 0):
bytes = framelist.to_bytes(True, True)
f.write(bytes)
header.data_size += len(bytes)
framelist = pcmreader.read(BUFFER_SIZE)
except (IOError, ValueError), err:
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
cls.__unlink__(filename)
raise err
#send out a complete header
f.seek(0, 0)
f.write(AuAudio.AU_HEADER.build(header))
finally:
f.close()
try:
pcmreader.close()
except DecodingError, err:
raise EncodingError(err.error_message)
return AuAudio(filename)
@classmethod
def track_name(cls, file_path, track_metadata=None, format=None,
suffix=None):
"""Constructs a new filename string.
Given a plain string to an existing path,
a MetaData-compatible object (or None),
a UTF-8-encoded Python format string
and an ASCII-encoded suffix string (such as "mp3")
returns a plain string of a new filename with format's
fields filled-in and encoded as FS_ENCODING.
Raises UnsupportedTracknameField if the format string
contains invalid template fields."""
if (format is None):
format = "track%(track_number)2.2d.au"
return AudioFile.track_name(file_path, track_metadata, format,
suffix=cls.SUFFIX)

687
Melodia/resources/audiotools/__dvda__.py Normal file
View File

@ -0,0 +1,687 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import Con, re, os, pcm, cStringIO, struct
class DVDAudio:
"""An object representing an entire DVD-Audio disc.
A DVDAudio object contains one or more DVDATitle objects
(accessible via the .titlesets attribute).
Typically, only the first DVDTitle is interesting.
Each DVDATitle then contains one or more DVDATrack objects.
"""
SECTOR_SIZE = 2048
PTS_PER_SECOND = 90000
AUDIO_TS_IFO = Con.Struct(
"AUDIO_TS_IFO",
Con.Const(Con.Bytes("identifier", 12), "DVDAUDIO-AMG"),
Con.UBInt32("AMG_start_sector"),
Con.Padding(12),
Con.UBInt32("AMGI_end_sector"),
Con.UBInt16("DVD_version"),
Con.Padding(4),
Con.UBInt16("volume_count"),
Con.UBInt16("volume_number"),
Con.UBInt8("disc_side"),
Con.Padding(4),
Con.UBInt8("autoplay"),
Con.UBInt32("ts_to_sv"),
Con.Padding(10),
Con.UBInt8("video_titlesets"),
Con.UBInt8("audio_titlesets"),
Con.Bytes("provider_identifier", 40))
ATS_XX_S1 = Con.Struct(
"ATS_XX",
Con.Const(Con.String("identifier", 12), "DVDAUDIO-ATS"),
Con.UBInt32("ATS_end_sector"),
Con.Padding(12),
Con.UBInt32("ATSI_end_sector"),
Con.UBInt16("DVD_specification_version"),
Con.UBInt32("VTS_category"),
Con.Padding(90),
Con.UBInt32("ATSI_MAT_end_sector"),
Con.Padding(60),
Con.UBInt32("VTSM_VOBS_start_sector"),
Con.UBInt32("ATST_AOBS_start_sector"),
Con.UBInt32("VTS_PTT_SRPT_start_sector"),
Con.UBInt32("ATS_PGCI_UT_start_sector"),
Con.UBInt32("VTSM_PGCI_UT_start_sector"),
Con.UBInt32("VTS_TMAPT_start_sector"),
Con.UBInt32("VTSM_C_ADT_start_sector"),
Con.UBInt32("VTSM_VOBU_ADMA_start_sector"),
Con.UBInt32("VTS_C_ADT_start_sector"),
Con.UBInt32("VTS_VOBU_ADMAP_start_sector"),
Con.Padding(24))
ATS_XX_S2 = Con.Struct(
"ATS_XX2",
Con.UBInt16("title_count"),
Con.Padding(2),
Con.UBInt32("last_byte_address"),
Con.StrictRepeater(
lambda ctx: ctx['title_count'],
Con.Struct('titles',
Con.UBInt16("unknown1"),
Con.UBInt16("unknown2"),
Con.UBInt32("byte_offset"))))
ATS_TITLE = Con.Struct(
"ATS_title",
Con.Bytes("unknown1", 2),
Con.UBInt8("tracks"),
Con.UBInt8("indexes"),
Con.UBInt32("track_length"),
Con.Bytes("unknown2", 4),
Con.UBInt16("sector_pointers_table"),
Con.Bytes("unknown3", 2),
Con.StrictRepeater(
lambda ctx: ctx["tracks"],
Con.Struct("timestamps",
Con.Bytes("unknown1", 2),
Con.Bytes("unknown2", 2),
Con.UBInt8("index_number"),
Con.Bytes("unknown3", 1),
Con.UBInt32("first_pts"),
Con.UBInt32("pts_length"),
Con.Padding(6))))
ATS_SECTOR_POINTER = Con.Struct(
"sector_pointer",
Con.Const(Con.Bytes("unknown", 4),
'\x01\x00\x00\x00'),
Con.UBInt32("first_sector"),
Con.UBInt32("last_sector"))
PACK_HEADER = Con.Struct(
"pack_header",
Con.Const(Con.UBInt32("sync_bytes"), 0x1BA),
Con.Embed(Con.BitStruct(
"markers",
Con.Const(Con.Bits("marker1", 2), 1),
Con.Bits("system_clock_high", 3),
Con.Const(Con.Bits("marker2", 1), 1),
Con.Bits("system_clock_mid", 15),
Con.Const(Con.Bits("marker3", 1), 1),
Con.Bits("system_clock_low", 15),
Con.Const(Con.Bits("marker4", 1), 1),
Con.Bits("scr_extension", 9),
Con.Const(Con.Bits("marker5", 1), 1),
Con.Bits("bit_rate", 22),
Con.Const(Con.Bits("marker6", 2), 3),
Con.Bits("reserved", 5),
Con.Bits("stuffing_length", 3))),
Con.StrictRepeater(lambda ctx: ctx["stuffing_length"],
Con.UBInt8("stuffing")))
PES_HEADER = Con.Struct(
"pes_header",
Con.Const(Con.Bytes("start_code", 3), "\x00\x00\x01"),
Con.UBInt8("stream_id"),
Con.UBInt16("packet_length"))
PACKET_HEADER = Con.Struct(
"packet_header",
Con.UBInt16("unknown1"),
Con.Byte("pad1_size"),
Con.StrictRepeater(lambda ctx: ctx["pad1_size"],
Con.Byte("pad1")),
Con.Byte("stream_id"),
Con.Byte("crc"),
Con.Byte("padding"),
Con.Switch("info",
lambda ctx: ctx["stream_id"],
{0xA0: Con.Struct( # PCM info
"pcm",
Con.Byte("pad2_size"),
Con.UBInt16("first_audio_frame"),
Con.UBInt8("padding2"),
Con.Embed(Con.BitStruct(
"flags",
Con.Bits("group1_bps", 4),
Con.Bits("group2_bps", 4),
Con.Bits("group1_sample_rate", 4),
Con.Bits("group2_sample_rate", 4))),
Con.UBInt8("padding3"),
Con.UBInt8("channel_assignment")),
0xA1: Con.Struct( # MLP info
"mlp",
Con.Byte("pad2_size"),
Con.StrictRepeater(lambda ctx: ctx["pad2_size"],
Con.Byte("pad2")),
Con.Bytes("mlp_size", 4),
Con.Const(Con.Bytes("sync_words", 3), "\xF8\x72\x6F"),
Con.Const(Con.UBInt8("stream_type"), 0xBB),
Con.Embed(Con.BitStruct(
"flags",
Con.Bits("group1_bps", 4),
Con.Bits("group2_bps", 4),
Con.Bits("group1_sample_rate", 4),
Con.Bits("group2_sample_rate", 4),
Con.Bits("unknown1", 11),
Con.Bits("channel_assignment", 5),
Con.Bits("unknown2", 48))))}))
def __init__(self, audio_ts_path, cdrom_device=None):
"""A DVD-A which contains PCMReader-compatible track objects."""
#an inventory of AUDIO_TS files converted to uppercase keys
self.files = dict([(name.upper(),
os.path.join(audio_ts_path, name))
for name in os.listdir(audio_ts_path)])
titleset_numbers = list(self.__titlesets__())
#for each titleset, read an ATS_XX_0.IFO file
#each titleset contains one or more DVDATitle objects
#and each DVDATitle object contains one or more DVDATrack objects
self.titlesets = [self.__titles__(titleset) for titleset in
titleset_numbers]
#for each titleset, calculate the lengths of the corresponding AOBs
#in terms of 2048 byte sectors
self.aob_sectors = []
for titleset in titleset_numbers:
aob_re = re.compile("ATS_%2.2d_\\d\\.AOB" % (titleset))
titleset_aobs = dict([(key, value) for (key, value) in
self.files.items()
if (aob_re.match(key))])
for aob_length in [os.path.getsize(titleset_aobs[key]) /
DVDAudio.SECTOR_SIZE
for key in sorted(titleset_aobs.keys())]:
if (len(self.aob_sectors) == 0):
self.aob_sectors.append(
(0, aob_length))
else:
self.aob_sectors.append(
(self.aob_sectors[-1][1],
self.aob_sectors[-1][1] + aob_length))
try:
if ((cdrom_device is not None) and
('DVDAUDIO.MKB' in self.files.keys())):
from audiotools.prot import CPPMDecoder
self.unprotector = CPPMDecoder(
cdrom_device, self.files['DVDAUDIO.MKB']).decode
else:
self.unprotector = lambda sector: sector
except ImportError:
self.unprotector = lambda sector: sector
def __getitem__(self, key):
return self.titlesets[key]
def __len__(self):
return len(self.titlesets)
def __titlesets__(self):
"""return valid audio titleset integers from AUDIO_TS.IFO"""
try:
f = open(self.files['AUDIO_TS.IFO'], 'rb')
except (KeyError, IOError):
raise InvalidDVDA(_(u"unable to open AUDIO_TS.IFO"))
try:
try:
for titleset in xrange(
1,
DVDAudio.AUDIO_TS_IFO.parse_stream(f).audio_titlesets + 1):
#ensure there are IFO files and AOBs
#for each valid titleset
if (("ATS_%2.2d_0.IFO" % (titleset) in
self.files.keys()) and
("ATS_%2.2d_1.AOB" % (titleset) in
self.files.keys())):
yield titleset
except Con.ConstError:
raise InvalidDVDA(_(u"invalid AUDIO_TS.IFO"))
finally:
f.close()
def __titles__(self, titleset):
"""returns a list of DVDATitle objects for the given titleset"""
try:
f = open(self.files['ATS_%2.2d_0.IFO' % (titleset)], 'rb')
except (KeyError, IOError):
raise InvalidDVDA(
_(u"unable to open ATS_%2.2d_0.IFO") % (titleset))
try:
try:
#the first sector contains little of interest
#but we'll read it to check the identifier string
DVDAudio.ATS_XX_S1.parse_stream(f)
except Con.ConstError:
raise InvalidDVDA(_(u"invalid ATS_%2.2d_0.IFO") % (titleset))
#then move to the second sector and continue parsing
f.seek(DVDAudio.SECTOR_SIZE, os.SEEK_SET)
#may contain one or more titles
title_records = DVDAudio.ATS_XX_S2.parse_stream(f)
titles = []
for (title_number,
title_offset) in enumerate(title_records.titles):
f.seek(DVDAudio.SECTOR_SIZE +
title_offset.byte_offset,
os.SEEK_SET)
title = DVDAudio.ATS_TITLE.parse_stream(f)
f.seek(DVDAudio.SECTOR_SIZE +
title_offset.byte_offset +
title.sector_pointers_table,
os.SEEK_SET)
sector_pointers = ([None] +
[DVDAudio.ATS_SECTOR_POINTER.parse_stream(f)
for i in xrange(title.indexes)])
dvda_title = DVDATitle(dvdaudio=self,
titleset=titleset,
title=title_number + 1,
pts_length=title.track_length,
tracks=[])
#for each track, determine its first and last sector
#based on the sector pointers between the track's
#initial index and the next track's initial index
for (track_number,
(timestamp, next_timestamp)) in enumerate(zip(
title.timestamps, title.timestamps[1:])):
dvda_title.tracks.append(
DVDATrack(
dvdaudio=self,
titleset=titleset,
title=dvda_title,
track=track_number + 1,
first_pts=timestamp.first_pts,
pts_length=timestamp.pts_length,
first_sector=sector_pointers[
timestamp.index_number].first_sector,
last_sector=sector_pointers[
next_timestamp.index_number - 1].last_sector))
#for the last track, its sector pointers
#simply consume what remains on the list
timestamp = title.timestamps[-1]
dvda_title.tracks.append(
DVDATrack(
dvdaudio=self,
titleset=titleset,
title=dvda_title,
track=len(title.timestamps),
first_pts=timestamp.first_pts,
pts_length=timestamp.pts_length,
first_sector=sector_pointers[
timestamp.index_number].first_sector,
last_sector=sector_pointers[-1].last_sector))
titles.append(dvda_title)
return titles
finally:
f.close()
def sector_reader(self, aob_filename):
if (self.unprotector is None):
return SectorReader(aob_filename)
else:
return UnprotectionSectorReader(aob_filename,
self.unprotector)
class InvalidDVDA(Exception):
pass
class DVDATitle:
"""An object representing a DVD-Audio title.
Contains one or more DVDATrack objects
which may are accessible via __getitem__
"""
def __init__(self, dvdaudio, titleset, title, pts_length, tracks):
"""length is in PTS ticks, tracks is a list of DVDATrack objects"""
self.dvdaudio = dvdaudio
self.titleset = titleset
self.title = title
self.pts_length = pts_length
self.tracks = tracks
def __len__(self):
return len(self.tracks)
def __getitem__(self, index):
return self.tracks[index]
def __repr__(self):
return "DVDATitle(%s)" % \
(",".join(["%s=%s" % (key, getattr(self, key))
for key in ["titleset", "title", "pts_length",
"tracks"]]))
def info(self):
"""returns a (sample_rate, channels, channel_mask, bps, type) tuple"""
#find the AOB file of the title's first track
track_sector = self[0].first_sector
titleset = re.compile("ATS_%2.2d_\\d\\.AOB" % (self.titleset))
for aob_path in sorted([self.dvdaudio.files[key] for key in
self.dvdaudio.files.keys()
if (titleset.match(key))]):
aob_sectors = os.path.getsize(aob_path) / DVDAudio.SECTOR_SIZE
if (track_sector > aob_sectors):
track_sector -= aob_sectors
else:
break
else:
raise ValueError(_(u"unable to find track sector in AOB files"))
#open that AOB file and seek to that track's first sector
aob_file = open(aob_path, 'rb')
try:
aob_file.seek(track_sector * DVDAudio.SECTOR_SIZE)
#read the pack header
DVDAudio.PACK_HEADER.parse_stream(aob_file)
#skip packets until the stream ID 0xBD is found
pes_header = DVDAudio.PES_HEADER.parse_stream(aob_file)
while (pes_header.stream_id != 0xBD):
aob_file.read(pes_header.packet_length)
pes_header = DVDAudio.PES_HEADER.parse_stream(aob_file)
#parse the PCM/MLP header
header = DVDAudio.PACKET_HEADER.parse_stream(aob_file)
#return the values indicated by the header
return (DVDATrack.SAMPLE_RATE[
header.info.group1_sample_rate],
DVDATrack.CHANNELS[
header.info.channel_assignment],
DVDATrack.CHANNEL_MASK[
header.info.channel_assignment],
DVDATrack.BITS_PER_SAMPLE[
header.info.group1_bps],
header.stream_id)
finally:
aob_file.close()
def stream(self):
titleset = re.compile("ATS_%2.2d_\\d\\.AOB" % (self.titleset))
return AOBStream(
aob_files=sorted([self.dvdaudio.files[key]
for key in self.dvdaudio.files.keys()
if (titleset.match(key))]),
first_sector=self[0].first_sector,
last_sector=self[-1].last_sector,
unprotector=self.dvdaudio.unprotector)
def to_pcm(self):
(sample_rate,
channels,
channel_mask,
bits_per_sample,
stream_type) = self.info()
if (stream_type == 0xA1):
from audiotools.decoders import MLPDecoder
return MLPDecoder(IterReader(self.stream().packet_payloads()),
(self.pts_length * sample_rate) /
DVDAudio.PTS_PER_SECOND)
elif (stream_type == 0xA0):
from audiotools.decoders import AOBPCMDecoder
return AOBPCMDecoder(IterReader(self.stream().packet_payloads()),
sample_rate,
channels,
channel_mask,
bits_per_sample)
else:
raise ValueError(_(u"unsupported DVD-Audio stream type"))
class DVDATrack:
"""An object representing an individual DVD-Audio track."""
SAMPLE_RATE = [48000, 96000, 192000, 0, 0, 0, 0, 0,
44100, 88200, 176400, 0, 0, 0, 0, 0]
CHANNELS = [1, 2, 3, 4, 3, 4, 5, 3, 4, 5, 4, 5, 6, 4, 5, 4, 5, 6, 5, 5, 6]
CHANNEL_MASK = [0x4, 0x3, 0x103, 0x33, 0xB, 0x10B, 0x3B, 0x7,
0x107, 0x37, 0xF, 0x10F, 0x3F, 0x107, 0x37, 0xF,
0x10F, 0x3F, 0x3B, 0x37, 0x3F]
BITS_PER_SAMPLE = [16, 20, 24] + [0] * 13
def __init__(self, dvdaudio,
titleset, title, track,
first_pts, pts_length,
first_sector, last_sector):
self.dvdaudio = dvdaudio
self.titleset = titleset
self.title = title
self.track = track
self.first_pts = first_pts
self.pts_length = pts_length
self.first_sector = first_sector
self.last_sector = last_sector
def __repr__(self):
return "DVDATrack(%s)" % \
(", ".join(["%s=%s" % (attr, getattr(self, attr))
for attr in ["titleset",
"title",
"track",
"first_pts",
"pts_length",
"first_sector",
"last_sector"]]))
def sectors(self):
"""iterates (aob_file, start_sector, end_sector)
for each AOB file necessary to extract the track's data
in the order in which they should be read."""
track_sectors = Rangeset(self.first_sector,
self.last_sector + 1)
for (i, (start_sector,
end_sector)) in enumerate(self.dvdaudio.aob_sectors):
aob_sectors = Rangeset(start_sector, end_sector)
intersection = aob_sectors & track_sectors
if (len(intersection)):
yield (self.dvdaudio.files["ATS_%2.2d_%d.AOB" % \
(self.titleset, i + 1)],
intersection.start - start_sector,
intersection.end - start_sector)
class Rangeset:
"""An optimized combination of range() and set()"""
#The purpose of this class is for finding the subset of
#two Rangesets, such as with:
#
# >>> Rangeset(1, 10) & Rangeset(5, 15)
# Rangeset(5, 10)
#
#which returns another Rangeset object.
#This is preferable to performing:
#
# >>> set(range(1, 10)) & set(range(5, 15))
# set([8, 9, 5, 6, 7])
#
#which allocates lots of unnecessary values
#when all we're interested in is the min and max.
def __init__(self, start, end):
self.start = start
self.end = end
def __repr__(self):
return "Rangeset(%s, %s)" % (repr(self.start), repr(self.end))
def __len__(self):
return self.end - self.start
def __getitem__(self, i):
if (i >= 0):
if (i < len(self)):
return self.start + i
else:
raise IndexError(i)
else:
if (-i - 1 < len(self)):
return self.end + i
else:
raise IndexError(i)
def __and__(self, rangeset):
min_point = max(self.start, rangeset.start)
max_point = min(self.end, rangeset.end)
if (min_point <= max_point):
return Rangeset(min_point, max_point)
else:
return Rangeset(0, 0)
class AOBSectorReader:
def __init__(self, aob_files):
self.aob_files = list(aob_files)
self.aob_files.sort()
self.current_file_index = 0
self.current_file = open(self.aob_files[self.current_file_index], 'rb')
def read(self, *args):
s = self.current_file.read(DVDAudio.SECTOR_SIZE)
if (len(s) == DVDAudio.SECTOR_SIZE):
return s
else:
try:
#if we can increment to the next file,
#close the current one and do so
self.current_file.close()
self.current_file_index += 1
self.current_file = open(
self.aob_files[self.current_file_index], 'rb')
return self.read()
except IndexError:
#otherwise, we've reached the end of all the files
return ""
def seek(self, sector):
for self.current_file_index in xrange(len(self.aob_files)):
aob_size = os.path.getsize(
self.aob_files[self.current_file_index]) / DVDAudio.SECTOR_SIZE
if (sector <= aob_size):
self.current_file = open(
self.aob_files[self.current_file_index], 'rb')
if (sector > 0):
self.current_file.seek(sector * DVDAudio.SECTOR_SIZE)
return
else:
sector -= aob_size
def close(self):
self.current_file.close()
del(self.aob_files)
del(self.current_file_index)
del(self.current_file)
class AOBStream:
def __init__(self, aob_files, first_sector, last_sector,
unprotector=lambda sector: sector):
self.aob_files = aob_files
self.first_sector = first_sector
self.last_sector = last_sector
self.unprotector = unprotector
def sectors(self):
first_sector = self.first_sector
last_sector = self.last_sector
reader = AOBSectorReader(self.aob_files)
reader.seek(first_sector)
last_sector -= first_sector
for i in xrange(last_sector + 1):
yield self.unprotector(reader.read())
reader.close()
def packets(self):
packet_header_size = struct.calcsize(">3sBH")
for sector in self.sectors():
assert(sector[0:4] == '\x00\x00\x01\xBA')
stuffing_count = ord(sector[13]) & 0x7
sector_bytes = 2048 - (14 + stuffing_count)
sector = cStringIO.StringIO(sector[-sector_bytes:])
while (sector_bytes > 0):
(start_code,
stream_id,
packet_length) = struct.unpack(
">3sBH", sector.read(packet_header_size))
sector_bytes -= packet_header_size
assert(start_code == '\x00\x00\x01')
if (stream_id == 0xBD):
yield sector.read(packet_length)
else:
sector.read(packet_length)
sector_bytes -= packet_length
def packet_payloads(self):
def payload(packet):
pad1_len = ord(packet[2])
pad2_len = ord(packet[3 + pad1_len + 3])
return packet[3 + pad1_len + 4 + pad2_len:]
for packet in self.packets():
yield payload(packet)
class IterReader:
def __init__(self, iterator):
self.iterator = iterator
def read(self, bytes):
try:
return self.iterator.next()
except StopIteration:
return ""
def close(self):
pass

2150
Melodia/resources/audiotools/__flac__.py Normal file
View File

File diff suppressed because it is too large Load Diff

724
Melodia/resources/audiotools/__freedb__.py Normal file
View File

@ -0,0 +1,724 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (VERSION, Con, cStringIO, sys, re, MetaData,
AlbumMetaData, AlbumMetaDataFile, __most_numerous__,
DummyAudioFile, MetaDataFileException)
import StringIO
import gettext
gettext.install("audiotools", unicode=True)
#######################
#XMCD
#######################
class XMCDException(MetaDataFileException):
"""Raised if some error occurs parsing an XMCD file."""
def __unicode__(self):
return _(u"Invalid XMCD file")
class XMCD(AlbumMetaDataFile):
LINE_LENGTH = 78
def __init__(self, fields, comments):
"""fields a dict of key->values. comment is a list of comments.
keys are plain strings. values and comments are unicode."""
self.fields = fields
self.comments = comments
def __getattr__(self, key):
if (key == 'album_name'):
dtitle = self.fields.get('DTITLE', u"")
if (u" / " in dtitle):
return dtitle.split(u" / ", 1)[1]
else:
return dtitle
elif (key == 'artist_name'):
dtitle = self.fields.get('DTITLE', u"")
if (u" / " in dtitle):
return dtitle.split(u" / ", 1)[0]
else:
return u""
elif (key == 'year'):
return self.fields.get('DYEAR', u"")
elif (key == 'catalog'):
return u""
elif (key == 'extra'):
return self.fields.get('EXTD', u"")
else:
try:
return self.__dict__[key]
except KeyError:
raise AttributeError(key)
def __setattr__(self, key, value):
if (key == 'album_name'):
dtitle = self.fields.get('DTITLE', u"")
if (u" / " in dtitle):
artist = dtitle.split(u" / ", 1)[0]
self.fields['DTITLE'] = u"%s / %s" % (artist, value)
else:
self.fields['DTITLE'] = value
elif (key == 'artist_name'):
dtitle = self.fields.get('DTITLE', u"")
if (u" / " in dtitle):
album = dtitle.split(u" / ", 1)[1]
else:
album = dtitle
self.fields['DTITLE'] = u"%s / %s" % (value, album)
elif (key == 'year'):
self.fields['DYEAR'] = value
elif (key == 'catalog'):
pass
elif (key == 'extra'):
self.fields['EXTD'] = value
else:
self.__dict__[key] = value
def __len__(self):
track_field = re.compile(r'(TTITLE|EXTT)(\d+)')
return max(set([int(m.group(2)) for m in
[track_field.match(key) for key in self.fields.keys()]
if m is not None])) + 1
def to_string(self):
def write_field(f, key, value):
chars = list(value)
encoded_value = "%s=" % (key)
while ((len(chars) > 0) and
(len(encoded_value +
chars[0].encode('utf-8', 'replace')) <
XMCD.LINE_LENGTH)):
encoded_value += chars.pop(0).encode('utf-8', 'replace')
f.write("%s\r\n" % (encoded_value))
if (len(chars) > 0):
write_field(f, key, u"".join(chars))
output = cStringIO.StringIO()
for comment in self.comments:
output.write(comment.encode('utf-8'))
output.write('\r\n')
fields = set(self.fields.keys())
for field in ['DISCID', 'DTITLE', 'DYEAR', 'DGENRE']:
if (field in fields):
write_field(output, field, self.fields[field])
fields.remove(field)
for i in xrange(len(self)):
field = 'TTITLE%d' % (i)
if (field in fields):
write_field(output, field, self.fields[field])
fields.remove(field)
if ('EXTD' in fields):
write_field(output, 'EXTD', self.fields['EXTD'])
fields.remove('EXTD')
for i in xrange(len(self)):
field = 'EXTT%d' % (i)
if (field in fields):
write_field(output, field, self.fields[field])
fields.remove(field)
for field in fields:
write_field(output, field, self.fields[field])
return output.getvalue()
@classmethod
def from_string(cls, string):
# try:
# data = string.decode('latin-1')
# except UnicodeDecodeError:
# data = string.decode('utf-8','replace')
#FIXME - handle latin-1 files?
data = string.decode('utf-8', 'replace')
if (not data.startswith(u"# xmcd")):
raise XMCDException()
fields = {}
comments = []
field_line = re.compile(r'([A-Z0-9]+?)=(.*)')
for line in StringIO.StringIO(data):
if (line.startswith(u'#')):
comments.append(line.rstrip('\r\n'))
else:
match = field_line.match(line.rstrip('\r\n'))
if (match is not None):
key = match.group(1).encode('ascii')
value = match.group(2)
if (key in fields):
fields[key] += value
else:
fields[key] = value
return cls(fields, comments)
def get_track(self, index):
try:
ttitle = self.fields['TTITLE%d' % (index)]
track_extra = self.fields['EXTT%d' % (index)]
except KeyError:
return (u"", u"", u"")
if (u' / ' in ttitle):
(track_artist, track_title) = ttitle.split(u' / ', 1)
else:
track_title = ttitle
track_artist = u""
return (track_title, track_artist, track_extra)
def set_track(self, index, name, artist, extra):
if ((index < 0) or (index >= len(self))):
raise IndexError(index)
if (len(artist) > 0):
self.fields["TTITLE%d" % (index)] = u"%s / %s" % (artist, name)
else:
self.fields["TTITLE%d" % (index)] = name
if (len(extra) > 0):
self.fields["EXTT%d" % (index)] = extra
@classmethod
def from_tracks(cls, tracks):
def track_string(track, album_artist, metadata):
if (track.track_number() in metadata.keys()):
metadata = metadata[track.track_number()]
if (metadata.artist_name == album_artist):
return metadata.track_name
else:
return u"%s / %s" % (metadata.artist_name,
metadata.track_name)
else:
return u""
audiofiles = [f for f in tracks if f.track_number() != 0]
audiofiles.sort(lambda t1, t2: cmp(t1.track_number(),
t2.track_number()))
discid = DiscID([track.cd_frames() for track in audiofiles])
metadata = dict([(t.track_number(), t.get_metadata())
for t in audiofiles
if (t.get_metadata() is not None)])
artist_names = [m.artist_name for m in metadata.values()]
if (len(artist_names) == 0):
album_artist = u""
elif ((len(artist_names) > 1) and
(len(set(artist_names)) == len(artist_names))):
#if all track artists are different, don't pick one
album_artist = u"Various"
else:
album_artist = __most_numerous__(artist_names)
return cls(dict([("DISCID", str(discid).decode('ascii')),
("DTITLE", u"%s / %s" % \
(album_artist,
__most_numerous__([m.album_name for m in
metadata.values()]))),
("DYEAR", __most_numerous__([m.year for m in
metadata.values()])),
("EXTDD", u""),
("PLAYORDER", u"")] + \
[("TTITLE%d" % (track.track_number() - 1),
track_string(track, album_artist, metadata))
for track in audiofiles] + \
[("EXTT%d" % (track.track_number() - 1),
u"")
for track in audiofiles]),
[u"# xmcd",
u"#",
u"# Track frame offsets:"] +
[u"#\t%d" % (offset) for offset in discid.offsets()] +
[u"#",
u"# Disc length: %d seconds" % (
(discid.length() / 75) + 2),
u"#"])
#######################
#FREEDB
#######################
class DiscID:
"""An object representing a 32 bit FreeDB disc ID value."""
DISCID = Con.Struct('discid',
Con.UBInt8('digit_sum'),
Con.UBInt16('length'),
Con.UBInt8('track_count'))
def __init__(self, tracks=[], offsets=None, length=None, lead_in=150):
"""Fields are as follows:
tracks - a list of track lengths in CD frames
offsets - a list of track offsets in CD frames
length - the length of the entire disc in CD frames
lead_in - the location of the first track on the CD, in frames
These fields are all optional.
One will presumably fill them with data later in that event.
"""
self.tracks = tracks
self.__offsets__ = offsets
self.__length__ = length
self.__lead_in__ = lead_in
@classmethod
def from_cdda(cls, cdda):
"""Given a CDDA object, returns a populated DiscID.
May raise ValueError if there are no audio tracks on the CD."""
tracks = list(cdda)
if (len(tracks) < 1):
raise ValueError(_(u"no audio tracks in CDDA object"))
return cls(tracks=[t.length() for t in tracks],
offsets=[t.offset() for t in tracks],
length=cdda.last_sector(),
lead_in=tracks[0].offset())
def add(self, track):
"""Adds a new track length, in CD frames."""
self.tracks.append(track)
def offsets(self):
"""Returns a list of calculated offset integers, from track lengths."""
if (self.__offsets__ is None):
offsets = [self.__lead_in__]
for track in self.tracks[0:-1]:
offsets.append(track + offsets[-1])
return offsets
else:
return self.__offsets__
def length(self):
"""Returns the total length of the disc, in seconds."""
if (self.__length__ is None):
return sum(self.tracks)
else:
return self.__length__
def idsuffix(self):
"""Returns a FreeDB disc ID suffix string.
This is for making server queries."""
return str(len(self.tracks)) + " " + \
" ".join([str(offset) for offset in self.offsets()]) + \
" " + str((self.length() + self.__lead_in__) / 75)
def __str__(self):
def __count_digits__(i):
if (i == 0):
return 0
else:
return (i % 10) + __count_digits__(i / 10)
disc_id = Con.Container()
disc_id.track_count = len(self.tracks)
disc_id.length = self.length() / 75
disc_id.digit_sum = sum([__count_digits__(o / 75)
for o in self.offsets()]) % 0xFF
return DiscID.DISCID.build(disc_id).encode('hex')
def freedb_id(self):
"""Returns the entire FreeDB disc ID, including suffix."""
return str(self) + " " + self.idsuffix()
def toxmcd(self, output):
"""Writes a newly created XMCD file to output.
Its values are populated from this DiscID's fields."""
output.write(XMCD.from_tracks(
[DummyAudioFile(length, None, i + 1)
for (i, length) in enumerate(self.tracks)]).to_string())
class FreeDBException(Exception):
"""Raised if some problem occurs during FreeDB querying."""
pass
class FreeDB:
"""A class for performing queries on a FreeDB or compatible server.
This operates using the original FreeDB client-server protocol."""
LINE = re.compile(r'\d\d\d\s.+')
def __init__(self, server, port, messenger):
"""server is a string, port is an int, messenger is a Messenger.
Queries are sent to the server, and output to the messenger."""
self.server = server
self.port = port
self.socket = None
self.r = None
self.w = None
self.messenger = messenger
def connect(self):
"""Performs the initial connection."""
import socket
try:
self.messenger.info(_(u"Connecting to \"%s\"") % (self.server))
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((self.server, self.port))
self.r = self.socket.makefile("rb")
self.w = self.socket.makefile("wb")
(code, msg) = self.read() # the welcome message
if (code == 201):
self.messenger.info(_(u"Connected ... attempting to login"))
else:
self.r.close()
self.w.close()
self.socket.close()
raise FreeDBException(_(u"Invalid hello message"))
self.write("cddb hello user %s %s %s" % \
(socket.getfqdn(), "audiotools", VERSION))
(code, msg) = self.read() # the handshake successful message
if (code != 200):
self.r.close()
self.w.close()
self.socket.close()
raise FreeDBException(_(u"Handshake unsuccessful"))
self.write("proto 6")
(code, msg) = self.read() # the protocol successful message
if ((code != 200) and (code != 201)):
self.r.close()
self.w.close()
self.socket.close()
raise FreeDBException(_(u"Protocol change unsuccessful"))
except socket.error, err:
raise FreeDBException(err[1])
def close(self):
"""Closes an open connection."""
self.messenger.info(_(u"Closing connection"))
self.write("quit")
(code, msg) = self.read() # the quit successful message
self.r.close()
self.w.close()
self.socket.close()
def write(self, line):
"""Writes a single command line to the server."""
if (self.socket is not None):
self.w.write(line)
self.w.write("\r\n")
self.w.flush()
def read(self):
"""Reads a result line from the server."""
line = self.r.readline()
if (FreeDB.LINE.match(line)):
return (int(line[0:3]), line[4:].rstrip("\r\n"))
else:
return (None, line.rstrip("\r\n"))
def query(self, disc_id):
"""Given a DiscID, performs an album query and returns matches.
Each match is a (category, id) pair, which the user may
need to decide between."""
matches = []
self.messenger.info(
_(u"Sending Disc ID \"%(disc_id)s\" to server \"%(server)s\"") % \
{"disc_id": str(disc_id).decode('ascii'),
"server": self.server.decode('ascii', 'replace')})
self.write("cddb query " + disc_id.freedb_id())
(code, msg) = self.read()
if (code == 200):
matches.append(msg)
elif ((code == 211) or (code == 210)):
while (msg != "."):
(code, msg) = self.read()
if (msg != "."):
matches.append(msg)
if (len(matches) == 1):
self.messenger.info(_(u"1 match found"))
else:
self.messenger.info(_(u"%s matches found") % (len(matches)))
return map(lambda m: m.split(" ", 2), matches)
def read_data(self, category, id, output):
"""Reads the FreeDB entry matching category and id to output.
category and id are raw strings, as returned by query().
output is an open file object.
"""
self.write("cddb read " + category + " " + id)
(code, msg) = self.read()
if (code == 210):
line = self.r.readline()
while (line.strip() != "."):
output.write(line)
line = self.r.readline()
else:
print >> sys.stderr, (code, msg)
class FreeDBWeb(FreeDB):
"""A class for performing queries on a FreeDB or compatible server.
This operates using the FreeDB web-based protocol."""
def __init__(self, server, port, messenger):
"""server is a string, port is an int, messenger is a Messenger.
Queries are sent to the server, and output to the messenger."""
self.server = server
self.port = port
self.connection = None
self.messenger = messenger
def connect(self):
"""Performs the initial connection."""
import httplib
self.connection = httplib.HTTPConnection(self.server, self.port,
timeout=10)
def close(self):
"""Closes an open connection."""
if (self.connection is not None):
self.connection.close()
def write(self, line):
"""Writes a single command line to the server."""
import urllib
import socket
u = urllib.urlencode({"hello": "user %s %s %s" % \
(socket.getfqdn(),
"audiotools",
VERSION),
"proto": str(6),
"cmd": line})
try:
self.connection.request(
"POST",
"/~cddb/cddb.cgi",
u,
{"Content-type": "application/x-www-form-urlencoded",
"Accept": "text/plain"})
except socket.error, msg:
raise FreeDBException(str(msg))
def read(self):
"""Reads a result line from the server."""
response = self.connection.getresponse()
return response.read()
def __parse_line__(self, line):
if (FreeDB.LINE.match(line)):
return (int(line[0:3]), line[4:].rstrip("\r\n"))
else:
return (None, line.rstrip("\r\n"))
def query(self, disc_id):
"""Given a DiscID, performs an album query and returns matches.
Each match is a (category, id) pair, which the user may
need to decide between."""
matches = []
self.messenger.info(
_(u"Sending Disc ID \"%(disc_id)s\" to server \"%(server)s\"") % \
{"disc_id": str(disc_id).decode('ascii'),
"server": self.server.decode('ascii', 'replace')})
self.write("cddb query " + disc_id.freedb_id())
data = cStringIO.StringIO(self.read())
(code, msg) = self.__parse_line__(data.readline())
if (code == 200):
matches.append(msg)
elif ((code == 211) or (code == 210)):
while (msg != "."):
(code, msg) = self.__parse_line__(data.readline())
if (msg != "."):
matches.append(msg)
if (len(matches) == 1):
self.messenger.info(_(u"1 match found"))
else:
self.messenger.info(_(u"%s matches found") % (len(matches)))
return map(lambda m: m.split(" ", 2), matches)
def read_data(self, category, id, output):
"""Reads the FreeDB entry matching category and id to output.
category and id are raw strings, as returned by query().
output is an open file object.
"""
self.write("cddb read " + category + " " + id)
data = cStringIO.StringIO(self.read())
(code, msg) = self.__parse_line__(data.readline())
if (code == 210):
line = data.readline()
while (line.strip() != "."):
output.write(line)
line = data.readline()
else:
print >> sys.stderr, (code, msg)
#matches is a list of (category,disc_id,title) tuples returned from
#FreeDB.query(). If the length of that list is 1, return the first
#item. If the length is greater than one, present the user a list of
#choices and force him/her to pick the closest match for the CD.
#That data can then be sent to FreeDB.read_data()
def __select_match__(matches, messenger):
if (len(matches) == 1):
return matches[0]
elif (len(matches) < 1):
return None
else:
messenger.info(_(u"Please Select the Closest Match:"))
selected = 0
while ((selected < 1) or (selected > len(matches))):
for i in range(len(matches)):
messenger.info(_(u"%(choice)s) [%(genre)s] %(name)s") % \
{"choice": i + 1,
"genre": matches[i][0],
"name": matches[i][2].decode('utf-8',
'replace')})
try:
messenger.partial_info(_(u"Your Selection [1-%s]:") % \
(len(matches)))
selected = int(sys.stdin.readline().strip())
except ValueError:
selected = 0
return matches[selected - 1]
def __select_default_match__(matches, selection):
if (len(matches) < 1):
return None
else:
try:
return matches[selection]
except IndexError:
return matches[0]
def get_xmcd(disc_id, output, freedb_server, freedb_server_port,
messenger, default_selection=None):
"""Runs through the entire FreeDB querying sequence.
Fields are as follows:
disc_id - a DiscID object
output - an open file object for writing
freedb_server - a server name string
freedb_port - a server port int
messenger - a Messenger object
default_selection - if given, the default match to choose
"""
try:
freedb = FreeDBWeb(freedb_server, freedb_server_port, messenger)
freedb.connect()
except FreeDBException, msg:
#if an exception occurs during the opening,
#freedb will auto-close its sockets
raise IOError(str(msg))
try:
matches = freedb.query(disc_id)
#HANDLE MULTIPLE MATCHES, or NO MATCHES
if (len(matches) > 0):
if (default_selection is None):
(category, idstring, title) = __select_match__(
matches, messenger)
else:
(category, idstring, title) = __select_default_match__(
matches, default_selection)
freedb.read_data(category, idstring, output)
output.flush()
freedb.close()
except FreeDBException, msg:
#otherwise, close the sockets manually
freedb.close()
raise IOError(str(msg))
return len(matches)

1765
Melodia/resources/audiotools/__id3__.py Normal file
View File

File diff suppressed because it is too large Load Diff

190
Melodia/resources/audiotools/__id3v1__.py Normal file
View File

@ -0,0 +1,190 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import MetaData, Con, os
class ID3v1Comment(MetaData, list):
"""A complete ID3v1 tag."""
ID3v1 = Con.Struct("id3v1",
Con.Const(Con.String("identifier", 3), 'TAG'),
Con.String("song_title", 30),
Con.String("artist", 30),
Con.String("album", 30),
Con.String("year", 4),
Con.String("comment", 28),
Con.Padding(1),
Con.Byte("track_number"),
Con.Byte("genre"))
ID3v1_NO_TRACKNUMBER = Con.Struct("id3v1_notracknumber",
Con.Const(Con.String("identifier", 3), 'TAG'),
Con.String("song_title", 30),
Con.String("artist", 30),
Con.String("album", 30),
Con.String("year", 4),
Con.String("comment", 30),
Con.Byte("genre"))
ATTRIBUTES = ['track_name',
'artist_name',
'album_name',
'year',
'comment',
'track_number']
@classmethod
def read_id3v1_comment(cls, mp3filename):
"""Reads a ID3v1Comment data from an MP3 filename.
Returns a (song title, artist, album, year, comment, track number)
tuple.
If no ID3v1 tag is present, returns a tuple with those fields blank.
All text is in unicode.
If track number is -1, the id3v1 comment could not be found.
"""
mp3file = file(mp3filename, "rb")
try:
mp3file.seek(-128, 2)
try:
id3v1 = ID3v1Comment.ID3v1.parse(mp3file.read())
except Con.adapters.PaddingError:
mp3file.seek(-128, 2)
id3v1 = ID3v1Comment.ID3v1_NO_TRACKNUMBER.parse(mp3file.read())
id3v1.track_number = 0
except Con.ConstError:
return tuple([u""] * 5 + [-1])
field_list = (id3v1.song_title,
id3v1.artist,
id3v1.album,
id3v1.year,
id3v1.comment)
return tuple(map(lambda t:
t.rstrip('\x00').decode('ascii', 'replace'),
field_list) + [id3v1.track_number])
finally:
mp3file.close()
@classmethod
def build_id3v1(cls, song_title, artist, album, year, comment,
track_number):
"""Turns fields into a complete ID3v1 binary tag string.
All fields are unicode except for track_number, an int."""
def __s_pad__(s, length):
if (len(s) < length):
return s + chr(0) * (length - len(s))
else:
s = s[0:length].rstrip()
return s + chr(0) * (length - len(s))
c = Con.Container()
c.identifier = 'TAG'
c.song_title = __s_pad__(song_title.encode('ascii', 'replace'), 30)
c.artist = __s_pad__(artist.encode('ascii', 'replace'), 30)
c.album = __s_pad__(album.encode('ascii', 'replace'), 30)
c.year = __s_pad__(year.encode('ascii', 'replace'), 4)
c.comment = __s_pad__(comment.encode('ascii', 'replace'), 28)
c.track_number = int(track_number)
c.genre = 0
return ID3v1Comment.ID3v1.build(c)
def __init__(self, metadata):
"""Initialized with a read_id3v1_comment tuple.
Fields are (title,artist,album,year,comment,tracknum)"""
list.__init__(self, metadata)
@classmethod
def supports_images(cls):
"""Returns False."""
return False
#if an attribute is updated (e.g. self.track_name)
#make sure to update the corresponding list item
def __setattr__(self, key, value):
if (key in self.ATTRIBUTES):
if (key != 'track_number'):
self[self.ATTRIBUTES.index(key)] = value
else:
self[self.ATTRIBUTES.index(key)] = int(value)
elif (key in MetaData.__FIELDS__):
pass
else:
self.__dict__[key] = value
def __delattr__(self, key):
if (key == 'track_number'):
setattr(self, key, 0)
elif (key in self.ATTRIBUTES):
setattr(self, key, u"")
def __getattr__(self, key):
if (key in self.ATTRIBUTES):
return self[self.ATTRIBUTES.index(key)]
elif (key in MetaData.__INTEGER_FIELDS__):
return 0
elif (key in MetaData.__FIELDS__):
return u""
else:
raise AttributeError(key)
@classmethod
def converted(cls, metadata):
"""Converts a MetaData object to an ID3v1Comment object."""
if ((metadata is None) or (isinstance(metadata, ID3v1Comment))):
return metadata
return ID3v1Comment((metadata.track_name,
metadata.artist_name,
metadata.album_name,
metadata.year,
metadata.comment,
int(metadata.track_number)))
def __comment_name__(self):
return u'ID3v1'
def __comment_pairs__(self):
return zip(('Title', 'Artist', 'Album', 'Year', 'Comment', 'Tracknum'),
self)
def build_tag(self):
"""Returns a binary string of this tag's data."""
return self.build_id3v1(self.track_name,
self.artist_name,
self.album_name,
self.year,
self.comment,
self.track_number)
def images(self):
"""Returns an empty list of Image objects."""
return []

538
Melodia/resources/audiotools/__image__.py Normal file
View File

@ -0,0 +1,538 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import Con
import imghdr
import cStringIO
import gettext
gettext.install("audiotools", unicode=True)
def __jpeg__(h, f):
if (h[0:3] == "FFD8FF".decode('hex')):
return 'jpeg'
else:
return None
imghdr.tests.append(__jpeg__)
def image_metrics(file_data):
"""Returns an ImageMetrics subclass from a string of file data.
Raises InvalidImage if there is an error parsing the file
or its type is unknown."""
header = imghdr.what(None, file_data)
file = cStringIO.StringIO(file_data)
try:
if (header == 'jpeg'):
return __JPEG__.parse(file)
elif (header == 'png'):
return __PNG__.parse(file)
elif (header == 'gif'):
return __GIF__.parse(file)
elif (header == 'bmp'):
return __BMP__.parse(file)
elif (header == 'tiff'):
return __TIFF__.parse(file)
else:
raise InvalidImage(_(u'Unknown image type'))
finally:
file.close()
#######################
#JPEG
#######################
class ImageMetrics:
"""A container for image data."""
def __init__(self, width, height, bits_per_pixel, color_count, mime_type):
"""Fields are as follows:
width - image width as an integer number of pixels
height - image height as an integer number of pixels
bits_per_pixel - the number of bits per pixel as an integer
color_count - for palette-based images, the total number of colors
mime_type - the image's MIME type, as a string
All of the ImageMetrics subclasses implement these fields.
In addition, they all implement a parse() classmethod
used to parse binary string data and return something
ImageMetrics compatible.
"""
self.width = width
self.height = height
self.bits_per_pixel = bits_per_pixel
self.color_count = color_count
self.mime_type = mime_type
def __repr__(self):
return "ImageMetrics(%s,%s,%s,%s,%s)" % \
(repr(self.width),
repr(self.height),
repr(self.bits_per_pixel),
repr(self.color_count),
repr(self.mime_type))
class InvalidImage(Exception):
"""Raised if an image cannot be parsed correctly."""
def __init__(self, err):
self.err = unicode(err)
def __unicode__(self):
return self.err
class InvalidJPEG(InvalidImage):
"""Raised if a JPEG cannot be parsed correctly."""
pass
class __JPEG__(ImageMetrics):
SEGMENT_HEADER = Con.Struct('segment_header',
Con.Const(Con.Byte('header'), 0xFF),
Con.Byte('type'),
Con.If(
lambda ctx: ctx['type'] not in (0xD8, 0xD9),
Con.UBInt16('length')))
APP0 = Con.Struct('JFIF_segment_marker',
Con.String('identifier', 5),
Con.Byte('major_version'),
Con.Byte('minor_version'),
Con.Byte('density_units'),
Con.UBInt16('x_density'),
Con.UBInt16('y_density'),
Con.Byte('thumbnail_width'),
Con.Byte('thumbnail_height'))
SOF = Con.Struct('start_of_frame',
Con.Byte('data_precision'),
Con.UBInt16('image_height'),
Con.UBInt16('image_width'),
Con.Byte('components'))
def __init__(self, width, height, bits_per_pixel):
ImageMetrics.__init__(self, width, height, bits_per_pixel,
0, u'image/jpeg')
@classmethod
def parse(cls, file):
try:
header = cls.SEGMENT_HEADER.parse_stream(file)
if (header.type != 0xD8):
raise InvalidJPEG(_(u'Invalid JPEG header'))
segment = cls.SEGMENT_HEADER.parse_stream(file)
while (segment.type != 0xD9):
if (segment.type == 0xDA):
break
if (segment.type in (0xC0, 0xC1, 0xC2, 0xC3,
0xC5, 0XC5, 0xC6, 0xC7,
0xC9, 0xCA, 0xCB, 0xCD,
0xCE, 0xCF)): # start of frame
segment_data = cStringIO.StringIO(
file.read(segment.length - 2))
frame0 = cls.SOF.parse_stream(segment_data)
segment_data.close()
return __JPEG__(width=frame0.image_width,
height=frame0.image_height,
bits_per_pixel=(frame0.data_precision *
frame0.components))
else:
file.seek(segment.length - 2, 1)
segment = cls.SEGMENT_HEADER.parse_stream(file)
raise InvalidJPEG(_(u'Start of frame not found'))
except Con.ConstError:
raise InvalidJPEG(_(u"Invalid JPEG segment marker at 0x%X") % \
(file.tell()))
#######################
#PNG
#######################
class InvalidPNG(InvalidImage):
"""Raised if a PNG cannot be parsed correctly."""
pass
class __PNG__(ImageMetrics):
HEADER = Con.Const(Con.String('header', 8),
'89504e470d0a1a0a'.decode('hex'))
CHUNK_HEADER = Con.Struct('chunk',
Con.UBInt32('length'),
Con.String('type', 4))
CHUNK_FOOTER = Con.Struct('crc32',
Con.UBInt32('crc'))
IHDR = Con.Struct('IHDR',
Con.UBInt32('width'),
Con.UBInt32('height'),
Con.Byte('bit_depth'),
Con.Byte('color_type'),
Con.Byte('compression_method'),
Con.Byte('filter_method'),
Con.Byte('interlace_method'))
def __init__(self, width, height, bits_per_pixel, color_count):
ImageMetrics.__init__(self, width, height, bits_per_pixel, color_count,
u'image/png')
@classmethod
def parse(cls, file):
ihdr = None
plte = None
try:
header = cls.HEADER.parse_stream(file)
chunk_header = cls.CHUNK_HEADER.parse_stream(file)
data = file.read(chunk_header.length)
chunk_footer = cls.CHUNK_FOOTER.parse_stream(file)
while (chunk_header.type != 'IEND'):
if (chunk_header.type == 'IHDR'):
ihdr = cls.IHDR.parse(data)
elif (chunk_header.type == 'PLTE'):
plte = data
chunk_header = cls.CHUNK_HEADER.parse_stream(file)
data = file.read(chunk_header.length)
chunk_footer = cls.CHUNK_FOOTER.parse_stream(file)
if (ihdr.color_type == 0): # grayscale
bits_per_pixel = ihdr.bit_depth
color_count = 0
elif (ihdr.color_type == 2): # RGB
bits_per_pixel = ihdr.bit_depth * 3
color_count = 0
elif (ihdr.color_type == 3): # palette
bits_per_pixel = 8
if ((len(plte) % 3) != 0):
raise InvalidPNG(_(u'Invalid PLTE chunk length'))
else:
color_count = len(plte) / 3
elif (ihdr.color_type == 4): # grayscale + alpha
bits_per_pixel = ihdr.bit_depth * 2
color_count = 0
elif (ihdr.color_type == 6): # RGB + alpha
bits_per_pixel = ihdr.bit_depth * 4
color_count = 0
return __PNG__(ihdr.width, ihdr.height, bits_per_pixel,
color_count)
except Con.ConstError:
raise InvalidPNG(_(u'Invalid PNG'))
#######################
#BMP
#######################
class InvalidBMP(InvalidImage):
"""Raised if a BMP cannot be parsed correctly."""
pass
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'))
#######################
#GIF
#######################
class InvalidGIF(InvalidImage):
"""Raised if a GIF cannot be parsed correctly."""
pass
class __GIF__(ImageMetrics):
HEADER = Con.Struct('header',
Con.Const(Con.String('gif', 3), 'GIF'),
Con.String('version', 3))
SCREEN_DESCRIPTOR = Con.Struct('logical_screen_descriptor',
Con.ULInt16('width'),
Con.ULInt16('height'),
Con.Embed(
Con.BitStruct('packed_fields',
Con.Flag('global_color_table'),
Con.Bits('color_resolution', 3),
Con.Flag('sort'),
Con.Bits('global_color_table_size', 3))),
Con.Byte('background_color_index'),
Con.Byte('pixel_aspect_ratio'))
def __init__(self, width, height, color_count):
ImageMetrics.__init__(self, width, height, 8, color_count,
u'image/gif')
@classmethod
def parse(cls, file):
try:
header = cls.HEADER.parse_stream(file)
descriptor = cls.SCREEN_DESCRIPTOR.parse_stream(file)
return __GIF__(descriptor.width, descriptor.height,
2 ** (descriptor.global_color_table_size + 1))
except Con.ConstError:
raise InvalidGIF(_(u'Invalid GIF'))
#######################
#TIFF
#######################
class InvalidTIFF(InvalidImage):
"""Raised if a TIFF cannot be parsed correctly."""
pass
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'))
def can_thumbnail():
"""Returns True if we have the capability to thumbnail images."""
try:
import Image as PIL_Image
return True
except ImportError:
return False
def thumbnail_formats():
"""Returns a list of available thumbnail image formats."""
import Image as PIL_Image
import cStringIO
#performing a dummy save seeds PIL_Image.SAVE with possible save types
PIL_Image.new("RGB", (1, 1)).save(cStringIO.StringIO(), "bmp")
return PIL_Image.SAVE.keys()
def thumbnail_image(image_data, width, height, format):
"""Generates a new, smaller image from a larger one.
image_data is a binary string.
width and height are the requested maximum values.
format as a binary string, such as 'JPEG'.
"""
import cStringIO
import Image as PIL_Image
import ImageFile as PIL_ImageFile
PIL_ImageFile.MAXBLOCK = 0x100000
img = PIL_Image.open(cStringIO.StringIO(image_data)).convert('RGB')
img.thumbnail((width, height), PIL_Image.ANTIALIAS)
output = cStringIO.StringIO()
if (format.upper() == 'JPEG'):
#PIL's default JPEG save quality isn't too great
#so it's best to add a couple of optimizing parameters
#since this is a common case
img.save(output, 'JPEG', quality=90, optimize=True)
else:
img.save(output, format)
return output.getvalue()

4591
Melodia/resources/audiotools/__init__.py Normal file
View File

File diff suppressed because it is too large Load Diff

1942
Melodia/resources/audiotools/__m4a__.py Normal file
View File

File diff suppressed because it is too large Load Diff

387
Melodia/resources/audiotools/__m4a_atoms__.py Normal file
View File

@ -0,0 +1,387 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import Con
#M4A atoms are typically laid on in the file as follows:
# ftyp
# mdat
# moov/
# +mvhd
# +iods
# +trak/
# +-tkhd
# +-mdia/
# +--mdhd
# +--hdlr
# +--minf/
# +---smhd
# +---dinf/
# +----dref
# +---stbl/
# +----stsd
# +----stts
# +----stsz
# +----stsc
# +----stco
# +----ctts
# +udta/
# +-meta
#
#Where atoms ending in / are container atoms and the rest are leaf atoms.
#'mdat' is where the file's audio stream is stored
#the rest are various bits of metadata
def VersionLength(name):
"""A struct for 32 or 64 bit fields, depending on version field."""
return Con.IfThenElse(name,
lambda ctx: ctx["version"] == 0,
Con.UBInt32(None),
Con.UBInt64(None))
class AtomAdapter(Con.Adapter):
"""An adapter which manages a proper size field."""
def _encode(self, obj, context):
obj.size = len(obj.data) + 8
return obj
def _decode(self, obj, context):
del(obj.size)
return obj
def Atom(name):
"""A basic QuickTime atom struct."""
return AtomAdapter(Con.Struct(
name,
Con.UBInt32("size"),
Con.String("type", 4),
Con.String("data", lambda ctx: ctx["size"] - 8)))
class AtomListAdapter(Con.Adapter):
"""An adapter for turning an Atom into a list of atoms.
This works by parsing its data contents with Atom."""
ATOM_LIST = Con.GreedyRepeater(Atom("atoms"))
def _encode(self, obj, context):
obj.data = self.ATOM_LIST.build(obj.data)
return obj
def _decode(self, obj, context):
obj.data = self.ATOM_LIST.parse(obj.data)
return obj
def AtomContainer(name):
"""An instantiation of AtomListAdapter."""
return AtomListAdapter(Atom(name))
class AtomWrapper(Con.Struct):
"""Wraps around an existing sub_atom and automatically handles headers."""
def __init__(self, atom_name, sub_atom):
Con.Struct.__init__(self, atom_name)
self.atom_name = atom_name
self.sub_atom = sub_atom
self.header = Con.Struct(atom_name,
Con.UBInt32("size"),
Con.Const(Con.String("type", 4), atom_name))
def _parse(self, stream, context):
header = self.header.parse_stream(stream)
return self.sub_atom.parse_stream(stream)
def _build(self, obj, stream, context):
data = self.sub_atom.build(obj)
stream.write(self.header.build(Con.Container(type=self.atom_name,
size=len(data) + 8)))
stream.write(data)
def _sizeof(self, context):
return self.sub_atom.sizeof(context) + 8
ATOM_FTYP = Con.Struct(
"ftyp",
Con.String("major_brand", 4),
Con.UBInt32("major_brand_version"),
Con.GreedyRepeater(Con.String("compatible_brands", 4)))
ATOM_MVHD = Con.Struct(
"mvhd",
Con.Byte("version"),
Con.String("flags", 3),
VersionLength("created_mac_UTC_date"),
VersionLength("modified_mac_UTC_date"),
Con.UBInt32("time_scale"),
VersionLength("duration"),
Con.UBInt32("playback_speed"),
Con.UBInt16("user_volume"),
Con.Padding(10),
Con.Struct("windows",
Con.UBInt32("geometry_matrix_a"),
Con.UBInt32("geometry_matrix_b"),
Con.UBInt32("geometry_matrix_u"),
Con.UBInt32("geometry_matrix_c"),
Con.UBInt32("geometry_matrix_d"),
Con.UBInt32("geometry_matrix_v"),
Con.UBInt32("geometry_matrix_x"),
Con.UBInt32("geometry_matrix_y"),
Con.UBInt32("geometry_matrix_w")),
Con.UBInt64("quicktime_preview"),
Con.UBInt32("quicktime_still_poster"),
Con.UBInt64("quicktime_selection_time"),
Con.UBInt32("quicktime_current_time"),
Con.UBInt32("next_track_id"))
ATOM_IODS = Con.Struct(
"iods",
Con.Byte("version"),
Con.String("flags", 3),
Con.Byte("type_tag"),
Con.Switch("descriptor",
lambda ctx: ctx.type_tag,
{0x10: Con.Struct(
None,
Con.StrictRepeater(3, Con.Byte("extended_descriptor_type")),
Con.Byte("descriptor_type_length"),
Con.UBInt16("OD_ID"),
Con.Byte("OD_profile"),
Con.Byte("scene_profile"),
Con.Byte("audio_profile"),
Con.Byte("video_profile"),
Con.Byte("graphics_profile")),
0x0E: Con.Struct(
None,
Con.StrictRepeater(3, Con.Byte("extended_descriptor_type")),
Con.Byte("descriptor_type_length"),
Con.String("track_id", 4))}))
ATOM_TKHD = Con.Struct(
"tkhd",
Con.Byte("version"),
Con.BitStruct("flags",
Con.Padding(20),
Con.Flag("TrackInPoster"),
Con.Flag("TrackInPreview"),
Con.Flag("TrackInMovie"),
Con.Flag("TrackEnabled")),
VersionLength("created_mac_UTC_date"),
VersionLength("modified_mac_UTC_date"),
Con.UBInt32("track_id"),
Con.Padding(4),
VersionLength("duration"),
Con.Padding(8),
Con.UBInt16("video_layer"),
Con.UBInt16("quicktime_alternate"),
Con.UBInt16("volume"),
Con.Padding(2),
Con.Struct("video",
Con.UBInt32("geometry_matrix_a"),
Con.UBInt32("geometry_matrix_b"),
Con.UBInt32("geometry_matrix_u"),
Con.UBInt32("geometry_matrix_c"),
Con.UBInt32("geometry_matrix_d"),
Con.UBInt32("geometry_matrix_v"),
Con.UBInt32("geometry_matrix_x"),
Con.UBInt32("geometry_matrix_y"),
Con.UBInt32("geometry_matrix_w")),
Con.UBInt32("video_width"),
Con.UBInt32("video_height"))
ATOM_MDHD = Con.Struct(
"mdhd",
Con.Byte("version"),
Con.String("flags", 3),
VersionLength("created_mac_UTC_date"),
VersionLength("modified_mac_UTC_date"),
Con.UBInt32("time_scale"),
VersionLength("duration"),
Con.BitStruct("languages",
Con.Padding(1),
Con.StrictRepeater(3,
Con.Bits("language", 5))),
Con.UBInt16("quicktime_quality"))
ATOM_HDLR = Con.Struct(
"hdlr",
Con.Byte("version"),
Con.String("flags", 3),
Con.String("quicktime_type", 4),
Con.String("subtype", 4),
Con.String("quicktime_manufacturer", 4),
Con.UBInt32("quicktime_component_reserved_flags"),
Con.UBInt32("quicktime_component_reserved_flags_mask"),
Con.PascalString("component_name"),
Con.Padding(1))
ATOM_SMHD = Con.Struct(
'smhd',
Con.Byte("version"),
Con.String("flags", 3),
Con.String("audio_balance", 2),
Con.Padding(2))
ATOM_DREF = Con.Struct(
'dref',
Con.Byte("version"),
Con.String("flags", 3),
Con.PrefixedArray(
length_field=Con.UBInt32("num_references"),
subcon=Atom("references")))
ATOM_STSD = Con.Struct(
'stsd',
Con.Byte("version"),
Con.String("flags", 3),
Con.PrefixedArray(
length_field=Con.UBInt32("num_descriptions"),
subcon=Atom("descriptions")))
ATOM_MP4A = Con.Struct(
"mp4a",
Con.Padding(6),
Con.UBInt16("reference_index"),
Con.UBInt16("quicktime_audio_encoding_version"),
Con.UBInt16("quicktime_audio_encoding_revision"),
Con.String("quicktime_audio_encoding_vendor", 4),
Con.UBInt16("channels"),
Con.UBInt16("sample_size"),
Con.UBInt16("audio_compression_id"),
Con.UBInt16("quicktime_audio_packet_size"),
Con.String("sample_rate", 4))
#out of all this mess, the only interesting bits are the _bit_rate fields
#and (maybe) the buffer_size
#everything else is a constant of some kind as far as I can tell
ATOM_ESDS = Con.Struct(
"esds",
Con.Byte("version"),
Con.String("flags", 3),
Con.Byte("ES_descriptor_type"),
Con.StrictRepeater(
3, Con.Byte("extended_descriptor_type_tag")),
Con.Byte("descriptor_type_length"),
Con.UBInt16("ES_ID"),
Con.Byte("stream_priority"),
Con.Byte("decoder_config_descriptor_type"),
Con.StrictRepeater(
3, Con.Byte("extended_descriptor_type_tag2")),
Con.Byte("descriptor_type_length2"),
Con.Byte("object_ID"),
Con.Embed(
Con.BitStruct(None, Con.Bits("stream_type", 6),
Con.Flag("upstream_flag"),
Con.Flag("reserved_flag"),
Con.Bits("buffer_size", 24))),
Con.UBInt32("maximum_bit_rate"),
Con.UBInt32("average_bit_rate"),
Con.Byte('decoder_specific_descriptor_type3'),
Con.StrictRepeater(
3, Con.Byte("extended_descriptor_type_tag2")),
Con.PrefixedArray(
length_field=Con.Byte("ES_header_length"),
subcon=Con.Byte("ES_header_start_codes")),
Con.Byte("SL_config_descriptor_type"),
Con.StrictRepeater(
3, Con.Byte("extended_descriptor_type_tag3")),
Con.Byte("descriptor_type_length3"),
Con.Byte("SL_value"))
ATOM_STTS = Con.Struct(
'stts',
Con.Byte("version"),
Con.String("flags", 3),
Con.PrefixedArray(length_field=Con.UBInt32("total_counts"),
subcon=Con.Struct("frame_size_counts",
Con.UBInt32("frame_count"),
Con.UBInt32("duration"))))
ATOM_STSZ = Con.Struct(
'stsz',
Con.Byte("version"),
Con.String("flags", 3),
Con.UBInt32("block_byte_size"),
Con.PrefixedArray(length_field=Con.UBInt32("total_sizes"),
subcon=Con.UBInt32("block_byte_sizes")))
ATOM_STSC = Con.Struct(
'stsc',
Con.Byte("version"),
Con.String("flags", 3),
Con.PrefixedArray(
length_field=Con.UBInt32("entry_count"),
subcon=Con.Struct("block",
Con.UBInt32("first_chunk"),
Con.UBInt32("samples_per_chunk"),
Con.UBInt32("sample_description_index"))))
ATOM_STCO = Con.Struct(
'stco',
Con.Byte("version"),
Con.String("flags", 3),
Con.PrefixedArray(
length_field=Con.UBInt32("total_offsets"),
subcon=Con.UBInt32("offset")))
ATOM_CTTS = Con.Struct(
'ctts',
Con.Byte("version"),
Con.String("flags", 3),
Con.PrefixedArray(
length_field=Con.UBInt32("entry_count"),
subcon=Con.Struct("sample",
Con.UBInt32("sample_count"),
Con.UBInt32("sample_offset"))))
ATOM_META = Con.Struct(
'meta',
Con.Byte("version"),
Con.String("flags", 3),
Con.GreedyRepeater(Atom("atoms")))
ATOM_ILST = Con.GreedyRepeater(AtomContainer('ilst'))
ATOM_TRKN = Con.Struct(
'trkn',
Con.Padding(2),
Con.UBInt16('track_number'),
Con.UBInt16('total_tracks'),
Con.Padding(2))
ATOM_DISK = Con.Struct(
'disk',
Con.Padding(2),
Con.UBInt16('disk_number'),
Con.UBInt16('total_disks'))

973
Melodia/resources/audiotools/__mp3__.py Normal file
View File

@ -0,0 +1,973 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, InvalidFile, PCMReader, PCMConverter,
Con, transfer_data, transfer_framelist_data,
subprocess, BIN, BIG_ENDIAN, ApeTag, ReplayGain,
ignore_sigint, open_files, EncodingError,
DecodingError, PCMReaderError, ChannelMask,
__default_quality__, config)
from __id3__ import *
import gettext
gettext.install("audiotools", unicode=True)
#######################
#MP3
#######################
class MPEG_Frame_Header(Con.Adapter):
#mpeg_version->sample_rate bits->Hz
SAMPLE_RATE = [[11025, 12000, 8000, None],
[None, None, None, None],
[22050, 24000, 16000, None],
[44100, 48000, 32000, None]]
#(mpeg_version, layer)->bitrate bits->bits per second
BIT_RATE = {(3, 3): [0, 32000, 64000, 96000,
128000, 160000, 192000, 224000,
256000, 288000, 320000, 352000,
384000, 416000, 448000, None],
(3, 2): [0, 32000, 48000, 56000,
64000, 80000, 96000, 112000,
128000, 160000, 192000, 224000,
256000, 320000, 384000, None],
(3, 1): [0, 32000, 40000, 48000,
56000, 64000, 80000, 96000,
112000, 128000, 160000, 192000,
224000, 256000, 320000, None],
(2, 3): [0, 32000, 48000, 56000,
64000, 80000, 96000, 112000,
128000, 144000, 160000, 176000,
192000, 224000, 256000, None],
(2, 2): [0, 8000, 16000, 24000,
32000, 40000, 48000, 56000,
64000, 80000, 96000, 112000,
128000, 144000, 160000, None]}
#mpeg_version->Hz->sample_rate bits
SAMPLE_RATE_REVERSE = {0: {11025: 0,
12000: 1,
8000: 2},
1: {None: 0},
2: {22050: 0,
24000: 1,
16000: 2,
None: 3},
3: {44100: 0,
48000: 1,
32000: 2,
None: 3}}
BIT_RATE_REVERSE = dict([(key, dict([(rate, i) for (i, rate) in
enumerate(values)]))
for (key, values) in BIT_RATE.items()])
def __init__(self, name):
Con.Adapter.__init__(
self,
Con.BitStruct("mp3_header",
Con.Const(Con.Bits("sync", 11), 0x7FF),
Con.Bits("mpeg_version", 2),
Con.Bits("layer", 2),
Con.Flag("no_crc16", 1),
Con.Bits("bitrate", 4),
Con.Bits("sample_rate", 2),
Con.Bits("pad", 1),
Con.Bits("private", 1),
Con.Bits("channel", 2),
Con.Bits("mode_extension", 2),
Con.Flag("copyright", 1),
Con.Flag("original", 1),
Con.Bits("emphasis", 2)))
def _encode(self, obj, content):
obj.sample_rate = self.SAMPLE_RATE_REVERSE[obj.mpeg_version][
obj.sample_rate]
obj.bitrate = self.BIT_RATE_REVERSE[(obj.mpeg_version, obj.layer)][
obj.bitrate]
return obj
def _decode(self, obj, content):
obj.sample_rate = self.SAMPLE_RATE[obj.mpeg_version][obj.sample_rate]
obj.channel_count = [2, 2, 2, 1][obj.channel]
obj.bitrate = self.BIT_RATE[(obj.mpeg_version, obj.layer)][obj.bitrate]
if (obj.layer == 3):
obj.byte_length = (((12 * obj.bitrate) / obj.sample_rate) +
obj.pad) * 4
else:
obj.byte_length = ((144 * obj.bitrate) / obj.sample_rate) + obj.pad
return obj
def MPEG_crc16(data, total_bits):
def crc16_val(value, crc, total_bits):
value <<= 8
for i in xrange(total_bits):
value <<= 1
crc <<= 1
if (((crc ^ value) & 0x10000)):
crc ^= 0x8005
return crc & 0xFFFF
checksum = 0xFFFF
data = map(ord, data)
while (total_bits >= 8):
checksum = crc16_val(data.pop(0), checksum, 8)
total_bits -= 8
if (total_bits > 0):
return crc16_val(data.pop(0), checksum, total_bits)
else:
return checksum
class InvalidMP3(InvalidFile):
"""Raised by invalid files during MP3 initialization."""
pass
class MP3Audio(AudioFile):
"""An MP3 audio file."""
SUFFIX = "mp3"
NAME = SUFFIX
DEFAULT_COMPRESSION = "2"
#0 is better quality/lower compression
#9 is worse quality/higher compression
COMPRESSION_MODES = ("0", "1", "2", "3", "4", "5", "6",
"medium", "standard", "extreme", "insane")
COMPRESSION_DESCRIPTIONS = {"0": _(u"high quality, larger files, " +
u"corresponds to lame's -V0"),
"6": _(u"lower quality, smaller files, " +
u"corresponds to lame's -V6"),
"medium": _(u"corresponds to lame's " +
u"--preset medium"),
"standard": _(u"corresponds to lame's " +
u"--preset standard"),
"extreme": _(u"corresponds to lame's " +
u"--preset extreme"),
"insane": _(u"corresponds to lame's " +
u"--preset insane")}
BINARIES = ("lame",)
REPLAYGAIN_BINARIES = ("mp3gain", )
#MPEG1, Layer 1
#MPEG1, Layer 2,
#MPEG1, Layer 3,
#MPEG2, Layer 1,
#MPEG2, Layer 2,
#MPEG2, Layer 3
MP3_BITRATE = ((None, None, None, None, None, None),
(32, 32, 32, 32, 8, 8),
(64, 48, 40, 48, 16, 16),
(96, 56, 48, 56, 24, 24),
(128, 64, 56, 64, 32, 32),
(160, 80, 64, 80, 40, 40),
(192, 96, 80, 96, 48, 48),
(224, 112, 96, 112, 56, 56),
(256, 128, 112, 128, 64, 64),
(288, 160, 128, 144, 80, 80),
(320, 192, 160, 160, 96, 96),
(352, 224, 192, 176, 112, 112),
(384, 256, 224, 192, 128, 128),
(416, 320, 256, 224, 144, 144),
(448, 384, 320, 256, 160, 160))
#MPEG1, MPEG2, MPEG2.5
MP3_SAMPLERATE = ((44100, 22050, 11025),
(48000, 24000, 12000),
(32000, 16000, 8000))
MP3_FRAME_HEADER = Con.BitStruct("mp3_header",
Con.Const(Con.Bits("sync", 11), 0x7FF),
Con.Bits("mpeg_version", 2),
Con.Bits("layer", 2),
Con.Flag("protection", 1),
Con.Bits("bitrate", 4),
Con.Bits("sampling_rate", 2),
Con.Bits("padding", 1),
Con.Bits("private", 1),
Con.Bits("channel", 2),
Con.Bits("mode_extension", 2),
Con.Flag("copyright", 1),
Con.Flag("original", 1),
Con.Bits("emphasis", 2))
XING_HEADER = Con.Struct("xing_header",
Con.Bytes("header_id", 4),
Con.Bytes("flags", 4),
Con.UBInt32("num_frames"),
Con.UBInt32("bytes"),
Con.StrictRepeater(100, Con.Byte("toc_entries")),
Con.UBInt32("quality"))
def __init__(self, filename):
"""filename is a plain string."""
AudioFile.__init__(self, filename)
try:
mp3file = file(filename, "rb")
except IOError, msg:
raise InvalidMP3(str(msg))
try:
try:
MP3Audio.__find_next_mp3_frame__(mp3file)
except ValueError:
raise InvalidMP3(_(u"MP3 frame not found"))
fr = MP3Audio.MP3_FRAME_HEADER.parse(mp3file.read(4))
self.__samplerate__ = MP3Audio.__get_mp3_frame_sample_rate__(fr)
self.__channels__ = MP3Audio.__get_mp3_frame_channels__(fr)
self.__framelength__ = self.__length__()
finally:
mp3file.close()
@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."""
ID3v2Comment.skip(file)
try:
frame = cls.MP3_FRAME_HEADER.parse_stream(file)
if ((frame.sync == 0x07FF) and
(frame.mpeg_version in (0x03, 0x02, 0x00)) and
(frame.layer in (0x01, 0x03))):
return True
else:
#oddly, MP3s sometimes turn up in RIFF containers
#this isn't a good idea, but can be supported nonetheless
file.seek(-cls.MP3_FRAME_HEADER.sizeof(), 1)
header = file.read(12)
if ((header[0:4] == 'RIFF') and
(header[8:12] == 'RMP3')):
return True
else:
return False
except:
return False
def lossless(self):
"""Returns False."""
return False
def to_pcm(self):
"""Returns a PCMReader object containing the track's PCM data."""
#if mpg123 is available, use that for decoding
if (BIN.can_execute(BIN["mpg123"])):
sub = subprocess.Popen([BIN["mpg123"], "-qs", self.filename],
stdout=subprocess.PIPE,
stderr=file(os.devnull, "a"))
return PCMReader(sub.stdout,
sample_rate=self.sample_rate(),
channels=self.channels(),
bits_per_sample=16,
channel_mask=int(ChannelMask.from_channels(
self.channels())),
process=sub,
big_endian=BIG_ENDIAN)
else:
#if not, use LAME for decoding
if (self.filename.endswith("." + self.SUFFIX)):
if (BIG_ENDIAN):
endian = ['-x']
else:
endian = []
sub = subprocess.Popen([BIN['lame']] + endian + \
["--decode", "-t", "--quiet",
self.filename, "-"],
stdout=subprocess.PIPE)
return PCMReader(
sub.stdout,
sample_rate=self.sample_rate(),
channels=self.channels(),
bits_per_sample=16,
channel_mask=int(self.channel_mask()),
process=sub)
else:
import tempfile
from audiotools import TempWaveReader
#copy our file to one that ends with .mp3
tempmp3 = tempfile.NamedTemporaryFile(suffix='.' + self.SUFFIX)
f = open(self.filename, 'rb')
transfer_data(f.read, tempmp3.write)
f.close()
tempmp3.flush()
#decode the mp3 file to a WAVE file
wave = tempfile.NamedTemporaryFile(suffix='.wav')
returnval = subprocess.call([BIN['lame'], "--decode",
"--quiet",
tempmp3.name, wave.name])
tempmp3.close()
if (returnval == 0):
#return WAVE file as a stream
wave.seek(0, 0)
return TempWaveReader(wave)
else:
return PCMReaderError(
error_message=u"lame exited with error",
sample_rate=self.sample_rate(),
channels=self.channels(),
channel_mask=int(self.channel_mask()),
bits_per_sample=16)
@classmethod
def __help_output__(cls):
import cStringIO
help_data = cStringIO.StringIO()
sub = subprocess.Popen([BIN['lame'], '--help'],
stdout=subprocess.PIPE)
transfer_data(sub.stdout.read, help_data.write)
sub.wait()
return help_data.getvalue()
@classmethod
def __lame_version__(cls):
try:
version = re.findall(r'version \d+\.\d+',
cls.__help_output__())[0]
return tuple(map(int, version[len('version '):].split(".")))
except IndexError:
return (0, 0)
@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 MP3Audio object."""
import decimal
import bisect
if ((compression is None) or
(compression not in cls.COMPRESSION_MODES)):
compression = __default_quality__(cls.NAME)
if ((pcmreader.channels > 2) or
(pcmreader.sample_rate not in (32000, 48000, 44100))):
pcmreader = PCMConverter(
pcmreader,
sample_rate=[32000, 32000, 44100, 48000][bisect.bisect(
[32000, 44100, 48000], pcmreader.sample_rate)],
channels=min(pcmreader.channels, 2),
channel_mask=ChannelMask.from_channels(
min(pcmreader.channels, 2)),
bits_per_sample=16)
if (pcmreader.channels > 1):
mode = "j"
else:
mode = "m"
#FIXME - not sure if all LAME versions support "--little-endian"
# #LAME 3.98 (and up, presumably) handle the byteswap correctly
# #LAME 3.97 always uses -x
# if (BIG_ENDIAN or (cls.__lame_version__() < (3,98))):
# endian = ['-x']
# else:
# endian = []
devnull = file(os.devnull, 'ab')
if (str(compression) in map(str, range(0, 10))):
compression = ["-V" + str(compression)]
else:
compression = ["--preset", str(compression)]
sub = subprocess.Popen([
BIN['lame'], "--quiet",
"-r",
"-s", str(decimal.Decimal(pcmreader.sample_rate) / 1000),
"--bitwidth", str(pcmreader.bits_per_sample),
"--signed", "--little-endian",
"-m", mode] + compression + ["-", filename],
stdin=subprocess.PIPE,
stdout=devnull,
stderr=devnull,
preexec_fn=ignore_sigint)
try:
transfer_framelist_data(pcmreader, sub.stdin.write)
except (IOError, ValueError), err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise err
try:
pcmreader.close()
except DecodingError, err:
cls.__unlink__(filename)
raise EncodingError(err.error_message)
sub.stdin.close()
devnull.close()
if (sub.wait() == 0):
return MP3Audio(filename)
else:
cls.__unlink__(filename)
raise EncodingError(u"error encoding file with lame")
def bits_per_sample(self):
"""Returns an integer number of bits-per-sample this track contains."""
return 16
def channels(self):
"""Returns an integer number of channels this track contains."""
return self.__channels__
def sample_rate(self):
"""Returns the rate of the track's audio as an integer number of Hz."""
return self.__samplerate__
def get_metadata(self):
"""Returns a MetaData object, or None.
Raises IOError if unable to read the file."""
f = file(self.filename, "rb")
try:
if (f.read(3) != "ID3"): # no ID3v2 tag, try ID3v1
id3v1 = ID3v1Comment.read_id3v1_comment(self.filename)
if (id3v1[-1] == -1): # no ID3v1 either
return None
else:
return ID3v1Comment(id3v1)
else:
id3v2 = ID3v2Comment.read_id3v2_comment(self.filename)
id3v1 = ID3v1Comment.read_id3v1_comment(self.filename)
if (id3v1[-1] == -1): # only ID3v2, no ID3v1
return id3v2
else: # both ID3v2 and ID3v1
return ID3CommentPair(
id3v2,
ID3v1Comment(id3v1))
finally:
f.close()
def set_metadata(self, metadata):
"""Takes a MetaData object and sets this track's metadata.
This metadata includes track name, album name, and so on.
Raises IOError if unable to write the file."""
if (metadata is None):
return
if ((not isinstance(metadata, ID3v2Comment)) and
(not isinstance(metadata, ID3v1Comment))):
DEFAULT_ID3V2 = "id3v2.3"
DEFAULT_ID3V1 = "id3v1.1"
id3v2_class = {"id3v2.2": ID3v22Comment,
"id3v2.3": ID3v23Comment,
"id3v2.4": ID3v24Comment,
"none": None}.get(config.get_default("ID3",
"id3v2",
DEFAULT_ID3V2),
DEFAULT_ID3V2)
id3v1_class = {"id3v1.1": ID3v1Comment,
"none": None}.get(config.get_default("ID3",
"id3v1",
DEFAULT_ID3V1))
if ((id3v2_class is not None) and (id3v1_class is not None)):
metadata = ID3CommentPair.converted(metadata,
id3v2_class=id3v2_class,
id3v1_class=id3v1_class)
elif (id3v2_class is not None):
metadata = id3v2_class.converted(metadata)
elif (id3v1_class is not None):
metadata = id3v1_class.converted(metadata)
else:
return
#get the original MP3 data
f = file(self.filename, "rb")
MP3Audio.__find_mp3_start__(f)
data_start = f.tell()
MP3Audio.__find_last_mp3_frame__(f)
data_end = f.tell()
f.seek(data_start, 0)
mp3_data = f.read(data_end - data_start)
f.close()
if (isinstance(metadata, ID3CommentPair)):
id3v2 = metadata.id3v2.build()
id3v1 = metadata.id3v1.build_tag()
elif (isinstance(metadata, ID3v2Comment)):
id3v2 = metadata.build()
id3v1 = ""
elif (isinstance(metadata, ID3v1Comment)):
id3v2 = ""
id3v1 = metadata.build_tag()
#write id3v2 + data + id3v1 to file
f = file(self.filename, "wb")
f.write(id3v2)
f.write(mp3_data)
f.write(id3v1)
f.close()
def delete_metadata(self):
"""Deletes the track's MetaData.
This removes or unsets tags as necessary in order to remove all data.
Raises IOError if unable to write the file."""
#get the original MP3 data
f = file(self.filename, "rb")
MP3Audio.__find_mp3_start__(f)
data_start = f.tell()
MP3Audio.__find_last_mp3_frame__(f)
data_end = f.tell()
f.seek(data_start, 0)
mp3_data = f.read(data_end - data_start)
f.close()
#write data to file
f = file(self.filename, "wb")
f.write(mp3_data)
f.close()
#places mp3file at the position of the next MP3 frame's start
@classmethod
def __find_next_mp3_frame__(cls, mp3file):
#if we're starting at an ID3v2 header, skip it to save a bunch of time
ID3v2Comment.skip(mp3file)
#then find the next mp3 frame
(b1, b2) = mp3file.read(2)
while ((b1 != chr(0xFF)) or ((ord(b2) & 0xE0) != 0xE0)):
mp3file.seek(-1, 1)
(b1, b2) = mp3file.read(2)
mp3file.seek(-2, 1)
#places mp3file at the position of the MP3 file's start
#either at the next frame (most commonly)
#or at the "RIFF????RMP3" header
@classmethod
def __find_mp3_start__(cls, mp3file):
#if we're starting at an ID3v2 header, skip it to save a bunch of time
ID3v2Comment.skip(mp3file)
while (True):
byte = mp3file.read(1)
while ((byte != chr(0xFF)) and (byte != 'R') and (len(byte) > 0)):
byte = mp3file.read(1)
if (byte == chr(0xFF)): # possibly a frame sync
mp3file.seek(-1, 1)
try:
header = cls.MP3_FRAME_HEADER.parse_stream(mp3file)
if ((header.sync == 0x07FF) and
(header.mpeg_version in (0x03, 0x02, 0x00)) and
(header.layer in (0x01, 0x02, 0x03))):
mp3file.seek(-4, 1)
return
else:
mp3file.seek(-3, 1)
except:
continue
elif (byte == 'R'): # possibly a 'RIFF????RMP3' header
header = mp3file.read(11)
if ((header[0:3] == 'IFF') and
(header[7:11] == 'RMP3')):
mp3file.seek(-12, 1)
return
else:
mp3file.seek(-11, 1)
elif (len(byte) == 0): # we've run out of MP3 file
return
#places mp3file at the position of the last MP3 frame's end
#(either the last byte in the file or just before the ID3v1 tag)
#this may not be strictly accurate if ReplayGain data is present,
#since APEv2 tags came before the ID3v1 tag,
#but we're not planning to change that tag anyway
@classmethod
def __find_last_mp3_frame__(cls, mp3file):
mp3file.seek(-128, 2)
if (mp3file.read(3) == 'TAG'):
mp3file.seek(-128, 2)
return
else:
mp3file.seek(0, 2)
return
#header is a Construct parsed from 4 bytes sent to MP3_FRAME_HEADER
#returns the total length of the frame, including the header
#(subtract 4 when doing a seek or read to the next one)
@classmethod
def __mp3_frame_length__(cls, header):
layer = 4 - header.layer # layer 1, 2 or 3
bit_rate = MP3Audio.__get_mp3_frame_bitrate__(header)
if (bit_rate is None):
raise InvalidMP3(_(u"Invalid bit rate"))
sample_rate = MP3Audio.__get_mp3_frame_sample_rate__(header)
if (layer == 1):
return (12 * (bit_rate * 1000) / sample_rate + header.padding) * 4
else:
return 144 * (bit_rate * 1000) / sample_rate + header.padding
#takes a parsed MP3_FRAME_HEADER
#returns the mp3's sample rate based on that information
#(typically 44100)
@classmethod
def __get_mp3_frame_sample_rate__(cls, frame):
try:
if (frame.mpeg_version == 0x00): # MPEG 2.5
return MP3Audio.MP3_SAMPLERATE[frame.sampling_rate][2]
elif (frame.mpeg_version == 0x02): # MPEG 2
return MP3Audio.MP3_SAMPLERATE[frame.sampling_rate][1]
else: # MPEG 1
return MP3Audio.MP3_SAMPLERATE[frame.sampling_rate][0]
except IndexError:
raise InvalidMP3(_(u"Invalid sampling rate"))
@classmethod
def __get_mp3_frame_channels__(cls, frame):
if (frame.channel == 0x03):
return 1
else:
return 2
@classmethod
def __get_mp3_frame_bitrate__(cls, frame):
layer = 4 - frame.layer # layer 1, 2 or 3
try:
if (frame.mpeg_version == 0x00): # MPEG 2.5
return MP3Audio.MP3_BITRATE[frame.bitrate][layer + 2]
elif (frame.mpeg_version == 0x02): # MPEG 2
return MP3Audio.MP3_BITRATE[frame.bitrate][layer + 2]
elif (frame.mpeg_version == 0x03): # MPEG 1
return MP3Audio.MP3_BITRATE[frame.bitrate][layer - 1]
else:
return 0
except IndexError:
raise InvalidMP3(_(u"Invalid bit rate"))
def cd_frames(self):
"""Returns the total length of the track in CD frames.
Each CD frame is 1/75th of a second."""
#calculate length at create-time so that we can
#throw InvalidMP3 as soon as possible
return self.__framelength__
#returns the length of this file in CD frame
#raises InvalidMP3 if any portion of the frame is invalid
def __length__(self):
mp3file = file(self.filename, "rb")
try:
MP3Audio.__find_next_mp3_frame__(mp3file)
start_position = mp3file.tell()
fr = MP3Audio.MP3_FRAME_HEADER.parse(mp3file.read(4))
first_frame = mp3file.read(MP3Audio.__mp3_frame_length__(fr) - 4)
sample_rate = MP3Audio.__get_mp3_frame_sample_rate__(fr)
if (fr.mpeg_version == 0x00): # MPEG 2.5
version = 3
elif (fr.mpeg_version == 0x02): # MPEG 2
version = 3
else: # MPEG 1
version = 0
try:
if (fr.layer == 0x03): # layer 1
frames_per_sample = 384
bit_rate = MP3Audio.MP3_BITRATE[fr.bitrate][version]
elif (fr.layer == 0x02): # layer 2
frames_per_sample = 1152
bit_rate = MP3Audio.MP3_BITRATE[fr.bitrate][version + 1]
elif (fr.layer == 0x01): # layer 3
frames_per_sample = 1152
bit_rate = MP3Audio.MP3_BITRATE[fr.bitrate][version + 2]
else:
raise InvalidMP3(_(u"Unsupported MPEG layer"))
except IndexError:
raise InvalidMP3(_(u"Invalid bit rate"))
if ('Xing' in first_frame):
#the first frame has a Xing header,
#use that to calculate the mp3's length
xing_header = MP3Audio.XING_HEADER.parse(
first_frame[first_frame.index('Xing'):])
return (xing_header.num_frames * frames_per_sample * 75 /
sample_rate)
else:
#no Xing header,
#assume a constant bitrate file
mp3file.seek(-128, 2)
if (mp3file.read(3) == "TAG"):
end_position = mp3file.tell() - 3
else:
mp3file.seek(0, 2)
end_position = mp3file.tell()
return ((end_position - start_position) * 75 * 8 /
(bit_rate * 1000))
finally:
mp3file.close()
def total_frames(self):
"""Returns the total PCM frames of the track as an integer."""
return self.cd_frames() * self.sample_rate() / 75
@classmethod
def can_add_replay_gain(cls):
"""Returns True if we have the necessary binaries to add ReplayGain."""
return BIN.can_execute(BIN['mp3gain'])
@classmethod
def lossless_replay_gain(cls):
"""Returns False."""
return False
@classmethod
def add_replay_gain(cls, filenames, progress=None):
"""Adds ReplayGain values to a list of filename strings.
All the filenames must be of this AudioFile type.
Raises ValueError if some problem occurs during ReplayGain application.
"""
track_names = [track.filename for track in
open_files(filenames) if
isinstance(track, cls)]
if (progress is not None):
progress(0, 1)
if ((len(track_names) > 0) and (BIN.can_execute(BIN['mp3gain']))):
devnull = file(os.devnull, 'ab')
sub = subprocess.Popen([BIN['mp3gain'], '-f', '-k', '-q', '-r'] + \
track_names,
stdout=devnull,
stderr=devnull)
sub.wait()
devnull.close()
if (progress is not None):
progress(1, 1)
def mpeg_frames(self):
"""Yields (header, data) tuples of the file's contents.
header is an MPEG_Frame_Header Construct.
data is a string of MP3 data."""
header_struct = MPEG_Frame_Header("header")
f = open(self.filename, 'rb')
try:
#FIXME - this won't handle RIFF RMP3 well
#perhaps I should use tracklint to clean those up
MP3Audio.__find_last_mp3_frame__(f)
stop_position = f.tell()
f.seek(0, 0)
MP3Audio.__find_mp3_start__(f)
while (f.tell() < stop_position):
header = header_struct.parse_stream(f)
data = f.read(header.byte_length - 4)
yield (header, data)
finally:
f.close()
def verify(self, progress=None):
from . import verify
try:
f = open(self.filename, 'rb')
except IOError, err:
raise InvalidMP3(str(err))
#MP3 verification is likely to be so fast
#that individual calls to progress() are
#a waste of time.
if (progress is not None):
progress(0, 1)
try:
try:
#skip ID3v2/ID3v1 tags during verification
self.__find_mp3_start__(f)
start = f.tell()
self.__find_last_mp3_frame__(f)
end = f.tell()
f.seek(start, 0)
verify.mpeg(f, start, end)
if (progress is not None):
progress(1, 1)
return True
except (IOError, ValueError), err:
raise InvalidMP3(str(err))
finally:
f.close()
#######################
#MP2 AUDIO
#######################
class MP2Audio(MP3Audio):
"""An MP2 audio file."""
SUFFIX = "mp2"
NAME = SUFFIX
DEFAULT_COMPRESSION = str(192)
COMPRESSION_MODES = tuple(map(str, (64, 96, 112, 128, 160, 192,
224, 256, 320, 384)))
COMPRESSION_DESCRIPTIONS = {"64": _(u"total bitrate of 64kbps"),
"384": _(u"total bitrate of 384kbps")}
BINARIES = ("lame", "twolame")
@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."""
ID3v2Comment.skip(file)
try:
frame = cls.MP3_FRAME_HEADER.parse_stream(file)
return ((frame.sync == 0x07FF) and
(frame.mpeg_version in (0x03, 0x02, 0x00)) and
(frame.layer == 0x02))
except:
return False
@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 MP2Audio object."""
import decimal
import bisect
if ((compression is None) or
(compression not in cls.COMPRESSION_MODES)):
compression = __default_quality__(cls.NAME)
if ((pcmreader.channels > 2) or
(pcmreader.sample_rate not in (32000, 48000, 44100)) or
(pcmreader.bits_per_sample != 16)):
pcmreader = PCMConverter(
pcmreader,
sample_rate=[32000, 32000, 44100, 48000][bisect.bisect(
[32000, 44100, 48000], pcmreader.sample_rate)],
channels=min(pcmreader.channels, 2),
channel_mask=pcmreader.channel_mask,
bits_per_sample=16)
devnull = file(os.devnull, 'ab')
sub = subprocess.Popen([BIN['twolame'], "--quiet",
"-r",
"-s", str(pcmreader.sample_rate),
"--samplesize", str(pcmreader.bits_per_sample),
"-N", str(pcmreader.channels),
"-m", "a",
"-b", compression,
"-",
filename],
stdin=subprocess.PIPE,
stdout=devnull,
stderr=devnull,
preexec_fn=ignore_sigint)
try:
transfer_framelist_data(pcmreader, sub.stdin.write)
except (ValueError, IOError), err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise err
try:
pcmreader.close()
except DecodingError, err:
cls.__unlink__(filename)
raise EncodingError(err.error_message)
sub.stdin.close()
devnull.close()
if (sub.wait() == 0):
return MP2Audio(filename)
else:
cls.__unlink__(filename)
raise EncodingError(u"twolame exited with error")

332
Melodia/resources/audiotools/__musepack__.py Normal file
View File

@ -0,0 +1,332 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, InvalidFile, InvalidFormat, PCMReader,
PCMConverter, Con, subprocess, BIN, ApeTaggedAudio,
os, TempWaveReader, ignore_sigint, transfer_data,
EncodingError, DecodingError)
from __wav__ import WaveAudio
import gettext
gettext.install("audiotools", unicode=True)
#######################
#Musepack Audio
#######################
class NutValue(Con.Adapter):
"""A construct for Musepack Nut-encoded integer fields."""
def __init__(self, name):
Con.Adapter.__init__(
self,
Con.RepeatUntil(lambda obj, ctx: (obj & 0x80) == 0x00,
Con.UBInt8(name)))
def _encode(self, value, context):
data = [value & 0x7F]
value = value >> 7
while (value != 0):
data.append(0x80 | (value & 0x7F))
value = value >> 7
data.reverse()
return data
def _decode(self, obj, context):
i = 0
for x in obj:
i = (i << 7) | (x & 0x7F)
return i
class Musepack8StreamReader:
"""An object for parsing Musepack SV8 streams."""
NUT_HEADER = Con.Struct('nut_header',
Con.String('key', 2),
NutValue('length'))
def __init__(self, stream):
"""Initialized with a file object."""
self.stream = stream
def packets(self):
"""Yields a set of (key, data) tuples."""
import string
UPPERCASE = frozenset(string.ascii_uppercase)
while (True):
try:
frame_header = self.NUT_HEADER.parse_stream(self.stream)
except Con.core.FieldError:
break
if (not frozenset(frame_header.key).issubset(UPPERCASE)):
break
yield (frame_header.key,
self.stream.read(frame_header.length -
len(self.NUT_HEADER.build(frame_header))))
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

638
Melodia/resources/audiotools/__musicbrainz__.py Normal file
View File

@ -0,0 +1,638 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (MetaData, AlbumMetaData, AlbumMetaDataFile,
MetaDataFileException,
__most_numerous__, DummyAudioFile, sys)
import urllib
import gettext
gettext.install("audiotools", unicode=True)
def get_xml_nodes(parent, child_tag):
"""A helper routine for returning all children with the given XML tag."""
return [node for node in parent.childNodes
if (hasattr(node, "tagName") and
(node.tagName == child_tag))]
def walk_xml_tree(parent, *child_tags):
"""A helper routine for walking through several children."""
if (len(child_tags) == 0):
return parent
else:
base_tag = child_tags[0]
remaining_tags = child_tags[1:]
for node in parent.childNodes:
if (hasattr(node, "tagName") and
(node.tagName == base_tag)):
return walk_xml_tree(node, *remaining_tags)
else:
return None
def walk_xml_tree_build(dom, parent, *child_tags):
if (len(child_tags) == 0):
return parent
else:
base_tag = child_tags[0]
remaining_tags = child_tags[1:]
for node in parent.childNodes:
if (hasattr(node, "tagName") and
(node.tagName == base_tag)):
return walk_xml_tree_build(dom, node, *remaining_tags)
else:
new_child = dom.createElement(base_tag)
parent.appendChild(new_child)
return walk_xml_tree_build(dom, new_child, *remaining_tags)
def get_xml_text_node(parent, child_tag):
"""A helper routine for returning the first text child XML node."""
try:
return get_xml_nodes(parent, child_tag)[0].childNodes[0].data.strip()
except IndexError:
return u''
def reorder_xml_children(parent, child_order):
"""Given an XML element with childNodes, reorders them to child_order.
child_order should be a list of unicode tag strings.
"""
if (parent.childNodes is None):
return
child_tags = {}
leftovers = []
for child in parent.childNodes:
if (hasattr(child, "tagName")):
child_tags.setdefault(child.tagName, []).append(child)
else:
leftovers.append(child)
#remove all the old childen from parent
for child in parent.childNodes:
parent.removeChild(child)
#re-add the childen in child_order
for tagName in child_order:
if (tagName in child_tags):
for child in child_tags[tagName]:
parent.appendChild(child)
del(child_tags[tagName])
#re-add any leftover children tags or non-tags
for child_tags in child_tags.values():
for child in child_tags:
parent.appendChild(child)
for child in leftovers:
parent.appendChild(child)
class MBDiscID:
"""A MusicBrainz disc ID."""
def __init__(self, tracks=[], offsets=None, length=None, lead_in=150,
first_track_number=None, last_track_number=None,
lead_out_track_offset=None):
"""Fields are as follows:
tracks - a list of track lengths in CD frames
offsets - a list of track offsets in CD frames
length - the length of the entire disc in CD frames
lead_in - the location of the first track on the CD, in frames
first_track_number, last_track_number and lead_out_track_offset
are integer values.
All fields are optional.
One will presumably fill them with data later in that event.
"""
self.tracks = tracks
self.__offsets__ = offsets
self.__length__ = length
self.__lead_in__ = lead_in
self.first_track_number = first_track_number
self.last_track_number = last_track_number
self.lead_out_track_offset = lead_out_track_offset
@classmethod
def from_cdda(cls, cdda):
"""Given a CDDA object, returns a populated MBDiscID
May raise ValueError if there are no audio tracks on the CD."""
tracks = list(cdda)
if (len(tracks) < 1):
raise ValueError(_(u"no audio tracks in CDDA object"))
return cls(
tracks=[t.length() for t in tracks],
offsets=[t.offset() for t in tracks],
length=cdda.length(),
lead_in=tracks[0].offset(),
lead_out_track_offset=cdda.last_sector() + 150 + 1)
def offsets(self):
"""Returns a list of calculated offset integers, from track lengths."""
if (self.__offsets__ is None):
offsets = [self.__lead_in__]
for track in self.tracks[0:-1]:
offsets.append(track + offsets[-1])
return offsets
else:
return self.__offsets__
def __repr__(self):
return ("MBDiscID(tracks=%s,offsets=%s,length=%s,lead_in=%s," +
"first_track_number=%s,last_track_number=%s," +
"lead_out_track_offset=%s)") % \
(repr(self.tracks),
repr(self.__offsets__),
repr(self.__length__),
repr(self.__lead_in__),
repr(self.first_track_number),
repr(self.last_track_number),
repr(self.lead_out_track_offset))
#returns a MusicBrainz DiscID value as a string
def __str__(self):
from hashlib import sha1
if (self.lead_out_track_offset is None):
if (self.__length__ is None):
lead_out_track_offset = sum(self.tracks) + self.__lead_in__
else:
lead_out_track_offset = self.__length__ + self.__lead_in__
else:
lead_out_track_offset = self.lead_out_track_offset
if (self.first_track_number is None):
first_track_number = 1
else:
first_track_number = self.first_track_number
if (self.last_track_number is None):
last_track_number = len(self.tracks)
else:
last_track_number = self.last_track_number
digest = sha1("%02X%02X%s" % \
(first_track_number,
last_track_number,
"".join(["%08X" % (i) for i in
[lead_out_track_offset] +
self.offsets() +
([0] * (99 - len(self.offsets())))])))
return "".join([{'=': '-', '+': '.', '/': '_'}.get(c, c) for c in
digest.digest().encode('base64').rstrip('\n')])
def toxml(self, output):
"""Writes an XML file to the output file object."""
output.write(MusicBrainzReleaseXML.from_tracks(
[DummyAudioFile(length, None, i + 1)
for (i, length) in enumerate(self.tracks)]).to_string())
class MusicBrainz:
"""A class for performing queries on a MusicBrainz or compatible server."""
def __init__(self, server, port, messenger):
self.server = server
self.port = port
self.connection = None
self.messenger = messenger
def connect(self):
"""Performs the initial connection."""
import httplib
self.connection = httplib.HTTPConnection(self.server, self.port)
def close(self):
"""Closes an open connection."""
if (self.connection is not None):
self.connection.close()
def read_data(self, disc_id, output):
"""Returns a (matches,dom) tuple from a MBDiscID object.
matches is an integer
and dom is a minidom Document object or None."""
from xml.dom.minidom import parseString
from xml.parsers.expat import ExpatError
self.connection.request(
"GET",
"%s?%s" % ("/ws/1/release",
urllib.urlencode({"type": "xml",
"discid": str(disc_id)})))
response = self.connection.getresponse()
#FIXME - check for errors in the HTTP response
data = response.read()
try:
dom = parseString(data)
return (len(dom.getElementsByTagName(u'release')), dom)
except ExpatError:
return (0, None)
class MBXMLException(MetaDataFileException):
"""Raised if MusicBrainzReleaseXML.read() encounters an error."""
def __unicode__(self):
return _(u"Invalid MusicBrainz XML file")
class MusicBrainzReleaseXML(AlbumMetaDataFile):
"""An XML file as returned by MusicBrainz."""
TAG_ORDER = {u"release": [u"title",
u"text-representation",
u"asin",
u"artist",
u"release-group",
u"release-event-list",
u"disc-list",
u"puid-list",
u"track-list",
u"relation-list",
u"tag-list",
u"user-tag-list",
u"rating",
u"user-rating"],
u"artist": [u"name",
u"sort-name",
u"disambiguation",
u"life-span",
u"alias-list",
u"release-list",
u"release-group-list",
u"relation-list",
u"tag-list",
u"user-tag-list",
u"rating"],
u"track": [u"title",
u"duration",
u"isrc-list",
u"artist",
u"release-list",
u"puid-list",
u"relation-list",
u"tag-list",
u"user-tag-list",
u"rating",
u"user-rating"]}
def __init__(self, dom):
self.dom = dom
def __getattr__(self, key):
if (key == 'album_name'):
try:
return get_xml_text_node(
walk_xml_tree(self.dom,
u'metadata', u'release-list', u'release'),
u'title')
except AttributeError:
return u""
elif (key == 'artist_name'):
try:
return get_xml_text_node(
walk_xml_tree(self.dom,
u'metadata', u'release-list', u'release',
u'artist'),
u'name')
except AttributeError:
return u""
elif (key == 'year'):
try:
return walk_xml_tree(
self.dom, u'metadata', u'release-list', u'release',
u'release-event-list',
u'event').getAttribute('date')[0:4]
except (IndexError, AttributeError):
return u""
elif (key == 'catalog'):
try:
return walk_xml_tree(
self.dom, u'metadata', u'release-list', u'release',
u'release-event-list',
u'event').getAttribute('catalog-number')
except (IndexError, AttributeError):
return u""
elif (key == 'extra'):
return u""
else:
try:
return self.__dict__[key]
except KeyError:
raise AttributeError(key)
def __setattr__(self, key, value):
#FIXME - create nodes if they don't exist
if (key == 'album_name'):
title = walk_xml_tree(self.dom, u'metadata', u'release-list',
u'release', u'title')
if (len(title.childNodes) > 0):
title.replaceChild(self.dom.createTextNode(value),
title.firstChild)
else:
title.appendChild(self.dom.createTextNode(value))
elif (key == 'artist_name'):
name = walk_xml_tree(self.dom, u'metadata', u'release-list',
u'release', u'artist', u'name')
if (len(name.childNodes) > 0):
name.replaceChild(self.dom.createTextNode(value),
name.firstChild)
else:
name.appendChild(self.dom.createTextNode(value))
elif (key == 'year'):
walk_xml_tree_build(self.dom, self.dom,
u'metadata', u'release-list',
u'release', u'release-event-list',
u'event').setAttribute(u"date", value)
elif (key == 'catalog'):
walk_xml_tree_build(self.dom, self.dom,
u'metadata', u'release-list',
u'release', u'release-event-list',
u'event').setAttribute(u"catalog-number",
value)
elif (key == 'extra'):
pass
else:
self.__dict__[key] = value
def __len__(self):
return len(self.dom.getElementsByTagName(u'track'))
def to_string(self):
for (tag, order) in MusicBrainzReleaseXML.TAG_ORDER.items():
for parent in self.dom.getElementsByTagName(tag):
reorder_xml_children(parent, order)
return self.dom.toxml(encoding='utf-8')
@classmethod
def from_string(cls, string):
from xml.dom.minidom import parseString
from xml.parsers.expat import ExpatError
try:
return cls(parseString(string))
except ExpatError:
raise MBXMLException("")
def get_track(self, index):
track_node = self.dom.getElementsByTagName(u'track')[index]
track_name = get_xml_text_node(track_node, u'title')
artist_node = walk_xml_tree(track_node, u'artist')
if (artist_node is not None):
artist_name = get_xml_text_node(artist_node, u'name')
if (len(artist_name) == 0):
artist_name = u""
else:
artist_name = u""
return (track_name, artist_name, u"")
def set_track(self, index, name, artist, extra):
track_node = self.dom.getElementsByTagName(u'track')[index]
title = walk_xml_tree(track_node, 'title')
if (len(title.childNodes) > 0):
title.replaceChild(self.dom.createTextNode(name),
title.firstChild)
else:
title.appendChild(self.dom.createTextNode(name))
if (len(artist) > 0):
artist_node = walk_xml_tree_build(self.dom,
track_node,
u'artist', u'name')
if (artist_node.hasChildNodes()):
artist_node.replaceChild(self.dom.createTextNode(artist),
artist_node.firstChild)
else:
artist_node.appendChild(self.dom.createTextNode(artist))
@classmethod
def from_tracks(cls, tracks):
"""Returns a MusicBrainzReleaseXML from a list of AudioFile objects.
These objects are presumably from the same album.
If not, these heuristics may generate something unexpected.
"""
from xml.dom.minidom import parseString
def make_text_node(document, tagname, text):
node = document.createElement(tagname)
node.appendChild(document.createTextNode(text))
return node
tracks.sort(lambda x, y: cmp(x.track_number(), y.track_number()))
#our base DOM to start with
dom = parseString('<?xml version="1.0" encoding="UTF-8"?>' +
'<metadata xmlns="http://musicbrainz.org/' +
'ns/mmd-1.0#" xmlns:ext="http://musicbrainz.org/' +
'ns/ext-1.0#"></metadata>')
release = dom.createElement(u'release')
track_metadata = [t.get_metadata() for t in tracks
if (t.get_metadata() is not None)]
#add album title
release.appendChild(make_text_node(
dom, u'title', unicode(__most_numerous__(
[m.album_name for m in track_metadata]))))
#add album artist
if (len(set([m.artist_name for m in track_metadata])) <
len(track_metadata)):
artist = dom.createElement(u'artist')
album_artist = unicode(__most_numerous__(
[m.artist_name for m in track_metadata]))
artist.appendChild(make_text_node(dom, u'name', album_artist))
release.appendChild(artist)
else:
album_artist = u'' # all track artist names differ
artist = dom.createElement(u'artist')
artist.appendChild(make_text_node(dom, u'name', album_artist))
release.appendChild(artist)
#add release info (catalog number, release date, media, etc.)
event_list = dom.createElement(u'release-event-list')
event = dom.createElement(u'event')
year = unicode(__most_numerous__(
[m.year for m in track_metadata]))
if (year != u""):
event.setAttribute(u'date', year)
catalog_number = unicode(__most_numerous__(
[m.catalog for m in track_metadata]))
if (catalog_number != u""):
event.setAttribute(u'catalog-number', catalog_number)
media = unicode(__most_numerous__(
[m.media for m in track_metadata]))
if (media != u""):
event.setAttribute(u'format', media)
event_list.appendChild(event)
release.appendChild(event_list)
#add tracks
track_list = dom.createElement(u'track-list')
for track in tracks:
node = dom.createElement(u'track')
track_metadata = track.get_metadata()
if (track_metadata is not None):
node.appendChild(make_text_node(
dom, u'title', track_metadata.track_name))
else:
node.appendChild(make_text_node(
dom, u'title', u''))
node.appendChild(make_text_node(
dom, u'duration',
unicode((track.total_frames() * 1000) /
track.sample_rate())))
if (track_metadata is not None):
#add track artist, if different from album artist
if (track_metadata.artist_name != album_artist):
artist = dom.createElement(u'artist')
artist.appendChild(make_text_node(
dom, u'name', track_metadata.artist_name))
node.appendChild(artist)
track_list.appendChild(node)
release.appendChild(track_list)
release_list = dom.createElement(u'release-list')
release_list.appendChild(release)
dom.getElementsByTagName(u'metadata')[0].appendChild(release_list)
return cls(dom)
#takes a Document containing multiple <release> tags
#and a Messenger object to query for output
#returns a modified Document containing only one <release>
def __select_match__(dom, messenger):
messenger.info(_(u"Please Select the Closest Match:"))
matches = dom.getElementsByTagName(u'release')
selected = 0
while ((selected < 1) or (selected > len(matches))):
for i in range(len(matches)):
messenger.info(_(u"%(choice)s) %(name)s") % \
{"choice": i + 1,
"name": get_xml_text_node(matches[i],
u'title')})
try:
messenger.partial_info(_(u"Your Selection [1-%s]:") % \
(len(matches)))
selected = int(sys.stdin.readline().strip())
except ValueError:
selected = 0
for (i, release) in enumerate(dom.getElementsByTagName(u'release')):
if (i != (selected - 1)):
release.parentNode.removeChild(release)
return dom
#takes a Document containing multiple <release> tags
#and a default selection integer
#returns a modified Document containing only one <release>
def __select_default_match__(dom, selection):
for (i, release) in enumerate(dom.getElementsByTagName(u'release')):
if (i != selection):
release.parentNode.removeChild(release)
return dom
def get_mbxml(disc_id, output, musicbrainz_server, musicbrainz_port,
messenger, default_selection=None):
"""Runs through the entire MusicBrainz querying sequence.
Fields are as follows:
disc_id - an MBDiscID object
output - an open file object for writing
musicbrainz_server - a server name string
musicbrainz_port - a server port int
messenger - a Messenger object
default_selection - if given, the default match to choose
"""
mb = MusicBrainz(musicbrainz_server, musicbrainz_port, messenger)
mb.connect()
messenger.info(
_(u"Sending Disc ID \"%(disc_id)s\" to server \"%(server)s\"") % \
{"disc_id": str(disc_id).decode('ascii'),
"server": musicbrainz_server.decode('ascii', 'replace')})
(matches, dom) = mb.read_data(disc_id, output)
mb.close()
if (matches == 1):
messenger.info(_(u"1 match found"))
else:
messenger.info(_(u"%s matches found") % (matches))
if (matches > 1):
if (default_selection is None):
output.write(__select_match__(
dom, messenger).toxml(encoding='utf-8'))
else:
output.write(__select_default_match__(
dom, default_selection).toxml(encoding='utf-8'))
output.flush()
elif (matches == 1):
output.write(dom.toxml(encoding='utf-8'))
output.flush()
else:
return matches

507
Melodia/resources/audiotools/__shn__.py Normal file
View File

@ -0,0 +1,507 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, ChannelMask, PCMReader,
transfer_framelist_data, WaveAudio,
AiffAudio, cStringIO, EncodingError,
UnsupportedBitsPerSample, InvalidFile,
PCMReaderError,
WaveContainer, AiffContainer, to_pcm_progress)
import audiotools.decoders
import os.path
class InvalidShorten(InvalidFile):
pass
class ShortenAudio(WaveContainer, AiffContainer):
"""A Shorten audio file."""
SUFFIX = "shn"
NAME = SUFFIX
def __init__(self, filename):
"""filename is a plain string."""
AudioFile.__init__(self, filename)
try:
f = open(filename, 'rb')
except IOError, msg:
raise InvalidShorten(str(msg))
try:
if (not ShortenAudio.is_type(f)):
raise InvalidShorten(_(u'Shorten header not detected'))
finally:
f.close()
#Why not call __populate_metadata__ here and raise InvalidShorten
#if it errors out?
#The problem is that __populate_metadata__ needs to walk
#through the *entire* file in order to calculate total PCM frames
#and so on.
#That's an expensive operation to perform at init-time
#so it's better to postpone it to an on-demand fetch.
def __populate_metadata__(self):
#set up some default values
self.__bits_per_sample__ = 16
self.__channels__ = 2
self.__channel_mask__ = 0x3
self.__sample_rate__ = 44100
self.__total_frames__ = 0
self.__blocks__ = []
self.__format__ = None
#grab a few pieces of technical metadata from the Shorten file itself
#which requires a dry-run through the decoder
try:
decoder = audiotools.decoders.SHNDecoder(self.filename)
try:
self.__bits_per_sample__ = decoder.bits_per_sample
self.__channels__ = decoder.channels
(self.__total_frames__,
self.__blocks__) = decoder.metadata()
finally:
decoder.close()
try:
self.__channel_mask__ = ChannelMask.from_channels(
self.__channels__)
except ValueError:
self.__channel_mask__ = 0
except (ValueError, IOError):
#if we hit an error in SHNDecoder while reading
#technical metadata, the default values will have to do
return
#the remainder requires parsing the file's VERBATIM blocks
#which may contain Wave, AIFF or Sun AU info
if (self.__blocks__[0] is not None):
header = cStringIO.StringIO(self.__blocks__[0])
for format in WaveAudio, AiffAudio:
header.seek(0, 0)
if (format.is_type(header)):
self.__format__ = format
break
if (self.__format__ is WaveAudio):
for (chunk_id, chunk_data) in self.__wave_chunks__():
if (chunk_id == 'fmt '):
fmt_chunk = WaveAudio.FMT_CHUNK.parse(chunk_data)
self.__sample_rate__ = fmt_chunk.sample_rate
if (fmt_chunk.compression == 0xFFFE):
self.__channel_mask__ = \
WaveAudio.fmt_chunk_to_channel_mask(
fmt_chunk.channel_mask)
elif (self.__format__ is AiffAudio):
for (chunk_id, chunk_data) in self.__aiff_chunks__():
if (chunk_id == 'COMM'):
comm_chunk = AiffAudio.COMM_CHUNK.parse(chunk_data)
self.__sample_rate__ = comm_chunk.sample_rate
def __wave_chunks__(self):
total_size = sum([len(block) for block in self.__blocks__
if block is not None])
wave_data = cStringIO.StringIO("".join([block for block in
self.__blocks__
if block is not None]))
wave_data.read(12) # skip the RIFFxxxxWAVE header data
total_size -= 12
#iterate over all the non-data chunks
while (total_size > 0):
header = WaveAudio.CHUNK_HEADER.parse_stream(wave_data)
total_size -= 8
if (header.chunk_id != 'data'):
yield (header.chunk_id, wave_data.read(header.chunk_length))
total_size -= header.chunk_length
else:
continue
def __aiff_chunks__(self):
total_size = sum([len(block) for block in self.__blocks__
if block is not None])
aiff_data = cStringIO.StringIO("".join([block for block in
self.__blocks__
if block is not None]))
aiff_data.read(12) # skip the FORMxxxxAIFF header data
total_size -= 12
#iterate over all the chunks
while (total_size > 0):
header = AiffAudio.CHUNK_HEADER.parse_stream(aiff_data)
total_size -= 8
if (header.chunk_id != 'SSND'):
yield (header.chunk_id, aiff_data.read(header.chunk_length))
total_size -= header.chunk_length
else:
#This presumes that audiotools encoded
#the Shorten file from an AIFF source.
#The reference encoder places the 8 alignment
#bytes in the PCM stream itself, which is wrong.
yield (header.chunk_id, aiff_data.read(8))
total_size -= 8
@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."""
return (file.read(4) == 'ajkg') and (ord(file.read(1)) == 2)
def bits_per_sample(self):
"""Returns an integer number of bits-per-sample this track contains."""
if (not hasattr(self, "__bits_per_sample__")):
self.__populate_metadata__()
return self.__bits_per_sample__
def channels(self):
"""Returns an integer number of channels this track contains."""
if (not hasattr(self, "__channels__")):
self.__populate_metadata__()
return self.__channels__
def channel_mask(self):
"""Returns a ChannelMask object of this track's channel layout."""
if (not hasattr(self, "__channel_mask__")):
self.__populate_metadata__()
return self.__channel_mask__
def lossless(self):
"""Returns True."""
return True
def total_frames(self):
"""Returns the total PCM frames of the track as an integer."""
if (not hasattr(self, "__total_frames__")):
self.__populate_metadata__()
return self.__total_frames__
def sample_rate(self):
"""Returns the rate of the track's audio as an integer number of Hz."""
if (not hasattr(self, "__sample_rate__")):
self.__populate_metadata__()
return self.__sample_rate__
def to_pcm(self):
"""Returns a PCMReader object containing the track's PCM data."""
try:
sample_rate = self.sample_rate()
channels = self.channels()
channel_mask = int(self.channel_mask())
bits_per_sample = self.bits_per_sample()
decoder = audiotools.decoders.SHNDecoder(self.filename)
decoder.sample_rate = sample_rate
decoder.channel_mask = channel_mask
return decoder
except (IOError, ValueError), msg:
#these may not be accurate if the Shorten file is broken
#but if it is broken, there'll be no way to
#cross-check the results anyway
return PCMReaderError(error_message=str(msg),
sample_rate=44100,
channels=2,
channel_mask=0x3,
bits_per_sample=16)
@classmethod
def from_pcm(cls, filename, pcmreader, compression=None,
block_size=256):
"""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 ShortenAudio object."""
if (pcmreader.bits_per_sample not in (8, 16)):
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
import tempfile
f = tempfile.NamedTemporaryFile(suffix=".wav")
try:
w = WaveAudio.from_pcm(f.name, pcmreader)
return cls.from_wave(filename, f.name, compression, block_size)
finally:
if (os.path.isfile(f.name)):
f.close()
else:
f.close_called = True
def to_wave(self, wave_filename, progress=None):
"""Writes the contents of this file to the given .wav filename string.
Raises EncodingError if some error occurs during decoding."""
if (not hasattr(self, "__format__")):
try:
self.__populate_metadata__()
except IOError, msg:
raise EncodingError(str(msg))
if (self.__format__ is WaveAudio):
try:
f = open(wave_filename, 'wb')
except IOError, msg:
raise EncodingError(str(msg))
for block in self.__blocks__:
if (block is not None):
f.write(block)
else:
try:
total_frames = self.total_frames()
current_frames = 0
decoder = audiotools.decoders.SHNDecoder(self.filename)
frame = decoder.read(4096)
while (len(frame) > 0):
f.write(frame.to_bytes(False, True))
current_frames += frame.frames
if (progress is not None):
progress(current_frames, total_frames)
frame = decoder.read(4096)
except IOError, msg:
raise EncodingError(str(msg))
else:
WaveAudio.from_pcm(wave_filename, to_pcm_progress(self, progress))
def to_aiff(self, aiff_filename, progress=None):
"""Writes the contents of this file to the given .aiff filename string.
Raises EncodingError if some error occurs during decoding."""
if (not hasattr(self, "__format__")):
try:
self.__populate_metadata__()
except IOError, msg:
raise EncodingError(str(msg))
if (self.__format__ is AiffAudio):
try:
f = open(aiff_filename, 'wb')
except IOError, msg:
raise EncodingError(str(msg))
for block in self.__blocks__:
if (block is not None):
f.write(block)
else:
try:
total_frames = self.total_frames()
current_frames = 0
decoder = audiotools.decoders.SHNDecoder(self.filename)
frame = decoder.read(4096)
while (len(frame) > 0):
f.write(frame.to_bytes(True, True))
current_frames += frame.frames
if (progress is not None):
progress(current_frames, total_frames)
frame = decoder.read(4096)
except IOError, msg:
raise EncodingError(str(msg))
else:
AiffAudio.from_pcm(aiff_filename, to_pcm_progress(self, progress))
@classmethod
def from_wave(cls, filename, wave_filename, compression=None,
block_size=256, progress=None):
"""Encodes a new AudioFile from an existing .wav file.
Takes a filename string, wave_filename string
of an existing WaveAudio file
and an optional compression level string.
Encodes a new audio file from the wave's data
at the given filename with the specified compression level
and returns a new ShortenAudio object."""
wave = WaveAudio(wave_filename)
if (wave.bits_per_sample() not in (8, 16)):
raise UnsupportedBitsPerSample(filename, wave.bits_per_sample())
(head, tail) = wave.pcm_split()
if (len(tail) > 0):
blocks = [head, None, tail]
else:
blocks = [head, None]
import audiotools.encoders
try:
audiotools.encoders.encode_shn(
filename=filename,
pcmreader=to_pcm_progress(wave, progress),
block_size=block_size,
file_type={8: 2,
16: 5}[wave.bits_per_sample()],
verbatim_chunks=blocks)
return cls(filename)
except IOError, err:
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
cls.__unlink__(filename)
raise err
@classmethod
def from_aiff(cls, filename, aiff_filename, compression=None,
block_size=256, progress=None):
"""Encodes a new AudioFile from an existing .aiff file.
Takes a filename string, aiff_filename string
of an existing WaveAudio file
and an optional compression level string.
Encodes a new audio file from the aiff's data
at the given filename with the specified compression level
and returns a new ShortenAudio object."""
aiff = AiffAudio(aiff_filename)
if (aiff.bits_per_sample() not in (8, 16)):
raise UnsupportedBitsPerSample(filename, aiff.bits_per_sample())
(head, tail) = aiff.pcm_split()
if (len(tail) > 0):
blocks = [head, None, tail]
else:
blocks = [head, None]
import audiotools.encoders
try:
audiotools.encoders.encode_shn(
filename=filename,
pcmreader=to_pcm_progress(aiff, progress),
block_size=block_size,
file_type={8: 1, # 8-bit AIFF seems to be signed
16: 3}[aiff.bits_per_sample()],
verbatim_chunks=blocks)
return cls(filename)
except IOError, err:
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
cls.__unlink__(filename)
raise err
def convert(self, target_path, target_class, compression=None,
progress=None):
"""Encodes a new AudioFile from existing AudioFile.
Take a filename string, target class and optional compression string.
Encodes a new AudioFile in the target class and returns
the resulting object.
Metadata is not copied during conversion, but embedded
RIFF chunks are (if any).
May raise EncodingError if some problem occurs during encoding."""
#Note that a Shorten file cannot contain
#both RIFF chunks and AIFF chunks at the same time.
import tempfile
if (target_class == WaveAudio):
self.to_wave(target_path, progress=progress)
return WaveAudio(target_path)
elif (target_class == AiffAudio):
self.to_aiff(target_path, progress=progress)
return AiffAudio(target_path)
elif (self.has_foreign_riff_chunks() and
hasattr(target_class, "from_wave")):
temp_wave = tempfile.NamedTemporaryFile(suffix=".wav")
try:
#we'll only log the second leg of conversion,
#since that's likely to be the slower portion
self.to_wave(temp_wave.name)
return target_class.from_wave(target_path,
temp_wave.name,
compression,
progress=progress)
finally:
temp_wave.close()
elif (self.has_foreign_aiff_chunks() and
hasattr(target_class, "from_aiff")):
temp_aiff = tempfile.NamedTemporaryFile(suffix=".aiff")
try:
self.to_aiff(temp_aiff.name)
return target_class.from_aiff(target_path,
temp_aiff.name,
compression,
progress=progress)
finally:
temp_aiff.close()
else:
return target_class.from_pcm(target_path,
to_pcm_progress(self, progress),
compression)
def has_foreign_riff_chunks(self):
"""Returns True if the audio file contains non-audio RIFF chunks.
During transcoding, if the source audio file has foreign RIFF chunks
and the target audio format supports foreign RIFF chunks,
conversion should be routed through .wav conversion
to avoid losing those chunks."""
if (not hasattr(self, "__format__")):
self.__populate_metadata__()
if (self.__format__ is WaveAudio):
for (chunk_id, chunk_data) in self.__wave_chunks__():
if (chunk_id != 'fmt '):
return True
else:
return False
else:
return False
def has_foreign_aiff_chunks(self):
"""Returns True if the audio file contains non-audio AIFF chunks.
During transcoding, if the source audio file has foreign AIFF chunks
and the target audio format supports foreign AIFF chunks,
conversion should be routed through .aiff conversion
to avoid losing those chunks."""
if (not hasattr(self, "__format__")):
self.__populate_metadata__()
if (self.__format__ is AiffAudio):
for (chunk_id, chunk_data) in self.__aiff_chunks__():
if ((chunk_id != 'COMM') and (chunk_id != 'SSND')):
return True
else:
return False
else:
return False

268
Melodia/resources/audiotools/__speex__.py Normal file
View File

@ -0,0 +1,268 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, InvalidFile, PCMReader, PCMConverter,
Con, transfer_data, transfer_framelist_data,
subprocess, BIN, cStringIO, os, ignore_sigint,
EncodingError, DecodingError, ChannelMask,
__default_quality__)
from __vorbis__ import *
#######################
#Speex File
#######################
class InvalidSpeex(InvalidFile):
pass
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"))))
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)])
COMPRESSION_DESCRIPTIONS = {"0":
_(u"corresponds to speexenc --quality 0"),
"10":
_(u"corresponds to speexenc --quality 10")}
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))
@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(0x23)
return (header.startswith('OggS') and
header[0x1C:0x23] == 'Speex ')
def __read_metadata__(self):
f = OggStreamReader(file(self.filename, "rb"))
packets = f.packets()
try:
#first read the Header packet
try:
header = SpeexAudio.SPEEX_HEADER.parse(packets.next())
except StopIteration:
raise InvalidSpeex(_(u"Header packet not found"))
self.__sample_rate__ = header.sampling_rate
self.__channels__ = header.channels
#the read the Comment packet
comment_packet = packets.next()
self.comment = UnframedVorbisComment.VORBIS_COMMENT.parse(
comment_packet)
finally:
del(packets)
f.close()
del(f)
def to_pcm(self):
"""Returns a PCMReader object containing the track's PCM data."""
devnull = file(os.devnull, 'ab')
sub = subprocess.Popen([BIN['speexdec'], self.filename, '-'],
stdout=subprocess.PIPE,
stderr=devnull)
return PCMReader(
sub.stdout,
sample_rate=self.sample_rate(),
channels=self.channels(),
channel_mask=int(ChannelMask.from_channels(self.channels())),
bits_per_sample=self.bits_per_sample(),
process=sub)
@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 SpeexAudio object."""
import bisect
if ((compression is None) or
(compression not in cls.COMPRESSION_MODES)):
compression = __default_quality__(cls.NAME)
if ((pcmreader.bits_per_sample not in (8, 16)) or
(pcmreader.channels > 2) or
(pcmreader.sample_rate not in (8000, 16000, 32000, 44100))):
pcmreader = PCMConverter(
pcmreader,
sample_rate=[8000, 8000, 16000, 32000, 44100][bisect.bisect(
[8000, 16000, 32000, 44100], pcmreader.sample_rate)],
channels=min(pcmreader.channels, 2),
channel_mask=ChannelMask.from_channels(
min(pcmreader.channels, 2)),
bits_per_sample=min(pcmreader.bits_per_sample, 16))
BITS_PER_SAMPLE = {8: ['--8bit'],
16: ['--16bit']}[pcmreader.bits_per_sample]
CHANNELS = {1: [], 2: ['--stereo']}[pcmreader.channels]
devnull = file(os.devnull, "ab")
sub = subprocess.Popen([BIN['speexenc'],
'--quality', str(compression),
'--rate', str(pcmreader.sample_rate),
'--le'] + \
BITS_PER_SAMPLE + \
CHANNELS + \
['-', filename],
stdin=subprocess.PIPE,
stderr=devnull,
preexec_fn=ignore_sigint)
try:
transfer_framelist_data(pcmreader, sub.stdin.write)
except (IOError, ValueError), err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise err
try:
pcmreader.close()
except DecodingError, err:
raise EncodingError(err.error_message)
sub.stdin.close()
result = sub.wait()
devnull.close()
if (result == 0):
return SpeexAudio(filename)
else:
raise EncodingError(u"unable to encode file with speexenc")
def set_metadata(self, metadata):
"""Takes a MetaData object and sets this track's metadata.
This metadata includes track name, album name, and so on.
Raises IOError if unable to write the file."""
comment = VorbisComment.converted(metadata)
if (comment is None):
return
reader = OggStreamReader(file(self.filename, 'rb'))
new_file = cStringIO.StringIO()
writer = OggStreamWriter(new_file)
pages = reader.pages()
#transfer our old header
(header_page, header_data) = pages.next()
writer.write_page(header_page, header_data)
#skip the existing comment packet
(page, data) = pages.next()
while (page.segment_lengths[-1] == 255):
(page, data) = pages.next()
#write the pages for our new comment packet
comment_pages = OggStreamWriter.build_pages(
0,
header_page.bitstream_serial_number,
header_page.page_sequence_number + 1,
comment.build())
for (page, data) in comment_pages:
writer.write_page(page, data)
#write the rest of the pages, re-sequenced and re-checksummed
sequence_number = comment_pages[-1][0].page_sequence_number + 1
for (i, (page, data)) in enumerate(pages):
page.page_sequence_number = i + sequence_number
page.checksum = OggStreamReader.calculate_ogg_checksum(page, data)
writer.write_page(page, data)
reader.close()
#re-write the file with our new data in "new_file"
f = file(self.filename, "wb")
f.write(new_file.getvalue())
f.close()
writer.close()
self.__read_metadata__()
@classmethod
def can_add_replay_gain(cls):
"""Returns False."""
return False

842
Melodia/resources/audiotools/__vorbis__.py Normal file
View File

@ -0,0 +1,842 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, InvalidFile, PCMReader,
ReorderedPCMReader, Con, transfer_data,
transfer_framelist_data, subprocess, BIN,
cStringIO, open_files, os, ReplayGain,
ignore_sigint, EncodingError, DecodingError,
ChannelMask, UnsupportedChannelMask,
__default_quality__)
from __vorbiscomment__ import *
import gettext
gettext.install("audiotools", unicode=True)
class InvalidVorbis(InvalidFile):
pass
def verify_ogg_stream(stream):
"""Verifies an Ogg stream file object.
This file must be rewound to the start of a page.
Returns True if the file is valid.
Raises IOError or ValueError if there is some problem with the file.
"""
from . import verify
verify.ogg(stream)
return True
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 OggStreamWriter:
"""A class for building an Ogg stream."""
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 write_page(self, page_header, page_data):
"""Writes a complete Ogg page to the stream.
page_header is an OGGS-generated Container with all of the
fields properly set.
page_data is a string containing all of the page's segment data.
"""
self.stream.write(OggStreamReader.OGGS.build(page_header))
self.stream.write(page_data)
@classmethod
def build_pages(cls, granule_position, serial_number,
starting_sequence_number, packet_data,
header_type=0):
"""Constructs an Ogg packet for page data.
takes serial_number, granule_position and starting_sequence_number
integers and a packet_data string.
Returns a list of (page_header,page_data) tuples containing
all of the Ogg pages necessary to contain the packet.
"""
page = Con.Container(magic_number='OggS',
version=0,
header_type=header_type,
granule_position=granule_position,
bitstream_serial_number=serial_number,
page_sequence_number=starting_sequence_number,
checksum=0)
if (len(packet_data) == 0):
#an empty Ogg page, but possibly a continuation
page.segments = 0
page.segment_lengths = []
page.checksum = OggStreamReader.calculate_ogg_checksum(
page, packet_data)
return [(page, "")]
if (len(packet_data) > (255 * 255)):
#if we need more than one Ogg page to store the packet,
#handle that case recursively
page.segments = 255
page.segment_lengths = [255] * 255
page.checksum = OggStreamReader.calculate_ogg_checksum(
page, packet_data[0:255 * 255])
return [(page, packet_data[0:255 * 255])] + \
cls.build_pages(granule_position,
serial_number,
starting_sequence_number + 1,
packet_data[255 * 255:],
header_type)
elif (len(packet_data) == (255 * 255)):
#we need two Ogg pages, one of which is empty
return cls.build_pages(granule_position,
serial_number,
starting_sequence_number,
packet_data,
header_type) + \
cls.build_pages(granule_position,
serial_number,
starting_sequence_number + 1,
"",
header_type)
else:
#we just need one Ogg page
page.segments = len(packet_data) / 255
if ((len(packet_data) % 255) > 0):
page.segments += 1
page.segment_lengths = [255] * (len(packet_data) / 255)
if ((len(packet_data) % 255) > 0):
page.segment_lengths += [len(packet_data) % 255]
page.checksum = OggStreamReader.calculate_ogg_checksum(
page, packet_data)
return [(page, packet_data)]
#######################
#Vorbis File
#######################
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)])
COMPRESSION_DESCRIPTIONS = {"0": _(u"very low quality, " +
u"corresponds to oggenc -q 0"),
"10": _(u"very high quality, " +
u"corresponds to oggenc -q 10")}
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))
@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(0x23)
return (header.startswith('OggS') and
header[0x1C:0x23] == '\x01vorbis')
def __read_metadata__(self):
f = OggStreamReader(file(self.filename, "rb"))
packets = f.packets()
try:
#we'll assume this Vorbis file isn't interleaved
#with any other Ogg stream
#the Identification packet comes first
try:
id_packet = packets.next()
except StopIteration:
raise InvalidVorbis("Vorbis identification packet not found")
header = VorbisAudio.COMMENT_HEADER.parse(
id_packet[0:VorbisAudio.COMMENT_HEADER.sizeof()])
if ((header.packet_type == 0x01) and
(header.vorbis == 'vorbis')):
identification = VorbisAudio.OGG_IDENTIFICATION.parse(
id_packet[VorbisAudio.COMMENT_HEADER.sizeof():])
self.__sample_rate__ = identification.sample_rate
self.__channels__ = identification.channels
else:
raise InvalidVorbis(_(u'First packet is not Vorbis'))
#the Comment packet comes next
comment_packet = packets.next()
header = VorbisAudio.COMMENT_HEADER.parse(
comment_packet[0:VorbisAudio.COMMENT_HEADER.sizeof()])
if ((header.packet_type == 0x03) and
(header.vorbis == 'vorbis')):
self.comment = VorbisComment.VORBIS_COMMENT.parse(
comment_packet[VorbisAudio.COMMENT_HEADER.sizeof():])
finally:
del(packets)
f.close()
del(f)
def lossless(self):
"""Returns False."""
return False
def bits_per_sample(self):
"""Returns an integer number of bits-per-sample this track contains."""
return 16
def channels(self):
"""Returns an integer number of channels this track contains."""
return self.__channels__
def channel_mask(self):
"""Returns a ChannelMask object of this track's channel layout."""
if (self.channels() == 1):
return ChannelMask.from_fields(
front_center=True)
elif (self.channels() == 2):
return ChannelMask.from_fields(
front_left=True, front_right=True)
elif (self.channels() == 3):
return ChannelMask.from_fields(
front_left=True, front_right=True,
front_center=True)
elif (self.channels() == 4):
return ChannelMask.from_fields(
front_left=True, front_right=True,
back_left=True, back_right=True)
elif (self.channels() == 5):
return ChannelMask.from_fields(
front_left=True, front_right=True,
front_center=True,
back_left=True, back_right=True)
elif (self.channels() == 6):
return ChannelMask.from_fields(
front_left=True, front_right=True,
front_center=True,
back_left=True, back_right=True,
low_frequency=True)
elif (self.channels() == 7):
return ChannelMask.from_fields(
front_left=True, front_right=True,
front_center=True,
side_left=True, side_right=True,
back_center=True, low_frequency=True)
elif (self.channels() == 8):
return ChannelMask.from_fields(
front_left=True, front_right=True,
side_left=True, side_right=True,
back_left=True, back_right=True,
front_center=True, low_frequency=True)
else:
return ChannelMask(0)
def total_frames(self):
"""Returns the total PCM frames of the track as an integer."""
pcm_samples = 0
f = file(self.filename, "rb")
try:
while (True):
try:
page = OggStreamReader.OGGS.parse_stream(f)
pcm_samples = page.granule_position
f.seek(sum(page.segment_lengths), 1)
except Con.core.FieldError:
break
except Con.ConstError:
break
return pcm_samples
finally:
f.close()
def sample_rate(self):
"""Returns the rate of the track's audio as an integer number of Hz."""
return self.__sample_rate__
def to_pcm(self):
"""Returns a PCMReader object containing the track's PCM data."""
sub = subprocess.Popen([BIN['oggdec'], '-Q',
'-b', str(16),
'-e', str(0),
'-s', str(1),
'-R',
'-o', '-',
self.filename],
stdout=subprocess.PIPE,
stderr=file(os.devnull, "a"))
pcmreader = PCMReader(sub.stdout,
sample_rate=self.sample_rate(),
channels=self.channels(),
channel_mask=int(self.channel_mask()),
bits_per_sample=self.bits_per_sample(),
process=sub)
if (self.channels() <= 2):
return pcmreader
elif (self.channels() <= 8):
#these mappings transform Vorbis order into ChannelMask order
standard_channel_mask = self.channel_mask()
vorbis_channel_mask = VorbisChannelMask(self.channel_mask())
return ReorderedPCMReader(
pcmreader,
[vorbis_channel_mask.channels().index(channel) for channel in
standard_channel_mask.channels()])
else:
return pcmreader
@classmethod
def from_pcm(cls, filename, pcmreader, compression=None):
"""Returns a PCMReader object containing the track's PCM data."""
if ((compression is None) or
(compression not in cls.COMPRESSION_MODES)):
compression = __default_quality__(cls.NAME)
devnull = file(os.devnull, 'ab')
sub = subprocess.Popen([BIN['oggenc'], '-Q',
'-r',
'-B', str(pcmreader.bits_per_sample),
'-C', str(pcmreader.channels),
'-R', str(pcmreader.sample_rate),
'--raw-endianness', str(0),
'-q', compression,
'-o', filename, '-'],
stdin=subprocess.PIPE,
stdout=devnull,
stderr=devnull,
preexec_fn=ignore_sigint)
if ((pcmreader.channels <= 2) or (int(pcmreader.channel_mask) == 0)):
try:
transfer_framelist_data(pcmreader, sub.stdin.write)
except (IOError, ValueError), err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise err
elif (pcmreader.channels <= 8):
if (int(pcmreader.channel_mask) in
(0x7, # FR, FC, FL
0x33, # FR, FL, BR, BL
0x37, # FR, FC, FL, BL, BR
0x3f, # FR, FC, FL, BL, BR, LFE
0x70f, # FL, FC, FR, SL, SR, BC, LFE
0x63f)): # FL, FC, FR, SL, SR, BL, BR, LFE
standard_channel_mask = ChannelMask(pcmreader.channel_mask)
vorbis_channel_mask = VorbisChannelMask(standard_channel_mask)
else:
raise UnsupportedChannelMask(filename,
int(pcmreader.channel_mask))
try:
transfer_framelist_data(ReorderedPCMReader(
pcmreader,
[standard_channel_mask.channels().index(channel)
for channel in vorbis_channel_mask.channels()]),
sub.stdin.write)
except (IOError, ValueError), err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception, err:
sub.stdin.close()
sub.wait()
cls.__unlink__(filename)
raise err
else:
raise UnsupportedChannelMask(filename,
int(pcmreader.channel_mask))
try:
pcmreader.close()
except DecodingError, err:
raise EncodingError(err.error_message)
sub.stdin.close()
devnull.close()
if (sub.wait() == 0):
return VorbisAudio(filename)
else:
raise EncodingError(u"unable to encode file with oggenc")
def set_metadata(self, metadata):
"""Takes a MetaData object and sets this track's metadata.
This metadata includes track name, album name, and so on.
Raises IOError if unable to write the file."""
metadata = VorbisComment.converted(metadata)
if (metadata is None):
return
reader = OggStreamReader(file(self.filename, 'rb'))
new_file = cStringIO.StringIO()
writer = OggStreamWriter(new_file)
current_sequence_number = 0
pages = reader.pages()
#transfer our old header
#this must always be the first packet and the first page
(header_page, header_data) = pages.next()
writer.write_page(header_page, header_data)
current_sequence_number += 1
#grab the current "comment" and "setup headers" packets
#these may take one or more pages,
#but will always end on a page boundary
del(pages)
packets = reader.packets(from_beginning=False)
comment_packet = packets.next()
headers_packet = packets.next()
#write the pages for our new "comment" packet
for (page, data) in OggStreamWriter.build_pages(
0,
header_page.bitstream_serial_number,
current_sequence_number,
VorbisAudio.COMMENT_HEADER.build(Con.Container(
packet_type=3,
vorbis='vorbis')) + metadata.build()):
writer.write_page(page, data)
current_sequence_number += 1
#write the pages for the old "setup headers" packet
for (page, data) in OggStreamWriter.build_pages(
0,
header_page.bitstream_serial_number,
current_sequence_number,
headers_packet):
writer.write_page(page, data)
current_sequence_number += 1
#write the rest of the pages, re-sequenced and re-checksummed
del(packets)
pages = reader.pages(from_beginning=False)
for (i, (page, data)) in enumerate(pages):
page.page_sequence_number = i + current_sequence_number
page.checksum = OggStreamReader.calculate_ogg_checksum(page, data)
writer.write_page(page, data)
reader.close()
#re-write the file with our new data in "new_file"
f = file(self.filename, "wb")
f.write(new_file.getvalue())
f.close()
writer.close()
self.__read_metadata__()
def get_metadata(self):
"""Returns a MetaData object, or None.
Raises IOError if unable to read the file."""
self.__read_metadata__()
data = {}
for pair in self.comment.value:
try:
(key, value) = pair.split('=', 1)
data.setdefault(key, []).append(value.decode('utf-8'))
except ValueError:
continue
return VorbisComment(data)
def delete_metadata(self):
"""Deletes the track's MetaData.
This removes or unsets tags as necessary in order to remove all data.
Raises IOError if unable to write the file."""
self.set_metadata(MetaData())
@classmethod
def add_replay_gain(cls, filenames, progress=None):
"""Adds ReplayGain values to a list of filename strings.
All the filenames must be of this AudioFile type.
Raises ValueError if some problem occurs during ReplayGain application.
"""
track_names = [track.filename for track in
open_files(filenames) if
isinstance(track, cls)]
if (progress is not None):
progress(0, 1)
if ((len(track_names) > 0) and
BIN.can_execute(BIN['vorbisgain'])):
devnull = file(os.devnull, 'ab')
sub = subprocess.Popen([BIN['vorbisgain'],
'-q', '-a'] + track_names,
stdout=devnull,
stderr=devnull)
sub.wait()
devnull.close()
if (progress is not None):
progress(1, 1)
@classmethod
def can_add_replay_gain(cls):
"""Returns True if we have the necessary binaries to add ReplayGain."""
return BIN.can_execute(BIN['vorbisgain'])
@classmethod
def lossless_replay_gain(cls):
"""Returns True."""
return True
def replay_gain(self):
"""Returns a ReplayGain object of our ReplayGain values.
Returns None if we have no values."""
vorbis_metadata = self.get_metadata()
if (set(['REPLAYGAIN_TRACK_PEAK', 'REPLAYGAIN_TRACK_GAIN',
'REPLAYGAIN_ALBUM_PEAK', 'REPLAYGAIN_ALBUM_GAIN']).issubset(
vorbis_metadata.keys())): # we have ReplayGain data
try:
return ReplayGain(
vorbis_metadata['REPLAYGAIN_TRACK_GAIN'][0][0:-len(" dB")],
vorbis_metadata['REPLAYGAIN_TRACK_PEAK'][0],
vorbis_metadata['REPLAYGAIN_ALBUM_GAIN'][0][0:-len(" dB")],
vorbis_metadata['REPLAYGAIN_ALBUM_PEAK'][0])
except ValueError:
return None
else:
return None
def verify(self, progress=None):
"""Verifies the current file for correctness.
Returns True if the file is okay.
Raises an InvalidFile with an error message if there is
some problem with the file."""
#Ogg stream verification is likely to be so fast
#that individual calls to progress() are
#a waste of time.
if (progress is not None):
progress(0, 1)
try:
f = open(self.filename, 'rb')
except IOError, err:
raise InvalidVorbis(str(err))
try:
try:
result = verify_ogg_stream(f)
if (progress is not None):
progress(1, 1)
return result
except (IOError, ValueError), err:
raise InvalidVorbis(str(err))
finally:
f.close()
class VorbisChannelMask(ChannelMask):
"""The Vorbis-specific channel mapping."""
def __repr__(self):
return "VorbisChannelMask(%s)" % \
",".join(["%s=%s" % (field, getattr(self, field))
for field in self.SPEAKER_TO_MASK.keys()
if (getattr(self, field))])
def channels(self):
"""Returns a list of speaker strings this mask contains.
Returned in the order in which they should appear
in the PCM stream.
"""
count = len(self)
if (count == 1):
return ["front_center"]
elif (count == 2):
return ["front_left", "front_right"]
elif (count == 3):
return ["front_left", "front_center", "front_right"]
elif (count == 4):
return ["front_left", "front_right",
"back_left", "back_right"]
elif (count == 5):
return ["front_left", "front_center", "front_right",
"back_left", "back_right"]
elif (count == 6):
return ["front_left", "front_center", "front_right",
"back_left", "back_right", "low_frequency"]
elif (count == 7):
return ["front_left", "front_center", "front_right",
"side_left", "side_right", "back_center",
"low_frequency"]
elif (count == 8):
return ["front_left", "front_center", "front_right",
"side_left", "side_right",
"back_left", "back_right", "low_frequency"]
else:
return []

294
Melodia/resources/audiotools/__vorbiscomment__.py Normal file
View File

@ -0,0 +1,294 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import MetaData, Con, VERSION, re
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)

1023
Melodia/resources/audiotools/__wav__.py Normal file
View File

File diff suppressed because it is too large Load Diff

661
Melodia/resources/audiotools/__wavpack__.py Normal file
View File

@ -0,0 +1,661 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from audiotools import (AudioFile, InvalidFile, Con, subprocess, BIN,
open_files, os, ReplayGain, ignore_sigint,
transfer_data, transfer_framelist_data,
BufferedPCMReader, Image, MetaData, sheet_to_unicode,
calculate_replay_gain, ApeTagItem,
EncodingError, DecodingError, PCMReaderError,
PCMReader, ChannelMask,
InvalidWave, __default_quality__,
WaveContainer, to_pcm_progress)
from __wav__ import WaveAudio, WaveReader
from __ape__ import ApeTaggedAudio, ApeTag, __number_pair__
import gettext
gettext.install("audiotools", unicode=True)
class InvalidWavPack(InvalidFile):
pass
class __24BitsLE__(Con.Adapter):
def _encode(self, value, context):
return chr(value & 0x0000FF) + \
chr((value & 0x00FF00) >> 8) + \
chr((value & 0xFF0000) >> 16)
def _decode(self, obj, context):
return (ord(obj[2]) << 16) | (ord(obj[1]) << 8) | ord(obj[0])
def ULInt24(name):
return __24BitsLE__(Con.Bytes(name, 3))
def __riff_chunk_ids__(data):
import cStringIO
total_size = len(data)
data = cStringIO.StringIO(data)
header = WaveAudio.WAVE_HEADER.parse_stream(data)
while (data.tell() < total_size):
chunk_header = WaveAudio.CHUNK_HEADER.parse_stream(data)
chunk_size = chunk_header.chunk_length
if ((chunk_size & 1) == 1):
chunk_size += 1
data.seek(chunk_size, 1)
yield chunk_header.chunk_id
#######################
#WavPack APEv2
#######################
class WavPackAPEv2(ApeTag):
"""A WavPack-specific APEv2 implementation with minor differences."""
def __init__(self, tags, tag_length=None, frame_count=0):
"""Constructs an ApeTag from a list of ApeTagItem objects.
tag_length is an optional total length integer.
frame_count is an optional number of PCM frames
to be used by cuesheets."""
ApeTag.__init__(self, tags=tags, tag_length=tag_length)
self.frame_count = frame_count
def __comment_pairs__(self):
return filter(lambda pair: pair[0] != 'Cuesheet',
ApeTag.__comment_pairs__(self))
def __unicode__(self):
if ('Cuesheet' not in self.keys()):
return ApeTag.__unicode__(self)
else:
import cue
try:
return u"%s%sCuesheet:\n%s" % \
(MetaData.__unicode__(self),
os.linesep * 2,
sheet_to_unicode(
cue.parse(
cue.tokens(unicode(self['Cuesheet']).encode(
'ascii', 'replace'))),
self.frame_count))
except cue.CueException:
return ApeTag.__unicode__(self)
@classmethod
def converted(cls, metadata):
"""Converts a MetaData object to a WavPackAPEv2 object."""
if ((metadata is None) or (isinstance(metadata, WavPackAPEv2))):
return metadata
elif (isinstance(metadata, ApeTag)):
return WavPackAPEv2(metadata.tags)
else:
return WavPackAPEv2(ApeTag.converted(metadata).tags)
WavePackAPEv2 = WavPackAPEv2
#######################
#WavPack
#######################
class WavPackAudio(ApeTaggedAudio, WaveContainer):
"""A WavPack audio file."""
SUFFIX = "wv"
NAME = SUFFIX
DEFAULT_COMPRESSION = "standard"
COMPRESSION_MODES = ("veryfast", "fast", "standard", "high", "veryhigh")
COMPRESSION_DESCRIPTIONS = {"veryfast": _(u"fastest encode/decode, " +
u"worst compression"),
"veryhigh": _(u"slowest encode/decode, " +
u"best compression")}
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_bits": 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))
@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."""
return file.read(4) == 'wvpk'
def lossless(self):
"""Returns True."""
return True
def channel_mask(self):
"""Returns a ChannelMask object of this track's channel layout."""
if ((self.__channels__ == 1) or (self.__channels__ == 2)):
return ChannelMask.from_channels(self.__channels__)
else:
for (block_id, nondecoder, data) in self.sub_frames():
if ((block_id == 0xD) and not nondecoder):
mask = 0
for byte in reversed(map(ord, data[1:])):
mask = (mask << 8) | byte
return ChannelMask(mask)
else:
return ChannelMask(0)
def get_metadata(self):
"""Returns a MetaData object, or None.
Raises IOError if unable to read the file."""
metadata = ApeTaggedAudio.get_metadata(self)
if (metadata is not None):
metadata.frame_count = self.total_frames()
return metadata
def has_foreign_riff_chunks(self):
"""Returns True if the audio file contains non-audio RIFF chunks.
During transcoding, if the source audio file has foreign RIFF chunks
and the target audio format supports foreign RIFF chunks,
conversion should be routed through .wav conversion
to avoid losing those chunks."""
for (sub_header, nondecoder, data) in self.sub_frames():
if ((sub_header == 1) and nondecoder):
if (set(__riff_chunk_ids__(data)) != set(['fmt ', 'data'])):
return True
elif ((sub_header == 2) and nondecoder):
return True
else:
return False
def frames(self):
"""Yields (header, data) tuples of WavPack frames.
header is a Container parsed from WavPackAudio.HEADER.
data is a binary string.
"""
f = file(self.filename)
total_size = os.path.getsize(self.filename)
try:
while (f.tell() < total_size):
try:
header = WavPackAudio.HEADER.parse(f.read(
WavPackAudio.HEADER.sizeof()))
except Con.ConstError:
break
data = f.read(header.block_size - 24)
yield (header, data)
finally:
f.close()
def sub_frames(self):
"""Yields (function,nondecoder,data) tuples.
function is an integer.
nondecoder is a boolean indicating non-decoder data.
data is a binary string.
"""
import cStringIO
for (header, data) in self.frames():
total_size = len(data)
data = cStringIO.StringIO(data)
while (data.tell() < total_size):
sub_header = WavPackAudio.SUB_HEADER.parse_stream(data)
if (sub_header.actual_size_1_less):
yield (sub_header.metadata_function,
sub_header.nondecoder_data,
data.read((sub_header.size * 2) - 1))
data.read(1)
else:
yield (sub_header.metadata_function,
sub_header.nondecoder_data,
data.read(sub_header.size * 2))
def __read_info__(self):
f = file(self.filename)
try:
try:
header = WavPackAudio.HEADER.parse(f.read(
WavPackAudio.HEADER.sizeof()))
except Con.ConstError:
raise InvalidWavPack(_(u'WavPack header ID invalid'))
except Con.FieldError:
raise InvalidWavPack(_(u'WavPack header ID invalid'))
self.__samplerate__ = WavPackAudio.SAMPLING_RATE[
(header.sampling_rate_high << 1) |
header.sampling_rate_low]
if (self.__samplerate__ == 0):
#if unknown, pull from the RIFF WAVE header
for (function, nondecoder, data) in self.sub_frames():
if ((function == 1) and nondecoder):
#fmt chunk must be in the header
#since it must come before the data chunk
import cStringIO
chunks = cStringIO.StringIO(data[12:-8])
try:
while (True):
chunk_header = \
WaveAudio.CHUNK_HEADER.parse_stream(
chunks)
chunk_data = chunks.read(
chunk_header.chunk_length)
if (chunk_header.chunk_id == 'fmt '):
self.__samplerate__ = \
WaveAudio.FMT_CHUNK.parse(
chunk_data).sample_rate
except Con.FieldError:
pass # finished with chunks
self.__bitspersample__ = WavPackAudio.BITS_PER_SAMPLE[
header.bits_per_sample]
self.__total_frames__ = header.total_samples
self.__channels__ = 0
#go through as many headers as necessary
#to count the number of channels
if (header.mono_output):
self.__channels__ += 1
else:
self.__channels__ += 2
while (not header.final_block_in_sequence):
f.seek(header.block_size - 24, 1)
header = WavPackAudio.HEADER.parse(f.read(
WavPackAudio.HEADER.sizeof()))
if (header.mono_output):
self.__channels__ += 1
else:
self.__channels__ += 2
finally:
f.close()
def bits_per_sample(self):
"""Returns an integer number of bits-per-sample this track contains."""
return self.__bitspersample__
def channels(self):
"""Returns an integer number of channels this track contains."""
return self.__channels__
def total_frames(self):
"""Returns the total PCM frames of the track as an integer."""
return self.__total_frames__
def sample_rate(self):
"""Returns the rate of the track's audio as an integer number of Hz."""
return self.__samplerate__
@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 WavPackAudio object."""
from . import encoders
if ((compression is None) or
(compression not in cls.COMPRESSION_MODES)):
compression = __default_quality__(cls.NAME)
try:
encoders.encode_wavpack(filename,
BufferedPCMReader(pcmreader),
**cls.__options__[compression])
return cls(filename)
except (ValueError, IOError), msg:
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception, err:
cls.__unlink__(filename)
raise err
def to_wave(self, wave_filename, progress=None):
"""Writes the contents of this file to the given .wav filename string.
Raises EncodingError if some error occurs during decoding."""
from . import decoders
try:
f = open(wave_filename, 'wb')
except IOError, msg:
raise EncodingError(str(msg))
(head, tail) = self.pcm_split()
try:
f.write(head)
total_frames = self.total_frames()
current_frames = 0
decoder = decoders.WavPackDecoder(self.filename)
frame = decoder.read(4096)
while (len(frame) > 0):
f.write(frame.to_bytes(False, self.bits_per_sample() > 8))
current_frames += frame.frames
if (progress is not None):
progress(current_frames, total_frames)
frame = decoder.read(4096)
f.write(tail)
f.close()
except IOError, msg:
self.__unlink__(wave_filename)
raise EncodingError(str(msg))
def to_pcm(self):
"""Returns a PCMReader object containing the track's PCM data."""
from . import decoders
try:
return decoders.WavPackDecoder(self.filename,
self.__samplerate__)
except (IOError, ValueError), msg:
return PCMReaderError(error_message=str(msg),
sample_rate=self.__samplerate__,
channels=self.__channels__,
channel_mask=int(self.channel_mask()),
bits_per_sample=self.__bitspersample__)
@classmethod
def from_wave(cls, filename, wave_filename, compression=None,
progress=None):
"""Encodes a new AudioFile from an existing .wav file.
Takes a filename string, wave_filename string
of an existing WaveAudio file
and an optional compression level string.
Encodes a new audio file from the wave's data
at the given filename with the specified compression level
and returns a new WavPackAudio object."""
from . import encoders
if ((compression is None) or
(compression not in cls.COMPRESSION_MODES)):
compression = __default_quality__(cls.NAME)
wave = WaveAudio(wave_filename)
(head, tail) = wave.pcm_split()
try:
encoders.encode_wavpack(filename,
to_pcm_progress(wave, progress),
wave_header=head,
wave_footer=tail,
**cls.__options__[compression])
return cls(filename)
except (ValueError, IOError), msg:
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception, err:
cls.__unlink__(filename)
raise err
def pcm_split(self):
"""Returns a pair of data strings before and after PCM data."""
head = ""
tail = ""
for (sub_block_id, nondecoder, data) in self.sub_frames():
if ((sub_block_id == 1) and nondecoder):
head = data
elif ((sub_block_id == 2) and nondecoder):
tail = data
return (head, tail)
@classmethod
def add_replay_gain(cls, filenames, progress=None):
"""Adds ReplayGain values to a list of filename strings.
All the filenames must be of this AudioFile type.
Raises ValueError if some problem occurs during ReplayGain application.
"""
tracks = [track for track in open_files(filenames) if
isinstance(track, cls)]
if (len(tracks) > 0):
for (track,
track_gain,
track_peak,
album_gain,
album_peak) in calculate_replay_gain(tracks, progress):
metadata = track.get_metadata()
if (metadata is None):
metadata = WavPackAPEv2([])
metadata["replaygain_track_gain"] = ApeTagItem.string(
"replaygain_track_gain",
u"%+1.2f dB" % (track_gain))
metadata["replaygain_track_peak"] = ApeTagItem.string(
"replaygain_track_peak",
u"%1.6f" % (track_peak))
metadata["replaygain_album_gain"] = ApeTagItem.string(
"replaygain_album_gain",
u"%+1.2f dB" % (album_gain))
metadata["replaygain_album_peak"] = ApeTagItem.string(
"replaygain_album_peak",
u"%1.6f" % (album_peak))
track.set_metadata(metadata)
@classmethod
def can_add_replay_gain(cls):
"""Returns True."""
return True
@classmethod
def lossless_replay_gain(cls):
"""Returns True."""
return True
def replay_gain(self):
"""Returns a ReplayGain object of our ReplayGain values.
Returns None if we have no values."""
metadata = self.get_metadata()
if (metadata is None):
return None
if (set(['replaygain_track_gain', 'replaygain_track_peak',
'replaygain_album_gain', 'replaygain_album_peak']).issubset(
metadata.keys())): # we have ReplayGain data
try:
return ReplayGain(
unicode(metadata['replaygain_track_gain'])[0:-len(" dB")],
unicode(metadata['replaygain_track_peak']),
unicode(metadata['replaygain_album_gain'])[0:-len(" dB")],
unicode(metadata['replaygain_album_peak']))
except ValueError:
return None
else:
return None
def get_cuesheet(self):
"""Returns the embedded Cuesheet-compatible object, or None.
Raises IOError if a problem occurs when reading the file."""
import cue
metadata = self.get_metadata()
if ((metadata is not None) and ('Cuesheet' in metadata.keys())):
try:
return cue.parse(cue.tokens(
unicode(metadata['Cuesheet']).encode('utf-8',
'replace')))
except cue.CueException:
#unlike FLAC, just because a cuesheet is embedded
#does not mean it is compliant
return None
else:
return None
def set_cuesheet(self, cuesheet):
"""Imports cuesheet data from a Cuesheet-compatible object.
This are objects with catalog(), ISRCs(), indexes(), and pcm_lengths()
methods. Raises IOError if an error occurs setting the cuesheet."""
import os.path
import cue
if (cuesheet is None):
return
metadata = self.get_metadata()
if (metadata is None):
metadata = WavPackAPEv2.converted(MetaData())
metadata['Cuesheet'] = WavPackAPEv2.ITEM.string('Cuesheet',
cue.Cuesheet.file(
cuesheet,
os.path.basename(self.filename)).decode('ascii', 'replace'))
self.set_metadata(metadata)

BIN
Melodia/resources/audiotools/cdio.so Executable file
View File

Binary file not shown.

115
Melodia/resources/audiotools/construct/__init__.py Normal file
View File

@ -0,0 +1,115 @@
"""
. #### ####
## #### ## ## #### ###### ##### ## ## #### ###### ## ##
## ## ## ### ## ## ## ## ## ## ## ## ## #### ##
## ## ## ###### ### ## ##### ## ## ## ## ##
## ## ## ## ### ## ## ## ## ## ## ## ## ##
#### #### ## ## #### ## ## ## ##### #### ## ######
Parsing made even more fun (and faster too)
Homepage:
http://construct.wikispaces.com (including online tutorial)
Typical usage:
>>> from construct import *
Hands-on example:
>>> from construct import *
>>>
>>> s = Struct("foo",
... UBInt8("a"),
... UBInt16("b"),
... )
>>>
>>> s.parse("\\x01\\x02\\x03")
Container(a = 1, b = 515)
>>>
>>> print s.parse("\\x01\\x02\\x03")
Container:
a = 1
b = 515
>>>
>>> s.build(Container(a = 1, b = 0x0203))
"\\x01\\x02\\x03"
"""
from core import *
from adapters import *
from macros import *
from debug import Probe, Debugger
#===============================================================================
# meta data
#===============================================================================
__author__ = "tomer filiba (tomerfiliba [at] gmail.com)"
__version__ = "2.04"
#===============================================================================
# shorthands
#===============================================================================
Bits = BitField
Byte = UBInt8
Bytes = Field
Const = ConstAdapter
Tunnel = TunnelAdapter
Embed = Embedded
#===============================================================================
# deprecated names (kept for backward compatibility with RC1)
#===============================================================================
MetaField = Field
MetaBytes = Field
GreedyRepeater = GreedyRange
OptionalGreedyRepeater = OptionalGreedyRange
Repeater = Range
StrictRepeater = Array
MetaRepeater = Array
OneOfValidator = OneOf
NoneOfValidator = NoneOf
#===============================================================================
# exposed names
#===============================================================================
__all__ = [
'AdaptationError', 'Adapter', 'Alias', 'Aligned', 'AlignedStruct',
'Anchor', 'Array', 'ArrayError', 'BFloat32', 'BFloat64', 'Bit', 'BitField',
'BitIntegerAdapter', 'BitIntegerError', 'BitStruct', 'Bits', 'Bitwise',
'Buffered', 'Byte', 'Bytes', 'CString', 'CStringAdapter', 'Const',
'ConstAdapter', 'ConstError', 'Construct', 'ConstructError', 'Container',
'Debugger', 'Embed', 'Embedded', 'EmbeddedBitStruct', 'Enum', 'ExprAdapter',
'Field', 'FieldError', 'Flag', 'FlagsAdapter', 'FlagsContainer',
'FlagsEnum', 'FormatField', 'GreedyRange', 'GreedyRepeater',
'HexDumpAdapter', 'If', 'IfThenElse', 'IndexingAdapter', 'LFloat32',
'LFloat64', 'LazyBound', 'LengthValueAdapter', 'ListContainer',
'MappingAdapter', 'MappingError', 'MetaArray', 'MetaBytes', 'MetaField',
'MetaRepeater', 'NFloat32', 'NFloat64', 'Nibble', 'NoneOf',
'NoneOfValidator', 'Octet', 'OnDemand', 'OnDemandPointer', 'OneOf',
'OneOfValidator', 'OpenRange', 'Optional', 'OptionalGreedyRange',
'OptionalGreedyRepeater', 'PaddedStringAdapter', 'Padding',
'PaddingAdapter', 'PaddingError', 'PascalString', 'Pass', 'Peek',
'Pointer', 'PrefixedArray', 'Probe', 'Range', 'RangeError', 'Reconfig',
'Rename', 'RepeatUntil', 'Repeater', 'Restream', 'SBInt16', 'SBInt32',
'SBInt64', 'SBInt8', 'SLInt16', 'SLInt32', 'SLInt64', 'SLInt8', 'SNInt16',
'SNInt32', 'SNInt64', 'SNInt8', 'Select', 'SelectError', 'Sequence',
'SizeofError', 'SlicingAdapter', 'StaticField', 'StrictRepeater', 'String',
'StringAdapter', 'Struct', 'Subconstruct', 'Switch', 'SwitchError',
'SymmetricMapping', 'Terminator', 'TerminatorError', 'Tunnel',
'TunnelAdapter', 'UBInt16', 'UBInt32', 'UBInt64', 'UBInt8', 'ULInt16',
'ULInt32', 'ULInt64', 'ULInt8', 'UNInt16', 'UNInt32', 'UNInt64', 'UNInt8',
'Union', 'ValidationError', 'Validator', 'Value', "Magic",
]

482
Melodia/resources/audiotools/construct/adapters.py Normal file
View File

@ -0,0 +1,482 @@
from core import Adapter, AdaptationError, Pass
from lib import int_to_bin, bin_to_int, swap_bytes, StringIO
from lib import FlagsContainer, HexString
#===============================================================================
# exceptions
#===============================================================================
class BitIntegerError(AdaptationError):
__slots__ = []
class MappingError(AdaptationError):
__slots__ = []
class ConstError(AdaptationError):
__slots__ = []
class ValidationError(AdaptationError):
__slots__ = []
class PaddingError(AdaptationError):
__slots__ = []
#===============================================================================
# adapters
#===============================================================================
class BitIntegerAdapter(Adapter):
"""
Adapter for bit-integers (converts bitstrings to integers, and vice versa).
See BitField.
Parameters:
* subcon - the subcon to adapt
* width - the size of the subcon, in bits
* swapped - whether to swap byte order (little endian/big endian).
default is False (big endian)
* signed - whether the value is signed (two's complement). the default
is False (unsigned)
* bytesize - number of bits per byte, used for byte-swapping (if swapped).
default is 8.
"""
__slots__ = ["width", "swapped", "signed", "bytesize"]
def __init__(self, subcon, width, swapped = False, signed = False,
bytesize = 8):
Adapter.__init__(self, subcon)
self.width = width
self.swapped = swapped
self.signed = signed
self.bytesize = bytesize
def _encode(self, obj, context):
if obj < 0 and not self.signed:
raise BitIntegerError("object is negative, but field is not signed",
obj)
obj2 = int_to_bin(obj, width = self.width)
if self.swapped:
obj2 = swap_bytes(obj2, bytesize = self.bytesize)
return obj2
def _decode(self, obj, context):
if self.swapped:
obj = swap_bytes(obj, bytesize = self.bytesize)
return bin_to_int(obj, signed = self.signed)
class MappingAdapter(Adapter):
"""
Adapter that maps objects to other objects.
See SymmetricMapping and Enum.
Parameters:
* subcon - the subcon to map
* decoding - the decoding (parsing) mapping (a dict)
* encoding - the encoding (building) mapping (a dict)
* decdefault - the default return value when the object is not found
in the decoding mapping. if no object is given, an exception is raised.
if `Pass` is used, the unmapped object will be passed as-is
* encdefault - the default return value when the object is not found
in the encoding mapping. if no object is given, an exception is raised.
if `Pass` is used, the unmapped object will be passed as-is
"""
__slots__ = ["encoding", "decoding", "encdefault", "decdefault"]
def __init__(self, subcon, decoding, encoding,
decdefault = NotImplemented, encdefault = NotImplemented):
Adapter.__init__(self, subcon)
self.decoding = decoding
self.encoding = encoding
self.decdefault = decdefault
self.encdefault = encdefault
def _encode(self, obj, context):
try:
return self.encoding[obj]
except (KeyError, TypeError):
if self.encdefault is NotImplemented:
raise MappingError("no encoding mapping for %r" % (obj,))
if self.encdefault is Pass:
return obj
return self.encdefault
def _decode(self, obj, context):
try:
return self.decoding[obj]
except (KeyError, TypeError):
if self.decdefault is NotImplemented:
raise MappingError("no decoding mapping for %r" % (obj,))
if self.decdefault is Pass:
return obj
return self.decdefault
class FlagsAdapter(Adapter):
"""
Adapter for flag fields. Each flag is extracted from the number, resulting
in a FlagsContainer object. Not intended for direct usage.
See FlagsEnum.
Parameters
* subcon - the subcon to extract
* flags - a dictionary mapping flag-names to their value
"""
__slots__ = ["flags"]
def __init__(self, subcon, flags):
Adapter.__init__(self, subcon)
self.flags = flags
def _encode(self, obj, context):
flags = 0
for name, value in self.flags.iteritems():
if getattr(obj, name, False):
flags |= value
return flags
def _decode(self, obj, context):
obj2 = FlagsContainer()
for name, value in self.flags.iteritems():
setattr(obj2, name, bool(obj & value))
return obj2
class StringAdapter(Adapter):
"""
Adapter for strings. Converts a sequence of characters into a python
string, and optionally handles character encoding.
See String.
Parameters:
* subcon - the subcon to convert
* encoding - the character encoding name (e.g., "utf8"), or None to
return raw bytes (usually 8-bit ASCII).
"""
__slots__ = ["encoding"]
def __init__(self, subcon, encoding = None):
Adapter.__init__(self, subcon)
self.encoding = encoding
def _encode(self, obj, context):
if self.encoding:
obj = obj.encode(self.encoding)
return obj
def _decode(self, obj, context):
obj = "".join(obj)
if self.encoding:
obj = obj.decode(self.encoding)
return obj
class PaddedStringAdapter(Adapter):
r"""
Adapter for padded strings.
See String.
Parameters:
* subcon - the subcon to adapt
* padchar - the padding character. default is "\x00".
* paddir - the direction where padding is placed ("right", "left", or
"center"). the default is "right".
* trimdir - the direction where trimming will take place ("right" or
"left"). the default is "right". trimming is only meaningful for
building, when the given string is too long.
"""
__slots__ = ["padchar", "paddir", "trimdir"]
def __init__(self, subcon, padchar = "\x00", paddir = "right",
trimdir = "right"):
if paddir not in ("right", "left", "center"):
raise ValueError("paddir must be 'right', 'left' or 'center'",
paddir)
if trimdir not in ("right", "left"):
raise ValueError("trimdir must be 'right' or 'left'", trimdir)
Adapter.__init__(self, subcon)
self.padchar = padchar
self.paddir = paddir
self.trimdir = trimdir
def _decode(self, obj, context):
if self.paddir == "right":
obj = obj.rstrip(self.padchar)
elif self.paddir == "left":
obj = obj.lstrip(self.padchar)
else:
obj = obj.strip(self.padchar)
return obj
def _encode(self, obj, context):
size = self._sizeof(context)
if self.paddir == "right":
obj = obj.ljust(size, self.padchar)
elif self.paddir == "left":
obj = obj.rjust(size, self.padchar)
else:
obj = obj.center(size, self.padchar)
if len(obj) > size:
if self.trimdir == "right":
obj = obj[:size]
else:
obj = obj[-size:]
return obj
class LengthValueAdapter(Adapter):
"""
Adapter for length-value pairs. It extracts only the value from the
pair, and calculates the length based on the value.
See PrefixedArray and PascalString.
Parameters:
* subcon - the subcon returning a length-value pair
"""
__slots__ = []
def _encode(self, obj, context):
return (len(obj), obj)
def _decode(self, obj, context):
return obj[1]
class CStringAdapter(StringAdapter):
r"""
Adapter for C-style strings (strings terminated by a terminator char).
Parameters:
* subcon - the subcon to convert
* terminators - a sequence of terminator chars. default is "\x00".
* encoding - the character encoding to use (e.g., "utf8"), or None to
return raw-bytes. the terminator characters are not affected by the
encoding.
"""
__slots__ = ["terminators"]
def __init__(self, subcon, terminators = "\x00", encoding = None):
StringAdapter.__init__(self, subcon, encoding = encoding)
self.terminators = terminators
def _encode(self, obj, context):
return StringAdapter._encode(self, obj, context) + self.terminators[0]
def _decode(self, obj, context):
return StringAdapter._decode(self, obj[:-1], context)
class TunnelAdapter(Adapter):
"""
Adapter for tunneling (as in protocol tunneling). A tunnel is construct
nested upon another (layering). For parsing, the lower layer first parses
the data (note: it must return a string!), then the upper layer is called
to parse that data (bottom-up). For building it works in a top-down manner;
first the upper layer builds the data, then the lower layer takes it and
writes it to the stream.
Parameters:
* subcon - the lower layer subcon
* inner_subcon - the upper layer (tunneled/nested) subcon
Example:
# a pascal string containing compressed data (zlib encoding), so first
# the string is read, decompressed, and finally re-parsed as an array
# of UBInt16
TunnelAdapter(
PascalString("data", encoding = "zlib"),
GreedyRange(UBInt16("elements"))
)
"""
__slots__ = ["inner_subcon"]
def __init__(self, subcon, inner_subcon):
Adapter.__init__(self, subcon)
self.inner_subcon = inner_subcon
def _decode(self, obj, context):
return self.inner_subcon._parse(StringIO(obj), context)
def _encode(self, obj, context):
stream = StringIO()
self.inner_subcon._build(obj, stream, context)
return stream.getvalue()
class ExprAdapter(Adapter):
"""
A generic adapter that accepts 'encoder' and 'decoder' as parameters. You
can use ExprAdapter instead of writing a full-blown class when only a
simple expression is needed.
Parameters:
* subcon - the subcon to adapt
* encoder - a function that takes (obj, context) and returns an encoded
version of obj
* decoder - a function that takes (obj, context) and returns an decoded
version of obj
Example:
ExprAdapter(UBInt8("foo"),
encoder = lambda obj, ctx: obj / 4,
decoder = lambda obj, ctx: obj * 4,
)
"""
__slots__ = ["_encode", "_decode"]
def __init__(self, subcon, encoder, decoder):
Adapter.__init__(self, subcon)
self._encode = encoder
self._decode = decoder
class HexDumpAdapter(Adapter):
"""
Adapter for hex-dumping strings. It returns a HexString, which is a string
"""
__slots__ = ["linesize"]
def __init__(self, subcon, linesize = 16):
Adapter.__init__(self, subcon)
self.linesize = linesize
def _encode(self, obj, context):
return obj
def _decode(self, obj, context):
return HexString(obj, linesize = self.linesize)
class ConstAdapter(Adapter):
"""
Adapter for enforcing a constant value ("magic numbers"). When decoding,
the return value is checked; when building, the value is substituted in.
Parameters:
* subcon - the subcon to validate
* value - the expected value
Example:
Const(Field("signature", 2), "MZ")
"""
__slots__ = ["value"]
def __init__(self, subcon, value):
Adapter.__init__(self, subcon)
self.value = value
def _encode(self, obj, context):
if obj is None or obj == self.value:
return self.value
else:
raise ConstError("expected %r, found %r" % (self.value, obj))
def _decode(self, obj, context):
if obj != self.value:
raise ConstError("expected %r, found %r" % (self.value, obj))
return obj
class SlicingAdapter(Adapter):
"""
Adapter for slicing a list (getting a slice from that list)
Parameters:
* subcon - the subcon to slice
* start - start index
* stop - stop index (or None for up-to-end)
* step - step (or None for every element)
"""
__slots__ = ["start", "stop", "step"]
def __init__(self, subcon, start, stop = None):
Adapter.__init__(self, subcon)
self.start = start
self.stop = stop
def _encode(self, obj, context):
if self.start is None:
return obj
return [None] * self.start + obj
def _decode(self, obj, context):
return obj[self.start:self.stop]
class IndexingAdapter(Adapter):
"""
Adapter for indexing a list (getting a single item from that list)
Parameters:
* subcon - the subcon to index
* index - the index of the list to get
"""
__slots__ = ["index"]
def __init__(self, subcon, index):
Adapter.__init__(self, subcon)
if type(index) is not int:
raise TypeError("index must be an integer", type(index))
self.index = index
def _encode(self, obj, context):
return [None] * self.index + [obj]
def _decode(self, obj, context):
return obj[self.index]
class PaddingAdapter(Adapter):
r"""
Adapter for padding.
Parameters:
* subcon - the subcon to pad
* pattern - the padding pattern (character). default is "\x00"
* strict - whether or not to verify, during parsing, that the given
padding matches the padding pattern. default is False (unstrict)
"""
__slots__ = ["pattern", "strict"]
def __init__(self, subcon, pattern = "\x00", strict = False):
Adapter.__init__(self, subcon)
self.pattern = pattern
self.strict = strict
def _encode(self, obj, context):
return self._sizeof(context) * self.pattern
def _decode(self, obj, context):
if self.strict:
expected = self._sizeof(context) * self.pattern
if obj != expected:
raise PaddingError("expected %r, found %r" % (expected, obj))
return obj
#===============================================================================
# validators
#===============================================================================
class Validator(Adapter):
"""
Abstract class: validates a condition on the encoded/decoded object.
Override _validate(obj, context) in deriving classes.
Parameters:
* subcon - the subcon to validate
"""
__slots__ = []
def _decode(self, obj, context):
if not self._validate(obj, context):
raise ValidationError("invalid object", obj)
return obj
def _encode(self, obj, context):
return self._decode(obj, context)
def _validate(self, obj, context):
raise NotImplementedError()
class OneOf(Validator):
"""
Validates that the value is one of the listed values
Parameters:
* subcon - the subcon to validate
* valids - a set of valid values
"""
__slots__ = ["valids"]
def __init__(self, subcon, valids):
Validator.__init__(self, subcon)
self.valids = valids
def _validate(self, obj, context):
return obj in self.valids
class NoneOf(Validator):
"""
Validates that the value is none of the listed values
Parameters:
* subcon - the subcon to validate
* invalids - a set of invalid values
"""
__slots__ = ["invalids"]
def __init__(self, subcon, invalids):
Validator.__init__(self, subcon)
self.invalids = invalids
def _validate(self, obj, context):
return obj not in self.invalids

1249
Melodia/resources/audiotools/construct/core.py Normal file
View File

File diff suppressed because it is too large Load Diff

160
Melodia/resources/audiotools/construct/debug.py Normal file
View File

@ -0,0 +1,160 @@
"""
Debugging utilities for constructs
"""
import sys
import traceback
import pdb
import inspect
from core import Construct, Subconstruct
from lib import HexString, Container, ListContainer, AttrDict
class Probe(Construct):
"""
A probe: dumps the context, stack frames, and stream content to the screen
to aid the debugging process.
See also Debugger.
Parameters:
* name - the display name
* show_stream - whether or not to show stream contents. default is True.
the stream must be seekable.
* show_context - whether or not to show the context. default is True.
* show_stack - whether or not to show the upper stack frames. default
is True.
* stream_lookahead - the number of bytes to dump when show_stack is set.
default is 100.
Example:
Struct("foo",
UBInt8("a"),
Probe("between a and b"),
UBInt8("b"),
)
"""
__slots__ = [
"printname", "show_stream", "show_context", "show_stack",
"stream_lookahead"
]
counter = 0
def __init__(self, name = None, show_stream = True,
show_context = True, show_stack = True,
stream_lookahead = 100):
Construct.__init__(self, None)
if name is None:
Probe.counter += 1
name = "<unnamed %d>" % (Probe.counter,)
self.printname = name
self.show_stream = show_stream
self.show_context = show_context
self.show_stack = show_stack
self.stream_lookahead = stream_lookahead
def __repr__(self):
return "%s(%r)" % (self.__class__.__name__, self.printname)
def _parse(self, stream, context):
self.printout(stream, context)
def _build(self, obj, stream, context):
self.printout(stream, context)
def _sizeof(self, context):
return 0
def printout(self, stream, context):
obj = Container()
if self.show_stream:
obj.stream_position = stream.tell()
follows = stream.read(self.stream_lookahead)
if not follows:
obj.following_stream_data = "EOF reached"
else:
stream.seek(-len(follows), 1)
obj.following_stream_data = HexString(follows)
print
if self.show_context:
obj.context = context
if self.show_stack:
obj.stack = ListContainer()
frames = [s[0] for s in inspect.stack()][1:-1]
frames.reverse()
for f in frames:
a = AttrDict()
a.__update__(f.f_locals)
obj.stack.append(a)
print "=" * 80
print "Probe", self.printname
print obj
print "=" * 80
class Debugger(Subconstruct):
"""
A pdb-based debugger. When an exception occurs in the subcon, a debugger
will appear and allow you to debug the error (and even fix on-the-fly).
Parameters:
* subcon - the subcon to debug
Example:
Debugger(
Enum(UBInt8("foo"),
a = 1,
b = 2,
c = 3
)
)
"""
__slots__ = ["retval"]
def _parse(self, stream, context):
try:
return self.subcon._parse(stream, context)
except Exception:
self.retval = NotImplemented
self.handle_exc("(you can set the value of 'self.retval', "
"which will be returned)")
if self.retval is NotImplemented:
raise
else:
return self.retval
def _build(self, obj, stream, context):
try:
self.subcon._build(obj, stream, context)
except Exception:
self.handle_exc()
def handle_exc(self, msg = None):
print "=" * 80
print "Debugging exception of %s:" % (self.subcon,)
print "".join(traceback.format_exception(*sys.exc_info())[1:])
if msg:
print msg
pdb.post_mortem(sys.exc_info()[2])
print "=" * 80

10
Melodia/resources/audiotools/construct/lib/__init__.py Normal file
View File

@ -0,0 +1,10 @@
from binary import int_to_bin, bin_to_int, swap_bytes, encode_bin, decode_bin
from bitstream import BitStreamReader, BitStreamWriter
from container import (Container, AttrDict, FlagsContainer,
ListContainer, LazyContainer)
from hex import HexString, hexdump
from utils import Packer, StringIO
from path import drill

61
Melodia/resources/audiotools/construct/lib/binary.py Normal file
View File

@ -0,0 +1,61 @@
def int_to_bin(number, width = 32):
if number < 0:
number += 1 << width
i = width - 1
bits = ["\x00"] * width
while number and i >= 0:
bits[i] = "\x00\x01"[number & 1]
number >>= 1
i -= 1
return "".join(bits)
_bit_values = {"\x00" : 0, "\x01" : 1, "0" : 0, "1" : 1}
def bin_to_int(bits, signed = False):
number = 0
bias = 0
if signed and _bit_values[bits[0]] == 1:
bits = bits[1:]
bias = 1 << len(bits)
for b in bits:
number <<= 1
number |= _bit_values[b]
return number - bias
def swap_bytes(bits, bytesize = 8):
i = 0
l = len(bits)
output = [""] * ((l // bytesize) + 1)
j = len(output) - 1
while i < l:
output[j] = bits[i : i + bytesize]
i += bytesize
j -= 1
return "".join(output)
_char_to_bin = {}
_bin_to_char = {}
for i in range(256):
ch = chr(i)
bin = int_to_bin(i, 8)
_char_to_bin[ch] = bin
_bin_to_char[bin] = ch
_bin_to_char[bin] = ch
def encode_bin(data):
return "".join(_char_to_bin[ch] for ch in data)
def decode_bin(data):
assert len(data) & 7 == 0, "data length must be a multiple of 8"
i = 0
j = 0
l = len(data) // 8
chars = [""] * l
while j < l:
chars[j] = _bin_to_char[data[i:i+8]]
i += 8
j += 1
return "".join(chars)

80
Melodia/resources/audiotools/construct/lib/bitstream.py Normal file
View File

@ -0,0 +1,80 @@
from binary import encode_bin, decode_bin
class BitStreamReader(object):
__slots__ = ["substream", "buffer", "total_size"]
def __init__(self, substream):
self.substream = substream
self.total_size = 0
self.buffer = ""
def close(self):
if self.total_size % 8 != 0:
raise ValueError("total size of read data must be a multiple of 8",
self.total_size)
def tell(self):
return self.substream.tell()
def seek(self, pos, whence = 0):
self.buffer = ""
self.total_size = 0
self.substream.seek(pos, whence)
def read(self, count):
assert count >= 0
l = len(self.buffer)
if count == 0:
data = ""
elif count <= l:
data = self.buffer[:count]
self.buffer = self.buffer[count:]
else:
data = self.buffer
count -= l
bytes = count // 8
if count & 7:
bytes += 1
buf = encode_bin(self.substream.read(bytes))
data += buf[:count]
self.buffer = buf[count:]
self.total_size += len(data)
return data
class BitStreamWriter(object):
__slots__ = ["substream", "buffer", "pos"]
def __init__(self, substream):
self.substream = substream
self.buffer = []
self.pos = 0
def close(self):
self.flush()
def flush(self):
bytes = decode_bin("".join(self.buffer))
self.substream.write(bytes)
self.buffer = []
self.pos = 0
def tell(self):
return self.substream.tell() + self.pos // 8
def seek(self, pos, whence = 0):
self.flush()
self.substream.seek(pos, whence)
def write(self, data):
if not data:
return
if type(data) is not str:
raise TypeError("data must be a string, not %r" % (type(data),))
self.buffer.append(data)

275
Melodia/resources/audiotools/construct/lib/container.py Normal file
View File

@ -0,0 +1,275 @@
def recursion_lock(retval, lock_name = "__recursion_lock__"):
def decorator(func):
def wrapper(self, *args, **kw):
if getattr(self, lock_name, False):
return retval
setattr(self, lock_name, True)
try:
return func(self, *args, **kw)
finally:
setattr(self, lock_name, False)
wrapper.__name__ = func.__name__
return wrapper
return decorator
class Container(object):
"""
A generic container of attributes
"""
__slots__ = ["__dict__", "__attrs__"]
def __init__(self, **kw):
self.__dict__.update(kw)
attrs = []
attrs.extend(kw.keys())
object.__setattr__(self, "__attrs__", attrs)
def __eq__(self, other):
try:
return self.__dict__ == other.__dict__
except AttributeError:
return False
def __ne__(self, other):
return not (self == other)
def __delattr__(self, name):
object.__delattr__(self, name)
self.__attrs__.remove(name)
def __setattr__(self, name, value):
d = self.__dict__
if name not in d and not name.startswith("__"):
self.__attrs__.append(name)
d[name] = value
def __getitem__(self, name):
return self.__dict__[name]
def __delitem__(self, name):
self.__delattr__(name)
def __setitem__(self, name, value):
self.__setattr__(name, value)
def __update__(self, obj):
for name in obj.__attrs__:
self[name] = obj[name]
def __copy__(self):
new = self.__class__()
new.__attrs__ = self.__attrs__[:]
new.__dict__ = self.__dict__.copy()
return new
def __iter__(self):
for name in self.__attrs__:
yield name, self.__dict__[name]
@recursion_lock("<...>")
def __repr__(self):
attrs = sorted("%s = %s" % (k, repr(v))
for k, v in self.__dict__.iteritems()
if not k.startswith("_"))
return "%s(%s)" % (self.__class__.__name__, ", ".join(attrs))
def __str__(self):
return self.__pretty_str__()
@recursion_lock("<...>")
def __pretty_str__(self, nesting = 1, indentation = " "):
attrs = []
ind = indentation * nesting
for k, v in self:
if not k.startswith("_"):
text = [ind, k, " = "]
if hasattr(v, "__pretty_str__"):
text.append(v.__pretty_str__(nesting + 1, indentation))
else:
text.append(repr(v))
attrs.append("".join(text))
if not attrs:
return "%s()" % (self.__class__.__name__,)
attrs.insert(0, self.__class__.__name__ + ":")
return "\n".join(attrs)
def __introspect__(self):
for k in self.__attrs__:
v = self.__dict__[k]
if not k.startswith("_"):
yield "kv", (k, v)
class FlagsContainer(Container):
"""
A container providing pretty-printing for flags. Only set flags are
displayed.
"""
def __inspect__(self):
for k in self.__attrs__:
v = self.__dict__[k]
if not k.startswith("_") and v:
yield "kv", (k, v)
def __pretty_str__(self, nesting = 1, indentation = " "):
attrs = []
ind = indentation * nesting
for k in self.__attrs__:
v = self.__dict__[k]
if not k.startswith("_") and v:
attrs.append(ind + k)
if not attrs:
return "%s()" % (self.__class__.__name__,)
attrs.insert(0, self.__class__.__name__+ ":")
return "\n".join(attrs)
class ListContainer(list):
"""
A container for lists
"""
__slots__ = ["__recursion_lock__"]
def __str__(self):
return self.__pretty_str__()
@recursion_lock("[...]")
def __pretty_str__(self, nesting = 1, indentation = " "):
if not self:
return "[]"
ind = indentation * nesting
lines = ["["]
for elem in self:
lines.append("\n")
lines.append(ind)
if hasattr(elem, "__pretty_str__"):
lines.append(elem.__pretty_str__(nesting + 1, indentation))
else:
lines.append(repr(elem))
lines.append("\n")
lines.append(indentation * (nesting - 1))
lines.append("]")
return "".join(lines)
class AttrDict(object):
"""
A dictionary that can be accessed both using indexing and attributes,
i.e.,
x = AttrDict()
x.foo = 5
print x["foo"]
"""
__slots__ = ["__dict__"]
def __init__(self, **kw):
self.__dict__ = kw
def __contains__(self, key):
return key in self.__dict__
def __nonzero__(self):
return bool(self.__dict__)
def __repr__(self):
return repr(self.__dict__)
def __str__(self):
return self.__pretty_str__()
def __pretty_str__(self, nesting = 1, indentation = " "):
if not self:
return "{}"
text = ["{\n"]
ind = nesting * indentation
for k in sorted(self.__dict__.keys()):
v = self.__dict__[k]
text.append(ind)
text.append(repr(k))
text.append(" : ")
if hasattr(v, "__pretty_str__"):
try:
text.append(v.__pretty_str__(nesting+1, indentation))
except Exception:
text.append(repr(v))
else:
text.append(repr(v))
text.append("\n")
text.append((nesting-1) * indentation)
text.append("}")
return "".join(text)
def __delitem__(self, key):
del self.__dict__[key]
def __getitem__(self, key):
return self.__dict__[key]
def __setitem__(self, key, value):
self.__dict__[key] = value
def __copy__(self):
new = self.__class__()
new.__dict__ = self.__dict__.copy()
return new
def __update__(self, other):
if isinstance(other, dict):
self.__dict__.update(other)
else:
self.__dict__.update(other.__dict__)
class LazyContainer(object):
__slots__ = ["subcon", "stream", "pos", "context", "_value"]
def __init__(self, subcon, stream, pos, context):
self.subcon = subcon
self.stream = stream
self.pos = pos
self.context = context
self._value = NotImplemented
def __eq__(self, other):
try:
return self._value == other._value
except AttributeError:
return False
def __ne__(self, other):
return not (self == other)
def __str__(self):
return self.__pretty_str__()
def __pretty_str__(self, nesting = 1, indentation = " "):
if self._value is NotImplemented:
text = "<unread>"
elif hasattr(self._value, "__pretty_str__"):
text = self._value.__pretty_str__(nesting, indentation)
else:
text = repr(self._value)
return "%s: %s" % (self.__class__.__name__, text)
def read(self):
self.stream.seek(self.pos)
return self.subcon._parse(self.stream, self.context)
def dispose(self):
self.subcon = None
self.stream = None
self.context = None
self.pos = None
def _get_value(self):
if self._value is NotImplemented:
self._value = self.read()
return self._value
value = property(_get_value)
has_value = property(lambda self: self._value is not NotImplemented)

36
Melodia/resources/audiotools/construct/lib/hex.py Normal file
View File

@ -0,0 +1,36 @@
_printable = dict((chr(i), ".") for i in range(256))
_printable.update((chr(i), chr(i)) for i in range(32, 128))
def hexdump(data, linesize = 16):
prettylines = []
if len(data) < 65536:
fmt = "%%04X %%-%ds %%s"
else:
fmt = "%%08X %%-%ds %%s"
fmt = fmt % (3 * linesize - 1,)
for i in xrange(0, len(data), linesize):
line = data[i : i + linesize]
hextext = " ".join(b.encode("hex") for b in line)
rawtext = "".join(_printable[b] for b in line)
prettylines.append(fmt % (i, hextext, rawtext))
return prettylines
class HexString(str):
"""
represents a string that will be hex-dumped (only via __pretty_str__).
this class derives of str, and behaves just like a normal string in all
other contexts.
"""
def __init__(self, data, linesize = 16):
str.__init__(self, data)
self.linesize = linesize
def __new__(cls, data, *args, **kwargs):
return str.__new__(cls, data)
def __pretty_str__(self, nesting = 1, indentation = " "):
if not self:
return "''"
sep = "\n" + indentation * nesting
return sep + sep.join(hexdump(self))

151
Melodia/resources/audiotools/construct/lib/path.py Normal file
View File

@ -0,0 +1,151 @@
from container import Container
def drill(obj, root = "", levels = -1):
if levels == 0:
yield root, obj
return
levels -= 1
if isinstance(obj, Container):
for k, v in obj:
r = "%s.%s" % (root, k)
if levels:
for r2, v2 in drill(v, r, levels):
yield r2, v2
else:
yield r, v
elif isinstance(obj, list):
for i, item in enumerate(obj):
r = "%s[%d]" % (root, i)
if levels:
for r2, v2 in drill(item, r, levels):
yield r2, v2
else:
yield r, item
else:
yield root, obj
if __name__ == "__main__":
from construct import *
c = Struct("foo",
Byte("a"),
Struct("b",
Byte("c"),
UBInt16("d"),
),
Byte("e"),
Array(4,
Struct("f",
Byte("x"),
Byte("y"),
),
),
Byte("g"),
)
o = c.parse("acddexyxyxyxyg")
for lvl in range(4):
for path, value in drill(o, levels = lvl):
print path, value
print "---"
output = """
Container:
a = 97
b = Container:
c = 99
d = 25700
e = 101
f = [
Container:
x = 120
y = 121
Container:
x = 120
y = 121
Container:
x = 120
y = 121
Container:
x = 120
y = 121
]
g = 103
---
.a 97
.b Container:
c = 99
d = 25700
.e 101
.f [
Container:
x = 120
y = 121
Container:
x = 120
y = 121
Container:
x = 120
y = 121
Container:
x = 120
y = 121
]
.g 103
---
.a 97
.b.c 99
.b.d 25700
.e 101
.f[0] Container:
x = 120
y = 121
.f[1] Container:
x = 120
y = 121
.f[2] Container:
x = 120
y = 121
.f[3] Container:
x = 120
y = 121
.g 103
---
.a 97
.b.c 99
.b.d 25700
.e 101
.f[0].x 120
.f[0].y 121
.f[1].x 120
.f[1].y 121
.f[2].x 120
.f[2].y 121
.f[3].x 120
.f[3].y 121
.g 103
---
"""

22
Melodia/resources/audiotools/construct/lib/utils.py Normal file
View File

@ -0,0 +1,22 @@
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
try:
from struct import Struct as Packer
except ImportError:
from struct import pack, unpack, calcsize
class Packer(object):
__slots__ = ["format", "size"]
def __init__(self, format):
self.format = format
self.size = calcsize(format)
def pack(self, *args):
return pack(self.format, *args)
def unpack(self, data):
return unpack(self.format, data)

628
Melodia/resources/audiotools/construct/macros.py Normal file
View File

@ -0,0 +1,628 @@
from lib import BitStreamReader, BitStreamWriter, encode_bin, decode_bin
from core import *
from adapters import *
#===============================================================================
# fields
#===============================================================================
def Field(name, length):
"""a field
* name - the name of the field
* length - the length of the field. the length can be either an integer
(StaticField), or a function that takes the context as an argument and
returns the length (MetaField)
"""
if callable(length):
return MetaField(name, length)
else:
return StaticField(name, length)
def BitField(name, length, swapped = False, signed = False, bytesize = 8):
"""a bit field; must be enclosed in a BitStruct
* name - the name of the field
* length - the length of the field in bits. the length can be either
an integer, or a function that takes the context as an argument and
returns the length
* swapped - whether the value is byte-swapped (little endian). the
default is False.
* signed - whether the value of the bitfield is a signed integer. the
default is False.
* bytesize - the number of bits in a byte (used for byte-swapping). the
default is 8.
"""
return BitIntegerAdapter(Field(name, length),
length,
swapped = swapped,
signed = signed,
bytesize = bytesize
)
def Padding(length, pattern = "\x00", strict = False):
r"""a padding field (value is discarded)
* length - the length of the field. the length can be either an integer,
or a function that takes the context as an argument and returns the
length
* pattern - the padding pattern (character) to use. default is "\x00"
* strict - whether or not to raise an exception is the actual padding
pattern mismatches the desired pattern. default is False.
"""
return PaddingAdapter(Field(None, length),
pattern = pattern,
strict = strict,
)
def Flag(name, truth = 1, falsehood = 0, default = False):
"""a flag field (True or False)
* name - the name of the field
* truth - the numeric value of truth. the default is 1.
* falsehood - the numeric value of falsehood. the default is 0.
* default - the default value to assume, when the value is neither
`truth` nor `falsehood`. the default is False.
"""
return SymmetricMapping(Field(name, 1),
{True : chr(truth), False : chr(falsehood)},
default = default,
)
#===============================================================================
# field shortcuts
#===============================================================================
def Bit(name):
"""a 1-bit BitField; must be enclosed in a BitStruct"""
return BitField(name, 1)
def Nibble(name):
"""a 4-bit BitField; must be enclosed in a BitStruct"""
return BitField(name, 4)
def Octet(name):
"""an 8-bit BitField; must be enclosed in a BitStruct"""
return BitField(name, 8)
def UBInt8(name):
"""unsigned, big endian 8-bit integer"""
return FormatField(name, ">", "B")
def UBInt16(name):
"""unsigned, big endian 16-bit integer"""
return FormatField(name, ">", "H")
def UBInt32(name):
"""unsigned, big endian 32-bit integer"""
return FormatField(name, ">", "L")
def UBInt64(name):
"""unsigned, big endian 64-bit integer"""
return FormatField(name, ">", "Q")
def SBInt8(name):
"""signed, big endian 8-bit integer"""
return FormatField(name, ">", "b")
def SBInt16(name):
"""signed, big endian 16-bit integer"""
return FormatField(name, ">", "h")
def SBInt32(name):
"""signed, big endian 32-bit integer"""
return FormatField(name, ">", "l")
def SBInt64(name):
"""signed, big endian 64-bit integer"""
return FormatField(name, ">", "q")
def ULInt8(name):
"""unsigned, little endian 8-bit integer"""
return FormatField(name, "<", "B")
def ULInt16(name):
"""unsigned, little endian 16-bit integer"""
return FormatField(name, "<", "H")
def ULInt32(name):
"""unsigned, little endian 32-bit integer"""
return FormatField(name, "<", "L")
def ULInt64(name):
"""unsigned, little endian 64-bit integer"""
return FormatField(name, "<", "Q")
def SLInt8(name):
"""signed, little endian 8-bit integer"""
return FormatField(name, "<", "b")
def SLInt16(name):
"""signed, little endian 16-bit integer"""
return FormatField(name, "<", "h")
def SLInt32(name):
"""signed, little endian 32-bit integer"""
return FormatField(name, "<", "l")
def SLInt64(name):
"""signed, little endian 64-bit integer"""
return FormatField(name, "<", "q")
def UNInt8(name):
"""unsigned, native endianity 8-bit integer"""
return FormatField(name, "=", "B")
def UNInt16(name):
"""unsigned, native endianity 16-bit integer"""
return FormatField(name, "=", "H")
def UNInt32(name):
"""unsigned, native endianity 32-bit integer"""
return FormatField(name, "=", "L")
def UNInt64(name):
"""unsigned, native endianity 64-bit integer"""
return FormatField(name, "=", "Q")
def SNInt8(name):
"""signed, native endianity 8-bit integer"""
return FormatField(name, "=", "b")
def SNInt16(name):
"""signed, native endianity 16-bit integer"""
return FormatField(name, "=", "h")
def SNInt32(name):
"""signed, native endianity 32-bit integer"""
return FormatField(name, "=", "l")
def SNInt64(name):
"""signed, native endianity 64-bit integer"""
return FormatField(name, "=", "q")
def BFloat32(name):
"""big endian, 32-bit IEEE floating point number"""
return FormatField(name, ">", "f")
def LFloat32(name):
"""little endian, 32-bit IEEE floating point number"""
return FormatField(name, "<", "f")
def NFloat32(name):
"""native endianity, 32-bit IEEE floating point number"""
return FormatField(name, "=", "f")
def BFloat64(name):
"""big endian, 64-bit IEEE floating point number"""
return FormatField(name, ">", "d")
def LFloat64(name):
"""little endian, 64-bit IEEE floating point number"""
return FormatField(name, "<", "d")
def NFloat64(name):
"""native endianity, 64-bit IEEE floating point number"""
return FormatField(name, "=", "d")
#===============================================================================
# arrays
#===============================================================================
def Array(count, subcon):
"""
Repeats the given unit a fixed number of times.
:param int count: number of times to repeat
:param ``Construct`` subcon: construct to repeat
>>> c = StrictRepeater(4, UBInt8("foo"))
>>> c
<Repeater('foo')>
>>> c.parse("\\x01\\x02\\x03\\x04")
[1, 2, 3, 4]
>>> c.parse("\\x01\\x02\\x03\\x04\\x05\\x06")
[1, 2, 3, 4]
>>> c.build([5,6,7,8])
'\\x05\\x06\\x07\\x08'
>>> c.build([5,6,7,8,9])
Traceback (most recent call last):
...
construct.core.RepeaterError: expected 4..4, found 5
"""
if callable(count):
con = MetaArray(count, subcon)
else:
con = MetaArray(lambda ctx: count, subcon)
con._clear_flag(con.FLAG_DYNAMIC)
return con
def PrefixedArray(subcon, length_field = UBInt8("length")):
"""an array prefixed by a length field.
* subcon - the subcon to be repeated
* length_field - a construct returning an integer
"""
return LengthValueAdapter(
Sequence(subcon.name,
length_field,
Array(lambda ctx: ctx[length_field.name], subcon),
nested = False
)
)
def OpenRange(mincount, subcon):
from sys import maxint
return Range(mincount, maxint, subcon)
def GreedyRange(subcon):
"""
Repeats the given unit one or more times.
:param ``Construct`` subcon: construct to repeat
>>> from construct import GreedyRepeater, UBInt8
>>> c = GreedyRepeater(UBInt8("foo"))
>>> c.parse("\\x01")
[1]
>>> c.parse("\\x01\\x02\\x03")
[1, 2, 3]
>>> c.parse("\\x01\\x02\\x03\\x04\\x05\\x06")
[1, 2, 3, 4, 5, 6]
>>> c.parse("")
Traceback (most recent call last):
...
construct.core.RepeaterError: expected 1..2147483647, found 0
>>> c.build([1,2])
'\\x01\\x02'
>>> c.build([])
Traceback (most recent call last):
...
construct.core.RepeaterError: expected 1..2147483647, found 0
"""
return OpenRange(1, subcon)
def OptionalGreedyRange(subcon):
"""
Repeats the given unit zero or more times. This repeater can't
fail, as it accepts lists of any length.
:param ``Construct`` subcon: construct to repeat
>>> from construct import OptionalGreedyRepeater, UBInt8
>>> c = OptionalGreedyRepeater(UBInt8("foo"))
>>> c.parse("")
[]
>>> c.parse("\\x01\\x02")
[1, 2]
>>> c.build([])
''
>>> c.build([1,2])
'\\x01\\x02'
"""
return OpenRange(0, subcon)
#===============================================================================
# subconstructs
#===============================================================================
def Optional(subcon):
"""an optional construct. if parsing fails, returns None.
* subcon - the subcon to optionally parse or build
"""
return Select(subcon.name, subcon, Pass)
def Bitwise(subcon):
"""converts the stream to bits, and passes the bitstream to subcon
* subcon - a bitwise construct (usually BitField)
"""
# subcons larger than MAX_BUFFER will be wrapped by Restream instead
# of Buffered. implementation details, don't stick your nose in :)
MAX_BUFFER = 1024 * 8
def resizer(length):
if length & 7:
raise SizeofError("size must be a multiple of 8", length)
return length >> 3
if not subcon._is_flag(subcon.FLAG_DYNAMIC) and subcon.sizeof() < MAX_BUFFER:
con = Buffered(subcon,
encoder = decode_bin,
decoder = encode_bin,
resizer = resizer
)
else:
con = Restream(subcon,
stream_reader = BitStreamReader,
stream_writer = BitStreamWriter,
resizer = resizer)
return con
def Aligned(subcon, modulus = 4, pattern = "\x00"):
r"""aligns subcon to modulus boundary using padding pattern
* subcon - the subcon to align
* modulus - the modulus boundary (default is 4)
* pattern - the padding pattern (default is \x00)
"""
if modulus < 2:
raise ValueError("modulus must be >= 2", modulus)
if modulus in (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024):
def padlength(ctx):
m1 = modulus - 1
return (modulus - (subcon._sizeof(ctx) & m1)) & m1
else:
def padlength(ctx):
return (modulus - (subcon._sizeof(ctx) % modulus)) % modulus
return SeqOfOne(subcon.name,
subcon,
# ??????
# ??????
# ??????
# ??????
Padding(padlength, pattern = pattern),
nested = False,
)
def SeqOfOne(name, *args, **kw):
"""a sequence of one element. only the first element is meaningful, the
rest are discarded
* name - the name of the sequence
* args - subconstructs
* kw - any keyword arguments to Sequence
"""
return IndexingAdapter(Sequence(name, *args, **kw), index = 0)
def Embedded(subcon):
"""embeds a struct into the enclosing struct.
* subcon - the struct to embed
"""
return Reconfig(subcon.name, subcon, subcon.FLAG_EMBED)
def Rename(newname, subcon):
"""renames an existing construct
* newname - the new name
* subcon - the subcon to rename
"""
return Reconfig(newname, subcon)
def Alias(newname, oldname):
"""creates an alias for an existing element in a struct
* newname - the new name
* oldname - the name of an existing element
"""
return Value(newname, lambda ctx: ctx[oldname])
#===============================================================================
# mapping
#===============================================================================
def SymmetricMapping(subcon, mapping, default = NotImplemented):
"""defines a symmetrical mapping: a->b, b->a.
* subcon - the subcon to map
* mapping - the encoding mapping (a dict); the decoding mapping is
achieved by reversing this mapping
* default - the default value to use when no mapping is found. if no
default value is given, and exception is raised. setting to Pass would
return the value "as is" (unmapped)
"""
reversed_mapping = dict((v, k) for k, v in mapping.iteritems())
return MappingAdapter(subcon,
encoding = mapping,
decoding = reversed_mapping,
encdefault = default,
decdefault = default,
)
def Enum(subcon, **kw):
"""a set of named values mapping.
* subcon - the subcon to map
* kw - keyword arguments which serve as the encoding mapping
* _default_ - an optional, keyword-only argument that specifies the
default value to use when the mapping is undefined. if not given,
and exception is raised when the mapping is undefined. use `Pass` to
pass the unmapped value as-is
"""
return SymmetricMapping(subcon, kw, kw.pop("_default_", NotImplemented))
def FlagsEnum(subcon, **kw):
"""a set of flag values mapping.
* subcon - the subcon to map
* kw - keyword arguments which serve as the encoding mapping
"""
return FlagsAdapter(subcon, kw)
#===============================================================================
# structs
#===============================================================================
def AlignedStruct(name, *subcons, **kw):
"""a struct of aligned fields
* name - the name of the struct
* subcons - the subcons that make up this structure
* kw - keyword arguments to pass to Aligned: 'modulus' and 'pattern'
"""
return Struct(name, *(Aligned(sc, **kw) for sc in subcons))
def BitStruct(name, *subcons):
"""a struct of bitwise fields
* name - the name of the struct
* subcons - the subcons that make up this structure
"""
return Bitwise(Struct(name, *subcons))
def EmbeddedBitStruct(*subcons):
"""an embedded BitStruct. no name is necessary.
* subcons - the subcons that make up this structure
"""
return Bitwise(Embedded(Struct(None, *subcons)))
#===============================================================================
# strings
#===============================================================================
def String(name, length, encoding=None, padchar=None, paddir="right",
trimdir="right"):
"""
A configurable, fixed-length string field.
The padding character must be specified for padding and trimming to work.
:param str name: name
:param int length: length, in bytes
:param str encoding: encoding (e.g. "utf8") or None for no encoding
:param str padchar: optional character to pad out strings
:param str paddir: direction to pad out strings; one of "right", "left",
or "both"
:param str trim: direction to trim strings; one of "right", "left"
>>> from construct import String
>>> String("foo", 5).parse("hello")
'hello'
>>>
>>> String("foo", 12, encoding = "utf8").parse("hello joh\\xd4\\x83n")
u'hello joh\\u0503n'
>>>
>>> foo = String("foo", 10, padchar = "X", paddir = "right")
>>> foo.parse("helloXXXXX")
'hello'
>>> foo.build("hello")
'helloXXXXX'
"""
con = StringAdapter(Field(name, length), encoding=encoding)
if padchar is not None:
con = PaddedStringAdapter(con, padchar=padchar, paddir=paddir,
trimdir=trimdir)
return con
def PascalString(name, length_field=UBInt8("length"), encoding=None):
"""
A length-prefixed string.
``PascalString`` is named after the string types of Pascal, which are
length-prefixed. Lisp strings also follow this convention.
The length field will appear in the same ``Container`` as the
``PascalString``, with the given name.
:param str name: name
:param ``Construct`` length_field: a field which will store the length of
the string
:param str encoding: encoding (e.g. "utf8") or None for no encoding
>>> foo = PascalString("foo")
>>> foo.parse("\\x05hello")
'hello'
>>> foo.build("hello world")
'\\x0bhello world'
>>>
>>> foo = PascalString("foo", length_field = UBInt16("length"))
>>> foo.parse("\\x00\\x05hello")
'hello'
>>> foo.build("hello")
'\\x00\\x05hello'
"""
return StringAdapter(
LengthValueAdapter(
Sequence(name,
length_field,
Field("data", lambda ctx: ctx[length_field.name]),
)
),
encoding=encoding,
)
def CString(name, terminators="\x00", encoding=None,
char_field=Field(None, 1)):
"""
A string ending in a terminator.
``CString`` is similar to the strings of C, C++, and other related
programming languages.
By default, the terminator is the NULL byte (0x00).
:param str name: name
:param iterable terminators: sequence of valid terminators, in order of
preference
:param str encoding: encoding (e.g. "utf8") or None for no encoding
:param ``Construct`` char_field: construct representing a single character
>>> foo = CString("foo")
>>>
>>> foo.parse("hello\\x00")
'hello'
>>> foo.build("hello")
'hello\\x00'
>>>
>>> foo = CString("foo", terminators = "XYZ")
>>>
>>> foo.parse("helloX")
'hello'
>>> foo.parse("helloY")
'hello'
>>> foo.parse("helloZ")
'hello'
>>> foo.build("hello")
'helloX'
"""
return Rename(name,
CStringAdapter(
RepeatUntil(lambda obj, ctx: obj in terminators,
char_field,
),
terminators=terminators,
encoding=encoding,
)
)
#===============================================================================
# conditional
#===============================================================================
def IfThenElse(name, predicate, then_subcon, else_subcon):
"""an if-then-else conditional construct: if the predicate indicates True,
`then_subcon` will be used; otherwise `else_subcon`
* name - the name of the construct
* predicate - a function taking the context as an argument and returning
True or False
* then_subcon - the subcon that will be used if the predicate returns True
* else_subcon - the subcon that will be used if the predicate returns False
"""
return Switch(name, lambda ctx: bool(predicate(ctx)),
{
True : then_subcon,
False : else_subcon,
}
)
def If(predicate, subcon, elsevalue = None):
"""an if-then conditional construct: if the predicate indicates True,
subcon will be used; otherwise, `elsevalue` will be returned instead.
* predicate - a function taking the context as an argument and returning
True or False
* subcon - the subcon that will be used if the predicate returns True
* elsevalue - the value that will be used should the predicate return False.
by default this value is None.
"""
return IfThenElse(subcon.name,
predicate,
subcon,
Value("elsevalue", lambda ctx: elsevalue)
)
#===============================================================================
# misc
#===============================================================================
def OnDemandPointer(offsetfunc, subcon, force_build = True):
"""an on-demand pointer.
* offsetfunc - a function taking the context as an argument and returning
the absolute stream position
* subcon - the subcon that will be parsed from the `offsetfunc()` stream
position on demand
* force_build - see OnDemand. by default True.
"""
return OnDemand(Pointer(offsetfunc, subcon),
advance_stream = False,
force_build = force_build
)
def Magic(data):
return ConstAdapter(Field(None, len(data)), data)

418
Melodia/resources/audiotools/cue.py Normal file
View File

@ -0,0 +1,418 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2008-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
"""The cuesheet handling module."""
import re
from audiotools import SheetException, parse_timestamp, build_timestamp
import gettext
gettext.install("audiotools", unicode=True)
###################
#Cue Sheet Parsing
###################
#This method of cuesheet reading involves a tokenizer and parser,
#analagous to lexx/yacc.
#It might be easier to use a line-by-line ad-hoc method for parsing,
#but this brute-force approach should be a bit more thorough.
SPACE = 0x0
TAG = 0x1
NUMBER = 0x2
EOL = 0x4
STRING = 0x8
ISRC = 0x10
TIMESTAMP = 0x20
class CueException(SheetException):
"""Raised by cuesheet parsing errors."""
pass
def tokens(cuedata):
"""Yields (text, token, line) tuples from cuedata stream.
text is a plain string.
token is an integer such as TAG or NUMBER.
line is a line number integer."""
full_length = len(cuedata)
cuedata = cuedata.lstrip('efbbbf'.decode('hex'))
line_number = 1
#This isn't completely accurate since the whitespace requirements
#between tokens aren't enforced.
TOKENS = [(re.compile("^(%s)" % (s)), element) for (s, element) in
[(r'[A-Z]{2}[A-Za-z0-9]{3}[0-9]{7}', ISRC),
(r'[0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}', TIMESTAMP),
(r'[0-9]+', NUMBER),
(r'[\r\n]+', EOL),
(r'".+?"', STRING),
(r'\S+', STRING),
(r'[ ]+', SPACE)]]
TAGMATCH = re.compile(r'^[A-Z]+$')
while (True):
for (token, element) in TOKENS:
t = token.search(cuedata)
if (t is not None):
cuedata = cuedata[len(t.group()):]
if (element == SPACE):
break
elif (element == NUMBER):
yield (int(t.group()), element, line_number)
elif (element == EOL):
line_number += 1
yield (t.group(), element, line_number)
elif (element == STRING):
if (TAGMATCH.match(t.group())):
yield (t.group(), TAG, line_number)
else:
yield (t.group().strip('"'), element, line_number)
elif (element == TIMESTAMP):
(m, s, f) = map(int, t.group().split(":"))
yield (((m * 60 * 75) + (s * 75) + f),
element, line_number)
else:
yield (t.group(), element, line_number)
break
else:
break
if (len(cuedata) > 0):
raise CueException(_(u"Invalid token at char %d") % \
(full_length - len(cuedata)))
def get_value(tokens, accept, error):
"""Retrieves a specific token from the stream of tokens.
tokens - the token iterator
accept - an "or"ed list of all the tokens we'll accept
error - the string to prepend to the error message
Returns the gotten value which matches one of the accepted tokens
or raises ValueError if the token matches none of them.
"""
(token, element, line_number) = tokens.next()
if ((element & accept) != 0):
return token
else:
raise CueException(_(u"%(error)s at line %(line)d") % \
{"error": error,
"line": line_number})
def parse(tokens):
"""Returns a Cuesheet object from the token iterator stream.
Raises CueException if a parsing error occurs.
"""
def skip_to_eol(tokens):
(token, element, line_number) = tokens.next()
while (element != EOL):
(token, element, line_number) = tokens.next()
cuesheet = Cuesheet()
track = None
try:
while (True):
(token, element, line_number) = tokens.next()
if (element == TAG):
#ignore comment lines
if (token == "REM"):
skip_to_eol(tokens)
#we're moving to a new track
elif (token == 'TRACK'):
if (track is not None):
cuesheet.tracks[track.number] = track
track = Track(get_value(tokens, NUMBER,
_(u"Invalid track number")),
get_value(tokens, TAG | STRING,
_(u"Invalid track type")))
get_value(tokens, EOL, "Excess data")
#if we haven't started on track data yet,
#add attributes to the main cue sheet
elif (track is None):
if (token in ('CATALOG', 'CDTEXTFILE',
'PERFORMER', 'SONGWRITER',
'TITLE')):
cuesheet.attribs[token] = get_value(
tokens,
STRING | TAG | NUMBER | ISRC,
_(u"Missing value"))
get_value(tokens, EOL, _(u"Excess data"))
elif (token == 'FILE'):
filename = get_value(tokens, STRING,
_(u"Missing filename"))
filetype = get_value(tokens, STRING | TAG,
_(u"Missing file type"))
cuesheet.attribs[token] = (filename, filetype)
get_value(tokens, EOL, _(u"Excess data"))
else:
raise CueException(
_(u"Invalid tag %(tag)s at line %(line)d") % \
{"tag": token,
"line": line_number})
#otherwise, we're adding data to the current track
else:
if (token in ('ISRC', 'PERFORMER',
'SONGWRITER', 'TITLE')):
track.attribs[token] = get_value(
tokens,
STRING | TAG | NUMBER | ISRC,
"Missing value")
get_value(tokens, EOL, _(u"Invalid data"))
elif (token == 'FLAGS'):
flags = []
s = get_value(tokens, STRING | TAG | EOL,
_(u"Invalid flag"))
while (('\n' not in s) and ('\r' not in s)):
flags.append(s)
s = get_value(tokens, STRING | TAG | EOL,
_(u"Invalid flag"))
track.attribs[token] = ",".join(flags)
elif (token in ('POSTGAP', 'PREGAP')):
track.attribs[token] = get_value(
tokens, TIMESTAMP,
_(u"Invalid timestamp"))
get_value(tokens, EOL, _(u"Excess data"))
elif (token == 'INDEX'):
index_number = get_value(tokens, NUMBER,
_(u"Invalid index number"))
index_timestamp = get_value(tokens, TIMESTAMP,
_(u"Invalid timestamp"))
track.indexes[index_number] = index_timestamp
get_value(tokens, EOL, _(u"Excess data"))
elif (token in ('FILE',)):
skip_to_eol(tokens)
else:
raise CueException(
_(u"Invalid tag %(tag)s at line %(line)d") % \
{"tag": token,
"line": line_number})
else:
raise CueException(_(u"Missing tag at line %d") % (
line_number))
except StopIteration:
if (track is not None):
cuesheet.tracks[track.number] = track
return cuesheet
def __attrib_str__(attrib):
if (isinstance(attrib, tuple)):
return " ".join([__attrib_str__(a) for a in attrib])
elif (re.match(r'^[A-Z]+$', attrib) is not None):
return attrib
else:
return "\"%s\"" % (attrib)
class Cuesheet:
"""An object representing a cuesheet file."""
def __init__(self):
self.attribs = {}
self.tracks = {}
def __repr__(self):
return "Cuesheet(attribs=%s,tracks=%s)" % \
(repr(self.attribs), repr(self.tracks))
def __str__(self):
return "\r\n".join(["%s %s" % (key, __attrib_str__(value))
for key, value in self.attribs.items()] + \
[str(track) for track in
sorted(self.tracks.values())])
def catalog(self):
"""Returns the cuesheet's CATALOG number as a plain string, or None.
If present, this value is typically a CD's UPC code."""
if ('CATALOG' in self.attribs):
return str(self.attribs['CATALOG'])
else:
return None
def single_file_type(self):
"""Returns True if this cuesheet is formatted for a single file."""
previous = -1
for t in self.indexes():
for index in t:
if (index <= previous):
return False
else:
previous = index
else:
return True
def indexes(self):
"""Yields a set of index lists, one for each track in the file."""
for key in sorted(self.tracks.keys()):
yield tuple(
[self.tracks[key].indexes[k]
for k in sorted(self.tracks[key].indexes.keys())])
def pcm_lengths(self, total_length):
"""Yields a list of PCM lengths for all audio tracks within the file.
total_length is the length of the entire file in PCM frames."""
previous = None
for key in sorted(self.tracks.keys()):
current = self.tracks[key].indexes
if (previous is None):
previous = current
else:
track_length = (current[max(current.keys())] -
previous[max(previous.keys())]) * (44100 / 75)
total_length -= track_length
yield track_length
previous = current
yield total_length
def ISRCs(self):
"""Returns a track_number->ISRC dict of all non-empty tracks."""
return dict([(track.number, track.ISRC()) for track in
self.tracks.values() if track.ISRC() is not None])
@classmethod
def file(cls, sheet, filename):
"""Constructs a new cuesheet string from a compatible object.
sheet must have catalog(), indexes() and ISRCs() methods.
filename is a string to the filename the cuesheet is created for.
Although we don't care whether the filename points to a real file,
other tools sometimes do.
"""
import cStringIO
catalog = sheet.catalog() # a catalog string, or None
indexes = list(sheet.indexes()) # a list of index tuples
ISRCs = sheet.ISRCs() # a track_number->ISRC dict
data = cStringIO.StringIO()
if (catalog is not None):
data.write("CATALOG %s\r\n" % (catalog))
data.write("FILE \"%s\" WAVE\r\n" % (filename))
for (i, current) in enumerate(indexes):
tracknum = i + 1
data.write(" TRACK %2.2d AUDIO\r\n" % (tracknum))
if (tracknum in ISRCs.keys()):
data.write(" ISRC %s\r\n" % (ISRCs[tracknum]))
for (j, index) in enumerate(current):
data.write(" INDEX %2.2d %s\r\n" % (j,
build_timestamp(index)))
return data.getvalue()
class Track:
"""A track inside a Cuesheet object."""
def __init__(self, number, type):
"""number is the track's number on disc, type is a string."""
self.number = number
self.type = type
self.attribs = {}
self.indexes = {}
def __cmp__(self, t):
return cmp(self.number, t.number)
def __repr__(self):
return "Track(%s,%s,attribs=%s,indexes=%s)" % \
(repr(self.number), repr(self.type),
repr(self.attribs), repr(self.indexes))
def __str__(self):
return (" TRACK %2.2d %s\r\n" % (self.number, self.type)) + \
"\r\n".join([" %s %s" % (key, __attrib_str__(value))
for key, value in self.attribs.items()] + \
[" INDEX %2.2d %2.2d:%2.2d:%2.2d" % \
(k, v / 75 / 60, v / 75 % 60, v % 75)
for (k, v) in sorted(self.indexes.items())])
def ISRC(self):
"""Returns the track's ISRC value, or None."""
if ('ISRC' in self.attribs.keys()):
return str(self.attribs['ISRC'])
else:
return None
def read_cuesheet(filename):
"""Returns a Cuesheet from a cuesheet filename on disk.
Raises CueException if some error occurs reading or parsing the file.
"""
try:
f = open(filename, 'r')
except IOError, msg:
raise CueException(unicode(_(u"Unable to read cuesheet")))
try:
sheet = parse(tokens(f.read()))
if (not sheet.single_file_type()):
raise CueException(_(u"Cuesheet not formatted for disc images"))
else:
return sheet
finally:
f.close()

BIN
Melodia/resources/audiotools/decoders.so Executable file
View File

Binary file not shown.

277
Melodia/resources/audiotools/delta.py Normal file
View File

@ -0,0 +1,277 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2008-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
import sys
from itertools import izip
import bz2
import sqlite3
from hashlib import sha1
import base64
import anydbm
import subprocess
import tempfile
import whichdb
from audiotools import BIN, transfer_data
import cStringIO
class UndoDB:
"""A class for performing undo operations on files.
This stores an undo/redo patch for transforming a file
back to its original value, or forward again to its modified form."""
def __init__(self, filename):
"""filename is the location on disk for this undo database."""
self.db = sqlite3.connect(filename)
self.cursor = self.db.cursor()
self.cursor.execute("""CREATE TABLE IF NOT EXISTS patch (
patch_id INTEGER PRIMARY KEY AUTOINCREMENT,
patch_data BLOB NOT NULL
)""")
self.cursor.execute("""CREATE TABLE IF NOT EXISTS source_file (
source_checksum CHAR(40) PRIMARY KEY,
source_size INTEGER NOT NULL,
target_size INTEGER NOT NULL,
patch_id INTEGER,
FOREIGN KEY (patch_id) REFERENCES patch (patch_id) ON DELETE CASCADE
)""")
def close(self):
"""Closes any open database handles."""
self.cursor.close()
self.db.close()
@classmethod
def build_patch(cls, s1, s2):
"""Given two strings, returns a transformation patch.
This function presumes the two strings will be largely
equal and similar in length. It operates by performing an
XOR operation across both and BZ2 compressing the result."""
if (len(s1) < len(s2)):
s1 += (chr(0) * (len(s2) - len(s1)))
elif (len(s2) < len(s1)):
s2 += (chr(0) * (len(s1) - len(s2)))
patch = bz2.compress("".join([chr(ord(x) ^ ord(y)) for (x, y) in
izip(s1, s2)]))
return patch
@classmethod
def apply_patch(cls, s, patch, new_length):
"""Given a string, patch and new length, restores string.
patch is the same BZ2 compressed output from build_patch().
new_length is the size of the string originally,
which must be stored externally from the patch itself."""
if (len(s) > new_length):
s = s[0:new_length]
elif (len(s) < new_length):
s += (chr(0) * (new_length - len(s)))
return "".join([chr(ord(x) ^ ord(y)) for (x, y) in
izip(s, bz2.decompress(patch))])
def __add__(self, file_data1, file_data2):
#file_data1's target is file_data2 and
#file_data2's target is file_data1
self.cursor.execute(
"INSERT INTO patch (patch_id, patch_data) VALUES (?, ?)",
[None,
base64.b64encode(
UndoDB.build_patch(file_data1,
file_data2)).decode('ascii')])
patch_id = self.cursor.lastrowid
try:
self.cursor.execute("""INSERT INTO source_file (
source_checksum, source_size, target_size, patch_id) values (?, ?, ?, ?)""",
[sha1(file_data1).hexdigest().decode('ascii'),
len(file_data1),
len(file_data2),
patch_id])
self.cursor.execute("""INSERT INTO source_file (
source_checksum, source_size, target_size, patch_id) values (?, ?, ?, ?)""",
[sha1(file_data2).hexdigest().decode('ascii'),
len(file_data2),
len(file_data1),
patch_id])
self.db.commit()
except sqlite3.IntegrityError:
self.db.rollback()
def __undo__(self, file_data):
self.cursor.execute("""SELECT target_size, patch_data FROM
source_file, patch WHERE ((source_checksum = ?) AND
(source_size = ?) AND
(source_file.patch_id = patch.patch_id))""",
[sha1(file_data).hexdigest().decode('ascii'),
len(file_data)])
row = self.cursor.fetchone()
if (row is not None):
(target_size, patch) = row
return UndoDB.apply_patch(
file_data,
base64.b64decode(patch.encode('ascii')),
target_size)
else:
return None
def add(self, old_file, new_file):
"""Adds an undo entry for transforming new_file to old_file.
Both are filename strings."""
old_f = open(old_file, 'rb')
new_f = open(new_file, 'rb')
try:
self.__add__(old_f.read(), new_f.read())
finally:
old_f.close()
new_f.close()
def undo(self, new_file):
"""Updates new_file to its original state,
if present in the undo database.
Returns True if undo performed, False if not."""
new_f = open(new_file, 'rb')
try:
old_data = self.__undo__(new_f.read())
finally:
new_f.close()
if (old_data is not None):
old_f = open(new_file, 'wb')
old_f.write(old_data)
old_f.close()
return True
else:
return False
class OldUndoDB:
"""A class for performing legacy undo operations on files.
This implementation is based on xdelta and requires it to be
installed to function.
"""
def __init__(self, filename):
"""filename is the location on disk for this undo database."""
self.db = anydbm.open(filename, 'c')
def close(self):
"""Closes any open database handles."""
self.db.close()
@classmethod
def checksum(cls, filename):
"""Returns the SHA1 checksum of the filename's contents."""
f = open(filename, "rb")
c = sha1("")
try:
transfer_data(f.read, c.update)
return c.hexdigest()
finally:
f.close()
def add(self, old_file, new_file):
"""Adds an undo entry for transforming new_file to old_file.
Both are filename strings."""
#perform xdelta between old and new track to temporary file
delta_f = tempfile.NamedTemporaryFile(suffix=".delta")
try:
if (subprocess.call([BIN["xdelta"],
"delta",
new_file, old_file, delta_f.name]) != 2):
#store the xdelta in our internal db
f = open(delta_f.name, 'rb')
data = cStringIO.StringIO()
transfer_data(f.read, data.write)
f.close()
self.db[OldUndoDB.checksum(new_file)] = data.getvalue()
else:
raise IOError("error performing xdelta operation")
finally:
delta_f.close()
def undo(self, new_file):
"""Updates new_file to its original state,
if present in the undo database."""
undo_checksum = OldUndoDB.checksum(new_file)
if (undo_checksum in self.db.keys()):
#copy the xdelta to a temporary file
xdelta_f = tempfile.NamedTemporaryFile(suffix=".delta")
xdelta_f.write(self.db[undo_checksum])
xdelta_f.flush()
#patch the existing track to a temporary track
old_track = tempfile.NamedTemporaryFile()
try:
if (subprocess.call([BIN["xdelta"],
"patch",
xdelta_f.name,
new_file,
old_track.name]) == 0):
#copy the temporary track over the existing file
f1 = open(old_track.name, 'rb')
f2 = open(new_file, 'wb')
transfer_data(f1.read, f2.write)
f1.close()
f2.close()
return True
else:
raise IOError("error performing xdelta operation")
finally:
old_track.close()
xdelta_f.close()
else:
return False
def open_db(filename):
"""Given a filename string, returns UndoDB or OldUndoDB.
If the file doesn't exist, this uses UndoDB by default.
Otherwise, detect OldUndoDB if xdelta is installed."""
if (BIN.can_execute(BIN["xdelta"])):
db = whichdb.whichdb(filename)
if ((db is not None) and (db != '')):
return OldUndoDB(filename)
else:
return UndoDB(filename)
else:
return UndoDB(filename)

BIN
Melodia/resources/audiotools/encoders.so Executable file
View File

Binary file not shown.

715
Melodia/resources/audiotools/flac.py Normal file
View File

@ -0,0 +1,715 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
import array
import audiotools
import sys,cStringIO
Con = audiotools.Con
class UTF8(Con.Struct):
@classmethod
def __total_utf8_bytes__(cls, header):
total = 0
for b in header:
if b == '\x01':
total += 1
else:
break
return max(1,total)
@classmethod
def __calculate_utf8_value__(cls, ctx):
import operator
return Con.lib.bin_to_int(ctx.header[ctx.header.index('\x00') + 1:] + \
reduce(operator.concat,
[s[2:] for s in ctx['sub_byte']],
''))
def __init__(self, name):
Con.Struct.__init__(
self,name,
Con.Bytes('header',8),
Con.Value('total_bytes',
lambda ctx: self.__total_utf8_bytes__(ctx['header'])),
Con.MetaRepeater(
lambda ctx: self.__total_utf8_bytes__(ctx['header']) - 1,
Con.Bytes('sub_byte',8)),
Con.Value('value',
lambda ctx: self.__calculate_utf8_value__(ctx)))
class Unary(Con.Adapter):
def __init__(self, name):
Con.Adapter.__init__(
self,
Con.RepeatUntil(lambda obj,ctx: obj == 1,
Con.Byte(name)))
def _encode(self, value, context):
if (value > 0):
return ([0] * (value)) + [1]
else:
return [1]
def _decode(self, obj, context):
return len(obj) - 1
class PlusOne(Con.Adapter):
def _encode(self, value, context):
return value - 1
def _decode(self, obj, context):
return obj + 1
class FlacStreamException(Exception): pass
class FlacReader:
FRAME_HEADER = Con.Struct('frame_header',
Con.Bits('sync',14),
Con.Bits('reserved',2),
Con.Bits('block_size',4),
Con.Bits('sample_rate',4),
Con.Bits('channel_assignment',4),
Con.Bits('bits_per_sample',3),
Con.Padding(1),
Con.IfThenElse(
'total_channels',
lambda ctx1: ctx1['channel_assignment'] <= 7,
Con.Value('c',lambda ctx2: ctx2['channel_assignment'] + 1),
Con.Value('c',lambda ctx3: 2)),
UTF8('frame_number'),
Con.IfThenElse(
'extended_block_size',
lambda ctx1: ctx1['block_size'] == 6,
Con.Bits('b',8),
Con.If(lambda ctx2: ctx2['block_size'] == 7,
Con.Bits('b',16))),
Con.IfThenElse(
'extended_sample_rate',
lambda ctx1: ctx1['sample_rate'] == 12,
Con.Bits('s',8),
Con.If(lambda ctx2: ctx2['sample_rate'] in (13,14),
Con.Bits('s',16))),
Con.Bits('crc8',8))
UNARY = Con.Struct('unary',
Con.RepeatUntil(
lambda obj,ctx: obj == '\x01',
Con.Field('bytes',1)),
Con.Value('value',
lambda ctx: len(ctx['bytes']) - 1)
)
SUBFRAME_HEADER = Con.Struct('subframe_header',
Con.Padding(1),
Con.Bits('subframe_type',6),
Con.Flag('has_wasted_bits_per_sample'),
Con.IfThenElse(
'wasted_bits_per_sample',
lambda ctx: ctx['has_wasted_bits_per_sample'],
PlusOne(Unary('value')),
Con.Value('value',lambda ctx2: 0)))
GET_BLOCKSIZE_FROM_STREAMINFO = -1
GET_8BIT_BLOCKSIZE_FROM_END_OF_HEADER = -2
GET_16BIT_BLOCKSIZE_FROM_END_OF_HEADER = -3
BLOCK_SIZE = (GET_BLOCKSIZE_FROM_STREAMINFO,
192,
576,1152,2304,4608,
GET_8BIT_BLOCKSIZE_FROM_END_OF_HEADER,
GET_16BIT_BLOCKSIZE_FROM_END_OF_HEADER,
256,512,1024,2048,4096,8192,16384,32768)
GET_SAMPLE_SIZE_FROM_STREAMINFO = -1
SAMPLE_SIZE = (GET_SAMPLE_SIZE_FROM_STREAMINFO,
8,12,None,16,20,24,None)
def FIXED0(subframe,residual,i):
subframe.insert(i,
residual[i])
def FIXED1(subframe,residual,i):
subframe.insert(i,
subframe[i - 1] + residual[i])
def FIXED2(subframe,residual,i):
subframe.insert(i,
((2 * subframe[i - 1]) - subframe[i - 2] + \
residual[i]))
def FIXED3(subframe,residual,i):
subframe.insert(i,
((3 * subframe[i - 1]) - (3 * subframe[i - 2]) + \
subframe[i - 3] + residual[i]))
def FIXED4(subframe,residual,i):
subframe.insert(i,
((4 * subframe[i - 1]) - (6 * subframe[i - 2]) + \
(4 * subframe[i - 3]) - subframe[i - 4] + residual[i]))
#iterates over all of the channels, in order
def MERGE_INDEPENDENT(channel_list):
channel_data = [iter(c) for c in channel_list]
while (True):
for channel in channel_data:
yield channel.next()
def MERGE_LEFT(channel_list):
channel_left = iter(channel_list[0])
channel_side = iter(channel_list[1])
while (True):
left = channel_left.next()
side = channel_side.next()
yield left
yield left - side
def MERGE_RIGHT(channel_list):
channel_side = iter(channel_list[0])
channel_right = iter(channel_list[1])
while (True):
side = channel_side.next()
right = channel_right.next()
yield side + right
yield right
def MERGE_MID(channel_list):
channel_mid = iter(channel_list[0])
channel_side = iter(channel_list[1])
while (True):
mid = channel_mid.next()
side = channel_side.next()
mid = mid << 1
mid |= (side & 0x1)
yield (mid + side) >> 1
yield (mid - side) >> 1
CHANNEL_FUNCTIONS = (MERGE_INDEPENDENT,
MERGE_INDEPENDENT,
MERGE_INDEPENDENT,
MERGE_INDEPENDENT,
MERGE_INDEPENDENT,
MERGE_INDEPENDENT,
MERGE_INDEPENDENT,
MERGE_INDEPENDENT,
MERGE_LEFT,
MERGE_RIGHT,
MERGE_MID)
FIXED_FUNCTIONS = (FIXED0,FIXED1,FIXED2,FIXED3,FIXED4)
def __init__(self, flac_stream):
self.stream = BufferedStream(flac_stream)
self.streaminfo = None
self.bitstream = None
#ensure the file starts with 'fLaC'
self.read_stream_marker()
#initialize self.bitstream
self.begin_bitstream()
#find self.streaminfo in case we need it
self.read_metadata_blocks()
def close(self):
if (self.bitstream != None):
self.bitstream.close()
else:
self.stream.close()
def read_stream_marker(self):
if (self.stream.read(4) != 'fLaC'):
raise FlacStreamException('invalid stream marker')
def read_metadata_blocks(self):
block = audiotools.FlacAudio.METADATA_BLOCK_HEADER.parse_stream(self.stream)
while (block.last_block == 0):
if (block.block_type == 0):
self.streaminfo = audiotools.FlacAudio.STREAMINFO.parse_stream(self.stream)
else:
self.stream.seek(block.block_length,1)
block = audiotools.FlacAudio.METADATA_BLOCK_HEADER.parse_stream(self.stream)
self.stream.seek(block.block_length,1)
def begin_bitstream(self):
import bitstream
#self.bitstream = Con.BitStreamReader(self.stream)
self.bitstream = bitstream.BitStreamReader(self.stream)
def read_frame(self):
self.stream.reset_buffer()
try:
header = FlacReader.FRAME_HEADER.parse_stream(self.bitstream)
except Con.core.FieldError:
return ""
if (header.sync != 0x3FFE):
raise FlacStreamException('invalid sync')
if (crc8(self.stream.getvalue()[0:-1]) != header.crc8):
raise FlacStreamException('crc8 checksum failed')
#block_size tells us how many samples we need from each subframe
block_size = FlacReader.BLOCK_SIZE[header.block_size]
if (block_size == self.GET_BLOCKSIZE_FROM_STREAMINFO):
block_size = self.streaminfo.maximum_blocksize
elif ((block_size == self.GET_8BIT_BLOCKSIZE_FROM_END_OF_HEADER) or
(block_size == self.GET_16BIT_BLOCKSIZE_FROM_END_OF_HEADER)):
block_size = header.extended_block_size + 1
#grab subframe data as 32-bit array objects
subframe_data = []
for channel_number in xrange(header.total_channels):
subframe_data.append(
self.read_subframe(header, block_size, channel_number))
crc16sum = crc16(self.stream.getvalue())
#try to byte-align the stream
if (len(self.bitstream.buffer) > 0):
self.bitstream.read(len(self.bitstream.buffer))
if (crc16sum != Con.Bits('crc16',16).parse_stream(self.bitstream)):
raise FlacStreamException('crc16 checksum failed')
#convert our list of subframe data arrays into
#a string of sample data
if (FlacReader.SAMPLE_SIZE[header.bits_per_sample] == 16):
merged_frames = array.array('h',
FlacReader.CHANNEL_FUNCTIONS[
header.channel_assignment](subframe_data))
if (audiotools.BIG_ENDIAN):
merged_frames.byteswap()
return merged_frames.tostring()
elif (FlacReader.SAMPLE_SIZE[header.bits_per_sample] == 8):
merged_frames = array.array('b',
FlacReader.CHANNEL_FUNCTIONS[
header.channel_assignment](subframe_data))
return merged_frames.tostring()
else:
if (FlacReader.SAMPLE_SIZE[header.bits_per_sample] == \
self.GET_SAMPLE_SIZE_FROM_STREAMINFO):
bits_per_sample = self.streaminfo.bits_per_sample + 1
elif (FlacReader.SAMPLE_SIZE[header.bits_per_sample] == None):
raise FlacStreamException('invalid bits per sample')
else:
bits_per_sample = FlacReader.SAMPLE_SIZE[header.bits_per_sample]
stream = Con.GreedyRepeater(
Con.BitStruct('bits',
Con.Bits('value',bits_per_sample,
swapped=True,signed=True)))
return stream.build(
[Con.Container(value=v) for v in
FlacReader.CHANNEL_FUNCTIONS[header.channel_assignment](
subframe_data)])
def read_subframe(self, frame_header, block_size, channel_number):
subframe_header = \
FlacReader.SUBFRAME_HEADER.parse_stream(self.bitstream)
#figure out the bits-per-sample of this subframe
if ((frame_header.channel_assignment == 8) and
(channel_number == 1)):
#if channel is stored as left+difference
#and this is the difference, add 1 bit
bits_per_sample = FlacReader.SAMPLE_SIZE[
frame_header.bits_per_sample] + 1
elif ((frame_header.channel_assignment == 9) and
(channel_number == 0)):
#if channel is stored as difference+right
#and this is the difference, add 1 bit
bits_per_sample = FlacReader.SAMPLE_SIZE[
frame_header.bits_per_sample] + 1
elif ((frame_header.channel_assignment == 10) and
(channel_number == 1)):
#if channel is stored as average+difference
#and this is the difference, add 1 bit
bits_per_sample = FlacReader.SAMPLE_SIZE[
frame_header.bits_per_sample] + 1
else:
#otherwise, use the number from the frame header
bits_per_sample = FlacReader.SAMPLE_SIZE[
frame_header.bits_per_sample]
if (subframe_header.has_wasted_bits_per_sample):
bits_per_sample -= subframe_header.wasted_bits_per_sample
if (subframe_header.subframe_type == 0):
subframe = self.read_subframe_constant(block_size, bits_per_sample)
elif (subframe_header.subframe_type == 1):
subframe = self.read_subframe_verbatim(block_size, bits_per_sample)
elif ((subframe_header.subframe_type & 0x38) == 0x08):
subframe = self.read_subframe_fixed(
subframe_header.subframe_type & 0x07,
block_size,
bits_per_sample)
elif ((subframe_header.subframe_type & 0x20) == 0x20):
subframe = self.read_subframe_lpc(
(subframe_header.subframe_type & 0x1F) + 1,
block_size,
bits_per_sample)
else:
raise FlacStreamException('invalid subframe type')
if (subframe_header.has_wasted_bits_per_sample):
return array.array(
'i',
[i << subframe_header.wasted_bits_per_sample
for i in subframe])
else:
return subframe
def read_subframe_constant(self, block_size, bits_per_sample):
sample = Con.Bits('b',bits_per_sample).parse_stream(
self.bitstream)
subframe = array.array('i',[sample] * block_size)
return subframe
def read_subframe_verbatim(self, block_size, bits_per_sample):
return array.array('i',
Con.StrictRepeater(
block_size,
Con.Bits("samples",
bits_per_sample,
signed=True)).parse_stream(self.bitstream))
def read_subframe_fixed(self, order, block_size, bits_per_sample):
samples = Con.StrictRepeater(
order,
Con.Bits("warm_up_samples",
bits_per_sample,
signed=True))
subframe = array.array('i',
samples.parse_stream(self.bitstream))
residual = self.read_residual(block_size,order)
fixed_func = self.FIXED_FUNCTIONS[order]
for i in xrange(len(subframe),block_size):
fixed_func(subframe,residual,i)
return subframe
def read_subframe_lpc(self, order, block_size, bits_per_sample):
samples = Con.StrictRepeater(
order,
Con.Bits("warm_up_samples",
bits_per_sample,
signed=True))
subframe = array.array('i',
samples.parse_stream(self.bitstream))
lpc_precision = Con.Bits('lpc_precision',
4).parse_stream(self.bitstream) + 1
lpc_shift = Con.Bits('lpc_shift',
5).parse_stream(self.bitstream)
coefficients = array.array('i',
Con.StrictRepeater(
order,
Con.Bits('coefficients',
lpc_precision,
signed=True)).parse_stream(self.bitstream))
residual = self.read_residual(block_size, order)
for i in xrange(len(subframe),block_size):
subframe.insert(i,
(sum(
[coefficients[j] * subframe[i - j - 1] for j in
xrange(0,len(coefficients))]) >> lpc_shift) + \
residual[i])
return subframe
def read_residual(self, block_size, predictor_order):
rice = array.array('i')
#add some dummy rice so that the Rice index matches
#that of the rest of the subframe
for i in xrange(predictor_order):
rice.append(0)
coding_method = self.bitstream.read(2)
if (coding_method == '\x00\x00'):
rice2 = False
elif (coding_method == '\x00\x01'):
rice2 = True
else:
raise FlacStreamException('invalid residual coding method')
partition_order = Con.Bits('partition_order',4).parse_stream(
self.bitstream)
if (partition_order > 0):
total_samples = ((block_size / 2 ** partition_order) -
predictor_order)
rice.extend(self.read_encoded_rice(total_samples,rice2))
for i in xrange(1,2 ** partition_order):
total_samples = (block_size / 2 ** partition_order)
rice.extend(self.read_encoded_rice(total_samples,rice2))
else:
rice.extend(self.read_encoded_rice(block_size - predictor_order,
rice2))
return rice
def read_encoded_rice(self, total_samples, rice2=False):
bin_to_int = Con.lib.binary.bin_to_int
samples = array.array('i')
if (not rice2):
rice_parameter = Con.Bits('rice_parameter',4).parse_stream(
self.bitstream)
else:
rice_parameter = Con.Bits('rice_parameter',5).parse_stream(
self.bitstream)
if (rice_parameter != 0xF):
#a Rice encoded residual
for x in xrange(total_samples):
#count the number of 0 bits before the next 1 bit
#(unary encoding)
#to find our most significant bits
msb = 0
s = self.bitstream.read(1)
while (s != '\x01'):
msb += 1
s = self.bitstream.read(1)
#grab the proper number of least significant bits
lsb = bin_to_int(self.bitstream.read(rice_parameter))
#combine msb and lsb to get the Rice-encoded value
value = (msb << rice_parameter) | lsb
if ((value & 0x1) == 0x1): #negative
samples.append(-(value >> 1) - 1)
else: #positive
samples.append(value >> 1)
else:
#unencoded residual
bits_per_sample = Con.Bits('escape_code',5).parse_stream(
self.bitstream)
sample = Con.Bits("sample",bits_per_sample,signed=True)
for x in xrange(total_samples):
samples.append(sample.parse_stream(self.bitstream))
return samples
###############################
#Checksum calculation functions
###############################
CRC8TABLE = (0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3)
def crc8(data, start=0):
value = start
for i in map(ord,data):
value = CRC8TABLE[value ^ i]
return value
CRC16TABLE = (0x0000,0x8005,0x800f,0x000a,0x801b,0x001e,0x0014,0x8011,
0x8033,0x0036,0x003c,0x8039,0x0028,0x802d,0x8027,0x0022,
0x8063,0x0066,0x006c,0x8069,0x0078,0x807d,0x8077,0x0072,
0x0050,0x8055,0x805f,0x005a,0x804b,0x004e,0x0044,0x8041,
0x80c3,0x00c6,0x00cc,0x80c9,0x00d8,0x80dd,0x80d7,0x00d2,
0x00f0,0x80f5,0x80ff,0x00fa,0x80eb,0x00ee,0x00e4,0x80e1,
0x00a0,0x80a5,0x80af,0x00aa,0x80bb,0x00be,0x00b4,0x80b1,
0x8093,0x0096,0x009c,0x8099,0x0088,0x808d,0x8087,0x0082,
0x8183,0x0186,0x018c,0x8189,0x0198,0x819d,0x8197,0x0192,
0x01b0,0x81b5,0x81bf,0x01ba,0x81ab,0x01ae,0x01a4,0x81a1,
0x01e0,0x81e5,0x81ef,0x01ea,0x81fb,0x01fe,0x01f4,0x81f1,
0x81d3,0x01d6,0x01dc,0x81d9,0x01c8,0x81cd,0x81c7,0x01c2,
0x0140,0x8145,0x814f,0x014a,0x815b,0x015e,0x0154,0x8151,
0x8173,0x0176,0x017c,0x8179,0x0168,0x816d,0x8167,0x0162,
0x8123,0x0126,0x012c,0x8129,0x0138,0x813d,0x8137,0x0132,
0x0110,0x8115,0x811f,0x011a,0x810b,0x010e,0x0104,0x8101,
0x8303,0x0306,0x030c,0x8309,0x0318,0x831d,0x8317,0x0312,
0x0330,0x8335,0x833f,0x033a,0x832b,0x032e,0x0324,0x8321,
0x0360,0x8365,0x836f,0x036a,0x837b,0x037e,0x0374,0x8371,
0x8353,0x0356,0x035c,0x8359,0x0348,0x834d,0x8347,0x0342,
0x03c0,0x83c5,0x83cf,0x03ca,0x83db,0x03de,0x03d4,0x83d1,
0x83f3,0x03f6,0x03fc,0x83f9,0x03e8,0x83ed,0x83e7,0x03e2,
0x83a3,0x03a6,0x03ac,0x83a9,0x03b8,0x83bd,0x83b7,0x03b2,
0x0390,0x8395,0x839f,0x039a,0x838b,0x038e,0x0384,0x8381,
0x0280,0x8285,0x828f,0x028a,0x829b,0x029e,0x0294,0x8291,
0x82b3,0x02b6,0x02bc,0x82b9,0x02a8,0x82ad,0x82a7,0x02a2,
0x82e3,0x02e6,0x02ec,0x82e9,0x02f8,0x82fd,0x82f7,0x02f2,
0x02d0,0x82d5,0x82df,0x02da,0x82cb,0x02ce,0x02c4,0x82c1,
0x8243,0x0246,0x024c,0x8249,0x0258,0x825d,0x8257,0x0252,
0x0270,0x8275,0x827f,0x027a,0x826b,0x026e,0x0264,0x8261,
0x0220,0x8225,0x822f,0x022a,0x823b,0x023e,0x0234,0x8231,
0x8213,0x0216,0x021c,0x8219,0x0208,0x820d,0x8207,0x0202)
def crc16(data, start=0):
value = start
for i in map(ord,data):
value = ((value << 8) ^ CRC16TABLE[(value >> 8) ^ i]) & 0xFFFF
return value
#BufferedStream stores the data that passes through read()
#so that checksums can be calculated from it.
#Be sure to reset the buffer as needed.
class BufferedStream:
def __init__(self, stream):
self.stream = stream
self.buffer = cStringIO.StringIO()
def read(self, count):
s = self.stream.read(count)
self.buffer.write(s)
return s
def seek(self, offset, whence=0):
self.stream.seek(offset,whence)
def tell(self):
return self.stream.tell()
def close(self):
self.stream.close()
def reset_buffer(self):
self.buffer.close()
self.buffer = cStringIO.StringIO()
def getvalue(self):
return self.buffer.getvalue()
class FlacPCMReader(audiotools.PCMReader):
#flac_file should be a file-like stream of FLAC data
def __init__(self, flac_file):
self.flacreader = FlacReader(flac_file)
self.sample_rate = self.flacreader.streaminfo.samplerate
self.channels = self.flacreader.streaminfo.channels + 1
self.bits_per_sample = self.flacreader.streaminfo.bits_per_sample + 1
self.process = None
self.buffer = []
#this won't return even close to the expected number of bytes
#(though that won't really break anything)
def read(self, bytes):
return self.flacreader.read_frame()
def close(self):
self.flacreader.close()

BIN
Melodia/resources/audiotools/pcm.so Executable file
View File

Binary file not shown.

804
Melodia/resources/audiotools/player.py Normal file
View File

@ -0,0 +1,804 @@
#!/usr/bin/bin
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
import os
import sys
import cPickle
import select
import audiotools
import time
import Queue
import threading
(RG_NO_REPLAYGAIN, RG_TRACK_GAIN, RG_ALBUM_GAIN) = range(3)
class Player:
"""A class for operating an audio player.
The player itself runs in a seperate thread,
which this sends commands to."""
def __init__(self, audio_output,
replay_gain=RG_NO_REPLAYGAIN,
next_track_callback=lambda: None):
"""audio_output is an AudioOutput subclass.
replay_gain is RG_NO_REPLAYGAIN, RG_TRACK_GAIN or RG_ALBUM_GAIN,
indicating how the player should apply ReplayGain.
next_track_callback is a function with no arguments
which is called by the player when the current track is finished."""
self.command_queue = Queue.Queue()
self.worker = PlayerThread(audio_output,
self.command_queue,
replay_gain)
self.thread = threading.Thread(target=self.worker.run,
args=(next_track_callback,))
self.thread.daemon = True
self.thread.start()
def open(self, track):
"""opens the given AudioFile for playing
stops playing the current file, if any"""
self.track = track
self.command_queue.put(("open", [track]))
def play(self):
"""begins or resumes playing an opened AudioFile, if any"""
self.command_queue.put(("play", []))
def set_replay_gain(self, replay_gain):
"""sets the given ReplayGain level to apply during playback
Choose from RG_NO_REPLAYGAIN, RG_TRACK_GAIN or RG_ALBUM_GAIN
ReplayGain cannot be applied mid-playback.
One must stop() and play() a file for it to take effect."""
self.command_queue.put(("set_replay_gain", [replay_gain]))
def pause(self):
"""pauses playback of the current file
Playback may be resumed with play() or toggle_play_pause()"""
self.command_queue.put(("pause", []))
def toggle_play_pause(self):
"""pauses the file if playing, play the file if paused"""
self.command_queue.put(("toggle_play_pause", []))
def stop(self):
"""stops playback of the current file
If play() is called, playback will start from the beginning."""
self.command_queue.put(("stop", []))
def close(self):
"""closes the player for playback
The player thread is halted and the AudioOutput is closed."""
self.command_queue.put(("exit", []))
def progress(self):
"""returns a (pcm_frames_played, pcm_frames_total) tuple
This indicates the current playback status in PCM frames."""
return (self.worker.frames_played, self.worker.total_frames)
(PLAYER_STOPPED, PLAYER_PAUSED, PLAYER_PLAYING) = range(3)
class PlayerThread:
"""The Player class' subthread.
This should not be instantiated directly;
Player will do so automatically."""
def __init__(self, audio_output, command_queue,
replay_gain=RG_NO_REPLAYGAIN):
self.audio_output = audio_output
self.command_queue = command_queue
self.replay_gain = replay_gain
self.track = None
self.pcmconverter = None
self.frames_played = 0
self.total_frames = 0
self.state = PLAYER_STOPPED
def open(self, track):
self.stop()
self.track = track
self.frames_played = 0
self.total_frames = track.total_frames()
def pause(self):
if (self.state == PLAYER_PLAYING):
self.state = PLAYER_PAUSED
def play(self):
if (self.track is not None):
if (self.state == PLAYER_STOPPED):
if (self.replay_gain == RG_TRACK_GAIN):
from audiotools.replaygain import ReplayGainReader
replay_gain = self.track.replay_gain()
if (replay_gain is not None):
pcmreader = ReplayGainReader(
self.track.to_pcm(),
replay_gain.track_gain,
replay_gain.track_peak)
else:
pcmreader = self.track.to_pcm()
elif (self.replay_gain == RG_ALBUM_GAIN):
from audiotools.replaygain import ReplayGainReader
replay_gain = self.track.replay_gain()
if (replay_gain is not None):
pcmreader = ReplayGainReader(
self.track.to_pcm(),
replay_gain.album_gain,
replay_gain.album_peak)
else:
pcmreader = self.track.to_pcm()
else:
pcmreader = self.track.to_pcm()
if (not self.audio_output.compatible(pcmreader)):
self.audio_output.init(
sample_rate=pcmreader.sample_rate,
channels=pcmreader.channels,
channel_mask=pcmreader.channel_mask,
bits_per_sample=pcmreader.bits_per_sample)
self.pcmconverter = ThreadedPCMConverter(
pcmreader,
self.audio_output.framelist_converter())
self.frames_played = 0
self.state = PLAYER_PLAYING
elif (self.state == PLAYER_PAUSED):
self.state = PLAYER_PLAYING
elif (self.state == PLAYER_PLAYING):
pass
def set_replay_gain(self, replay_gain):
self.replay_gain = replay_gain
def toggle_play_pause(self):
if (self.state == PLAYER_PLAYING):
self.pause()
elif ((self.state == PLAYER_PAUSED) or
(self.state == PLAYER_STOPPED)):
self.play()
def stop(self):
if (self.pcmconverter is not None):
self.pcmconverter.close()
del(self.pcmconverter)
self.pcmconverter = None
self.frames_played = 0
self.state = PLAYER_STOPPED
def run(self, next_track_callback=lambda: None):
while (True):
if ((self.state == PLAYER_STOPPED) or
(self.state == PLAYER_PAUSED)):
(command, args) = self.command_queue.get(True)
if (command == "exit"):
self.audio_output.close()
return
else:
getattr(self, command)(*args)
else:
try:
(command, args) = self.command_queue.get_nowait()
if (command == "exit"):
return
else:
getattr(self, command)(*args)
except Queue.Empty:
if (self.frames_played < self.total_frames):
(data, frames) = self.pcmconverter.read()
if (frames > 0):
self.audio_output.play(data)
self.frames_played += frames
if (self.frames_played >= self.total_frames):
next_track_callback()
else:
self.frames_played = self.total_frames
next_track_callback()
else:
self.stop()
class CDPlayer:
"""A class for operating a CDDA player.
The player itself runs in a seperate thread,
which this sends commands to."""
def __init__(self, cdda, audio_output,
next_track_callback=lambda: None):
"""cdda is a audiotools.CDDA object.
audio_output is an AudioOutput subclass.
next_track_callback is a function with no arguments
which is called by the player when the current track is finished."""
self.command_queue = Queue.Queue()
self.worker = CDPlayerThread(cdda,
audio_output,
self.command_queue)
self.thread = threading.Thread(target=self.worker.run,
args=(next_track_callback,))
self.thread.daemon = True
self.thread.start()
def open(self, track_number):
"""track_number indicates which track to open, starting from 1
stops playing the current track, if any"""
self.command_queue.put(("open", [track_number]))
def play(self):
"""begins or resumes playing the currently open track, if any"""
self.command_queue.put(("play", []))
def pause(self):
"""pauses playback of the current track
Playback may be resumed with play() or toggle_play_pause()"""
self.command_queue.put(("pause", []))
def toggle_play_pause(self):
"""pauses the track if playing, play the track if paused"""
self.command_queue.put(("toggle_play_pause", []))
def stop(self):
"""stops playback of the current track
If play() is called, playback will start from the beginning."""
self.command_queue.put(("stop", []))
def close(self):
"""closes the player for playback
The player thread is halted and the AudioOutput is closed."""
self.command_queue.put(("exit", []))
def progress(self):
"""returns a (pcm_frames_played, pcm_frames_total) tuple
This indicates the current playback status in PCM frames."""
return (self.worker.frames_played, self.worker.total_frames)
class CDPlayerThread:
"""The CDPlayer class' subthread.
This should not be instantiated directly;
CDPlayer will do so automatically."""
def __init__(self, cdda, audio_output, command_queue):
self.cdda = cdda
self.audio_output = audio_output
self.command_queue = command_queue
self.audio_output.init(
sample_rate=44100,
channels=2,
channel_mask=3,
bits_per_sample=16)
self.framelist_converter = self.audio_output.framelist_converter()
self.track = None
self.pcmconverter = None
self.frames_played = 0
self.total_frames = 0
self.state = PLAYER_STOPPED
def open(self, track_number):
self.stop()
self.track = self.cdda[track_number]
self.frames_played = 0
self.total_frames = self.track.length() * 44100 / 75
def play(self):
if (self.track is not None):
if (self.state == PLAYER_STOPPED):
self.pcmconverter = ThreadedPCMConverter(
self.track,
self.framelist_converter)
self.frames_played = 0
self.state = PLAYER_PLAYING
elif (self.state == PLAYER_PAUSED):
self.state = PLAYER_PLAYING
elif (self.state == PLAYER_PLAYING):
pass
def pause(self):
if (self.state == PLAYER_PLAYING):
self.state = PLAYER_PAUSED
def toggle_play_pause(self):
if (self.state == PLAYER_PLAYING):
self.pause()
elif ((self.state == PLAYER_PAUSED) or
(self.state == PLAYER_STOPPED)):
self.play()
def stop(self):
if (self.pcmconverter is not None):
self.pcmconverter.close()
del(self.pcmconverter)
self.pcmconverter = None
self.frames_played = 0
self.state = PLAYER_STOPPED
def run(self, next_track_callback=lambda: None):
while (True):
if ((self.state == PLAYER_STOPPED) or
(self.state == PLAYER_PAUSED)):
(command, args) = self.command_queue.get(True)
if (command == "exit"):
self.audio_output.close()
return
else:
getattr(self, command)(*args)
else:
try:
(command, args) = self.command_queue.get_nowait()
if (command == "exit"):
return
else:
getattr(self, command)(*args)
except Queue.Empty:
if (self.frames_played < self.total_frames):
(data, frames) = self.pcmconverter.read()
if (frames > 0):
self.audio_output.play(data)
self.frames_played += frames
if (self.frames_played >= self.total_frames):
next_track_callback()
else:
self.frames_played = self.total_frames
next_track_callback()
else:
self.stop()
class ThreadedPCMConverter:
"""A class for decoding a PCMReader in a seperate thread.
PCMReader's data is queued such that even if decoding and
conversion are relatively time-consuming, read() will
continue smoothly."""
def __init__(self, pcmreader, converter):
"""pcmreader is a PCMReader object.
converter is a function which takes a FrameList
and returns an object suitable for the current AudioOutput object.
Upon conclusion, the PCMReader is automatically closed."""
self.decoded_data = Queue.Queue()
self.stop_decoding = threading.Event()
def convert(pcmreader, buffer_size, converter, decoded_data,
stop_decoding):
try:
frame = pcmreader.read(buffer_size)
while ((not stop_decoding.is_set()) and (len(frame) > 0)):
decoded_data.put((converter(frame), frame.frames))
frame = pcmreader.read(buffer_size)
else:
decoded_data.put((None, 0))
pcmreader.close()
except (ValueError, IOError):
decoded_data.put((None, 0))
pcmreader.close()
buffer_size = (pcmreader.sample_rate *
pcmreader.channels *
(pcmreader.bits_per_sample / 8)) / 20
self.thread = threading.Thread(
target=convert,
args=(pcmreader,
buffer_size,
converter,
self.decoded_data,
self.stop_decoding))
self.thread.daemon = True
self.thread.start()
def read(self):
"""returns a (converted_data, pcm_frame_count) tuple"""
return self.decoded_data.get(True)
def close(self):
"""stops the decoding thread and closes the PCMReader"""
self.stop_decoding.set()
self.thread.join()
class AudioOutput:
"""An abstract parent class for playing audio."""
def __init__(self):
self.sample_rate = 0
self.channels = 0
self.channel_mask = 0
self.bits_per_sample = 0
self.initialized = False
def compatible(self, pcmreader):
"""Returns True if the given pcmreader is compatible.
If False, one is expected to open a new output stream
which is compatible."""
return ((self.sample_rate == pcmreader.sample_rate) and
(self.channels == pcmreader.channels) and
(self.channel_mask == pcmreader.channel_mask) and
(self.bits_per_sample == pcmreader.bits_per_sample))
def framelist_converter(self):
"""Returns a function which converts framelist objects
to objects acceptable by our play() method."""
raise NotImplementedError()
def init(self, sample_rate, channels, channel_mask, bits_per_sample):
"""Initializes the output stream.
This *must* be called prior to play() and close().
The general flow of audio playing is:
>>> pcm = audiofile.to_pcm()
>>> player = AudioOutput()
>>> player.init(pcm.sample_rate,
... pcm.channels,
... pcm.channel_mask,
... pcm.bits_per_sample)
>>> convert = player.framelist_converter()
>>> frame = pcm.read(1024)
>>> while (len(frame) > 0):
... player.play(convert(frame))
... frame = pcm.read(1024)
>>> player.close()
"""
raise NotImplementedError()
def play(self, data):
"""plays a chunk of converted data"""
raise NotImplementedError()
def close(self):
"""closes the output stream"""
raise NotImplementedError()
@classmethod
def available(cls):
"""returns True if the AudioOutput is available on the system"""
return False
class NULLAudioOutput(AudioOutput):
"""An AudioOutput subclass which does not actually play anything.
Although this consumes audio output at the rate it would normally
play, it generates no output."""
NAME = "NULL"
def framelist_converter(self):
"""Returns a function which converts framelist objects
to objects acceptable by our play() method."""
return lambda f: f.frames
def init(self, sample_rate, channels, channel_mask, bits_per_sample):
"""Initializes the output stream.
This *must* be called prior to play() and close()."""
self.sample_rate = sample_rate
self.channels = channels
self.channel_mask = channel_mask
self.bits_per_sample = bits_per_sample
def play(self, data):
"""plays a chunk of converted data"""
time.sleep(float(data) / self.sample_rate)
def close(self):
"""closes the output stream"""
pass
@classmethod
def available(cls):
"""returns True"""
return True
class OSSAudioOutput(AudioOutput):
"""An AudioOutput subclass for OSS output."""
NAME = "OSS"
def init(self, sample_rate, channels, channel_mask, bits_per_sample):
"""Initializes the output stream.
This *must* be called prior to play() and close()."""
if (not self.initialized):
import ossaudiodev
self.sample_rate = sample_rate
self.channels = channels
self.channel_mask = channel_mask
self.bits_per_sample = bits_per_sample
self.ossaudio = ossaudiodev.open('w')
if (self.bits_per_sample == 8):
self.ossaudio.setfmt(ossaudiodev.AFMT_S8_LE)
elif (self.bits_per_sample == 16):
self.ossaudio.setfmt(ossaudiodev.AFMT_S16_LE)
elif (self.bits_per_sample == 24):
self.ossaudio.setfmt(ossaudiodev.AFMT_S16_LE)
else:
raise ValueError("Unsupported bits-per-sample")
self.ossaudio.channels(channels)
self.ossaudio.speed(sample_rate)
self.initialized = True
else:
self.close()
self.init(sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)
def framelist_converter(self):
"""Returns a function which converts framelist objects
to objects acceptable by our play() method."""
if (self.bits_per_sample == 8):
return lambda f: f.to_bytes(False, True)
elif (self.bits_per_sample == 16):
return lambda f: f.to_bytes(False, True)
elif (self.bits_per_sample == 24):
import audiotools.pcm
return lambda f: audiotools.pcm.from_list(
[i >> 8 for i in list(f)],
self.channels, 16, True).to_bytes(False, True)
else:
raise ValueError("Unsupported bits-per-sample")
def play(self, data):
"""plays a chunk of converted data"""
self.ossaudio.writeall(data)
def close(self):
"""closes the output stream"""
if (self.initialized):
self.initialized = False
self.ossaudio.close()
@classmethod
def available(cls):
"""returns True if OSS output is available on the system"""
try:
import ossaudiodev
return True
except ImportError:
return False
class PulseAudioOutput(AudioOutput):
"""An AudioOutput subclass for PulseAudio output."""
NAME = "PulseAudio"
def init(self, sample_rate, channels, channel_mask, bits_per_sample):
"""Initializes the output stream.
This *must* be called prior to play() and close()."""
if (not self.initialized):
import subprocess
self.sample_rate = sample_rate
self.channels = channels
self.channel_mask = channel_mask
self.bits_per_sample = bits_per_sample
if (bits_per_sample == 8):
format = "u8"
elif (bits_per_sample == 16):
format = "s16le"
elif (bits_per_sample == 24):
format = "s24le"
else:
raise ValueError("Unsupported bits-per-sample")
self.pacat = subprocess.Popen(
[audiotools.BIN["pacat"],
"-n", "Python Audio Tools",
"--rate", str(sample_rate),
"--format", format,
"--channels", str(channels),
"--latency-msec", str(100)],
stdin=subprocess.PIPE)
self.initialized = True
else:
self.close()
self.init(sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)
def framelist_converter(self):
"""Returns a function which converts framelist objects
to objects acceptable by our play() method."""
if (self.bits_per_sample == 8):
return lambda f: f.to_bytes(True, False)
elif (self.bits_per_sample == 16):
return lambda f: f.to_bytes(False, True)
elif (self.bits_per_sample == 24):
return lambda f: f.to_bytes(False, True)
else:
raise ValueError("Unsupported bits-per-sample")
def play(self, data):
"""plays a chunk of converted data"""
self.pacat.stdin.write(data)
self.pacat.stdin.flush()
def close(self):
"""closes the output stream"""
if (self.initialized):
self.initialized = False
self.pacat.stdin.close()
self.pacat.wait()
@classmethod
def server_alive(cls):
import subprocess
dev = subprocess.Popen([audiotools.BIN["pactl"], "stat"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
dev.stdout.read()
dev.stderr.read()
return (dev.wait() == 0)
@classmethod
def available(cls):
"""returns True if PulseAudio is available and running on the system"""
return (audiotools.BIN.can_execute(audiotools.BIN["pacat"]) and
audiotools.BIN.can_execute(audiotools.BIN["pactl"]) and
cls.server_alive())
class PortAudioOutput(AudioOutput):
"""An AudioOutput subclass for PortAudio output."""
NAME = "PortAudio"
def init(self, sample_rate, channels, channel_mask, bits_per_sample):
"""Initializes the output stream.
This *must* be called prior to play() and close()."""
if (not self.initialized):
import pyaudio
self.sample_rate = sample_rate
self.channels = channels
self.channel_mask = channel_mask
self.bits_per_sample = bits_per_sample
self.pyaudio = pyaudio.PyAudio()
self.stream = self.pyaudio.open(
format=self.pyaudio.get_format_from_width(
self.bits_per_sample / 8, False),
channels=self.channels,
rate=self.sample_rate,
output=True)
self.initialized = True
else:
self.close()
self.init(sample_rate=sample_rate,
channels=channels,
channel_mask=channel_mask,
bits_per_sample=bits_per_sample)
def framelist_converter(self):
"""Returns a function which converts framelist objects
to objects acceptable by our play() method."""
return lambda f: f.to_bytes(False, True)
def play(self, data):
"""plays a chunk of converted data"""
self.stream.write(data)
def close(self):
"""closes the output stream"""
if (self.initialized):
self.stream.close()
self.pyaudio.terminate()
self.initialized = False
@classmethod
def available(cls):
"""returns True if the AudioOutput is available on the system"""
try:
import pyaudio
return True
except ImportError:
return False
AUDIO_OUTPUT = (PulseAudioOutput, OSSAudioOutput,
PortAudioOutput, NULLAudioOutput)

BIN
Melodia/resources/audiotools/prot.so Executable file
View File

Binary file not shown.

BIN
Melodia/resources/audiotools/replaygain.so Executable file
View File

Binary file not shown.

259
Melodia/resources/audiotools/replaygain_old.py Normal file
View File

@ -0,0 +1,259 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2007-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#This is a module for ReplayGain calculation of a given PCM stream.
#It is included as a reference implementation and not as a substitute
#for external ReplayGain calculators.
#The first problem with it is that the results are not identical
#to those of external calculators, by about a 100th of a dB or so.
#This is probably because the C-based implementations use floats
#while Python uses doubles. Thus the difference in rounding errors.
#The second problem with it is it's very, very slow.
#Python is ill-suited to these kinds of rolling loop calculations
#involving thousands of samples per second, so the Python-based
#approach is several times slower than real-time.
import audiotools
import audiotools.pcmstream
from itertools import izip
AYule = ((1.0, -3.8466461711806699, 7.81501653005538, -11.341703551320419, 13.055042193275449, -12.28759895145294, 9.4829380631978992, -5.8725786177599897, 2.7546586187461299, -0.86984376593551005, 0.13919314567432001),
(1.0, -3.4784594855007098, 6.3631777756614802, -8.5475152747187408, 9.4769360780128, -8.8149868137015499, 6.8540154093699801, -4.3947099607955904, 2.1961168489077401, -0.75104302451432003, 0.13149317958807999),
(1.0, -2.3789883497308399, 2.84868151156327, -2.6457717022982501, 2.2369765745171302, -1.67148153367602, 1.0059595480854699, -0.45953458054982999, 0.16378164858596, -0.050320777171309998, 0.023478974070199998),
(1.0, -1.6127316513724701, 1.0797749225997, -0.2565625775407, -0.1627671912044, -0.22638893773905999, 0.39120800788283999, -0.22138138954924999, 0.045002353873520001, 0.020058518065010002, 0.0030243909574099999),
(1.0, -1.4985897936779899, 0.87350271418187997, 0.12205022308084, -0.80774944671437998, 0.47854794562325997, -0.12453458140019, -0.040675101970140001, 0.083337552841070001, -0.042373480257460003, 0.029772073199250002),
(1.0, -0.62820619233671005, 0.29661783706366002, -0.37256372942400001, 0.0021376785712399998, -0.42029820170917997, 0.22199650564824, 0.0061342435068200002, 0.06747620744683, 0.057848203758010003, 0.032227540721730001),
(1.0, -1.0480033512634901, 0.29156311971248999, -0.26806001042946997, 0.0081999964585799997, 0.45054734505007998, -0.33032403314005998, 0.067393683331100004, -0.047842542290329998, 0.016399078361890002, 0.018073643235729998),
(1.0, -0.51035327095184002, -0.31863563325244998, -0.20256413484477001, 0.14728154134329999, 0.38952639978998999, -0.23313271880868, -0.052460190244630001, -0.025059617240530001, 0.02442357316099, 0.01818801111503),
(1.0, -0.25049871956019998, -0.43193942311113998, -0.034246810176749999, -0.046783287842420002, 0.26408300200954998, 0.15113130533215999, -0.17556493366449, -0.18823009262115001, 0.054777204286740003, 0.047044096881200002)
)
BYule = ((0.038575994352000001, -0.021603671841850001, -0.0012339531685100001, -9.2916779589999993e-05, -0.016552603416190002, 0.02161526843274, -0.02074045215285, 0.0059429806512499997, 0.0030642802319099998, 0.00012025322027, 0.0028846368391600001),
(0.054186564064300002, -0.029110078089480001, -0.0084870937985100006, -0.0085116564546900003, -0.0083499090493599996, 0.022452932533390001, -0.025963385129149998, 0.016248649629749999, -0.0024087905158400001, 0.0067461368224699999, -0.00187763777362),
(0.15457299681924, -0.093310490563149995, -0.062478801536530001, 0.021635418887979999, -0.05588393329856, 0.047814766749210001, 0.0022231259774300001, 0.031740925400489998, -0.013905894218979999, 0.00651420667831, -0.0088136273383899993),
(0.30296907319326999, -0.22613988682123001, -0.085873237307719993, 0.032829301726640003, -0.0091570293343400007, -0.02364141202522, -0.0058445603991300003, 0.062761013217490003, -8.2808674800000004e-06, 0.0020586188556400002, -0.029501349832869998),
(0.33642304856131999, -0.25572241425570003, -0.11828570177555001, 0.11921148675203, -0.078344896094790006, -0.0046997791438, -0.0058950022444000001, 0.057242281403510002, 0.0083204398077299999, -0.016353813845399998, -0.017601765681500001),
(0.44915256608449999, -0.14351757464546999, -0.22784394429749, -0.01419140100551, 0.040782627971389998, -0.12398163381747999, 0.04097565135648, 0.10478503600251, -0.01863887810927, -0.031934284389149997, 0.0054190774870700002),
(0.56619470757640999, -0.75464456939302005, 0.16242137742230001, 0.16744243493672001, -0.18901604199609001, 0.30931782841830002, -0.27562961986223999, 0.0064731067724599998, 0.086475037803509999, -0.037889845548399997, -0.0058821544342100001),
(0.58100494960552995, -0.53174909058578002, -0.14289799034253001, 0.17520704835522, 0.02377945217615, 0.15558449135572999, -0.25344790059353001, 0.016284624063329999, 0.069204677639589998, -0.03721611395801, -0.0074961879717200001),
(0.53648789255105001, -0.42163034350695999, -0.0027595361192900001, 0.042678422194150002, -0.10214864179676, 0.14590772289387999, -0.024598648593450002, -0.11202315195388, -0.04060034127, 0.047886655481800003, -0.02217936801134)
)
AButter = ((1.0, -1.9722337291952701, 0.97261396931305999),
(1.0, -1.96977855582618, 0.97022847566350001),
(1.0, -1.9583538097539801, 0.95920349965458995),
(1.0, -1.9500275914987799, 0.95124613669835001),
(1.0, -1.94561023566527, 0.94705070426117999),
(1.0, -1.9278328697703599, 0.93034775234267997),
(1.0, -1.91858953033784, 0.92177618768380998),
(1.0, -1.9154210807478, 0.91885558323625005),
(1.0, -1.88903307939452, 0.89487434461663995))
BButter = ((0.98621192462707996, -1.9724238492541599, 0.98621192462707996),
(0.98500175787241995, -1.9700035157448399, 0.98500175787241995),
(0.97938932735214002, -1.95877865470428, 0.97938932735214002),
(0.97531843204928004, -1.9506368640985701, 0.97531843204928004),
(0.97316523498161001, -1.94633046996323, 0.97316523498161001),
(0.96454515552826003, -1.9290903110565201, 0.96454515552826003),
(0.96009142950541004, -1.9201828590108201, 0.96009142950541004),
(0.95856916599601005, -1.9171383319920301, 0.95856916599601005),
(0.94597685600279002, -1.89195371200558, 0.94597685600279002))
SAMPLE_RATE_MAP = {48000:0,44100:1,32000:2,24000:3,22050:4,
16000:5,12000:6,11025:7,8000:8}
PINK_REF = 64.82
class Filter:
def __init__(self, input_kernel, output_kernel):
self.input_kernel = input_kernel
self.output_kernel = output_kernel
self.unfiltered_samples = [0.0] * len(self.input_kernel)
self.filtered_samples = [0.0] * len(self.output_kernel)
#takes a list of floating point samples
#returns a list of filtered floating point samples
def filter(self, samples):
toreturn = []
input_kernel = tuple(reversed(self.input_kernel))
output_kernel = tuple(reversed(self.output_kernel[1:]))
for s in samples:
self.unfiltered_samples.append(s)
filtered = sum([i * k for i,k in zip(
self.unfiltered_samples[-len(input_kernel):],
input_kernel)]) - \
sum([i * k for i,k in zip(
self.filtered_samples[-len(output_kernel):],
output_kernel)])
self.filtered_samples.append(filtered)
toreturn.append(filtered)
#if we have more filtered and unfiltered samples than we'll need,
#chop off the excess at the beginning
if (len(self.unfiltered_samples) > (len(self.input_kernel))):
self.unfiltered_samples = self.unfiltered_samples[-len(self.input_kernel):]
if (len(self.filtered_samples) > (len(self.output_kernel))):
self.filtered_samples = self.filtered_samples[-len(self.output_kernel):]
return toreturn
MAX_ORDER = 10
class EqualLoudnessFilter(audiotools.PCMReader):
def __init__(self, pcmreader):
if (pcmreader.channels != 2):
raise ValueError("channels must equal 2")
if (pcmreader.sample_rate not in SAMPLE_RATE_MAP.keys()):
raise ValueError("unsupported sample rate")
self.stream = audiotools.pcmstream.PCMStreamReader(
pcmreader,
pcmreader.bits_per_sample / 8,
False,True)
audiotools.PCMReader.__init__(
self,
self.stream,
pcmreader.sample_rate,
2,
pcmreader.bits_per_sample)
self.leftover_samples = []
self.yule_filter_l = Filter(
BYule[SAMPLE_RATE_MAP[self.sample_rate]],
AYule[SAMPLE_RATE_MAP[self.sample_rate]])
self.yule_filter_r = Filter(
BYule[SAMPLE_RATE_MAP[self.sample_rate]],
AYule[SAMPLE_RATE_MAP[self.sample_rate]])
self.butter_filter_l = Filter(
BButter[SAMPLE_RATE_MAP[self.sample_rate]],
AButter[SAMPLE_RATE_MAP[self.sample_rate]])
self.butter_filter_r = Filter(
BButter[SAMPLE_RATE_MAP[self.sample_rate]],
AButter[SAMPLE_RATE_MAP[self.sample_rate]])
def read(self, bytes):
#read in a bunch of floating point samples
(frame_list,self.leftover_samples) = audiotools.FrameList.from_samples(
self.leftover_samples + self.stream.read(bytes),
self.channels)
#convert them to a pair of floating-point channel lists
l_channel = frame_list.channel(0)
r_channel = frame_list.channel(1)
#run our channel lists through the Yule and Butter filters
l_channel = self.butter_filter_l.filter(
self.yule_filter_l.filter(l_channel))
r_channel = self.butter_filter_r.filter(
self.yule_filter_r.filter(r_channel))
#convert our channel lists back to integer samples
multiplier = 1 << (self.bits_per_sample - 1)
return audiotools.pcmstream.pcm_to_string(
audiotools.FrameList.from_channels(
([int(round(s * multiplier)) for s in l_channel],
[int(round(s * multiplier)) for s in r_channel])),
self.bits_per_sample / 8,
False)
#this takes a PCMReader-compatible object
#it yields FrameLists, each 50ms long (1/20th of a second)
#how many PCM frames that is varies depending on the sample rate
def replay_gain_blocks(pcmreader):
unhandled_samples = [] #partial PCM frames
frame_pool = audiotools.FrameList([],pcmreader.channels)
reader = audiotools.pcmstream.PCMStreamReader(pcmreader,
pcmreader.bits_per_sample / 8,
False,False)
(framelist,unhandled_samples) = audiotools.FrameList.from_samples(
unhandled_samples + reader.read(audiotools.BUFFER_SIZE),
pcmreader.channels)
while ((len(framelist) > 0) or (len(unhandled_samples) > 0)):
frame_pool.extend(framelist)
while (frame_pool.total_frames() >= (pcmreader.sample_rate / 20)):
yield audiotools.FrameList(
frame_pool[0:
((pcmreader.sample_rate / 20) * pcmreader.channels)],
pcmreader.channels)
frame_pool = audiotools.FrameList(
frame_pool[((pcmreader.sample_rate / 20) * pcmreader.channels):],
pcmreader.channels)
(framelist,unhandled_samples) = audiotools.FrameList.from_samples(
unhandled_samples + reader.read(audiotools.BUFFER_SIZE),
pcmreader.channels)
reader.close()
#this drops the last block that's not 50ms long
#that's probably the right thing to do
#takes a PCMReader-compatible object with 2 channels and a
#supported sample rate
#returns the stream's ReplayGain value in dB
def calculate_replay_gain(pcmstream):
import math
def __mean__(l):
return sum(l) / len(l)
pcmstream = EqualLoudnessFilter(pcmstream)
db_blocks = []
for block in replay_gain_blocks(pcmstream):
left = __mean__([s ** 2 for s in block.channel(0)])
right = __mean__([s ** 2 for s in block.channel(1)])
db_blocks.append((left + right) / 2)
db_blocks = [10 * math.log10(b + 10 ** -10) for b in db_blocks]
db_blocks.sort()
replay_gain = db_blocks[int(round(len(db_blocks) * 0.95))]
return PINK_REF - replay_gain
if (__name__ == '__main__'):
pass

BIN
Melodia/resources/audiotools/resample.so Executable file
View File

Binary file not shown.

246
Melodia/resources/audiotools/toc.py Normal file
View File

@ -0,0 +1,246 @@
#!/usr/bin/python
#Audio Tools, a module and set of tools for manipulating audio data
#Copyright (C) 2008-2011 Brian Langenberger
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
"""The TOC file handling module."""
import re
from audiotools import SheetException, parse_timestamp, build_timestamp
import gettext
gettext.install("audiotools", unicode=True)
###################
#TOC Parsing
###################
class TOCException(SheetException):
"""Raised by TOC file parsing errors."""
pass
def parse(lines):
"""Returns a TOCFile object from an iterator of lines.
Raises TOCException if some problem occurs parsing the file."""
TRACKLINE = re.compile(r'TRACK AUDIO')
lines = list(lines)
if ('CD_DA' not in [line.strip() for line in lines]):
raise TOCException(_(u"No CD_DA TOC header found"))
lines = iter(lines)
toc = TOCFile()
track = None
track_number = 0
line_number = 0
try:
while (True):
line_number += 1
line = lines.next().strip()
if (len(line) == 0):
pass
elif (TRACKLINE.match(line)):
if (track is not None):
toc.tracks[track.number] = track
track_number += 1
track = Track(track_number)
else:
if (track is not None):
track.lines.append(line)
if (line.startswith('FILE') or
line.startswith('AUDIOFILE')):
if ('"' in line):
track.indexes = map(
parse_timestamp,
re.findall(r'\d+:\d+:\d+|\d+',
line[line.rindex('"') + 1:]))
else:
track.indexes = map(
parse_timestamp,
re.findall(r'\d+:\d+:\d+|\d+',
line))
elif (line.startswith('START')):
track.start = parse_timestamp(line[len('START '):])
else:
toc.lines.append(line)
except StopIteration:
if (track is not None):
toc.tracks[track.number] = track
return toc
class TOCFile:
"""An object representing a TOC file."""
def __init__(self):
self.lines = []
self.tracks = {}
def __repr__(self):
return "TOCFile(lines=%s,tracks=%s)" % (repr(self.lines),
repr(self.tracks))
def catalog(self):
"""Returns the cuesheet's CATALOG number as a plain string, or None.
If present, this value is typically a CD's UPC code."""
for line in self.lines:
if (line.startswith('CATALOG')):
result = re.search(r'"(.+)"', line)
if (result is not None):
return result.group(1)
else:
continue
else:
return None
def indexes(self):
"""Yields a set of index lists, one for each track in the file."""
for track in sorted(self.tracks.values()):
if (track.start != 0):
yield (track.indexes[0], track.indexes[0] + track.start)
else:
yield (track.indexes[0],)
def pcm_lengths(self, total_length):
"""Yields a list of PCM lengths for all audio tracks within the file.
total_length is the length of the entire file in PCM frames."""
previous = None
for current in self.indexes():
if (previous is None):
previous = current
else:
track_length = (max(current) - max(previous)) * (44100 / 75)
total_length -= track_length
yield track_length
previous = current
yield total_length
def ISRCs(self):
"""Returns a track_number->ISRC dict of all non-empty tracks."""
return dict([(track.number, track.ISRC()) for track in
self.tracks.values() if track.ISRC() is not None])
@classmethod
def file(cls, sheet, filename):
"""Constructs a new TOC file string from a compatible object.
sheet must have catalog(), indexes() and ISRCs() methods.
filename is a string to the filename the TOC file is created for.
Although we don't care whether the filename points to a real file,
other tools sometimes do.
"""
import cStringIO
catalog = sheet.catalog() # a catalog string, or None
indexes = list(sheet.indexes()) # a list of index tuples
ISRCs = sheet.ISRCs() # a track_number->ISRC dict
data = cStringIO.StringIO()
data.write("CD_DA\n\n")
if ((catalog is not None) and (len(catalog) > 0)):
data.write("CATALOG \"%s\"\n\n" % (catalog))
for (i, (current, next)) in enumerate(zip(indexes,
indexes[1:] + [None])):
tracknum = i + 1
data.write("TRACK AUDIO\n")
if (tracknum in ISRCs.keys()):
data.write("ISRC \"%s\"\n" % (ISRCs[tracknum]))
if (next is not None):
data.write("AUDIOFILE \"%s\" %s %s\n" % \
(filename,
build_timestamp(current[0]),
build_timestamp(next[0] - current[0])))
else:
data.write("AUDIOFILE \"%s\" %s\n" % \
(filename,
build_timestamp(current[0])))
if (len(current) > 1):
data.write("START %s\n" % \
(build_timestamp(current[-1] - current[0])))
if (next is not None):
data.write("\n")
return data.getvalue()
class Track:
"""A track inside a TOCFile object."""
def __init__(self, number):
self.number = number
self.lines = []
self.indexes = []
self.start = 0
def __cmp__(self, t):
return cmp(self.number, t.number)
def __repr__(self):
return "Track(%s,lines=%s,indexes=%s,start=%s)" % \
(repr(self.number), repr(self.lines),
repr(self.indexes), repr(self.start))
def ISRC(self):
"""Returns the track's ISRC value, or None."""
for line in self.lines:
if (line.startswith('ISRC')):
match = re.search(r'"(.+)"', line)
if (match is not None):
return match.group(1)
else:
return None
def read_tocfile(filename):
"""Returns a TOCFile from a TOC filename on disk.
Raises TOCException if some error occurs reading or parsing the file.
"""
try:
f = open(filename, 'r')
except IOError, msg:
raise TOCException(str(msg))
try:
return parse(iter(f.readlines()))
finally:
f.close()

BIN
Melodia/resources/audiotools/verify.so Executable file
View File

Binary file not shown.