static status
read_frame(decoders_ALACDecoder *self,
BitstreamReader* mdat,
array_ia* frameset_channels,
unsigned channel_count)
{
unsigned has_sample_count;
unsigned uncompressed_LSBs;
unsigned not_compressed;
unsigned sample_count;
/*read frame header*/
if (mdat->read(mdat, 16) != 0) {
return alacdec_ValueError(self, "invalid unused bits");
}
has_sample_count = mdat->read(mdat, 1);
uncompressed_LSBs = mdat->read(mdat, 2);
not_compressed = mdat->read(mdat, 1);
if (has_sample_count == 0)
sample_count = self->max_samples_per_frame;
else
sample_count = mdat->read(mdat, 32);
if (not_compressed == 1) {
unsigned channel;
unsigned i;
array_ia* frame_channels = self->frame_channels;
/*if uncompressed, read and return a bunch of verbatim samples*/
frame_channels->reset(frame_channels);
for (channel = 0; channel < channel_count; channel++)
frame_channels->append(frame_channels);
for (i = 0; i < sample_count; i++) {
for (channel = 0; channel < channel_count; channel++) {
frame_channels->_[channel]->append(
frame_channels->_[channel],
mdat->read_signed(mdat, self->bits_per_sample));
}
}
for (channel = 0; channel < channel_count; channel++)
frame_channels->_[channel]->swap(
frame_channels->_[channel],
frameset_channels->append(frameset_channels));
return OK;
} else {
unsigned interlacing_shift;
unsigned interlacing_leftweight;
unsigned channel;
unsigned i;
unsigned sample_size;
array_i* LSBs = NULL;
array_i* residuals = self->residuals;
array_ia* frame_channels = self->frame_channels;
array_i* channel_data;
frame_channels->reset(frame_channels);
/*if compressed, read interlacing shift and leftweight*/
interlacing_shift = mdat->read(mdat, 8);
interlacing_leftweight = mdat->read(mdat, 8);
/*read a subframe header per channel*/
for (channel = 0; channel < channel_count; channel++) {
read_subframe_header(mdat,
&(self->subframe_headers[channel]));
}
/*if uncompressed LSBs, read a block of partial samples to prepend*/
if (uncompressed_LSBs > 0) {
LSBs = self->uncompressed_LSBs;
LSBs->reset(LSBs);
for (i = 0; i < (channel_count * sample_count); i++)
LSBs->append(LSBs,
mdat->read(mdat, uncompressed_LSBs * 8));
}
sample_size = (self->bits_per_sample -
(uncompressed_LSBs * 8) +
(channel_count - 1));
/*read a residual block per channel
and calculate the subframe's samples*/
for (channel = 0; channel < channel_count; channel++) {
residuals->reset(residuals);
read_residuals(mdat,
residuals,
sample_count,
sample_size,
self->initial_history,
self->history_multiplier,
self->maximum_k);
decode_subframe(
frame_channels->append(frame_channels),
sample_size,
residuals,
self->subframe_headers[channel].qlp_coeff,
self->subframe_headers[channel].qlp_shift_needed);
}
/*if stereo, decorrelate channels
according to interlacing shift and interlacing leftweight*/
if ((channel_count == 2) && (interlacing_leftweight > 0)) {
decorrelate_channels(frame_channels->_[0],
frame_channels->_[1],
interlacing_shift,
interlacing_leftweight);
}
/*if uncompressed LSBs, prepend partial samples to output*/
if (uncompressed_LSBs > 0) {
for (channel = 0; channel < channel_count; channel++) {
channel_data = frame_channels->_[channel];
for (i = 0; i < sample_count; i++) {
channel_data->_[i] = ((channel_data->_[i] <<
uncompressed_LSBs * 8) |
LSBs->_[(i * channel_count) +
channel]);
}
}
}
/*finally, return frame's channel data*/
for (channel = 0; channel < channel_count; channel++)
frame_channels->_[channel]->swap(
frame_channels->_[channel],
frameset_channels->append(frameset_channels));
return OK;
}
}
static status_t
decode_compressed_frame(BitstreamReader *br,
const struct alac_parameters *params,
unsigned uncompressed_LSBs,
unsigned bits_per_sample,
unsigned block_size,
unsigned channels,
int channel_0[],
int channel_1[])
{
const unsigned uncompressed_bits = uncompressed_LSBs * 8;
const unsigned sample_size =
bits_per_sample - uncompressed_bits + (channels - 1);
const unsigned interlacing_shift = br->read(br, 8);
const unsigned interlacing_leftweight = br->read(br, 8);
struct subframe_header subframe_header[channels];
int subframe[channels][block_size];
unsigned i;
unsigned c;
status_t status;
for (c = 0; c < channels; c++) {
if ((status = read_subframe_header(br, &subframe_header[c])) != OK) {
return status;
}
}
if (!uncompressed_bits) {
/*the common case where there's no uncompressed
least-significant bits to handle, such as 16bps audio*/
for (c = 0; c < channels; c++) {
int residual[block_size];
read_residual_block(br, params, sample_size, block_size, residual);
decode_subframe(block_size,
sample_size,
&subframe_header[c],
residual,
subframe[c]);
}
/*perform channel decorrelation, if necessary*/
if (channels == 2) {
if (interlacing_leftweight > 0) {
decorrelate_channels(block_size,
interlacing_shift,
interlacing_leftweight,
subframe[0],
subframe[1],
channel_0,
channel_1);
} else {
memcpy(channel_0, subframe[0], block_size * sizeof(int));
memcpy(channel_1, subframe[1], block_size * sizeof(int));
}
} else {
memcpy(channel_0, subframe[0], block_size * sizeof(int));
}
} else {
/*the case where there are least significant bits to handle
such as for 24bps audio*/
int LSBs[channels][block_size];
for (i = 0; i < block_size; i++) {
for (c = 0; c < channels; c++) {
LSBs[c][i] = br->read(br, uncompressed_bits);
}
}
for (c = 0; c < channels; c++) {
int residual[block_size];
read_residual_block(br, params, sample_size, block_size, residual);
decode_subframe(block_size,
sample_size,
&subframe_header[c],
residual,
subframe[c]);
}
/*perform channel decorrelation, if necessary*/
if (channels == 2) {
if (interlacing_leftweight > 0) {
decorrelate_channels(block_size,
interlacing_shift,
interlacing_leftweight,
subframe[0],
subframe[1],
channel_0,
channel_1);
} else {
memcpy(channel_0, subframe[0], block_size * sizeof(int));
memcpy(channel_1, subframe[1], block_size * sizeof(int));
}
/*apply uncompressed LSBs to channel data*/
for (i = 0; i < block_size; i++) {
channel_0[i] <<= uncompressed_bits;
channel_0[i] |= LSBs[0][i];
channel_1[i] <<= uncompressed_bits;
channel_1[i] |= LSBs[1][i];
}
} else {
memcpy(channel_0, subframe[0], block_size * sizeof(int));
/*apply uncompressed LSBs to channel data*/
for (i = 0; i < block_size; i++) {
channel_0[i] <<= uncompressed_bits;
channel_0[i] |= LSBs[0][i];
}
}
}
return OK;
}