585 lines
17 KiB
Java
585 lines
17 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 Floor1 extends FuncFloor {
|
|
static final int floor1_rangedb = 140;
|
|
static final int VIF_POSIT = 63;
|
|
|
|
void pack(Object i, Buffer opb) {
|
|
InfoFloor1 info = (InfoFloor1) i;
|
|
|
|
int count = 0;
|
|
int rangebits;
|
|
int maxposit = info.postlist[1];
|
|
int maxclass = -1;
|
|
|
|
/* save out partitions */
|
|
opb.write(info.partitions, 5); /* only 0 to 31 legal */
|
|
for (int j = 0; j < info.partitions; j++) {
|
|
opb.write(info.partitionclass[j], 4); /* only 0 to 15 legal */
|
|
if (maxclass < info.partitionclass[j])
|
|
maxclass = info.partitionclass[j];
|
|
}
|
|
|
|
/* save out partition classes */
|
|
for (int j = 0; j < maxclass + 1; j++) {
|
|
opb.write(info.class_dim[j] - 1, 3); /* 1 to 8 */
|
|
opb.write(info.class_subs[j], 2); /* 0 to 3 */
|
|
if (info.class_subs[j] != 0) {
|
|
opb.write(info.class_book[j], 8);
|
|
}
|
|
for (int k = 0; k < (1 << info.class_subs[j]); k++) {
|
|
opb.write(info.class_subbook[j][k] + 1, 8);
|
|
}
|
|
}
|
|
|
|
/* save out the post list */
|
|
opb.write(info.mult - 1, 2); /* only 1,2,3,4 legal now */
|
|
opb.write(Util.ilog2(maxposit), 4);
|
|
rangebits = Util.ilog2(maxposit);
|
|
|
|
for (int j = 0, k = 0; j < info.partitions; j++) {
|
|
count += info.class_dim[info.partitionclass[j]];
|
|
for (; k < count; k++) {
|
|
opb.write(info.postlist[k + 2], rangebits);
|
|
}
|
|
}
|
|
}
|
|
|
|
Object unpack(Info vi, Buffer opb) {
|
|
int count = 0, maxclass = -1, rangebits;
|
|
InfoFloor1 info = new InfoFloor1();
|
|
|
|
/* read partitions */
|
|
info.partitions = opb.read(5); /* only 0 to 31 legal */
|
|
for (int j = 0; j < info.partitions; j++) {
|
|
info.partitionclass[j] = opb.read(4); /* only 0 to 15 legal */
|
|
if (maxclass < info.partitionclass[j])
|
|
maxclass = info.partitionclass[j];
|
|
}
|
|
|
|
/* read partition classes */
|
|
for (int j = 0; j < maxclass + 1; j++) {
|
|
info.class_dim[j] = opb.read(3) + 1; /* 1 to 8 */
|
|
info.class_subs[j] = opb.read(2); /* 0,1,2,3 bits */
|
|
if (info.class_subs[j] < 0) {
|
|
info.free();
|
|
return (null);
|
|
}
|
|
if (info.class_subs[j] != 0) {
|
|
info.class_book[j] = opb.read(8);
|
|
}
|
|
if (info.class_book[j] < 0 || info.class_book[j] >= vi.books) {
|
|
info.free();
|
|
return (null);
|
|
}
|
|
for (int k = 0; k < (1 << info.class_subs[j]); k++) {
|
|
info.class_subbook[j][k] = opb.read(8) - 1;
|
|
if (info.class_subbook[j][k] < -1 || info.class_subbook[j][k] >= vi.books) {
|
|
info.free();
|
|
return (null);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* read the post list */
|
|
info.mult = opb.read(2) + 1; /* only 1,2,3,4 legal now */
|
|
rangebits = opb.read(4);
|
|
|
|
for (int j = 0, k = 0; j < info.partitions; j++) {
|
|
count += info.class_dim[info.partitionclass[j]];
|
|
for (; k < count; k++) {
|
|
int t = info.postlist[k + 2] = opb.read(rangebits);
|
|
if (t < 0 || t >= (1 << rangebits)) {
|
|
info.free();
|
|
return (null);
|
|
}
|
|
}
|
|
}
|
|
info.postlist[0] = 0;
|
|
info.postlist[1] = 1 << rangebits;
|
|
|
|
return (info);
|
|
}
|
|
|
|
Object look(DspState vd, InfoMode mi, Object i) {
|
|
int _n = 0;
|
|
|
|
int[] sortpointer = new int[VIF_POSIT + 2];
|
|
|
|
// Info vi=vd.vi;
|
|
|
|
InfoFloor1 info = (InfoFloor1) i;
|
|
LookFloor1 look = new LookFloor1();
|
|
look.vi = info;
|
|
look.n = info.postlist[1];
|
|
|
|
/*
|
|
* we drop each position value in-between already decoded values, and use linear
|
|
* interpolation to predict each new value past the edges. The positions are
|
|
* read in the order of the position list... we precompute the bounding
|
|
* positions in the lookup. Of course, the neighbors can change (if a position
|
|
* is declined), but this is an initial mapping
|
|
*/
|
|
|
|
for (int j = 0; j < info.partitions; j++) {
|
|
_n += info.class_dim[info.partitionclass[j]];
|
|
}
|
|
_n += 2;
|
|
look.posts = _n;
|
|
|
|
/* also store a sorted position index */
|
|
for (int j = 0; j < _n; j++) {
|
|
sortpointer[j] = j;
|
|
}
|
|
// qsort(sortpointer,n,sizeof(int),icomp); // !!
|
|
|
|
int foo;
|
|
for (int j = 0; j < _n - 1; j++) {
|
|
for (int k = j; k < _n; k++) {
|
|
if (info.postlist[sortpointer[j]] > info.postlist[sortpointer[k]]) {
|
|
foo = sortpointer[k];
|
|
sortpointer[k] = sortpointer[j];
|
|
sortpointer[j] = foo;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* points from sort order back to range number */
|
|
for (int j = 0; j < _n; j++) {
|
|
look.forward_index[j] = sortpointer[j];
|
|
}
|
|
/* points from range order to sorted position */
|
|
for (int j = 0; j < _n; j++) {
|
|
look.reverse_index[look.forward_index[j]] = j;
|
|
}
|
|
/* we actually need the post values too */
|
|
for (int j = 0; j < _n; j++) {
|
|
look.sorted_index[j] = info.postlist[look.forward_index[j]];
|
|
}
|
|
|
|
/* quantize values to multiplier spec */
|
|
switch (info.mult) {
|
|
case 1: /* 1024 -> 256 */
|
|
look.quant_q = 256;
|
|
break;
|
|
case 2: /* 1024 -> 128 */
|
|
look.quant_q = 128;
|
|
break;
|
|
case 3: /* 1024 -> 86 */
|
|
look.quant_q = 86;
|
|
break;
|
|
case 4: /* 1024 -> 64 */
|
|
look.quant_q = 64;
|
|
break;
|
|
default:
|
|
look.quant_q = -1;
|
|
}
|
|
|
|
/*
|
|
* discover our neighbors for decode where we don't use fit flags (that would
|
|
* push the neighbors outward)
|
|
*/
|
|
for (int j = 0; j < _n - 2; j++) {
|
|
int lo = 0;
|
|
int hi = 1;
|
|
int lx = 0;
|
|
int hx = look.n;
|
|
int currentx = info.postlist[j + 2];
|
|
for (int k = 0; k < j + 2; k++) {
|
|
int x = info.postlist[k];
|
|
if (x > lx && x < currentx) {
|
|
lo = k;
|
|
lx = x;
|
|
}
|
|
if (x < hx && x > currentx) {
|
|
hi = k;
|
|
hx = x;
|
|
}
|
|
}
|
|
look.loneighbor[j] = lo;
|
|
look.hineighbor[j] = hi;
|
|
}
|
|
|
|
return look;
|
|
}
|
|
|
|
void free_info(Object i) {
|
|
}
|
|
|
|
void free_look(Object i) {
|
|
}
|
|
|
|
void free_state(Object vs) {
|
|
}
|
|
|
|
int forward(Block vb, Object i, float[] in, float[] out, Object vs) {
|
|
return 0;
|
|
}
|
|
|
|
Object inverse1(Block vb, Object ii, Object memo) {
|
|
LookFloor1 look = (LookFloor1) ii;
|
|
InfoFloor1 info = look.vi;
|
|
CodeBook[] books = vb.vd.fullbooks;
|
|
|
|
/* unpack wrapped/predicted values from stream */
|
|
if (vb.opb.read(1) == 1) {
|
|
int[] fit_value = null;
|
|
if (memo instanceof int[]) {
|
|
fit_value = (int[]) memo;
|
|
}
|
|
if (fit_value == null || fit_value.length < look.posts) {
|
|
fit_value = new int[look.posts];
|
|
} else {
|
|
for (int i = 0; i < fit_value.length; i++)
|
|
fit_value[i] = 0;
|
|
}
|
|
|
|
fit_value[0] = vb.opb.read(Util.ilog(look.quant_q - 1));
|
|
fit_value[1] = vb.opb.read(Util.ilog(look.quant_q - 1));
|
|
|
|
/* partition by partition */
|
|
for (int i = 0, j = 2; i < info.partitions; i++) {
|
|
int clss = info.partitionclass[i];
|
|
int cdim = info.class_dim[clss];
|
|
int csubbits = info.class_subs[clss];
|
|
int csub = 1 << csubbits;
|
|
int cval = 0;
|
|
|
|
/* decode the partition's first stage cascade value */
|
|
if (csubbits != 0) {
|
|
cval = books[info.class_book[clss]].decode(vb.opb);
|
|
|
|
if (cval == -1) {
|
|
return (null);
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < cdim; k++) {
|
|
int book = info.class_subbook[clss][cval & (csub - 1)];
|
|
cval >>>= csubbits;
|
|
if (book >= 0) {
|
|
if ((fit_value[j + k] = books[book].decode(vb.opb)) == -1) {
|
|
return (null);
|
|
}
|
|
} else {
|
|
fit_value[j + k] = 0;
|
|
}
|
|
}
|
|
j += cdim;
|
|
}
|
|
|
|
/* unwrap positive values and reconsitute via linear interpolation */
|
|
for (int i = 2; i < look.posts; i++) {
|
|
int predicted = render_point(info.postlist[look.loneighbor[i - 2]],
|
|
info.postlist[look.hineighbor[i - 2]], fit_value[look.loneighbor[i - 2]],
|
|
fit_value[look.hineighbor[i - 2]], info.postlist[i]);
|
|
int hiroom = look.quant_q - predicted;
|
|
int loroom = predicted;
|
|
int room = (hiroom < loroom ? hiroom : loroom) << 1;
|
|
int val = fit_value[i];
|
|
|
|
if (val != 0) {
|
|
if (val >= room) {
|
|
if (hiroom > loroom) {
|
|
val = val - loroom;
|
|
} else {
|
|
val = -1 - (val - hiroom);
|
|
}
|
|
} else {
|
|
if ((val & 1) != 0) {
|
|
val = -((val + 1) >>> 1);
|
|
} else {
|
|
val >>= 1;
|
|
}
|
|
}
|
|
|
|
fit_value[i] = val + predicted;
|
|
fit_value[look.loneighbor[i - 2]] &= 0x7fff;
|
|
fit_value[look.hineighbor[i - 2]] &= 0x7fff;
|
|
} else {
|
|
fit_value[i] = predicted | 0x8000;
|
|
}
|
|
}
|
|
return (fit_value);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
private static int render_point(int x0, int x1, int y0, int y1, int x) {
|
|
y0 &= 0x7fff; /* mask off flag */
|
|
y1 &= 0x7fff;
|
|
|
|
{
|
|
int dy = y1 - y0;
|
|
int adx = x1 - x0;
|
|
int ady = Math.abs(dy);
|
|
int err = ady * (x - x0);
|
|
|
|
int off = (int) (err / adx);
|
|
if (dy < 0)
|
|
return (y0 - off);
|
|
return (y0 + off);
|
|
}
|
|
}
|
|
|
|
int inverse2(Block vb, Object i, Object memo, float[] out) {
|
|
LookFloor1 look = (LookFloor1) i;
|
|
InfoFloor1 info = look.vi;
|
|
int n = vb.vd.vi.blocksizes[vb.mode] / 2;
|
|
|
|
if (memo != null) {
|
|
/* render the lines */
|
|
int[] fit_value = (int[]) memo;
|
|
int hx = 0;
|
|
int lx = 0;
|
|
int ly = fit_value[0] * info.mult;
|
|
for (int j = 1; j < look.posts; j++) {
|
|
int current = look.forward_index[j];
|
|
int hy = fit_value[current] & 0x7fff;
|
|
if (hy == fit_value[current]) {
|
|
hy *= info.mult;
|
|
hx = info.postlist[current];
|
|
|
|
render_line(lx, hx, ly, hy, out);
|
|
|
|
lx = hx;
|
|
ly = hy;
|
|
}
|
|
}
|
|
for (int j = hx; j < n; j++) {
|
|
out[j] *= out[j - 1]; /* be certain */
|
|
}
|
|
return (1);
|
|
}
|
|
for (int j = 0; j < n; j++) {
|
|
out[j] = 0.f;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
private static float[] FLOOR_fromdB_LOOKUP = { 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
|
|
1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F, 1.7623575e-07F, 1.8768855e-07F,
|
|
1.9988561e-07F, 2.128753e-07F, 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
|
|
2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F, 3.7516214e-07F, 3.9954229e-07F,
|
|
4.2550680e-07F, 4.5315863e-07F, 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
|
|
6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F, 7.9862701e-07F, 8.5052630e-07F,
|
|
9.0579828e-07F, 9.6466216e-07F, 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
|
|
1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F, 1.7000785e-06F, 1.8105592e-06F,
|
|
1.9282195e-06F, 2.0535261e-06F, 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
|
|
2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F, 3.6190449e-06F, 3.8542308e-06F,
|
|
4.1047004e-06F, 4.3714470e-06F, 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
|
|
5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F, 7.7040476e-06F, 8.2047000e-06F,
|
|
8.7378876e-06F, 9.3057248e-06F, 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
|
|
1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F, 1.6400004e-05F, 1.7465768e-05F,
|
|
1.8600792e-05F, 1.9809576e-05F, 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
|
|
2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F, 3.4911534e-05F, 3.7180282e-05F,
|
|
3.9596466e-05F, 4.2169667e-05F, 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
|
|
5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F, 7.4317983e-05F, 7.9147585e-05F,
|
|
8.4291040e-05F, 8.9768747e-05F, 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
|
|
0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F, 0.00015820453F, 0.00016848555F,
|
|
0.00017943469F, 0.00019109536F, 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
|
|
0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F, 0.00033677814F, 0.00035866388F,
|
|
0.00038197188F, 0.00040679456F, 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
|
|
0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F, 0.00071691700F, 0.00076350630F,
|
|
0.00081312324F, 0.00086596457F, 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F, 0.0011863665F,
|
|
0.0012634633F, 0.0013455702F, 0.0014330129F, 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
|
|
0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F, 0.0025254795F, 0.0026895994F, 0.0028643847F,
|
|
0.0030505286F, 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F, 0.0041792066F, 0.0044507950F,
|
|
0.0047400328F, 0.0050480668F, 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F, 0.0069158225F,
|
|
0.0073652516F, 0.0078438871F, 0.0083536271F, 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
|
|
0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F, 0.014722068F, 0.015678791F, 0.016697687F,
|
|
0.017782797F, 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F, 0.024362330F, 0.025945531F,
|
|
0.027631618F, 0.029427276F, 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F, 0.040315199F,
|
|
0.042935108F, 0.045725273F, 0.048696758F, 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
|
|
0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F, 0.085821044F, 0.091398179F, 0.097337747F,
|
|
0.10366330F, 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F, 0.14201813F, 0.15124727F, 0.16107617F,
|
|
0.17154380F, 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F, 0.23501402F, 0.25028656F, 0.26655159F,
|
|
0.28387361F, 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F, 0.38890521F, 0.41417847F, 0.44109412F,
|
|
0.46975890F, 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F, 0.64356699F, 0.68538959F, 0.72993007F,
|
|
0.77736504F, 0.82788260F, 0.88168307F, 0.9389798F, 1.F };
|
|
|
|
private static void render_line(int x0, int x1, int y0, int y1, float[] d) {
|
|
int dy = y1 - y0;
|
|
int adx = x1 - x0;
|
|
int ady = Math.abs(dy);
|
|
int base = dy / adx;
|
|
int sy = (dy < 0 ? base - 1 : base + 1);
|
|
int x = x0;
|
|
int y = y0;
|
|
int err = 0;
|
|
|
|
ady -= Math.abs(base * adx);
|
|
|
|
d[x] *= FLOOR_fromdB_LOOKUP[y];
|
|
while (++x < x1) {
|
|
err = err + ady;
|
|
if (err >= adx) {
|
|
err -= adx;
|
|
y += sy;
|
|
} else {
|
|
y += base;
|
|
}
|
|
d[x] *= FLOOR_fromdB_LOOKUP[y];
|
|
}
|
|
}
|
|
|
|
class InfoFloor1 {
|
|
static final int VIF_POSIT = 63;
|
|
static final int VIF_CLASS = 16;
|
|
static final int VIF_PARTS = 31;
|
|
|
|
int partitions; /* 0 to 31 */
|
|
int[] partitionclass = new int[VIF_PARTS]; /* 0 to 15 */
|
|
|
|
int[] class_dim = new int[VIF_CLASS]; /* 1 to 8 */
|
|
int[] class_subs = new int[VIF_CLASS]; /* 0,1,2,3 (bits: 1<<n poss) */
|
|
int[] class_book = new int[VIF_CLASS]; /* subs ^ dim entries */
|
|
int[][] class_subbook = new int[VIF_CLASS][]; /* [VIF_CLASS][subs] */
|
|
|
|
int mult; /* 1 2 3 or 4 */
|
|
int[] postlist = new int[VIF_POSIT + 2]; /* first two implicit */
|
|
|
|
/* encode side analysis parameters */
|
|
float maxover;
|
|
float maxunder;
|
|
float maxerr;
|
|
|
|
int twofitminsize;
|
|
int twofitminused;
|
|
int twofitweight;
|
|
float twofitatten;
|
|
int unusedminsize;
|
|
int unusedmin_n;
|
|
|
|
int n;
|
|
|
|
InfoFloor1() {
|
|
for (int i = 0; i < class_subbook.length; i++) {
|
|
class_subbook[i] = new int[8];
|
|
}
|
|
}
|
|
|
|
void free() {
|
|
partitionclass = null;
|
|
class_dim = null;
|
|
class_subs = null;
|
|
class_book = null;
|
|
class_subbook = null;
|
|
postlist = null;
|
|
}
|
|
|
|
Object copy_info() {
|
|
InfoFloor1 info = this;
|
|
InfoFloor1 ret = new InfoFloor1();
|
|
|
|
ret.partitions = info.partitions;
|
|
System.arraycopy(info.partitionclass, 0, ret.partitionclass, 0, VIF_PARTS);
|
|
System.arraycopy(info.class_dim, 0, ret.class_dim, 0, VIF_CLASS);
|
|
System.arraycopy(info.class_subs, 0, ret.class_subs, 0, VIF_CLASS);
|
|
System.arraycopy(info.class_book, 0, ret.class_book, 0, VIF_CLASS);
|
|
|
|
for (int j = 0; j < VIF_CLASS; j++) {
|
|
System.arraycopy(info.class_subbook[j], 0, ret.class_subbook[j], 0, 8);
|
|
}
|
|
|
|
ret.mult = info.mult;
|
|
System.arraycopy(info.postlist, 0, ret.postlist, 0, VIF_POSIT + 2);
|
|
|
|
ret.maxover = info.maxover;
|
|
ret.maxunder = info.maxunder;
|
|
ret.maxerr = info.maxerr;
|
|
|
|
ret.twofitminsize = info.twofitminsize;
|
|
ret.twofitminused = info.twofitminused;
|
|
ret.twofitweight = info.twofitweight;
|
|
ret.twofitatten = info.twofitatten;
|
|
ret.unusedminsize = info.unusedminsize;
|
|
ret.unusedmin_n = info.unusedmin_n;
|
|
|
|
ret.n = info.n;
|
|
|
|
return (ret);
|
|
}
|
|
|
|
}
|
|
|
|
class LookFloor1 {
|
|
static final int VIF_POSIT = 63;
|
|
|
|
int[] sorted_index = new int[VIF_POSIT + 2];
|
|
int[] forward_index = new int[VIF_POSIT + 2];
|
|
int[] reverse_index = new int[VIF_POSIT + 2];
|
|
int[] hineighbor = new int[VIF_POSIT];
|
|
int[] loneighbor = new int[VIF_POSIT];
|
|
int posts;
|
|
|
|
int n;
|
|
int quant_q;
|
|
InfoFloor1 vi;
|
|
|
|
int phrasebits;
|
|
int postbits;
|
|
int frames;
|
|
|
|
void free() {
|
|
sorted_index = null;
|
|
forward_index = null;
|
|
reverse_index = null;
|
|
hineighbor = null;
|
|
loneighbor = null;
|
|
}
|
|
}
|
|
|
|
class Lsfit_acc {
|
|
long x0;
|
|
long x1;
|
|
|
|
long xa;
|
|
long ya;
|
|
long x2a;
|
|
long y2a;
|
|
long xya;
|
|
long n;
|
|
long an;
|
|
long un;
|
|
long edgey0;
|
|
long edgey1;
|
|
}
|
|
|
|
class EchstateFloor1 {
|
|
int[] codewords;
|
|
float[] curve;
|
|
long frameno;
|
|
long codes;
|
|
}
|
|
}
|