def encode_frame(writer, pcmreader, options, channels):
assert (len(channels) > 0)
uncompressed_frame = BitstreamRecorder(0)
compressed_frame = BitstreamRecorder(0)
writer.write(3, len(channels) - 1)
encode_uncompressed_frame(uncompressed_frame, pcmreader, options, channels)
if (len(channels[0]) >= 10):
try:
encode_compressed_frame(compressed_frame, pcmreader, options,
channels)
if (compressed_frame.bits() < uncompressed_frame.bits()):
compressed_frame.copy(writer)
else:
uncompressed_frame.copy(writer)
except ResidualOverflow:
uncompressed_frame.copy(writer)
else:
uncompressed_frame.copy(writer)
def encode_compressed_frame(writer, pcmreader, options, channels):
if pcmreader.bits_per_sample <= 16:
uncompressed_LSBs = 0
LSBs = []
else:
from audiotools.pcm import from_list
# extract uncompressed LSBs
uncompressed_LSBs = (pcmreader.bits_per_sample - 16) // 8
LSBs = []
for i in range(len(channels[0])):
for c in range(len(channels)):
LSBs.append(channels[c][i] %
(2 ** (pcmreader.bits_per_sample - 16)))
channels = [from_list([i >> (pcmreader.bits_per_sample - 16)
for i in channel], 1, 16, True)
for channel in channels]
if len(channels) == 1:
encode_non_interlaced_frame(writer,
pcmreader,
options,
uncompressed_LSBs,
LSBs,
channels)
else:
interlaced_frames = [BitstreamRecorder(0) for i in
range(options.min_interlacing_leftweight,
options.max_interlacing_leftweight + 1)]
for (leftweight,
frame) in zip(range(options.min_interlacing_leftweight,
options.max_interlacing_leftweight + 1),
interlaced_frames):
encode_interlaced_frame(frame,
pcmreader,
options,
uncompressed_LSBs,
LSBs,
options.interlacing_shift,
leftweight,
channels)
for i in range(len(interlaced_frames) - 1):
if ((interlaced_frames[i].bits() <
min([f.bits() for f in interlaced_frames[i + 1:]]))):
interlaced_frames[i].copy(writer)
break
else:
interlaced_frames[0].copy(writer)
def build(self, writer):
"""outputs an APEv2 tag to writer"""
from audiotools.bitstream import BitstreamRecorder
tags = BitstreamRecorder(1)
for tag in self.tags:
tag.build(tags)
if (self.contains_header):
writer.build(
ApeTag.HEADER_FORMAT,
(
"APETAGEX", # preamble
2000, # version
tags.bytes() + 32, # tag size
len(self.tags), # item count
0, # read only
0, # encoding
1, # is header
not self.contains_footer, # no footer
self.contains_header)) # has header
tags.copy(writer)
if (self.contains_footer):
writer.build(
ApeTag.HEADER_FORMAT,
(
"APETAGEX", # preamble
2000, # version
tags.bytes() + 32, # tag size
len(self.tags), # item count
0, # read only
0, # encoding
0, # is header
not self.contains_footer, # no footer
self.contains_header)) # has header
def encode_flac(filename,
pcmreader,
block_size=4096,
max_lpc_order=8,
min_residual_partition_order=0,
max_residual_partition_order=5,
mid_side=True,
adaptive_mid_side=False,
exhaustive_model_search=False,
disable_verbatim_subframes=False,
disable_constant_subframes=False,
disable_fixed_subframes=False,
disable_lpc_subframes=False,
padding_size=4096):
frame_sizes = []
options = Encoding_Options(block_size, max_lpc_order, adaptive_mid_side,
mid_side, exhaustive_model_search,
max_residual_partition_order,
14 if pcmreader.bits_per_sample <= 16 else 30)
streaminfo = STREAMINFO(block_size, block_size, (2**24) - 1, 0,
pcmreader.sample_rate, pcmreader.channels,
pcmreader.bits_per_sample, 0, md5())
pcmreader = BufferedPCMReader(pcmreader)
output_file = open(filename, "wb")
writer = BitstreamWriter(output_file, False)
# write placeholder metadata blocks such as STREAMINFO and PADDING
writer.write_bytes("fLaC")
writer.build("1u 7u 24u", [0, 0, 34])
streaminfo_start = writer.getpos()
streaminfo.write(writer)
writer.build("1u 7u 24u", [1, 1, padding_size])
writer.write_bytes(b"\x00" * padding_size)
# walk through PCM reader's FrameLists
frame_number = 0
frame = pcmreader.read(block_size)
flac_frame = BitstreamRecorder(0)
while len(frame) > 0:
streaminfo.input_update(frame)
flac_frame.reset()
encode_flac_frame(flac_frame, pcmreader, options, frame_number, frame)
frame_sizes.append((flac_frame.bytes(), frame.frames))
streaminfo.output_update(flac_frame)
flac_frame.copy(writer)
frame_number += 1
frame = pcmreader.read(block_size)
# return to beginning of file and rewrite STREAMINFO block
writer.setpos(streaminfo_start)
streaminfo.write(writer)
writer.flush()
writer.close()
return frame_sizes
def encode_lpc_subframe(writer, options, wasted_bps, bits_per_sample, samples):
"""computes the best LPC subframe from the given samples
according to the options and writes it to the given BitstreamWriter"""
# window signal
windowed = [(sample * tukey)
for (sample,
tukey) in zip(samples, tukey_window(len(samples), 0.5))]
# compute autocorrelation values
if len(samples) > (options.max_lpc_order + 1):
autocorrelation_values = [
sum(x * y for x, y in zip(windowed, windowed[lag:]))
for lag in range(0, options.max_lpc_order + 1)
]
else:
# not enough samples, so build LPC with dummy coeffs
write_lpc_subframe(writer=writer,
options=options,
wasted_bps=wasted_bps,
bits_per_sample=bits_per_sample,
order=1,
qlp_precision=options.qlp_precision,
qlp_shift_needed=0,
qlp_coefficients=[0],
samples=samples)
return
# compute LP coefficients from autocorrelation values
if ((len(autocorrelation_values) > 1)
and (set(autocorrelation_values) != {0.0})):
(lp_coefficients, error) = \
compute_lp_coefficients(autocorrelation_values)
else:
# all autocorrelation values are zero
# so build LPC with dummy coeffs
write_lpc_subframe(writer=writer,
options=options,
wasted_bps=wasted_bps,
bits_per_sample=bits_per_sample,
order=1,
qlp_precision=options.qlp_precision,
qlp_shift_needed=0,
qlp_coefficients=[0],
samples=samples)
return
if not options.exhaustive_model_search:
# if not performaing an exhaustive model search
# estimate which set of LP coefficients is best
# and use those to build subframe
order = estimate_best_lpc_order(options, len(samples), bits_per_sample,
error)
(qlp_coefficients, qlp_shift_needed) = \
quantize_coefficients(options.qlp_precision,
lp_coefficients,
order)
write_lpc_subframe(writer=writer,
options=options,
wasted_bps=wasted_bps,
bits_per_sample=bits_per_sample,
order=order,
qlp_precision=options.qlp_precision,
qlp_shift_needed=qlp_shift_needed,
qlp_coefficients=qlp_coefficients,
samples=samples)
else:
# otherwise, build all possible subframes
# and return the one which is actually the smallest
best_subframe_size = 2**32
best_subframe = BitstreamRecorder(0)
for order in range(1, options.max_lpc_order + 1):
(qlp_coefficients, qlp_shift_needed) = \
quantize_coefficients(options.qlp_precision,
lp_coefficients,
order)
subframe = BitstreamRecorder(0)
write_lpc_subframe(writer=subframe,
options=options,
wasted_bps=wasted_bps,
bits_per_sample=bits_per_sample,
order=order,
qlp_precision=options.qlp_precision,
qlp_shift_needed=qlp_shift_needed,
qlp_coefficients=qlp_coefficients,
samples=samples)
if subframe.bits() < best_subframe_size:
best_subframe = subframe
else:
best_subframe.copy(writer)
def encode_flac_frame(writer, pcmreader, options, frame_number, frame):
crc16 = CRC16()
writer.add_callback(crc16.update)
if ((pcmreader.channels == 2)
and (options.adaptive_mid_side or options.mid_side)):
# calculate average/difference
average = [(c0 + c1) // 2
for c0, c1 in zip(frame.channel(0), frame.channel(1))]
difference = [
c0 - c1 for c0, c1 in zip(frame.channel(0), frame.channel(1))
]
# try different subframes based on encoding options
left_subframe = BitstreamRecorder(0)
encode_subframe(left_subframe, options, pcmreader.bits_per_sample,
list(frame.channel(0)))
right_subframe = BitstreamRecorder(0)
encode_subframe(right_subframe, options, pcmreader.bits_per_sample,
list(frame.channel(1)))
average_subframe = BitstreamRecorder(0)
encode_subframe(average_subframe, options, pcmreader.bits_per_sample,
average)
difference_subframe = BitstreamRecorder(0)
encode_subframe(difference_subframe, options,
pcmreader.bits_per_sample + 1, difference)
# write best header/subframes to disk
if options.mid_side:
if ((left_subframe.bits() + right_subframe.bits()) < min(
left_subframe.bits() + difference_subframe.bits(),
difference_subframe.bits() + right_subframe.bits(),
average_subframe.bits() + difference_subframe.bits())):
write_frame_header(writer, pcmreader, frame_number, frame, 0x1)
left_subframe.copy(writer)
right_subframe.copy(writer)
elif (left_subframe.bits() < min(right_subframe.bits(),
difference_subframe.bits())):
write_frame_header(writer, pcmreader, frame_number, frame, 0x8)
left_subframe.copy(writer)
difference_subframe.copy(writer)
elif right_subframe.bits() < average_subframe.bits():
write_frame_header(writer, pcmreader, frame_number, frame, 0x9)
difference_subframe.copy(writer)
right_subframe.copy(writer)
else:
write_frame_header(writer, pcmreader, frame_number, frame, 0xA)
average_subframe.copy(writer)
difference_subframe.copy(writer)
else:
if (((left_subframe.bits() + right_subframe.bits()) <
(average_subframe.bits() + difference_subframe.bits()))):
write_frame_header(writer, pcmreader, frame_number, frame, 0x1)
left_subframe.copy(writer)
right_subframe.copy(writer)
else:
write_frame_header(writer, pcmreader, frame_number, frame, 0xA)
average_subframe.copy(writer)
difference_subframe.copy(writer)
else:
write_frame_header(writer, pcmreader, frame_number, frame,
pcmreader.channels - 1)
for i in range(frame.channels):
encode_subframe(writer, options, pcmreader.bits_per_sample,
list(frame.channel(i)))
writer.byte_align()
writer.pop_callback()
writer.write(16, int(crc16))
def update_metadata(self, metadata):
"""takes this track's current MetaData object
as returned by get_metadata() and sets this track's metadata
with any fields updated in that object
raises IOError if unable to write the file
"""
import os
from audiotools import TemporaryFile
from audiotools.ogg import (PageReader,
PacketReader,
PageWriter,
packet_to_pages,
packets_to_pages)
from audiotools.vorbiscomment import VorbisComment
from audiotools.bitstream import BitstreamRecorder
if (metadata is None):
return
elif (not isinstance(metadata, VorbisComment)):
from .text import ERR_FOREIGN_METADATA
raise ValueError(ERR_FOREIGN_METADATA)
elif (not os.access(self.filename, os.W_OK)):
raise IOError(self.filename)
original_ogg = PacketReader(PageReader(file(self.filename, "rb")))
new_ogg = PageWriter(TemporaryFile(self.filename))
sequence_number = 0
#transfer current file's identification packet in its own page
identification_packet = original_ogg.read_packet()
for (i, page) in enumerate(packet_to_pages(
identification_packet,
self.__serial_number__,
starting_sequence_number=sequence_number)):
page.stream_beginning = (i == 0)
new_ogg.write(page)
sequence_number += 1
#discard the current file's comment packet
comment_packet = original_ogg.read_packet()
#generate new comment packet
comment_writer = BitstreamRecorder(True)
comment_writer.build("8u 6b", (3, "vorbis"))
vendor_string = metadata.vendor_string.encode('utf-8')
comment_writer.build("32u %db" % (len(vendor_string)),
(len(vendor_string), vendor_string))
comment_writer.write(32, len(metadata.comment_strings))
for comment_string in metadata.comment_strings:
comment_string = comment_string.encode('utf-8')
comment_writer.build("32u %db" % (len(comment_string)),
(len(comment_string), comment_string))
comment_writer.build("1u a", (1,)) # framing bit
#transfer codebooks packet from original file to new file
codebooks_packet = original_ogg.read_packet()
for page in packets_to_pages(
[comment_writer.data(), codebooks_packet],
self.__serial_number__,
starting_sequence_number=sequence_number):
new_ogg.write(page)
sequence_number += 1
#transfer remaining pages after re-sequencing
page = original_ogg.read_page()
page.sequence_number = sequence_number
sequence_number += 1
new_ogg.write(page)
while (not page.stream_end):
page = original_ogg.read_page()
page.sequence_number = sequence_number
page.bitstream_serial_number = self.__serial_number__
sequence_number += 1
new_ogg.write(page)
original_ogg.close()
new_ogg.close()
def wave_header_footer(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
for example:
>>> w = audiotools.open("input.wav")
>>> (head, tail) = w.wave_header_footer()
>>> f = open("output.wav", "wb")
>>> f.write(head)
>>> audiotools.transfer_framelist_data(w.to_pcm(), f.write)
>>> f.write(tail)
>>> f.close()
should result in "output.wav" being identical to "input.wav"
"""
from audiotools.bitstream import BitstreamReader
from audiotools.bitstream import BitstreamRecorder
head = BitstreamRecorder(1)
tail = BitstreamRecorder(1)
current_block = head
fmt_found = False
with BitstreamReader(open(self.filename, 'rb'), 1) as wave_file:
# transfer the 12-byte "RIFFsizeWAVE" header to head
(riff, size, wave) = wave_file.parse("4b 32u 4b")
if riff != b'RIFF':
from audiotools.text import ERR_WAV_NOT_WAVE
raise ValueError(ERR_WAV_NOT_WAVE)
elif wave != b'WAVE':
from audiotools.text import ERR_WAV_INVALID_WAVE
raise ValueError(ERR_WAV_INVALID_WAVE)
else:
current_block.build("4b 32u 4b", (riff, size, wave))
total_size = size - 4
while total_size > 0:
# transfer each chunk header
(chunk_id, chunk_size) = wave_file.parse("4b 32u")
if not frozenset(chunk_id).issubset(self.PRINTABLE_ASCII):
from audiotools.text import ERR_WAV_INVALID_CHUNK
raise ValueError(ERR_WAV_INVALID_CHUNK)
else:
current_block.build("4b 32u", (chunk_id, chunk_size))
total_size -= 8
# and transfer the full content of non-audio chunks
if chunk_id != b"data":
if chunk_id == b"fmt ":
if not fmt_found:
fmt_found = True
else:
from audiotools.text import ERR_WAV_MULTIPLE_FMT
raise ValueError(ERR_WAV_MULTIPLE_FMT)
if chunk_size % 2:
current_block.write_bytes(
wave_file.read_bytes(chunk_size + 1))
total_size -= (chunk_size + 1)
else:
current_block.write_bytes(
wave_file.read_bytes(chunk_size))
total_size -= chunk_size
else:
wave_file.skip_bytes(chunk_size)
current_block = tail
if chunk_size % 2:
current_block.write_bytes(wave_file.read_bytes(1))
total_size -= (chunk_size + 1)
else:
total_size -= chunk_size
if fmt_found:
return (head.data(), tail.data())
else:
from audiotools.text import ERR_WAV_NO_FMT_CHUNK
raise ValueError(ERR_WAV_NO_FMT_CHUNK)
def wave_header(sample_rate,
channels,
channel_mask,
bits_per_sample,
total_pcm_frames):
"""given a set of integer stream attributes,
returns header string of everything before a RIFF WAVE's PCM data
may raise ValueError if the total size of the file is too large"""
from audiotools.bitstream import (BitstreamRecorder, format_size)
assert(isinstance(sample_rate, int))
assert(isinstance(channels, int))
assert(isinstance(channel_mask, int))
assert(isinstance(bits_per_sample, int))
assert(isinstance(total_pcm_frames, int) or
isinstance(total_pcm_frames, long))
header = BitstreamRecorder(True)
avg_bytes_per_second = sample_rate * channels * (bits_per_sample // 8)
block_align = channels * (bits_per_sample // 8)
# build a regular or extended fmt chunk
# based on the reader's attributes
if ((channels <= 2) and (bits_per_sample <= 16)):
fmt = "16u 16u 32u 32u 16u 16u"
fmt_fields = (1, # compression code
channels,
sample_rate,
avg_bytes_per_second,
block_align,
bits_per_sample)
else:
if channel_mask == 0:
channel_mask = {1: 0x4,
2: 0x3,
3: 0x7,
4: 0x33,
5: 0x37,
6: 0x3F}.get(channels, 0)
fmt = "16u 16u 32u 32u 16u 16u" + "16u 16u 32u 16b"
fmt_fields = (0xFFFE, # compression code
channels,
sample_rate,
avg_bytes_per_second,
block_align,
bits_per_sample,
22, # CB size
bits_per_sample,
channel_mask,
b'\x01\x00\x00\x00\x00\x00\x10\x00' +
b'\x80\x00\x00\xaa\x00\x38\x9b\x71' # sub format
)
data_size = (bits_per_sample // 8) * channels * total_pcm_frames
total_size = ((format_size("4b" + "4b 32u" + fmt + "4b 32u") // 8) +
data_size + (data_size % 2))
if total_size < (2 ** 32):
header.build("4b 32u 4b", (b"RIFF", total_size, b"WAVE"))
header.build("4b 32u", (b"fmt ", format_size(fmt) // 8))
header.build(fmt, fmt_fields)
header.build("4b 32u", (b"data", data_size))
return header.data()
else:
raise ValueError("total size too large for wave file")
def aiff_header_footer(self):
"""returns (header, footer) tuple of strings
containing all data before and after the PCM stream
if self.has_foreign_aiff_chunks() is False,
may raise ValueError if the file has no header and footer
for any reason"""
from audiotools.bitstream import BitstreamReader
from audiotools.bitstream import BitstreamRecorder
from audiotools.text import (ERR_AIFF_NOT_AIFF, ERR_AIFF_INVALID_AIFF,
ERR_AIFF_INVALID_CHUNK_ID)
head = BitstreamRecorder(0)
tail = BitstreamRecorder(0)
current_block = head
with BitstreamReader(open(self.filename, 'rb'), False) as aiff_file:
# transfer the 12-byte "RIFFsizeWAVE" header to head
(form, size, aiff) = aiff_file.parse("4b 32u 4b")
if form != b'FORM':
raise InvalidAIFF(ERR_AIFF_NOT_AIFF)
elif aiff != b'AIFF':
raise InvalidAIFF(ERR_AIFF_INVALID_AIFF)
else:
current_block.build("4b 32u 4b", (form, size, aiff))
total_size = size - 4
while total_size > 0:
# transfer each chunk header
(chunk_id, chunk_size) = aiff_file.parse("4b 32u")
if not frozenset(chunk_id).issubset(self.PRINTABLE_ASCII):
raise InvalidAIFF(ERR_AIFF_INVALID_CHUNK_ID)
else:
current_block.build("4b 32u", (chunk_id, chunk_size))
total_size -= 8
# and transfer the full content of non-audio chunks
if chunk_id != b"SSND":
if chunk_size % 2:
current_block.write_bytes(
aiff_file.read_bytes(chunk_size + 1))
total_size -= (chunk_size + 1)
else:
current_block.write_bytes(
aiff_file.read_bytes(chunk_size))
total_size -= chunk_size
else:
# transfer alignment as part of SSND's chunk header
align = aiff_file.parse("32u 32u")
current_block.build("32u 32u", align)
aiff_file.skip_bytes(chunk_size - 8)
current_block = tail
if chunk_size % 2:
current_block.write_bytes(aiff_file.read_bytes(1))
total_size -= (chunk_size + 1)
else:
total_size -= chunk_size
return (head.data(), tail.data())
def encode_subframe(writer, options, bits_per_sample, samples):
def all_identical(l):
if (len(l) == 1):
return True
else:
for i in l[1:]:
if (i != l[0]):
return False
else:
return True
def wasted(s):
w = 0
while ((s & 1) == 0):
w += 1
s >>= 1
return w
if (all_identical(samples)):
encode_constant_subframe(writer, bits_per_sample, samples[0])
else:
# account for wasted BPS, if any
wasted_bps = 2 ** 32
for sample in samples:
if (sample != 0):
wasted_bps = min(wasted_bps, wasted(sample))
if (wasted_bps == 0):
break
if (wasted_bps == 2 ** 32):
# all samples are 0
wasted_bps = 0
elif (wasted_bps > 0):
samples = [s >> wasted_bps for s in samples]
fixed_subframe = BitstreamRecorder(0)
encode_fixed_subframe(fixed_subframe,
options,
wasted_bps,
bits_per_sample,
samples)
if (options.max_lpc_order > 0):
(lpc_order,
qlp_coeffs,
qlp_shift_needed) = compute_lpc_coefficients(options,
wasted_bps,
bits_per_sample,
samples)
lpc_subframe = BitstreamRecorder(0)
encode_lpc_subframe(lpc_subframe,
options,
wasted_bps,
bits_per_sample,
lpc_order,
options.qlp_precision,
qlp_shift_needed,
qlp_coeffs,
samples)
if (((bits_per_sample * len(samples)) <
min(fixed_subframe.bits(), lpc_subframe.bits()))):
encode_verbatim_subframe(writer, wasted_bps,
bits_per_sample, samples)
elif (fixed_subframe.bits() < lpc_subframe.bits()):
fixed_subframe.copy(writer)
else:
lpc_subframe.copy(writer)
else:
if ((bits_per_sample * len(samples)) < fixed_subframe.bits()):
encode_verbatim_subframe(writer, wasted_bps,
bits_per_sample, samples)
else:
fixed_subframe.copy(writer)
def update_metadata(self, metadata):
"""takes this track's current MetaData object
as returned by get_metadata() and sets this track's metadata
with any fields updated in that object
raises IOError if unable to write the file
"""
import os
from audiotools import TemporaryFile
from audiotools.ogg import (PageReader, PacketReader, PageWriter,
packet_to_pages)
from audiotools.bitstream import BitstreamRecorder
if (metadata is None):
return
elif (not isinstance(metadata, VorbisComment)):
from .text import ERR_FOREIGN_METADATA
raise ValueError(ERR_FOREIGN_METADATA)
elif (not os.access(self.filename, os.W_OK)):
raise IOError(self.filename)
original_ogg = PacketReader(PageReader(file(self.filename, "rb")))
new_ogg = PageWriter(TemporaryFile(self.filename))
#transfer current file's identification page/packet
#(the ID packet is always fixed size, and fits in one page)
identification_page = original_ogg.read_page()
new_ogg.write(identification_page)
sequence_number = 1
#discard the current file's comment packet
original_ogg.read_packet()
#write the new comment packet in its own page(s)
comment_writer = BitstreamRecorder(True)
comment_writer.write_bytes("OpusTags")
vendor_string = metadata.vendor_string.encode('utf-8')
comment_writer.build("32u %db" % (len(vendor_string)),
(len(vendor_string), vendor_string))
comment_writer.write(32, len(metadata.comment_strings))
for comment_string in metadata.comment_strings:
comment_string = comment_string.encode('utf-8')
comment_writer.build("32u %db" % (len(comment_string)),
(len(comment_string), comment_string))
for page in packet_to_pages(
comment_writer.data(),
identification_page.bitstream_serial_number,
starting_sequence_number=sequence_number):
new_ogg.write(page)
sequence_number += 1
#transfer remaining pages after re-sequencing
page = original_ogg.read_page()
page.sequence_number = sequence_number
sequence_number += 1
new_ogg.write(page)
while (not page.stream_end):
page = original_ogg.read_page()
page.sequence_number = sequence_number
sequence_number += 1
new_ogg.write(page)
original_ogg.close()
new_ogg.close()
