static_codebook.java

/*
 * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.
 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS
 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE
 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.
 *
 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002
 * by the Xiph.Org Foundation http://www.xiph.org/
 */

package org.xiph.libvorbis;

public class static_codebook {

    int dim;            // long dim // codebook dimensions (elements per vector)
    int entries;        // long entries // codebook entries
    int[] lengthlist;    // long *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;            // long q_min // packed 32 bit float; quant value 0 maps to minval
    int q_delta;        // long q_delta // packed 32 bit float; val 1 - val 0 == delta
    int q_quant;        // bits: 0 < quant <= 16
    int q_sequencep;    // bitflag

    int[] quantlist;    // long *quantlist
    // map == 1: (int)(entries^(1/dim)) element column map
    // map == 2: list of dim*entries quantized entry vals

    // encode helpers *******************************************
    encode_aux_nearestmatch nearest_tree;    // *nearest_tree
    encode_aux_threshmatch thresh_tree;        // *thresh_tree
    encode_aux_pigeonhole pigeon_tree;        // *pigeon_tree

    int allocedp;


    public static_codebook(int _dim, int _entries, int[] _lengthlist, int _maptype, int _q_min, int _q_delta, int _q_quant, int _q_sequencep, int[] _quantlist,
                           encode_aux_nearestmatch _nearest_tree, encode_aux_threshmatch _thresh_tree, encode_aux_pigeonhole _pigeon_tree, int _allocedp) {

        dim = _dim;
        entries = _entries;

        if (_lengthlist == null)
            lengthlist = null;
        else
            lengthlist = (int[]) _lengthlist.clone();


        maptype = _maptype;

        q_min = _q_min;
        q_delta = _q_delta;
        q_quant = _q_quant;
        q_sequencep = _q_sequencep;

        if (_quantlist == null)
            quantlist = null;
        else
            quantlist = (int[]) _quantlist.clone();

        nearest_tree = _nearest_tree;
        thresh_tree = _thresh_tree;
        pigeon_tree = _pigeon_tree;

        allocedp = _allocedp;
    }

    public static_codebook(int _dim) {

        dim = _dim;
        entries = _dim;
        lengthlist = new int[]{};
        maptype = _dim;

        q_min = _dim;
        q_delta = _dim;
        q_quant = _dim;
        q_sequencep = _dim;

        quantlist = new int[]{};

        nearest_tree = null;
        thresh_tree = null;
        pigeon_tree = null;

        allocedp = _dim;
    }

    public static_codebook(static_codebook src) {

        this(src.dim, src.entries, src.lengthlist, src.maptype, src.q_min, src.q_delta, src.q_quant, src.q_sequencep, src.quantlist,
                new encode_aux_nearestmatch(src.nearest_tree), new encode_aux_threshmatch(src.thresh_tree), new encode_aux_pigeonhole(src.pigeon_tree), src.allocedp);
    }

    // public long _book_maptype1_quantvals()
    public int _book_maptype1_quantvals() {

        // long vals
        int vals = new Double(Math.floor(Math.pow(new Integer(entries).floatValue(), 1.0f / dim))).intValue();

        // 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) {
            long acc = 1;
            long acc1 = 1;
            int i;
            for (i = 0; i < dim; i++) {
                acc *= vals;
                acc1 *= vals + 1;
            }

            if (acc <= entries && acc1 > entries) {
                return vals;
            } else {
                if (acc > entries) {
                    vals--;
                } else {
                    vals++;
                }
            }
        }
    }
}