/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/* JOrbis
* Copyright (C) 2000 ymnk, JCraft,Inc.
*
* Written by: 2000 ymnk<ymnk@jcraft.com>
*
* Many thanks to
* Monty <monty@xiph.org> and
* The XIPHOPHORUS Company http://www.xiph.org/ .
* JOrbis has been based on their awesome works, Vorbis codec.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
package com.jcraft.jorbis;
import com.jcraft.jogg.Buffer;
class CodeBook {
int dim; // codebook dimensions (elements per vector)
int entries; // codebook entries
StaticCodeBook c = new StaticCodeBook();
float[] valuelist; // list of dim*entries actual entry values
int[] codelist; // list of bitstream codewords for each entry
DecodeAux decode_tree;
// returns the number of bits
int encode(int a, Buffer b) {
b.write(codelist[a], c.lengthlist[a]);
return (c.lengthlist[a]);
}
// One the encode side, our vector writers are each designed for a
// specific purpose, and the encoder is not flexible without modification:
//
// The LSP vector coder uses a single stage nearest-match with no
// interleave, so no step and no error return. This is specced by floor0
// and doesn't change.
//
// Residue0 encoding interleaves, uses multiple stages, and each stage
// peels of a specific amount of resolution from a lattice (thus we want
// to match by threshhold, not nearest match). Residue doesn't *have* to
// be encoded that way, but to change it, one will need to add more
// infrastructure on the encode side (decode side is specced and simpler)
// floor0 LSP (single stage, non interleaved, nearest match)
// returns entry number and *modifies a* to the quantization value
int errorv(float[] a) {
int best = best(a, 1);
for (int k = 0; k < dim; k++) {
a[k] = valuelist[best * dim + k];
}
return (best);
}
// returns the number of bits and *modifies a* to the quantization value
int encodev(int best, float[] a, Buffer b) {
for (int k = 0; k < dim; k++) {
a[k] = valuelist[best * dim + k];
}
return (encode(best, b));
}
// res0 (multistage, interleave, lattice)
// returns the number of bits and *modifies a* to the remainder value
int encodevs(float[] a, Buffer b, int step, int addmul) {
int best = besterror(a, step, addmul);
return (encode(best, b));
}
private int[] t = new int[15]; // decodevs_add is synchronized for re-using t.
synchronized int decodevs_add(float[] a, int offset, Buffer b, int n) {
int step = n / dim;
int entry;
int i, j, o;
if (t.length < step) {
t = new int[step];
}
for (i = 0; i < step; i++) {
entry = decode(b);
if (entry == -1)
return (-1);
t[i] = entry * dim;
}
for (i = 0, o = 0; i < dim; i++, o += step) {
for (j = 0; j < step; j++) {
a[offset + o + j] += valuelist[t[j] + i];
}
}
return (0);
}
int decodev_add(float[] a, int offset, Buffer b, int n) {
int i, j, entry;
int t;
if (dim > 8) {
for (i = 0; i < n;) {
entry = decode(b);
if (entry == -1)
return (-1);
t = entry * dim;
for (j = 0; j < dim;) {
a[offset + (i++)] += valuelist[t + (j++)];
}
}
} else {
for (i = 0; i < n;) {
entry = decode(b);
if (entry == -1)
return (-1);
t = entry * dim;
j = 0;
switch (dim) {
case 8:
a[offset + (i++)] += valuelist[t + (j++)];
case 7:
a[offset + (i++)] += valuelist[t + (j++)];
case 6:
a[offset + (i++)] += valuelist[t + (j++)];
case 5:
a[offset + (i++)] += valuelist[t + (j++)];
case 4:
a[offset + (i++)] += valuelist[t + (j++)];
case 3:
a[offset + (i++)] += valuelist[t + (j++)];
case 2:
a[offset + (i++)] += valuelist[t + (j++)];
case 1:
a[offset + (i++)] += valuelist[t + (j++)];
case 0:
break;
}
}
}
return (0);
}
int decodev_set(float[] a, int offset, Buffer b, int n) {
int i, j, entry;
int t;
for (i = 0; i < n;) {
entry = decode(b);
if (entry == -1)
return (-1);
t = entry * dim;
for (j = 0; j < dim;) {
a[offset + i++] = valuelist[t + (j++)];
}
}
return (0);
}
int decodevv_add(float[][] a, int offset, int ch, Buffer b, int n) {
int i, j, entry;
int chptr = 0;
for (i = offset / ch; i < (offset + n) / ch;) {
entry = decode(b);
if (entry == -1)
return (-1);
int t = entry * dim;
for (j = 0; j < dim; j++) {
a[chptr++][i] += valuelist[t + j];
if (chptr == ch) {
chptr = 0;
i++;
}
}
}
return (0);
}
// Decode side is specced and easier, because we don't need to find
// matches using different criteria; we simply read and map. There are
// two things we need to do 'depending':
//
// We may need to support interleave. We don't really, but it's
// convenient to do it here rather than rebuild the vector later.
//
// Cascades may be additive or multiplicitive; this is not inherent in
// the codebook, but set in the code using the codebook. Like
// interleaving, it's easiest to do it here.
// stage==0 -> declarative (set the value)
// stage==1 -> additive
// stage==2 -> multiplicitive
// returns the entry number or -1 on eof
int decode(Buffer b) {
int ptr = 0;
DecodeAux t = decode_tree;
int lok = b.look(t.tabn);
if (lok >= 0) {
ptr = t.tab[lok];
b.adv(t.tabl[lok]);
if (ptr <= 0) {
return -ptr;
}
}
do {
switch (b.read1()) {
case 0:
ptr = t.ptr0[ptr];
break;
case 1:
ptr = t.ptr1[ptr];
break;
case -1:
default:
return (-1);
}
}
while (ptr > 0);
return (-ptr);
}
// returns the entry number or -1 on eof
int decodevs(float[] a, int index, Buffer b, int step, int addmul) {
int entry = decode(b);
if (entry == -1)
return (-1);
switch (addmul) {
case -1:
for (int i = 0, o = 0; i < dim; i++, o += step)
a[index + o] = valuelist[entry * dim + i];
break;
case 0:
for (int i = 0, o = 0; i < dim; i++, o += step)
a[index + o] += valuelist[entry * dim + i];
break;
case 1:
for (int i = 0, o = 0; i < dim; i++, o += step)
a[index + o] *= valuelist[entry * dim + i];
break;
default:
//System.err.println("CodeBook.decodeves: addmul="+addmul);
}
return (entry);
}
int best(float[] a, int step) {
// brute force it!
{
int besti = -1;
float best = 0.f;
int e = 0;
for (int i = 0; i < entries; i++) {
if (c.lengthlist[i] > 0) {
float _this = dist(dim, valuelist, e, a, step);
if (besti == -1 || _this < best) {
best = _this;
besti = i;
}
}
e += dim;
}
return (besti);
}
}
// returns the entry number and *modifies a* to the remainder value
int besterror(float[] a, int step, int addmul) {
int best = best(a, step);
switch (addmul) {
case 0:
for (int i = 0, o = 0; i < dim; i++, o += step)
a[o] -= valuelist[best * dim + i];
break;
case 1:
for (int i = 0, o = 0; i < dim; i++, o += step) {
float val = valuelist[best * dim + i];
if (val == 0) {
a[o] = 0;
} else {
a[o] /= val;
}
}
break;
}
return (best);
}
void clear() {
}
private static float dist(int el, float[] ref, int index, float[] b, int step) {
float acc = (float) 0.;
for (int i = 0; i < el; i++) {
float val = (ref[index + i] - b[i * step]);
acc += val * val;
}
return (acc);
}
int init_decode(StaticCodeBook s) {
c = s;
entries = s.entries;
dim = s.dim;
valuelist = s.unquantize();
decode_tree = make_decode_tree();
if (decode_tree == null) {
clear();
return (-1);
}
return (0);
}
// given a list of word lengths, generate a list of codewords. Works
// for length ordered or unordered, always assigns the lowest valued
// codewords first. Extended to handle unused entries (length 0)
static int[] make_words(int[] l, int n) {
int[] marker = new int[33];
int[] r = new int[n];
for (int i = 0; i < n; i++) {
int length = l[i];
if (length > 0) {
int entry = marker[length];
// when we claim a node for an entry, we also claim the nodes
// below it (pruning off the imagined tree that may have dangled
// from it) as well as blocking the use of any nodes directly
// above for leaves
// update ourself
if (length < 32 && (entry >>> length) != 0) {
// error condition; the lengths must specify an overpopulated tree
//free(r);
return (null);
}
r[i] = entry;
// Look to see if the next shorter marker points to the node
// above. if so, update it and repeat.
{
for (int j = length; j > 0; j--) {
if ((marker[j] & 1) != 0) {
// have to jump branches
if (j == 1)
marker[1]++;
else
marker[j] = marker[j - 1] << 1;
break; // invariant says next upper marker would already
// have been moved if it was on the same path
}
marker[j]++;
}
}
// prune the tree; the implicit invariant says all the longer
// markers were dangling from our just-taken node. Dangle them
// from our *new* node.
for (int j = length + 1; j < 33; j++) {
if ((marker[j] >>> 1) == entry) {
entry = marker[j];
marker[j] = marker[j - 1] << 1;
} else {
break;
}
}
}
}
// bitreverse the words because our bitwise packer/unpacker is LSb
// endian
for (int i = 0; i < n; i++) {
int temp = 0;
for (int j = 0; j < l[i]; j++) {
temp <<= 1;
temp |= (r[i] >>> j) & 1;
}
r[i] = temp;
}
return (r);
}
// build the decode helper tree from the codewords
DecodeAux make_decode_tree() {
int top = 0;
DecodeAux t = new DecodeAux();
int[] ptr0 = t.ptr0 = new int[entries * 2];
int[] ptr1 = t.ptr1 = new int[entries * 2];
int[] codelist = make_words(c.lengthlist, c.entries);
if (codelist == null)
return (null);
t.aux = entries * 2;
for (int i = 0; i < entries; i++) {
if (c.lengthlist[i] > 0) {
int ptr = 0;
int j;
for (j = 0; j < c.lengthlist[i] - 1; j++) {
int bit = (codelist[i] >>> j) & 1;
if (bit == 0) {
if (ptr0[ptr] == 0) {
ptr0[ptr] = ++top;
}
ptr = ptr0[ptr];
} else {
if (ptr1[ptr] == 0) {
ptr1[ptr] = ++top;
}
ptr = ptr1[ptr];
}
}
if (((codelist[i] >>> j) & 1) == 0) {
ptr0[ptr] = -i;
} else {
ptr1[ptr] = -i;
}
}
}
t.tabn = Util.ilog(entries) - 4;
if (t.tabn < 5)
t.tabn = 5;
int n = 1 << t.tabn;
t.tab = new int[n];
t.tabl = new int[n];
for (int i = 0; i < n; i++) {
int p = 0;
int j = 0;
for (j = 0; j < t.tabn && (p > 0 || j == 0); j++) {
if ((i & (1 << j)) != 0) {
p = ptr1[p];
} else {
p = ptr0[p];
}
}
t.tab[i] = p; // -code
t.tabl[i] = j; // length
}
return (t);
}
class DecodeAux {
int[] tab;
int[] tabl;
int tabn;
int[] ptr0;
int[] ptr1;
int aux; // number of tree entries
}
}