override public Object look(DspState vd, InfoMode vm, Object vr)
{
InfoResidue0 info = (InfoResidue0)vr;
LookResidue0 look = new LookResidue0();
int acc = 0;
int dim;
int maxstage = 0;
look.info = info;
look.map = vm.mapping;
look.parts = info.partitions;
look.fullbooks = vd.fullbooks;
look.phrasebook = vd.fullbooks[info.groupbook];
dim = look.phrasebook.dim;
look.partbooks = new int[look.parts][];
for (int j = 0; j < look.parts; j++)
{
int stages = ilog(info.secondstages[j]);
if (stages != 0)
{
if (stages > maxstage)
{
maxstage = stages;
}
look.partbooks[j] = new int[stages];
for (int k = 0; k < stages; k++)
{
if ((info.secondstages[j] & (1 << k)) != 0)
{
look.partbooks[j][k] = info.booklist[acc++];
}
}
}
}
look.partvals = (int)Math.Round(Math.Pow(look.parts, dim));
look.stages = maxstage;
look.decodemap = new int[look.partvals][];
for (int j = 0; j < look.partvals; j++)
{
int val = j;
int mult = look.partvals / look.parts;
look.decodemap[j] = new int[dim];
for (int k = 0; k < dim; k++)
{
int deco = val / mult;
val -= deco * mult;
mult /= look.parts;
look.decodemap[j][k] = deco;
}
}
return(look);
}
override public Object look(DspState vd, InfoMode vm, Object m)
{
Info vi = vd.vi;
LookMapping0 looks = new LookMapping0();
InfoMapping0 info = looks.map = (InfoMapping0)m;
looks.mode = vm;
looks.time_look = new Object[info.submaps];
looks.floor_look = new Object[info.submaps];
looks.residue_look = new Object[info.submaps];
looks.time_func = new FuncTime[info.submaps];
looks.floor_func = new FuncFloor[info.submaps];
looks.residue_func = new FuncResidue[info.submaps];
for (int i = 0; i < info.submaps; i++)
{
int timenum = info.timesubmap[i];
int floornum = info.floorsubmap[i];
int resnum = info.residuesubmap[i];
looks.time_func[i] = FuncTime.time_P[vi.time_type[timenum]];
looks.time_look[i] = looks.time_func[i].look(vd, vm, vi.time_param[timenum]);
looks.floor_func[i] = FuncFloor.floor_P[vi.floor_type[floornum]];
looks.floor_look[i] = looks.floor_func[i].
look(vd, vm, vi.floor_param[floornum]);
looks.residue_func[i] = FuncResidue.residue_P[vi.residue_type[resnum]];
looks.residue_look[i] = looks.residue_func[i].
look(vd, vm, vi.residue_param[resnum]);
}
if (vi.psys != 0 && vd.analysisp != 0)
{
}
looks.ch = vi.channels;
return(looks);
}
override public Object look(DspState vd, InfoMode mi, Object i)
{
float scale;
Info vi = vd.vi;
InfoFloor0 info = (InfoFloor0)i;
LookFloor0 look = new LookFloor0();
look.m = info.order;
look.n = vi.blocksizes[mi.blockflag] / 2;
look.ln = info.barkmap;
look.vi = info;
look.lpclook.init(look.ln, look.m);
// we choose a scaling constant so that:
// floor(bark(rate/2-1)*C)=mapped-1
// floor(bark(rate/2)*C)=mapped
scale = look.ln / (float)toBARK((float)(info.rate / 2.0));
// the mapping from a linear scale to a smaller bark scale is
// straightforward. We do *not* make sure that the linear mapping
// does not skip bark-scale bins; the decoder simply skips them and
// the encoder may do what it wishes in filling them. They're
// necessary in some mapping combinations to keep the scale spacing
// accurate
look.linearmap = new int[look.n];
for (int j = 0; j < look.n; j++)
{
int val = (int)Math.Floor(toBARK((float)((info.rate / 2.0) / look.n * j))
* scale); // bark numbers represent band edges
if (val >= look.ln)
{
val = look.ln; // guard against the approximation
}
look.linearmap[j] = val;
}
return(look);
}
override public int inverse(Block vb, Object l)
{
lock (this)
{
//System.err.println("Mapping0.inverse");
DspState vd = vb.vd;
Info vi = vd.vi;
LookMapping0 look = (LookMapping0)l;
InfoMapping0 info = look.map;
InfoMode mode = look.mode;
int n = vb.pcmend = vi.blocksizes[vb.W];
float[] window = vd.wnd[vb.W][vb.lW][vb.nW][mode.windowtype];
// float[][] pcmbundle=new float[vi.channels][];
// int[] nonzero=new int[vi.channels];
if (pcmbundle == null || pcmbundle.Length < vi.channels)
{
pcmbundle = new float[vi.channels][];
nonzero = new int[vi.channels];
zerobundle = new int[vi.channels];
floormemo = new Object[vi.channels];
}
// time domain information decode (note that applying the
// information would have to happen later; we'll probably add a
// function entry to the harness for that later
// NOT IMPLEMENTED
// recover the spectral envelope; store it in the PCM vector for now
for (int i = 0; i < vi.channels; i++)
{
float[] pcm = vb.pcm[i];
int submap = info.chmuxlist[i];
floormemo[i] = look.floor_func[submap].inverse1(vb, look.
floor_look[submap],
floormemo[i]
);
if (floormemo[i] != null)
{
nonzero[i] = 1;
}
else
{
nonzero[i] = 0;
}
for (int j = 0; j < n / 2; j++)
{
pcm[j] = 0;
}
//_analysis_output("ifloor",seq+i,pcm,n/2,0,1);
}
for (int i = 0; i < info.coupling_steps; i++)
{
if (nonzero[info.coupling_mag[i]] != 0 ||
nonzero[info.coupling_ang[i]] != 0)
{
nonzero[info.coupling_mag[i]] = 1;
nonzero[info.coupling_ang[i]] = 1;
}
}
// recover the residue, apply directly to the spectral envelope
for (int i = 0; i < info.submaps; i++)
{
int ch_in_bundle = 0;
for (int j = 0; j < vi.channels; j++)
{
if (info.chmuxlist[j] == i)
{
if (nonzero[j] != 0)
{
zerobundle[ch_in_bundle] = 1;
}
else
{
zerobundle[ch_in_bundle] = 0;
}
pcmbundle[ch_in_bundle++] = vb.pcm[j];
}
}
look.residue_func[i].inverse(vb, look.residue_look[i],
pcmbundle, zerobundle, ch_in_bundle);
}
for (int i = info.coupling_steps - 1; i >= 0; i--)
{
float[] pcmM = vb.pcm[info.coupling_mag[i]];
float[] pcmA = vb.pcm[info.coupling_ang[i]];
for (int j = 0; j < n / 2; j++)
{
float mag = pcmM[j];
float ang = pcmA[j];
if (mag > 0)
{
if (ang > 0)
{
pcmM[j] = mag;
pcmA[j] = mag - ang;
}
else
{
pcmA[j] = mag;
pcmM[j] = mag + ang;
}
}
else
{
if (ang > 0)
{
pcmM[j] = mag;
pcmA[j] = mag + ang;
}
else
{
pcmA[j] = mag;
pcmM[j] = mag - ang;
}
}
}
}
// /* compute and apply spectral envelope */
for (int i = 0; i < vi.channels; i++)
{
float[] pcm = vb.pcm[i];
int submap = info.chmuxlist[i];
look.floor_func[submap].inverse2(vb, look.floor_look[submap], floormemo[i], pcm);
}
// transform the PCM data; takes PCM vector, vb; modifies PCM vector
// only MDCT right now....
for (int i = 0; i < vi.channels; i++)
{
float[] pcm = vb.pcm[i];
//_analysis_output("out",seq+i,pcm,n/2,0,0);
((Mdct)vd.transform[vb.W][0]).backward(pcm, pcm);
}
// now apply the decoded pre-window time information
// NOT IMPLEMENTED
// window the data
for (int i = 0; i < vi.channels; i++)
{
float[] pcm = vb.pcm[i];
if (nonzero[i] != 0)
{
for (int j = 0; j < n; j++)
{
pcm[j] *= window[j];
}
}
else
{
for (int j = 0; j < n; j++)
{
pcm[j] = 0.0f;
}
}
//_analysis_output("final",seq++,pcm,n,0,0);
}
// now apply the decoded post-window time information
// NOT IMPLEMENTED
// all done!
return(0);
}
}
public abstract Object look(DspState vd, InfoMode vm, Object vr);
// all of the real encoding details are here. The modes, books,
// everything
int unpack_books(csBuffer opb)
{
//d* codebooks
books = opb.read(8) + 1;
if (book_param == null || book_param.Length != books)
{
book_param = new StaticCodeBook[books];
}
for (int i = 0; i < books; i++)
{
book_param[i] = new StaticCodeBook();
if (book_param[i].unpack(opb) != 0)
{
//goto err_out;
clear();
return(-1);
}
}
// time backend settings
times = opb.read(6) + 1;
if (time_type == null || time_type.Length != times)
{
time_type = new int[times];
}
if (time_param == null || time_param.Length != times)
{
time_param = new Object[times];
}
for (int i = 0; i < times; i++)
{
time_type[i] = opb.read(16);
if (time_type[i] < 0 || time_type[i] >= VI_TIMEB)
{
//goto err_out;
clear();
return(-1);
}
time_param[i] = FuncTime.time_P[time_type[i]].unpack(this, opb);
if (time_param[i] == null)
{
//goto err_out;
clear();
return(-1);
}
}
// floor backend settings
floors = opb.read(6) + 1;
if (floor_type == null || floor_type.Length != floors)
{
floor_type = new int[floors];
}
if (floor_param == null || floor_param.Length != floors)
{
floor_param = new Object[floors];
}
for (int i = 0; i < floors; i++)
{
floor_type[i] = opb.read(16);
if (floor_type[i] < 0 || floor_type[i] >= VI_FLOORB)
{
//goto err_out;
clear();
return(-1);
}
floor_param[i] = FuncFloor.floor_P[floor_type[i]].unpack(this, opb);
if (floor_param[i] == null)
{
//goto err_out;
clear();
return(-1);
}
}
// residue backend settings
residues = opb.read(6) + 1;
if (residue_type == null || residue_type.Length != residues)
{
residue_type = new int[residues];
}
if (residue_param == null || residue_param.Length != residues)
{
residue_param = new Object[residues];
}
for (int i = 0; i < residues; i++)
{
residue_type[i] = opb.read(16);
if (residue_type[i] < 0 || residue_type[i] >= VI_RESB)
{
// goto err_out;
clear();
return(-1);
}
residue_param[i] = FuncResidue.residue_P[residue_type[i]].unpack(this, opb);
if (residue_param[i] == null)
{
// goto err_out;
clear();
return(-1);
}
}
// map backend settings
maps = opb.read(6) + 1;
if (map_type == null || map_type.Length != maps)
{
map_type = new int[maps];
}
if (map_param == null || map_param.Length != maps)
{
map_param = new Object[maps];
}
for (int i = 0; i < maps; i++)
{
map_type[i] = opb.read(16);
if (map_type[i] < 0 || map_type[i] >= VI_MAPB)
{
// goto err_out;
clear();
return(-1);
}
map_param[i] = FuncMapping.mapping_P[map_type[i]].unpack(this, opb);
if (map_param[i] == null)
{
// goto err_out;
clear();
return(-1);
}
}
// mode settings
modes = opb.read(6) + 1;
if (mode_param == null || mode_param.Length != modes)
{
mode_param = new InfoMode[modes];
}
for (int i = 0; i < modes; i++)
{
mode_param[i] = new InfoMode();
mode_param[i].blockflag = opb.read(1);
mode_param[i].windowtype = opb.read(16);
mode_param[i].transformtype = opb.read(16);
mode_param[i].mapping = opb.read(8);
if ((mode_param[i].windowtype >= VI_WINDOWB) ||
(mode_param[i].transformtype >= VI_WINDOWB) ||
(mode_param[i].mapping >= maps))
{
// goto err_out;
clear();
return(-1);
}
}
if (opb.read(1) != 1)
{
//goto err_out; // top level EOP check
clear();
return(-1);
}
return(0);
// err_out:
// vorbis_info_clear(vi);
// return(-1);
}
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)
{
return("");
}
public abstract Object look(DspState vd, InfoMode mi, Object i);