def from_pcm(cls, filename, pcmreader,
compression=None, total_pcm_frames=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
encodes a new audio file from pcmreader's data
at the given filename with the specified compression level
and returns a new MP2Audio object"""
from audiotools import (PCMConverter,
BufferedPCMReader,
ChannelMask,
__default_quality__,
EncodingError)
from audiotools.encoders import encode_mp2
import bisect
if (((compression is None) or
(compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
if pcmreader.sample_rate in (32000, 48000, 44100):
sample_rate = pcmreader.sample_rate
else:
sample_rate = [32000,
32000,
44100,
48000][bisect.bisect([32000,
44100,
48000],
pcmreader.sample_rate)]
if total_pcm_frames is not None:
from audiotools import CounterPCMReader
pcmreader = CounterPCMReader(pcmreader)
try:
encode_mp2(filename,
PCMConverter(pcmreader,
sample_rate=sample_rate,
channels=min(pcmreader.channels, 2),
channel_mask=ChannelMask.from_channels(
min(pcmreader.channels, 2)),
bits_per_sample=16),
int(compression))
if ((total_pcm_frames is not None) and
(total_pcm_frames != pcmreader.frames_written)):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
cls.__unlink__(filename)
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return MP2Audio(filename)
except (ValueError, IOError) as err:
cls.__unlink__(filename)
raise EncodingError(str(err))
finally:
pcmreader.close()
def from_pcm(cls, filename, pcmreader,
compression=None, total_pcm_frames=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
encodes a new audio file from pcmreader's data
at the given filename with the specified compression level
and returns a new VorbisAudio object"""
from audiotools import (BufferedPCMReader,
__default_quality__,
EncodingError)
from audiotools.encoders import encode_vorbis
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, 24}:
from audiotools import UnsupportedBitsPerSample
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
if (pcmreader.channels > 2) and (pcmreader.channels <= 8):
channel_mask = int(pcmreader.channel_mask)
if ((channel_mask != 0) and
(channel_mask not 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
from audiotools import UnsupportedChannelMask
pcmreader.close()
raise UnsupportedChannelMask(filename, channel_mask)
if total_pcm_frames is not None:
from audiotools import CounterPCMReader
pcmreader = CounterPCMReader(pcmreader)
try:
encode_vorbis(filename,
pcmreader,
float(compression) / 10)
if ((total_pcm_frames is not None) and
(total_pcm_frames != pcmreader.frames_written)):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
cls.__unlink__(filename)
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return VorbisAudio(filename)
except (ValueError, IOError) as err:
cls.__unlink__(filename)
raise EncodingError(str(err))
finally:
pcmreader.close()
def from_pcm(cls,
filename,
pcmreader,
compression=None,
total_pcm_frames=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
encodes a new audio file from pcmreader's data
at the given filename with the specified compression level
and returns a new VorbisAudio object"""
from audiotools import (BufferedPCMReader, __default_quality__,
EncodingError)
from audiotools.encoders import encode_vorbis
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, 24}:
from audiotools import UnsupportedBitsPerSample
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
if (pcmreader.channels > 2) and (pcmreader.channels <= 8):
channel_mask = int(pcmreader.channel_mask)
if ((channel_mask != 0) and (channel_mask not 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
from audiotools import UnsupportedChannelMask
pcmreader.close()
raise UnsupportedChannelMask(filename, channel_mask)
if total_pcm_frames is not None:
from audiotools import CounterPCMReader
pcmreader = CounterPCMReader(pcmreader)
try:
encode_vorbis(filename, pcmreader, float(compression) / 10)
if ((total_pcm_frames is not None)
and (total_pcm_frames != pcmreader.frames_written)):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
cls.__unlink__(filename)
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return VorbisAudio(filename)
except (ValueError, IOError) as err:
cls.__unlink__(filename)
raise EncodingError(str(err))
finally:
pcmreader.close()
def from_pcm(cls, filename, pcmreader,
compression=None,
total_pcm_frames=None,
encoding_function=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
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 audiotools.encoders import encode_wavpack
from audiotools import BufferedPCMReader
from audiotools import CounterPCMReader
from audiotools import EncodingError
from audiotools import __default_quality__
if pcmreader.bits_per_sample not in (8, 16, 24):
# WavPack technically supports up to 32 bits-per-sample
# but nothing else does
# so I'll treat it as unsupported for now
from audiotools import UnsupportedBitsPerSample
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
if (((compression is None) or
(compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
counter = CounterPCMReader(pcmreader)
try:
(encode_wavpack if encoding_function is None
else encoding_function)(
filename=filename,
pcmreader=counter,
total_pcm_frames=(total_pcm_frames if
total_pcm_frames is not None else 0),
compression=compression)
counter.close()
except (ValueError, IOError) as msg:
counter.close()
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception:
counter.close()
cls.__unlink__(filename)
raise
# ensure actual total PCM frames matches argument, if any
if (((total_pcm_frames is not None) and
(counter.frames_written != total_pcm_frames))):
cls.__unlink__(filename)
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return cls(filename)
def from_pcm(cls, filename, pcmreader, compression=None, total_pcm_frames=None, encoding_function=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
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 audiotools.encoders import encode_wavpack
from audiotools import BufferedPCMReader
from audiotools import CounterPCMReader
from audiotools import EncodingError
from audiotools import __default_quality__
if pcmreader.bits_per_sample not in (8, 16, 24):
# WavPack technically supports up to 32 bits-per-sample
# but nothing else does
# so I'll treat it as unsupported for now
from audiotools import UnsupportedBitsPerSample
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
if (compression is None) or (compression not in cls.COMPRESSION_MODES):
compression = __default_quality__(cls.NAME)
counter = CounterPCMReader(pcmreader)
try:
(encode_wavpack if encoding_function is None else encoding_function)(
filename=filename,
pcmreader=counter,
total_pcm_frames=(total_pcm_frames if total_pcm_frames is not None else 0),
compression=compression,
)
counter.close()
except (ValueError, IOError) as msg:
counter.close()
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception:
counter.close()
cls.__unlink__(filename)
raise
# ensure actual total PCM frames matches argument, if any
if (total_pcm_frames is not None) and (counter.frames_written != total_pcm_frames):
cls.__unlink__(filename)
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return cls(filename)
def from_pcm(cls, filename, pcmreader,
compression=None,
total_pcm_frames=None,
encoding_function=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
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 audiotools.encoders import encode_wavpack
from audiotools import BufferedPCMReader
from audiotools import CounterPCMReader
from audiotools import EncodingError
from audiotools import __default_quality__
if (((compression is None) or
(compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
counter = CounterPCMReader(pcmreader)
try:
(encode_wavpack if encoding_function is None
else encoding_function)(
filename,
BufferedPCMReader(counter),
total_pcm_frames=(total_pcm_frames if
total_pcm_frames is not None else 0),
**cls.__options__[compression])
counter.close()
except (ValueError, IOError) as msg:
counter.close()
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception:
counter.close()
cls.__unlink__(filename)
raise
# ensure actual total PCM frames matches argument, if any
if (((total_pcm_frames is not None) and
(counter.frames_written != total_pcm_frames))):
cls.__unlink__(filename)
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return cls(filename)
def from_pcm(cls, filename, pcmreader,
compression=None,
total_pcm_frames=None,
encoding_function=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
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 audiotools.encoders import encode_wavpack
from audiotools import BufferedPCMReader
from audiotools import CounterPCMReader
from audiotools import EncodingError
from audiotools import __default_quality__
if (((compression is None) or
(compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
counter = CounterPCMReader(pcmreader)
try:
(encode_wavpack if encoding_function is None
else encoding_function)(
filename,
BufferedPCMReader(counter),
total_pcm_frames=(total_pcm_frames if
total_pcm_frames is not None else 0),
**cls.__options__[compression])
counter.close()
except (ValueError, IOError) as msg:
counter.close()
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception:
counter.close()
cls.__unlink__(filename)
raise
# ensure actual total PCM frames matches argument, if any
if (((total_pcm_frames is not None) and
(counter.frames_written != total_pcm_frames))):
cls.__unlink__(filename)
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return cls(filename)
def from_wave(cls, filename, header, pcmreader, footer, compression=None,
encoding_function=None):
"""encodes a new file from wave data
takes a filename string, header string,
PCMReader object, footer string
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 WaveAudio object
header + pcm data + footer should always result
in the original wave file being restored
without need for any padding bytes
may raise EncodingError if some problem occurs when
encoding the input file"""
from audiotools.encoders import encode_wavpack
from audiotools import BufferedPCMReader
from audiotools import CounterPCMReader
from audiotools.wav import (validate_header, validate_footer)
from audiotools import EncodingError
from audiotools import __default_quality__
if (((compression is None) or
(compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
# ensure header is valid
try:
(total_size, data_size) = validate_header(header)
except ValueError as err:
raise EncodingError(str(err))
counter = CounterPCMReader(pcmreader)
try:
(encode_wavpack if encoding_function is None
else encoding_function)(filename,
BufferedPCMReader(counter),
wave_header=header,
wave_footer=footer,
**cls.__options__[compression])
counter.close()
data_bytes_written = counter.bytes_written()
# ensure output data size matches the "data" chunk's size
if (data_size != data_bytes_written):
from audiotools.text import ERR_WAV_TRUNCATED_DATA_CHUNK
raise EncodingError(ERR_WAV_TRUNCATED_DATA_CHUNK)
# ensure footer validates correctly
try:
validate_footer(footer, data_bytes_written)
except ValueError as err:
raise EncodingError(str(err))
# ensure total size is correct
if ((len(header) + data_size + len(footer)) != total_size):
from audiotools.text import ERR_WAV_INVALID_SIZE
raise EncodingError(ERR_WAV_INVALID_SIZE)
return cls(filename)
except (ValueError, IOError) as msg:
counter.close()
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception as err:
counter.close()
cls.__unlink__(filename)
raise err
def from_pcm(cls, filename, pcmreader,
compression=None, total_pcm_frames=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
encodes a new audio file from pcmreader's data
at the given filename with the specified compression level
and returns a new AudioFile-compatible object
may raise EncodingError if some problem occurs when
encoding the input file. This includes an error
in the input stream, a problem writing the output file,
or even an EncodingError subclass such as
"UnsupportedBitsPerSample" if the input stream
is formatted in a way this class is unable to support
"""
from audiotools import (BufferedPCMReader,
PCMConverter,
__default_quality__,
EncodingError)
from audiotools.encoders import encode_opus
if (((compression is None) or
(compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
if (pcmreader.channels > 2) and (pcmreader.channels <= 8):
if ((pcmreader.channel_mask != 0) and
(pcmreader.channel_mask not 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
from audiotools import UnsupportedChannelMask
pcmreader.close()
raise UnsupportedChannelMask(filename, channel_mask)
try:
if total_pcm_frames is not None:
from audiotools import CounterPCMReader
pcmreader = CounterPCMReader(pcmreader)
encode_opus(filename,
PCMConverter(pcmreader,
sample_rate=48000,
channels=pcmreader.channels,
channel_mask=pcmreader.channel_mask,
bits_per_sample=16),
quality=int(compression),
original_sample_rate=pcmreader.sample_rate)
pcmreader.close()
if ((total_pcm_frames is not None) and
(total_pcm_frames != pcmreader.frames_written)):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
cls.__unlink__(filename)
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return cls(filename)
except (ValueError, IOError) as err:
pcmreader.close()
cls.__unlink__(filename)
raise EncodingError(err)
def from_aiff(cls, filename, header, pcmreader, footer, compression=None,
block_size=256, encoding_function=None):
"""encodes a new file from AIFF data
takes a filename string, header string,
PCMReader object, footer string
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
header + pcm data + footer should always result
in the original AIFF file being restored
without need for any padding bytes
may raise EncodingError if some problem occurs when
encoding the input file"""
from audiotools import (CounterPCMReader,
BufferedPCMReader,
UnsupportedBitsPerSample,
EncodingError)
from audiotools.aiff import (validate_header, validate_footer)
if encoding_function is None:
from audiotools.encoders import encode_shn
else:
encode_shn = encoding_function
if pcmreader.bits_per_sample not in {8, 16}:
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
# ensure header is valid
try:
(total_size, ssnd_size) = validate_header(header)
except ValueError as err:
pcmreader.close()
raise EncodingError(str(err))
counter = CounterPCMReader(pcmreader)
try:
if len(footer) == 0:
encode_shn(filename=filename,
pcmreader=BufferedPCMReader(counter),
is_big_endian=True,
signed_samples=True,
header_data=header,
block_size=block_size)
else:
encode_shn(filename=filename,
pcmreader=BufferedPCMReader(counter),
is_big_endian=True,
signed_samples=True,
header_data=header,
footer_data=footer,
block_size=block_size)
counter.close()
ssnd_bytes_written = counter.bytes_written()
# ensure output data size matches the "SSND" chunk's size
if ssnd_size != ssnd_bytes_written:
from audiotools.text import ERR_AIFF_TRUNCATED_SSND_CHUNK
raise EncodingError(ERR_AIFF_TRUNCATED_SSND_CHUNK)
# ensure footer validates correctly
try:
validate_footer(footer, ssnd_bytes_written)
except ValueError as err:
raise EncodingError(str(err))
# ensure total size is correct
if (len(header) + ssnd_size + len(footer)) != total_size:
from audiotools.text import ERR_AIFF_INVALID_SIZE
raise EncodingError(ERR_AIFF_INVALID_SIZE)
return cls(filename)
except IOError as err:
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception as err:
cls.__unlink__(filename)
raise err
def from_wave(cls, filename, header, pcmreader, footer, compression=None,
encoding_function=None):
"""encodes a new file from wave data
takes a filename string, header string,
PCMReader object, footer string
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 WaveAudio object
header + pcm data + footer should always result
in the original wave file being restored
without need for any padding bytes
may raise EncodingError if some problem occurs when
encoding the input file"""
from audiotools.encoders import encode_wavpack
from audiotools import BufferedPCMReader
from audiotools import CounterPCMReader
from audiotools.wav import (validate_header, validate_footer)
from audiotools import EncodingError
from audiotools import __default_quality__
if (((compression is None) or
(compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
# ensure header is valid
try:
(total_size, data_size) = validate_header(header)
except ValueError as err:
raise EncodingError(str(err))
counter = CounterPCMReader(pcmreader)
try:
(encode_wavpack if encoding_function is None
else encoding_function)(filename,
BufferedPCMReader(counter),
wave_header=header,
wave_footer=footer,
**cls.__options__[compression])
counter.close()
data_bytes_written = counter.bytes_written()
# ensure output data size matches the "data" chunk's size
if data_size != data_bytes_written:
from audiotools.text import ERR_WAV_TRUNCATED_DATA_CHUNK
raise EncodingError(ERR_WAV_TRUNCATED_DATA_CHUNK)
# ensure footer validates correctly
try:
validate_footer(footer, data_bytes_written)
except ValueError as err:
raise EncodingError(str(err))
# ensure total size is correct
if (len(header) + data_size + len(footer)) != total_size:
from audiotools.text import ERR_WAV_INVALID_SIZE
raise EncodingError(ERR_WAV_INVALID_SIZE)
return cls(filename)
except (ValueError, IOError) as msg:
counter.close()
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception as err:
counter.close()
cls.__unlink__(filename)
raise err
def from_pcm(cls,
filename,
pcmreader,
compression=None,
total_pcm_frames=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
encodes a new audio file from pcmreader's data
at the given filename with the specified compression level
and returns a new AudioFile-compatible object
may raise EncodingError if some problem occurs when
encoding the input file. This includes an error
in the input stream, a problem writing the output file,
or even an EncodingError subclass such as
"UnsupportedBitsPerSample" if the input stream
is formatted in a way this class is unable to support
"""
from audiotools import (BufferedPCMReader, PCMConverter,
__default_quality__, EncodingError)
from audiotools.encoders import encode_opus
if (((compression is None)
or (compression not in cls.COMPRESSION_MODES))):
compression = __default_quality__(cls.NAME)
if (pcmreader.channels > 2) and (pcmreader.channels <= 8):
if ((pcmreader.channel_mask != 0)
and (pcmreader.channel_mask not 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
from audiotools import UnsupportedChannelMask
pcmreader.close()
raise UnsupportedChannelMask(filename, channel_mask)
try:
if total_pcm_frames is not None:
from audiotools import CounterPCMReader
pcmreader = CounterPCMReader(pcmreader)
encode_opus(filename,
PCMConverter(pcmreader,
sample_rate=48000,
channels=pcmreader.channels,
channel_mask=pcmreader.channel_mask,
bits_per_sample=16),
quality=int(compression),
original_sample_rate=pcmreader.sample_rate)
pcmreader.close()
if ((total_pcm_frames is not None)
and (total_pcm_frames != pcmreader.frames_written)):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
cls.__unlink__(filename)
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return cls(filename)
except (ValueError, IOError) as err:
pcmreader.close()
cls.__unlink__(filename)
raise EncodingError(err)
def from_aiff(cls, filename, header, pcmreader, footer, compression=None,
block_size=256, encoding_function=None):
"""encodes a new file from AIFF data
takes a filename string, header string,
PCMReader object, footer string
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
header + pcm data + footer should always result
in the original AIFF file being restored
without need for any padding bytes
may raise EncodingError if some problem occurs when
encoding the input file"""
from audiotools import (CounterPCMReader,
BufferedPCMReader,
UnsupportedBitsPerSample,
EncodingError)
from audiotools.aiff import (validate_header, validate_footer)
if (encoding_function is None):
from audiotools.encoders import encode_shn
else:
encode_shn = encoding_function
if (pcmreader.bits_per_sample not in {8, 16}):
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
# ensure header is valid
try:
(total_size, ssnd_size) = validate_header(header)
except ValueError as err:
pcmreader.close()
raise EncodingError(str(err))
counter = CounterPCMReader(pcmreader)
try:
if (len(footer) == 0):
encode_shn(filename=filename,
pcmreader=BufferedPCMReader(counter),
is_big_endian=True,
signed_samples=True,
header_data=header,
block_size=block_size)
else:
encode_shn(filename=filename,
pcmreader=BufferedPCMReader(counter),
is_big_endian=True,
signed_samples=True,
header_data=header,
footer_data=footer,
block_size=block_size)
counter.close()
ssnd_bytes_written = counter.bytes_written()
# ensure output data size matches the "SSND" chunk's size
if (ssnd_size != ssnd_bytes_written):
from audiotools.text import ERR_AIFF_TRUNCATED_SSND_CHUNK
raise EncodingError(ERR_AIFF_TRUNCATED_SSND_CHUNK)
# ensure footer validates correctly
try:
validate_footer(footer, ssnd_bytes_written)
except ValueError as err:
raise EncodingError(str(err))
# ensure total size is correct
if ((len(header) + ssnd_size + len(footer)) != total_size):
from audiotools.text import ERR_AIFF_INVALID_SIZE
raise EncodingError(ERR_AIFF_INVALID_SIZE)
return cls(filename)
except IOError as err:
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception as err:
cls.__unlink__(filename)
raise err
def from_pcm(cls, filename, pcmreader,
compression=None,
total_pcm_frames=None):
from audiotools import __default_quality__
from audiotools import PCMConverter
from audiotools import ChannelMask
from audiotools.encoders import encode_mpc
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, 24}:
from audiotools import UnsupportedBitsPerSample
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
if pcmreader.sample_rate in (32000, 37800, 44100, 48000):
sample_rate = pcmreader.sample_rate
if total_pcm_frames is not None:
from audiotools import CounterPCMReader
pcmreader = CounterPCMReader(pcmreader)
else:
from bisect import bisect
sample_rate = [32000,
32000,
37800,
44100,
48000][bisect([32000, 37800, 44100, 4800],
pcmreader.sample_rate)]
total_pcm_frames = None
try:
encode_mpc(
filename,
PCMConverter(pcmreader,
sample_rate=sample_rate,
channels=min(pcmreader.channels, 2),
channel_mask=int(ChannelMask.from_channels(
min(pcmreader.channels, 2))),
bits_per_sample=16),
float(compression),
total_pcm_frames if (total_pcm_frames is not None) else 0)
# ensure PCM frames match, if indicated
if ((total_pcm_frames is not None) and
(total_pcm_frames != pcmreader.frames_written)):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
from audiotools import EncodingError
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return MPCAudio(filename)
except (IOError, ValueError) as err:
from audiotools import EncodingError
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception:
cls.__unlink__(filename)
raise
finally:
pcmreader.close()
def from_pcm(cls,
filename,
pcmreader,
compression=None,
total_pcm_frames=None):
from audiotools import __default_quality__
from audiotools import PCMConverter
from audiotools import ChannelMask
from audiotools.encoders import encode_mpc
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, 24}:
from audiotools import UnsupportedBitsPerSample
pcmreader.close()
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
if pcmreader.sample_rate in (32000, 37800, 44100, 48000):
sample_rate = pcmreader.sample_rate
if total_pcm_frames is not None:
from audiotools import CounterPCMReader
pcmreader = CounterPCMReader(pcmreader)
else:
from bisect import bisect
sample_rate = [32000, 32000, 37800, 44100,
48000][bisect([32000, 37800, 44100, 4800],
pcmreader.sample_rate)]
total_pcm_frames = None
try:
encode_mpc(
filename,
PCMConverter(pcmreader,
sample_rate=sample_rate,
channels=min(pcmreader.channels, 2),
channel_mask=int(
ChannelMask.from_channels(
min(pcmreader.channels, 2))),
bits_per_sample=16), float(compression),
total_pcm_frames if (total_pcm_frames is not None) else 0)
# ensure PCM frames match, if indicated
if ((total_pcm_frames is not None)
and (total_pcm_frames != pcmreader.frames_written)):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
from audiotools import EncodingError
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
return MPCAudio(filename)
except (IOError, ValueError) as err:
from audiotools import EncodingError
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception:
cls.__unlink__(filename)
raise
finally:
pcmreader.close()
def from_pcm(cls, filename, pcmreader,
compression=None,
total_pcm_frames=None,
encoding_function=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
encodes a new audio file from pcmreader's data
at the given filename with the specified compression level
and returns a new AudioFile-compatible object
may raise EncodingError if some problem occurs when
encoding the input file. This includes an error
in the input stream, a problem writing the output file,
or even an EncodingError subclass such as
"UnsupportedBitsPerSample" if the input stream
is formatted in a way this class is unable to support
"""
from audiotools import (BufferedPCMReader,
CounterPCMReader,
transfer_data,
EncodingError)
# from audiotools.py_encoders import encode_tta
from audiotools.encoders import encode_tta
from audiotools.bitstream import BitstreamWriter
# open output file right away
# so we can fail as soon as possible
try:
file = open(filename, "wb")
except IOError as err:
pcmreader.close()
raise EncodingError(str(err))
writer = BitstreamWriter(file, True)
counter = CounterPCMReader(pcmreader)
try:
if (total_pcm_frames is not None):
# write header to disk
write_header(writer,
pcmreader.channels,
pcmreader.bits_per_sample,
pcmreader.sample_rate,
total_pcm_frames)
block_size = (pcmreader.sample_rate * 256) // 245
total_tta_frames = div_ceil(total_pcm_frames, block_size)
# write temporary seektable to disk
writer.mark()
write_seektable(writer, [0] * total_tta_frames)
writer.flush()
# write frames to disk
try:
frame_sizes = \
(encode_tta if encoding_function is None
else encoding_function)(file,
BufferedPCMReader(counter))
except (IOError, ValueError) as err:
cls.__unlink__(filename)
raise EncodingError(str(err))
# ensure written number of PCM frames
# matches total_pcm_frames
if (counter.frames_written != total_pcm_frames):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
cls.__unlink__(filename)
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
assert(len(frame_sizes) == total_tta_frames)
# go back and rewrite seektable with completed one
writer.rewind()
write_seektable(writer, frame_sizes)
writer.unmark()
else:
import tempfile
frames = tempfile.TemporaryFile()
# encode TTA frames to temporary file
try:
frame_sizes = \
(encode_tta if encoding_function is None
else encoding_function)(frames,
BufferedPCMReader(counter))
except (IOError, ValueError) as err:
frames.close()
cls.__unlink__(filename)
raise EncodingError(str(err))
# write header to disk
write_header(writer,
pcmreader.channels,
pcmreader.bits_per_sample,
pcmreader.sample_rate,
counter.frames_written)
# write seektable to disk
write_seektable(writer, frame_sizes)
# transfer TTA frames from temporary space to disk
frames.seek(0, 0)
transfer_data(frames.read, writer.write_bytes)
frames.close()
finally:
counter.close()
if (writer.has_mark()):
writer.unmark()
writer.close()
return cls(filename)
def from_pcm(cls,
filename,
pcmreader,
compression=None,
total_pcm_frames=None,
encoding_function=None):
"""encodes a new file from PCM data
takes a filename string, PCMReader object,
optional compression level string and
optional total_pcm_frames integer
encodes a new audio file from pcmreader's data
at the given filename with the specified compression level
and returns a new AudioFile-compatible object
may raise EncodingError if some problem occurs when
encoding the input file. This includes an error
in the input stream, a problem writing the output file,
or even an EncodingError subclass such as
"UnsupportedBitsPerSample" if the input stream
is formatted in a way this class is unable to support
"""
from audiotools import (BufferedPCMReader, CounterPCMReader,
transfer_data, EncodingError)
# from audiotools.py_encoders import encode_tta
from audiotools.encoders import encode_tta
from audiotools.bitstream import BitstreamWriter
# open output file right away
# so we can fail as soon as possible
try:
file = open(filename, "wb")
except IOError as err:
pcmreader.close()
raise EncodingError(str(err))
writer = BitstreamWriter(file, True)
counter = CounterPCMReader(pcmreader)
try:
if (total_pcm_frames is not None):
# write header to disk
write_header(writer, pcmreader.channels,
pcmreader.bits_per_sample, pcmreader.sample_rate,
total_pcm_frames)
block_size = (pcmreader.sample_rate * 256) // 245
total_tta_frames = div_ceil(total_pcm_frames, block_size)
# write temporary seektable to disk
writer.mark()
write_seektable(writer, [0] * total_tta_frames)
writer.flush()
# write frames to disk
try:
frame_sizes = \
(encode_tta if encoding_function is None
else encoding_function)(file,
BufferedPCMReader(counter))
except (IOError, ValueError) as err:
cls.__unlink__(filename)
raise EncodingError(str(err))
# ensure written number of PCM frames
# matches total_pcm_frames
if (counter.frames_written != total_pcm_frames):
from audiotools.text import ERR_TOTAL_PCM_FRAMES_MISMATCH
cls.__unlink__(filename)
raise EncodingError(ERR_TOTAL_PCM_FRAMES_MISMATCH)
assert (len(frame_sizes) == total_tta_frames)
# go back and rewrite seektable with completed one
writer.rewind()
write_seektable(writer, frame_sizes)
writer.unmark()
else:
import tempfile
frames = tempfile.TemporaryFile()
# encode TTA frames to temporary file
try:
frame_sizes = \
(encode_tta if encoding_function is None
else encoding_function)(frames,
BufferedPCMReader(counter))
except (IOError, ValueError) as err:
frames.close()
cls.__unlink__(filename)
raise EncodingError(str(err))
# write header to disk
write_header(writer, pcmreader.channels,
pcmreader.bits_per_sample, pcmreader.sample_rate,
counter.frames_written)
# write seektable to disk
write_seektable(writer, frame_sizes)
# transfer TTA frames from temporary space to disk
frames.seek(0, 0)
transfer_data(frames.read, writer.write_bytes)
frames.close()
finally:
counter.close()
if (writer.has_mark()):
writer.unmark()
writer.close()
return cls(filename)
