437 lines
11 KiB
Java
437 lines
11 KiB
Java
|
/* -*-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.*;
|
||
|
|
|
||
|
|
class StaticCodeBook {
|
||
|
|
int dim; // codebook dimensions (elements per vector)
|
||
|
|
int entries; // codebook entries
|
||
|
|
int[] lengthlist; // codeword lengths in bits
|
||
|
|
|
||
|
|
// mapping
|
||
|
|
int maptype; // 0=none
|
||
|
|
// 1=implicitly populated values from map column
|
||
|
|
// 2=listed arbitrary values
|
||
|
|
|
||
|
|
// The below does a linear, single monotonic sequence mapping.
|
||
|
|
int q_min; // packed 32 bit float; quant value 0 maps to minval
|
||
|
|
int q_delta; // packed 32 bit float; val 1 - val 0 == delta
|
||
|
|
int q_quant; // bits: 0 < quant <= 16
|
||
|
|
int q_sequencep; // bitflag
|
||
|
|
|
||
|
|
// additional information for log (dB) mapping; the linear mapping
|
||
|
|
// is assumed to actually be values in dB. encodebias is used to
|
||
|
|
// assign an error weight to 0 dB. We have two additional flags:
|
||
|
|
// zeroflag indicates if entry zero is to represent -Inf dB; negflag
|
||
|
|
// indicates if we're to represent negative linear values in a
|
||
|
|
// mirror of the positive mapping.
|
||
|
|
|
||
|
|
int[] quantlist; // map == 1: (int)(entries/dim) element column map
|
||
|
|
// map == 2: list of dim*entries quantized entry vals
|
||
|
|
|
||
|
|
StaticCodeBook() {
|
||
|
|
}
|
||
|
|
|
||
|
|
int pack(Buffer opb) {
|
||
|
|
int i;
|
||
|
|
boolean ordered = false;
|
||
|
|
|
||
|
|
opb.write(0x564342, 24);
|
||
|
|
opb.write(dim, 16);
|
||
|
|
opb.write(entries, 24);
|
||
|
|
|
||
|
|
// pack the codewords. There are two packings; length ordered and
|
||
|
|
// length random. Decide between the two now.
|
||
|
|
|
||
|
|
for (i = 1; i < entries; i++) {
|
||
|
|
if (lengthlist[i] < lengthlist[i - 1])
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (i == entries)
|
||
|
|
ordered = true;
|
||
|
|
|
||
|
|
if (ordered) {
|
||
|
|
// length ordered. We only need to say how many codewords of
|
||
|
|
// each length. The actual codewords are generated
|
||
|
|
// deterministically
|
||
|
|
|
||
|
|
int count = 0;
|
||
|
|
opb.write(1, 1); // ordered
|
||
|
|
opb.write(lengthlist[0] - 1, 5); // 1 to 32
|
||
|
|
|
||
|
|
for (i = 1; i < entries; i++) {
|
||
|
|
int _this = lengthlist[i];
|
||
|
|
int _last = lengthlist[i - 1];
|
||
|
|
if (_this > _last) {
|
||
|
|
for (int j = _last; j < _this; j++) {
|
||
|
|
opb.write(i - count, Util.ilog(entries - count));
|
||
|
|
count = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
opb.write(i - count, Util.ilog(entries - count));
|
||
|
|
} else {
|
||
|
|
// length random. Again, we don't code the codeword itself, just
|
||
|
|
// the length. This time, though, we have to encode each length
|
||
|
|
opb.write(0, 1); // unordered
|
||
|
|
|
||
|
|
// algortihmic mapping has use for 'unused entries', which we tag
|
||
|
|
// here. The algorithmic mapping happens as usual, but the unused
|
||
|
|
// entry has no codeword.
|
||
|
|
for (i = 0; i < entries; i++) {
|
||
|
|
if (lengthlist[i] == 0)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i == entries) {
|
||
|
|
opb.write(0, 1); // no unused entries
|
||
|
|
for (i = 0; i < entries; i++) {
|
||
|
|
opb.write(lengthlist[i] - 1, 5);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
opb.write(1, 1); // we have unused entries; thus we tag
|
||
|
|
for (i = 0; i < entries; i++) {
|
||
|
|
if (lengthlist[i] == 0) {
|
||
|
|
opb.write(0, 1);
|
||
|
|
} else {
|
||
|
|
opb.write(1, 1);
|
||
|
|
opb.write(lengthlist[i] - 1, 5);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// is the entry number the desired return value, or do we have a
|
||
|
|
// mapping? If we have a mapping, what type?
|
||
|
|
opb.write(maptype, 4);
|
||
|
|
switch (maptype) {
|
||
|
|
case 0:
|
||
|
|
// no mapping
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
case 2:
|
||
|
|
// implicitly populated value mapping
|
||
|
|
// explicitly populated value mapping
|
||
|
|
if (quantlist == null) {
|
||
|
|
// no quantlist? error
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// values that define the dequantization
|
||
|
|
opb.write(q_min, 32);
|
||
|
|
opb.write(q_delta, 32);
|
||
|
|
opb.write(q_quant - 1, 4);
|
||
|
|
opb.write(q_sequencep, 1);
|
||
|
|
|
||
|
|
{
|
||
|
|
int quantvals = 0;
|
||
|
|
switch (maptype) {
|
||
|
|
case 1:
|
||
|
|
// a single column of (c->entries/c->dim) quantized values for
|
||
|
|
// building a full value list algorithmically (square lattice)
|
||
|
|
quantvals = maptype1_quantvals();
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
// every value (c->entries*c->dim total) specified explicitly
|
||
|
|
quantvals = entries * dim;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// quantized values
|
||
|
|
for (i = 0; i < quantvals; i++) {
|
||
|
|
opb.write(Math.abs(quantlist[i]), q_quant);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
// error case; we don't have any other map types now
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
return (0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// unpacks a codebook from the packet buffer into the codebook struct,
|
||
|
|
// readies the codebook auxiliary structures for decode
|
||
|
|
int unpack(Buffer opb) {
|
||
|
|
int i;
|
||
|
|
// memset(s,0,sizeof(static_codebook));
|
||
|
|
|
||
|
|
// make sure alignment is correct
|
||
|
|
if (opb.read(24) != 0x564342) {
|
||
|
|
// goto _eofout;
|
||
|
|
clear();
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// first the basic parameters
|
||
|
|
dim = opb.read(16);
|
||
|
|
entries = opb.read(24);
|
||
|
|
if (entries == -1) {
|
||
|
|
// goto _eofout;
|
||
|
|
clear();
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// codeword ordering.... length ordered or unordered?
|
||
|
|
switch (opb.read(1)) {
|
||
|
|
case 0:
|
||
|
|
// unordered
|
||
|
|
lengthlist = new int[entries];
|
||
|
|
|
||
|
|
// allocated but unused entries?
|
||
|
|
if (opb.read(1) != 0) {
|
||
|
|
// yes, unused entries
|
||
|
|
|
||
|
|
for (i = 0; i < entries; i++) {
|
||
|
|
if (opb.read(1) != 0) {
|
||
|
|
int num = opb.read(5);
|
||
|
|
if (num == -1) {
|
||
|
|
// goto _eofout;
|
||
|
|
clear();
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
lengthlist[i] = num + 1;
|
||
|
|
} else {
|
||
|
|
lengthlist[i] = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// all entries used; no tagging
|
||
|
|
for (i = 0; i < entries; i++) {
|
||
|
|
int num = opb.read(5);
|
||
|
|
if (num == -1) {
|
||
|
|
// goto _eofout;
|
||
|
|
clear();
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
lengthlist[i] = num + 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
// ordered
|
||
|
|
{
|
||
|
|
int length = opb.read(5) + 1;
|
||
|
|
lengthlist = new int[entries];
|
||
|
|
|
||
|
|
for (i = 0; i < entries;) {
|
||
|
|
int num = opb.read(Util.ilog(entries - i));
|
||
|
|
if (num == -1) {
|
||
|
|
// goto _eofout;
|
||
|
|
clear();
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
for (int j = 0; j < num; j++, i++) {
|
||
|
|
lengthlist[i] = length;
|
||
|
|
}
|
||
|
|
length++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
// EOF
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Do we have a mapping to unpack?
|
||
|
|
switch ((maptype = opb.read(4))) {
|
||
|
|
case 0:
|
||
|
|
// no mapping
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
case 2:
|
||
|
|
// implicitly populated value mapping
|
||
|
|
// explicitly populated value mapping
|
||
|
|
q_min = opb.read(32);
|
||
|
|
q_delta = opb.read(32);
|
||
|
|
q_quant = opb.read(4) + 1;
|
||
|
|
q_sequencep = opb.read(1);
|
||
|
|
|
||
|
|
{
|
||
|
|
int quantvals = 0;
|
||
|
|
switch (maptype) {
|
||
|
|
case 1:
|
||
|
|
quantvals = maptype1_quantvals();
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
quantvals = entries * dim;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// quantized values
|
||
|
|
quantlist = new int[quantvals];
|
||
|
|
for (i = 0; i < quantvals; i++) {
|
||
|
|
quantlist[i] = opb.read(q_quant);
|
||
|
|
}
|
||
|
|
if (quantlist[quantvals - 1] == -1) {
|
||
|
|
// goto _eofout;
|
||
|
|
clear();
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
// goto _eofout;
|
||
|
|
clear();
|
||
|
|
return (-1);
|
||
|
|
}
|
||
|
|
// all set
|
||
|
|
return (0);
|
||
|
|
// _errout:
|
||
|
|
// _eofout:
|
||
|
|
// vorbis_staticbook_clear(s);
|
||
|
|
// return(-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// there might be a straightforward one-line way to do the below
|
||
|
|
// that's portable and totally safe against roundoff, but I haven't
|
||
|
|
// thought of it. Therefore, we opt on the side of caution
|
||
|
|
private int maptype1_quantvals() {
|
||
|
|
int vals = (int) (Math.floor(Math.pow(entries, 1. / dim)));
|
||
|
|
|
||
|
|
// the above *should* be reliable, but we'll not assume that FP is
|
||
|
|
// ever reliable when bitstream sync is at stake; verify via integer
|
||
|
|
// means that vals really is the greatest value of dim for which
|
||
|
|
// vals^b->bim <= b->entries
|
||
|
|
// treat the above as an initial guess
|
||
|
|
while (true) {
|
||
|
|
int acc = 1;
|
||
|
|
int acc1 = 1;
|
||
|
|
for (int i = 0; i < dim; i++) {
|
||
|
|
acc *= vals;
|
||
|
|
acc1 *= vals + 1;
|
||
|
|
}
|
||
|
|
if (acc <= entries && acc1 > entries) {
|
||
|
|
return (vals);
|
||
|
|
} else {
|
||
|
|
if (acc > entries) {
|
||
|
|
vals--;
|
||
|
|
} else {
|
||
|
|
vals++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void clear() {
|
||
|
|
}
|
||
|
|
|
||
|
|
// unpack the quantized list of values for encode/decode
|
||
|
|
// we need to deal with two map types: in map type 1, the values are
|
||
|
|
// generated algorithmically (each column of the vector counts through
|
||
|
|
// the values in the quant vector). in map type 2, all the values came
|
||
|
|
// in in an explicit list. Both value lists must be unpacked
|
||
|
|
float[] unquantize() {
|
||
|
|
|
||
|
|
if (maptype == 1 || maptype == 2) {
|
||
|
|
int quantvals;
|
||
|
|
float mindel = float32_unpack(q_min);
|
||
|
|
float delta = float32_unpack(q_delta);
|
||
|
|
float[] r = new float[entries * dim];
|
||
|
|
|
||
|
|
// maptype 1 and 2 both use a quantized value vector, but
|
||
|
|
// different sizes
|
||
|
|
switch (maptype) {
|
||
|
|
case 1:
|
||
|
|
// most of the time, entries%dimensions == 0, but we need to be
|
||
|
|
// well defined. We define that the possible vales at each
|
||
|
|
// scalar is values == entries/dim. If entries%dim != 0, we'll
|
||
|
|
// have 'too few' values (values*dim<entries), which means that
|
||
|
|
// we'll have 'left over' entries; left over entries use zeroed
|
||
|
|
// values (and are wasted). So don't generate codebooks like that
|
||
|
|
quantvals = maptype1_quantvals();
|
||
|
|
for (int j = 0; j < entries; j++) {
|
||
|
|
float last = 0.f;
|
||
|
|
int indexdiv = 1;
|
||
|
|
for (int k = 0; k < dim; k++) {
|
||
|
|
int index = (j / indexdiv) % quantvals;
|
||
|
|
float val = quantlist[index];
|
||
|
|
val = Math.abs(val) * delta + mindel + last;
|
||
|
|
if (q_sequencep != 0)
|
||
|
|
last = val;
|
||
|
|
r[j * dim + k] = val;
|
||
|
|
indexdiv *= quantvals;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
for (int j = 0; j < entries; j++) {
|
||
|
|
float last = 0.f;
|
||
|
|
for (int k = 0; k < dim; k++) {
|
||
|
|
float val = quantlist[j * dim + k];
|
||
|
|
// if((j*dim+k)==0){System.err.println(" | 0 -> "+val+" | ");}
|
||
|
|
val = Math.abs(val) * delta + mindel + last;
|
||
|
|
if (q_sequencep != 0)
|
||
|
|
last = val;
|
||
|
|
r[j * dim + k] = val;
|
||
|
|
// if((j*dim+k)==0){System.err.println(" $ r[0] -> "+r[0]+" | ");}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// System.err.println("\nr[0]="+r[0]);
|
||
|
|
}
|
||
|
|
return (r);
|
||
|
|
}
|
||
|
|
return (null);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 32 bit float (not IEEE; nonnormalized mantissa +
|
||
|
|
// biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm
|
||
|
|
// Why not IEEE? It's just not that important here.
|
||
|
|
|
||
|
|
static final int VQ_FEXP = 10;
|
||
|
|
static final int VQ_FMAN = 21;
|
||
|
|
static final int VQ_FEXP_BIAS = 768; // bias toward values smaller than 1.
|
||
|
|
|
||
|
|
// doesn't currently guard under/overflow
|
||
|
|
static long float32_pack(float val) {
|
||
|
|
int sign = 0;
|
||
|
|
int exp;
|
||
|
|
int mant;
|
||
|
|
if (val < 0) {
|
||
|
|
sign = 0x80000000;
|
||
|
|
val = -val;
|
||
|
|
}
|
||
|
|
exp = (int) Math.floor(Math.log(val) / Math.log(2));
|
||
|
|
mant = (int) Math.rint(Math.pow(val, (VQ_FMAN - 1) - exp));
|
||
|
|
exp = (exp + VQ_FEXP_BIAS) << VQ_FMAN;
|
||
|
|
return (sign | exp | mant);
|
||
|
|
}
|
||
|
|
|
||
|
|
static float float32_unpack(int val) {
|
||
|
|
float mant = val & 0x1fffff;
|
||
|
|
float exp = (val & 0x7fe00000) >>> VQ_FMAN;
|
||
|
|
if ((val & 0x80000000) != 0)
|
||
|
|
mant = -mant;
|
||
|
|
return (ldexp(mant, ((int) exp) - (VQ_FMAN - 1) - VQ_FEXP_BIAS));
|
||
|
|
}
|
||
|
|
|
||
|
|
static float ldexp(float foo, int e) {
|
||
|
|
return (float) (foo * Math.pow(2, e));
|
||
|
|
}
|
||
|
|
}
|