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"""
from audiotools import CounterPCMReader
from audiotools import transfer_framelist_data
from audiotools import to_pcm_progress
try:
(header, footer) = self.wave_header_footer()
except IOError as err:
raise InvalidWave(err)
except ValueError as err:
raise InvalidWave(err)
# ensure header is valid
try:
(total_size, data_size) = validate_header(header)
except ValueError as err:
raise InvalidWave(err)
# ensure "data" chunk has all its data
counter = CounterPCMReader(to_pcm_progress(self, progress))
try:
transfer_framelist_data(counter, lambda f: f)
except (IOError, ValueError):
from audiotools.text import ERR_WAV_TRUNCATED_DATA_CHUNK
raise InvalidWave(ERR_WAV_TRUNCATED_DATA_CHUNK)
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 InvalidWave(ERR_WAV_TRUNCATED_DATA_CHUNK)
# ensure footer validates correctly
try:
validate_footer(footer, data_bytes_written)
except ValueError as err:
from audiotools.text import ERR_WAV_INVALID_SIZE
raise InvalidWave(ERR_WAV_INVALID_SIZE)
# ensure total size is correct
if (len(header) + data_size + len(footer)) != total_size:
from audiotools.text import ERR_WAV_INVALID_SIZE
raise InvalidWave(ERR_WAV_INVALID_SIZE)
return True
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_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])
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:
cls.__unlink__(filename)
raise EncodingError(str(msg))
except Exception as err:
cls.__unlink__(filename)
raise 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)):
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
# ensure header is valid
try:
(total_size, ssnd_size) = validate_header(header)
except ValueError as err:
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)
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_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)):
raise UnsupportedBitsPerSample(filename, pcmreader.bits_per_sample)
# ensure header is valid
try:
(total_size, ssnd_size) = validate_header(header)
except ValueError as err:
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)
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,
block_size=256, 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 import (CounterPCMReader,
BufferedPCMReader,
UnsupportedBitsPerSample,
EncodingError)
from audiotools.wav 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, data_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=False,
signed_samples=pcmreader.bits_per_sample == 16,
header_data=header,
block_size=block_size)
else:
encode_shn(filename=filename,
pcmreader=BufferedPCMReader(counter),
is_big_endian=False,
signed_samples=pcmreader.bits_per_sample == 16,
header_data=header,
footer_data=footer,
block_size=block_size)
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 (IOError, ValueError) as err:
counter.close()
cls.__unlink__(filename)
raise EncodingError(str(err))
except Exception as err:
counter.close()
cls.__unlink__(filename)
raise err
