diff options
Diffstat (limited to 'songdbj/com/jcraft/jorbis/Residue0.java')
-rw-r--r-- | songdbj/com/jcraft/jorbis/Residue0.java | 454 |
1 files changed, 0 insertions, 454 deletions
diff --git a/songdbj/com/jcraft/jorbis/Residue0.java b/songdbj/com/jcraft/jorbis/Residue0.java deleted file mode 100644 index be42518f1c..0000000000 --- a/songdbj/com/jcraft/jorbis/Residue0.java +++ /dev/null | |||
@@ -1,454 +0,0 @@ | |||
1 | /* JOrbis | ||
2 | * Copyright (C) 2000 ymnk, JCraft,Inc. | ||
3 | * | ||
4 | * Written by: 2000 ymnk<ymnk@jcraft.com> | ||
5 | * | ||
6 | * Many thanks to | ||
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. | ||
10 | * | ||
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. | ||
15 | |||
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. | ||
20 | * | ||
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. | ||
24 | */ | ||
25 | |||
26 | package com.jcraft.jorbis; | ||
27 | |||
28 | import com.jcraft.jogg.*; | ||
29 | |||
30 | class Residue0 extends FuncResidue{ | ||
31 | void pack(Object vr, Buffer opb){ | ||
32 | InfoResidue0 info=(InfoResidue0)vr; | ||
33 | int acc=0; | ||
34 | opb.write(info.begin,24); | ||
35 | opb.write(info.end,24); | ||
36 | |||
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 */ | ||
41 | |||
42 | /* secondstages is a bitmask; as encoding progresses pass by pass, a | ||
43 | bitmask of one indicates this partition class has bits to write | ||
44 | this pass */ | ||
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); | ||
49 | opb.write(1,1); | ||
50 | opb.write(info.secondstages[j]>>>3,5); | ||
51 | } | ||
52 | else{ | ||
53 | opb.write(info.secondstages[j],4); /* trailing zero */ | ||
54 | } | ||
55 | acc+=icount(info.secondstages[j]); | ||
56 | } | ||
57 | for(int j=0;j<acc;j++){ | ||
58 | opb.write(info.booklist[j],8); | ||
59 | } | ||
60 | } | ||
61 | |||
62 | Object unpack(Info vi, Buffer opb){ | ||
63 | int acc=0; | ||
64 | InfoResidue0 info=new InfoResidue0(); | ||
65 | |||
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); | ||
71 | |||
72 | for(int j=0;j<info.partitions;j++){ | ||
73 | int cascade=opb.read(3); | ||
74 | if(opb.read(1)!=0){ | ||
75 | cascade|=(opb.read(5)<<3); | ||
76 | } | ||
77 | info.secondstages[j]=cascade; | ||
78 | acc+=icount(cascade); | ||
79 | } | ||
80 | |||
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; | ||
84 | } | ||
85 | |||
86 | if(info.groupbook>=vi.books){ | ||
87 | free_info(info); | ||
88 | return(null); | ||
89 | } | ||
90 | |||
91 | for(int j=0;j<acc;j++){ | ||
92 | if(info.booklist[j]>=vi.books){ | ||
93 | free_info(info); | ||
94 | return(null); | ||
95 | } | ||
96 | } | ||
97 | return(info); | ||
98 | // errout: | ||
99 | // free_info(info); | ||
100 | // return(NULL); | ||
101 | } | ||
102 | |||
103 | Object look(DspState vd, InfoMode vm, Object vr){ | ||
104 | InfoResidue0 info=(InfoResidue0)vr; | ||
105 | LookResidue0 look=new LookResidue0(); | ||
106 | int acc=0; | ||
107 | int dim; | ||
108 | int maxstage=0; | ||
109 | look.info=info; | ||
110 | look.map=vm.mapping; | ||
111 | |||
112 | look.parts=info.partitions; | ||
113 | look.fullbooks=vd.fullbooks; | ||
114 | look.phrasebook=vd.fullbooks[info.groupbook]; | ||
115 | |||
116 | dim=look.phrasebook.dim; | ||
117 | |||
118 | look.partbooks=new int[look.parts][]; | ||
119 | |||
120 | for(int j=0;j<look.parts;j++){ | ||
121 | int stages=ilog(info.secondstages[j]); | ||
122 | if(stages!=0){ | ||
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++]; | ||
128 | } | ||
129 | } | ||
130 | } | ||
131 | } | ||
132 | |||
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++){ | ||
137 | int val=j; | ||
138 | int mult=look.partvals/look.parts; | ||
139 | look.decodemap[j]=new int[dim]; | ||
140 | |||
141 | for(int k=0;k<dim;k++){ | ||
142 | int deco=val/mult; | ||
143 | val-=deco*mult; | ||
144 | mult/=look.parts; | ||
145 | look.decodemap[j][k]=deco; | ||
146 | } | ||
147 | } | ||
148 | return(look); | ||
149 | } | ||
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"); | ||
154 | return 0; | ||
155 | } | ||
156 | |||
157 | static int[][][] partword=new int[2][][]; // _01inverse is synchronized for | ||
158 | // re-using partword | ||
159 | synchronized static int _01inverse(Block vb, Object vl, | ||
160 | float[][] in,int ch,int decodepart){ | ||
161 | int i,j,k,l,s; | ||
162 | LookResidue0 look=(LookResidue0 )vl; | ||
163 | InfoResidue0 info=look.info; | ||
164 | |||
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; | ||
169 | |||
170 | int partvals=n/samples_per_partition; | ||
171 | int partwords=(partvals+partitions_per_word-1)/partitions_per_word; | ||
172 | |||
173 | if(partword.length<ch){ | ||
174 | partword=new int[ch][][]; | ||
175 | for(j=0;j<ch;j++){ | ||
176 | partword[j]=new int[partwords][]; | ||
177 | } | ||
178 | } | ||
179 | else{ | ||
180 | for(j=0;j<ch;j++){ | ||
181 | if(partword[j]==null || partword[j].length<partwords) | ||
182 | partword[j]=new int[partwords][]; | ||
183 | } | ||
184 | } | ||
185 | |||
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++){ | ||
190 | if(s==0){ | ||
191 | // fetch the partition word for each channel | ||
192 | for(j=0;j<ch;j++){ | ||
193 | int temp=look.phrasebook.decode(vb.opb); | ||
194 | if(temp==-1){ | ||
195 | //goto eopbreak; | ||
196 | return(0); | ||
197 | } | ||
198 | partword[j][l]=look.decodemap[temp]; | ||
199 | if(partword[j][l]==null){ | ||
200 | // goto errout; | ||
201 | return(0); | ||
202 | } | ||
203 | } | ||
204 | } | ||
205 | |||
206 | // now we decode residual values for the partitions | ||
207 | for(k=0;k<partitions_per_word && i<partvals;k++,i++) | ||
208 | for(j=0;j<ch;j++){ | ||
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]; | ||
213 | if(stagebook!=null){ | ||
214 | if(decodepart==0){ | ||
215 | if(stagebook.decodevs_add(in[j],offset,vb.opb,samples_per_partition)==-1){ | ||
216 | // goto errout; | ||
217 | return(0); | ||
218 | } | ||
219 | } | ||
220 | else if(decodepart==1){ | ||
221 | if(stagebook.decodev_add(in[j], offset, vb.opb,samples_per_partition)==-1){ | ||
222 | // goto errout; | ||
223 | return(0); | ||
224 | } | ||
225 | } | ||
226 | } | ||
227 | } | ||
228 | } | ||
229 | } | ||
230 | } | ||
231 | // errout: | ||
232 | // eopbreak: | ||
233 | return(0); | ||
234 | } | ||
235 | |||
236 | static int _2inverse(Block vb, Object vl, float[][] in, int ch){ | ||
237 | int i,j,k,l,s; | ||
238 | LookResidue0 look=(LookResidue0 )vl; | ||
239 | InfoResidue0 info=look.info; | ||
240 | |||
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; | ||
245 | |||
246 | int partvals=n/samples_per_partition; | ||
247 | int partwords=(partvals+partitions_per_word-1)/partitions_per_word; | ||
248 | |||
249 | int[][] partword=new int[partwords][]; | ||
250 | for(s=0;s<look.stages;s++){ | ||
251 | for(i=0,l=0;i<partvals;l++){ | ||
252 | if(s==0){ | ||
253 | // fetch the partition word for each channel | ||
254 | int temp=look.phrasebook.decode(vb.opb); | ||
255 | if(temp==-1){ | ||
256 | // goto eopbreak; | ||
257 | return(0); | ||
258 | } | ||
259 | partword[l]=look.decodemap[temp]; | ||
260 | if(partword[l]==null){ | ||
261 | // goto errout; | ||
262 | return(0); | ||
263 | } | ||
264 | } | ||
265 | |||
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]]; | ||
271 | if(stagebook!=null){ | ||
272 | if(stagebook.decodevv_add(in, offset, ch, vb.opb,samples_per_partition)==-1){ | ||
273 | // goto errout; | ||
274 | return(0); | ||
275 | } | ||
276 | } | ||
277 | } | ||
278 | } | ||
279 | } | ||
280 | } | ||
281 | // errout: | ||
282 | // eopbreak: | ||
283 | return(0); | ||
284 | } | ||
285 | |||
286 | int inverse(Block vb, Object vl, float[][] in, int[] nonzero, int ch){ | ||
287 | //System.err.println("Residue0.inverse"); | ||
288 | int used=0; | ||
289 | for(int i=0;i<ch;i++){ | ||
290 | if(nonzero[i]!=0){ | ||
291 | in[used++]=in[i]; | ||
292 | } | ||
293 | } | ||
294 | if(used!=0) | ||
295 | return(_01inverse(vb,vl,in,used,0)); | ||
296 | else | ||
297 | return(0); | ||
298 | } | ||
299 | |||
300 | /* | ||
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; | ||
306 | |||
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; | ||
311 | |||
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; | ||
317 | |||
318 | // make sure we're zeroed up to the start | ||
319 | for(j=0;j<ch;j++){ | ||
320 | for(k=0; k<info.begin; k++)in[j][k]=0.0f; | ||
321 | } | ||
322 | |||
323 | for(i=info.begin,l=0;i<info.end;){ | ||
324 | // fetch the partition word for each channel | ||
325 | for(j=0;j<ch;j++){ | ||
326 | int temp=look.phrasebook.decode(vb.opb); | ||
327 | if(temp==-1){ | ||
328 | //goto eopbreak; | ||
329 | if(i<transend){ | ||
330 | for(j=0;j<ch;j++){ | ||
331 | for(k=0;k<transend-i;k++)in[j][i+k]=0.0f; | ||
332 | } | ||
333 | } | ||
334 | return(0); | ||
335 | } | ||
336 | partword[j]=look.decodemap[temp]; | ||
337 | if(partword[j]==null){ | ||
338 | //goto errout; | ||
339 | for(j=0;j<ch;j++){ | ||
340 | for(k=0;k<transend;k++)in[j][k]=0.0f; | ||
341 | } | ||
342 | return(0); | ||
343 | } | ||
344 | } | ||
345 | |||
346 | // now we decode interleaved residual values for the partitions | ||
347 | for(k=0;k<partitions_per_word;k++,l++,i+=samples_per_partition){ | ||
348 | for(j=0;j<ch;j++){ | ||
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){ | ||
353 | //goto eopbreak; | ||
354 | if(i<transend){ | ||
355 | for(j=0;j<ch;j++){ | ||
356 | for(k=0;k<transend-i;k++)in[j][i+k]=0.0f; | ||
357 | } | ||
358 | } | ||
359 | return(0); | ||
360 | } | ||
361 | } | ||
362 | } | ||
363 | } | ||
364 | |||
365 | // eopbreak: | ||
366 | if(i<transend){ | ||
367 | for(j=0;j<ch;j++){ | ||
368 | for(k=0;k<transend-i;k++)in[j][i+k]=0.0f; | ||
369 | } | ||
370 | } | ||
371 | return(0); | ||
372 | |||
373 | // errout: | ||
374 | // for(j=0;j<ch;j++) | ||
375 | // for(k=0;k<transend;k++)in[j][k]=0.0f; | ||
376 | // return(0); | ||
377 | } | ||
378 | int decodepart(Buffer opb, float[] work, float[] vec, int veci, | ||
379 | int n, int stages, CodeBook[] books){ | ||
380 | int i,j; | ||
381 | for(i=0;i<n;i++)work[i]=0.0f; | ||
382 | |||
383 | for(j=0;j<stages;j++){ | ||
384 | int dim=books[j].dim; | ||
385 | int step=n/dim; | ||
386 | for(i=0;i<step;i++){ | ||
387 | if(books[j].decodevs(work, i, opb, step, 0)==-1){ | ||
388 | return(-1); | ||
389 | } | ||
390 | } | ||
391 | } | ||
392 | for(i=0;i<n;i++){ | ||
393 | vec[veci+i]*=work[i]; | ||
394 | } | ||
395 | return(0); | ||
396 | } | ||
397 | */ | ||
398 | |||
399 | private static int ilog(int v){ | ||
400 | int ret=0; | ||
401 | while(v!=0){ | ||
402 | ret++; | ||
403 | v>>>=1; | ||
404 | } | ||
405 | return(ret); | ||
406 | } | ||
407 | private static int icount(int v){ | ||
408 | int ret=0; | ||
409 | while(v!=0){ | ||
410 | ret+=(v&1); | ||
411 | v>>>=1; | ||
412 | } | ||
413 | return(ret); | ||
414 | } | ||
415 | } | ||
416 | |||
417 | class LookResidue0 { | ||
418 | InfoResidue0 info; | ||
419 | int map; | ||
420 | |||
421 | int parts; | ||
422 | int stages; | ||
423 | CodeBook[] fullbooks; | ||
424 | CodeBook phrasebook; | ||
425 | int[][] partbooks; | ||
426 | // CodeBook[][] partbooks; | ||
427 | |||
428 | int partvals; | ||
429 | int[][] decodemap; | ||
430 | |||
431 | int postbits; | ||
432 | int phrasebits; | ||
433 | // int[][] frames; | ||
434 | int frames; | ||
435 | } | ||
436 | |||
437 | class InfoResidue0{ | ||
438 | // block-partitioned VQ coded straight residue | ||
439 | int begin; | ||
440 | int end; | ||
441 | |||
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 | ||
448 | |||
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 | ||
454 | } | ||