com.jcraft.jorbis.CodeBook Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of sound Show documentation
Etyl's default sound module
There is a newer version: 1.2.0
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/* JOrbis
 * Copyright (C) 2000 ymnk, JCraft,Inc.
 *  
 * Written by: 2000 ymnk
 *   
 * Many thanks to 
 *   Monty  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; k8){
      for(i=0; i 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-->