public override int inverse2(Block vb, Object i, Object memo, float[] fout)
{
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, fout);
lx = hx;
ly = hy;
}
}
for (int j = hx; j < n; j++)
{
// Be certain
fout[j] *= fout[j - 1];
}
return(1);
}
for (int j = 0; j < n; j++)
{
fout[j] = 0.0f;
}
return(0);
}
override public 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 is 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(ilog(look.quant_q - 1));
fit_value[1] = vb.opb.read(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)
{
//goto eop;
return(null);
}
}
for (int k = 0; k < cdim; k++)
{
int book = info.class_subbook[clss][cval & (csub - 1)];
cval = (int)((uint)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 = (int)(-((uint)(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);
}
// eop:
// return(NULL);
return(null);
}
override public 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;
break;
}
/* 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);
}
override public 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;
break;
}
/* 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;
}
