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);
}
public Block(DspState vd)
{
this.vd = vd;
// localalloc=0;
// localstore=null;
if (vd.analysisp != 0)
{
opb.writeinit();
}
}
public VorbisFileInstance(VorbisFile sourceFile)
{
vorbisFile = sourceFile;
oy = new SyncState();
bittrack = 0;
samptrack = 0;
os = new StreamState(); // take physical pages, weld into a logical
// stream of packets
vd = new DspState(); // central working state for
// the packet->PCM decoder
vb = new Block(vd); // local working space for packet->PCM decode
raw_seek(0);
lastStreamPosition = sourceFile.datasource.Position;
}
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);
}
public void init(DspState vd)
{
this.vd = vd;
}
public abstract Object look(DspState vd, InfoMode mi, Object i);
public abstract Object look(DspState vd, InfoMode vm, Object m);
override public Object look(DspState vd, InfoMode mi, Object i)
{
return("");
}
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 int inverse(Block vb, Object l)
{
#if DEBUG
//Debug.Assert(l != null);
#endif
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);
}
}