2 * Copyright (C) 2000 ymnk, JCraft,Inc.
4 * Written by: 2000 ymnk<ymnk@jcraft.com>
7 * Monty <monty@xiph.org> and
8 * The XIPHOPHORUS Company http://www.xiph.org/ .
9 * JOrbis has been based on their awesome works, Vorbis codec.
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public License
13 * as published by the Free Software Foundation; either version 2 of
14 * the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Library General Public License for more details.
21 * You should have received a copy of the GNU Library General Public
22 * License along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 package com.jcraft.jorbis;
28 import com.jcraft.jogg.*;
30 class Residue0 extends FuncResidue{
31 void pack(Object vr, Buffer opb){
32 InfoResidue0 info=(InfoResidue0)vr;
34 opb.write(info.begin,24);
35 opb.write(info.end,24);
37 opb.write(info.grouping-1,24); /* residue vectors to group and
38 code with a partitioned book */
39 opb.write(info.partitions-1,6); /* possible partition choices */
40 opb.write(info.groupbook,8); /* group huffman book */
42 /* secondstages is a bitmask; as encoding progresses pass by pass, a
43 bitmask of one indicates this partition class has bits to write
45 for(int j=0;j<info.partitions;j++){
46 if(ilog(info.secondstages[j])>3){
47 /* yes, this is a minor hack due to not thinking ahead */
48 opb.write(info.secondstages[j],3);
50 opb.write(info.secondstages[j]>>>3,5);
53 opb.write(info.secondstages[j],4); /* trailing zero */
55 acc+=icount(info.secondstages[j]);
57 for(int j=0;j<acc;j++){
58 opb.write(info.booklist[j],8);
62 Object unpack(Info vi, Buffer opb){
64 InfoResidue0 info=new InfoResidue0();
66 info.begin=opb.read(24);
67 info.end=opb.read(24);
68 info.grouping=opb.read(24)+1;
69 info.partitions=opb.read(6)+1;
70 info.groupbook=opb.read(8);
72 for(int j=0;j<info.partitions;j++){
73 int cascade=opb.read(3);
75 cascade|=(opb.read(5)<<3);
77 info.secondstages[j]=cascade;
81 for(int j=0;j<acc;j++){
82 info.booklist[j]=opb.read(8);
83 // if(info.booklist[j]==255)info.booklist[j]=-1;
86 if(info.groupbook>=vi.books){
91 for(int j=0;j<acc;j++){
92 if(info.booklist[j]>=vi.books){
103 Object look(DspState vd, InfoMode vm, Object vr){
104 InfoResidue0 info=(InfoResidue0)vr;
105 LookResidue0 look=new LookResidue0();
112 look.parts=info.partitions;
113 look.fullbooks=vd.fullbooks;
114 look.phrasebook=vd.fullbooks[info.groupbook];
116 dim=look.phrasebook.dim;
118 look.partbooks=new int[look.parts][];
120 for(int j=0;j<look.parts;j++){
121 int stages=ilog(info.secondstages[j]);
123 if(stages>maxstage)maxstage=stages;
124 look.partbooks[j]=new int[stages];
125 for(int k=0; k<stages; k++){
126 if((info.secondstages[j]&(1<<k))!=0){
127 look.partbooks[j][k]=info.booklist[acc++];
133 look.partvals=(int)Math.rint(Math.pow(look.parts,dim));
134 look.stages=maxstage;
135 look.decodemap=new int[look.partvals][];
136 for(int j=0;j<look.partvals;j++){
138 int mult=look.partvals/look.parts;
139 look.decodemap[j]=new int[dim];
141 for(int k=0;k<dim;k++){
145 look.decodemap[j][k]=deco;
150 void free_info(Object i){}
151 void free_look(Object i){}
152 int forward(Block vb,Object vl, float[][] in, int ch){
153 System.err.println("Residue0.forward: not implemented");
157 static int[][][] partword=new int[2][][]; // _01inverse is synchronized for
159 synchronized static int _01inverse(Block vb, Object vl,
160 float[][] in,int ch,int decodepart){
162 LookResidue0 look=(LookResidue0 )vl;
163 InfoResidue0 info=look.info;
165 // move all this setup out later
166 int samples_per_partition=info.grouping;
167 int partitions_per_word=look.phrasebook.dim;
168 int n=info.end-info.begin;
170 int partvals=n/samples_per_partition;
171 int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
173 if(partword.length<ch){
174 partword=new int[ch][][];
176 partword[j]=new int[partwords][];
181 if(partword[j]==null || partword[j].length<partwords)
182 partword[j]=new int[partwords][];
186 for(s=0;s<look.stages;s++){
187 // each loop decodes on partition codeword containing
188 // partitions_pre_word partitions
189 for(i=0,l=0;i<partvals;l++){
191 // fetch the partition word for each channel
193 int temp=look.phrasebook.decode(vb.opb);
198 partword[j][l]=look.decodemap[temp];
199 if(partword[j][l]==null){
206 // now we decode residual values for the partitions
207 for(k=0;k<partitions_per_word && i<partvals;k++,i++)
209 int offset=info.begin+i*samples_per_partition;
210 if((info.secondstages[partword[j][l][k]]&(1<<s))!=0){
211 CodeBook stagebook=look.fullbooks[look.partbooks[partword[j][l][k]][s]];
212 // CodeBook stagebook=look.partbooks[partword[j][l][k]][s];
215 if(stagebook.decodevs_add(in[j],offset,vb.opb,samples_per_partition)==-1){
220 else if(decodepart==1){
221 if(stagebook.decodev_add(in[j], offset, vb.opb,samples_per_partition)==-1){
236 static int _2inverse(Block vb, Object vl, float[][] in, int ch){
238 LookResidue0 look=(LookResidue0 )vl;
239 InfoResidue0 info=look.info;
241 // move all this setup out later
242 int samples_per_partition=info.grouping;
243 int partitions_per_word=look.phrasebook.dim;
244 int n=info.end-info.begin;
246 int partvals=n/samples_per_partition;
247 int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
249 int[][] partword=new int[partwords][];
250 for(s=0;s<look.stages;s++){
251 for(i=0,l=0;i<partvals;l++){
253 // fetch the partition word for each channel
254 int temp=look.phrasebook.decode(vb.opb);
259 partword[l]=look.decodemap[temp];
260 if(partword[l]==null){
266 // now we decode residual values for the partitions
267 for(k=0;k<partitions_per_word && i<partvals;k++,i++){
268 int offset=info.begin+i*samples_per_partition;
269 if((info.secondstages[partword[l][k]]&(1<<s))!=0){
270 CodeBook stagebook=look.fullbooks[look.partbooks[partword[l][k]][s]];
272 if(stagebook.decodevv_add(in, offset, ch, vb.opb,samples_per_partition)==-1){
286 int inverse(Block vb, Object vl, float[][] in, int[] nonzero, int ch){
287 //System.err.println("Residue0.inverse");
289 for(int i=0;i<ch;i++){
295 return(_01inverse(vb,vl,in,used,0));
301 int inverse(Block vb, Object vl, float[][] in, int ch){
302 //System.err.println("Residue0.inverse");
303 int i,j,k,l,transend=vb.pcmend/2;
304 LookResidue0 look=(LookResidue0 )vl;
305 InfoResidue0 info=look.info;
307 // move all this setup out later
308 int samples_per_partition=info.grouping;
309 int partitions_per_word=look.phrasebook.dim;
310 int n=info.end-info.begin;
312 int partvals=n/samples_per_partition;
313 int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
314 int[][] partword=new int[ch][];
315 float[] work=new float[samples_per_partition];
316 partvals=partwords*partitions_per_word;
318 // make sure we're zeroed up to the start
320 for(k=0; k<info.begin; k++)in[j][k]=0.0f;
323 for(i=info.begin,l=0;i<info.end;){
324 // fetch the partition word for each channel
326 int temp=look.phrasebook.decode(vb.opb);
331 for(k=0;k<transend-i;k++)in[j][i+k]=0.0f;
336 partword[j]=look.decodemap[temp];
337 if(partword[j]==null){
340 for(k=0;k<transend;k++)in[j][k]=0.0f;
346 // now we decode interleaved residual values for the partitions
347 for(k=0;k<partitions_per_word;k++,l++,i+=samples_per_partition){
349 int part=partword[j][k];
350 if(decodepart(vb.opb,work, in[j], i,samples_per_partition,
351 info.secondstages[part],
352 look.partbooks[part])==-1){
356 for(k=0;k<transend-i;k++)in[j][i+k]=0.0f;
368 for(k=0;k<transend-i;k++)in[j][i+k]=0.0f;
375 // for(k=0;k<transend;k++)in[j][k]=0.0f;
378 int decodepart(Buffer opb, float[] work, float[] vec, int veci,
379 int n, int stages, CodeBook[] books){
381 for(i=0;i<n;i++)work[i]=0.0f;
383 for(j=0;j<stages;j++){
384 int dim=books[j].dim;
387 if(books[j].decodevs(work, i, opb, step, 0)==-1){
393 vec[veci+i]*=work[i];
399 private static int ilog(int v){
407 private static int icount(int v){
423 CodeBook[] fullbooks;
426 // CodeBook[][] partbooks;
438 // block-partitioned VQ coded straight residue
442 // first stage (lossless partitioning)
443 int grouping; // group n vectors per partition
444 int partitions; // possible codebooks for a partition
445 int groupbook; // huffbook for partitioning
446 int[] secondstages=new int[64]; // expanded out to pointers in lookup
447 int[] booklist=new int[256]; // list of second stage books
449 // encode-only heuristic settings
450 float[] entmax=new float[64]; // book entropy threshholds
451 float[] ampmax=new float[64]; // book amp threshholds
452 int[] subgrp=new int[64]; // book heuristic subgroup size
453 int[] blimit=new int[64]; // subgroup position limits