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))
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 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()
#FIXME - check errors here
try:
encoders.encode_wavpack(filename,
wave.to_pcm(),
wave_header=head,
wave_footer=tail,
**cls.__options__[compression])
return cls(filename)
except (ValueError, IOError), msg:
cls.__unlink__(filename)
raise EncodingError(str(msg))
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()
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()
def channel_mask(self):
fmt_chunk = WaveAudio.FMT_CHUNK.parse(self.__fmt_chunk__())
if (fmt_chunk.compression != 0xFFFE):
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)
#if we have a multi-channel WavPack file
#that's not WAVEFORMATEXTENSIBLE,
#assume the channels follow SMPTE/ITU-R recommendations
#and hope for the best
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,
back_left=True,
back_right=True,
front_center=True)
elif (self.__channels__ == 6):
return ChannelMask.from_fields(front_left=True,
front_right=True,
back_left=True,
back_right=True,
front_center=True,
low_frequency=True)
else:
return ChannelMask(0)
else:
return WaveAudio.fmt_chunk_to_channel_mask(fmt_chunk.channel_mask)
def from_pcm(cls, filename, pcmreader, compression=None):
compression_param = {
"fast": ["-f"],
"standard": [],
"high": ["-h"],
"veryhigh": ["-hh"]
}
if (str(compression) not in cls.COMPRESSION_MODES):
compression = cls.DEFAULT_COMPRESSION
if ('--raw-pcm' in cls.__wavpack_help__()):
if (filename.endswith(".wv")):
devnull = file(os.devnull, 'ab')
if (pcmreader.channels > 18):
raise UnsupportedChannelMask()
elif (pcmreader.channels > 2):
order_map = {
"front_left": "FL",
"front_right": "FR",
"front_center": "FC",
"low_frequency": "LFE",
"back_left": "BL",
"back_right": "BR",
"front_left_of_center": "FLC",
"front_right_of_center": "FRC",
"back_center": "BC",
"side_left": "SL",
"side_right": "SR",
"top_center": "TC",
"top_front_left": "TFL",
"top_front_center": "TFC",
"top_front_right": "TFR",
"top_back_left": "TBL",
"top_back_center": "TBC",
"top_back_right": "TBR"
}
channel_order = [
"--channel-order=%s" % (",".join([
order_map[channel] for channel in ChannelMask(
pcmreader.channel_mask).channels()
]))
]
else:
channel_order = []
sub = subprocess.Popen([BIN['wavpack']] + \
compression_param[compression] + \
['-q','-y',
"--raw-pcm=%(sr)s,%(bps)s,%(ch)s"%\
{"sr":pcmreader.sample_rate,
"bps":pcmreader.bits_per_sample,
"ch":pcmreader.channels}] + \
channel_order + \
['-','-o',filename],
stdout=devnull,
stderr=devnull,
stdin=subprocess.PIPE,
preexec_fn=ignore_sigint)
transfer_framelist_data(pcmreader, sub.stdin.write)
devnull.close()
sub.stdin.close()
if (sub.wait() == 0):
return WavPackAudio(filename)
else:
raise EncodingError(BIN['wavpack'])
else:
import tempfile
tempdir = tempfile.mkdtemp()
symlink = os.path.join(tempdir,
os.path.basename(filename) + ".wv")
try:
os.symlink(os.path.abspath(filename), symlink)
cls.from_pcm(symlink, pcmreader, compression)
return WavPackAudio(filename)
finally:
os.unlink(symlink)
os.rmdir(tempdir)
else:
import tempfile
f = tempfile.NamedTemporaryFile(suffix=".wav")
w = WaveAudio.from_pcm(f.name, pcmreader)
try:
return cls.from_wave(filename, w.filename, compression)
finally:
del (w)
f.close()
