// 10th added for get_scale_factors
// llth added for decode
// @LATTICE("IS1D*,RO<IS1D,IS1D<SI2,SI2<SI1,SI<P2S,SF1<CH0,SF0*,SFB_SH<NS,NS<SI,SFB_SH*,SFB<SFB_SH,C,C*,SI1<SF2,SF2<SFB,SF1<BR,LR*,OUT<LR,LR<RO,NZ*,SI<SF1,SI1<NZ,NZ<SI,SI1<SBI,SBI<SI,BUF<FT,SF1<SF0,SF0<HD1,BR<ST,ST,FT<SP,SP<OUT,OUT<SI1,SI1<SI,P2S<CH0,CH0<MAX0,MAX0<BR1,FS<BR1,BR1<BR,BR<HD1,HD1<HD,OUT*,BR1*,SI1*,MAX0*,CH0*,RAW,TS,F,C,K,LY,VAR,IR,IP,CSH,GLSFD3,GLSFD4,GLSFD5,GLSFF4,GLSFF2,GLSFF3,GLSFF1,GSF4,GSF5,GSF1,GSF2,GSF3,HD2,HD3,BT,GR,RO6,RO5,RO9,RO8,RO7,RO4,RO1,RO3,RO2,SH,ME,TMP2,S,LSF,J")
-@LATTICE("SI0*,INIT*,ISR*,ISP*,HD<CH0,LR<ISR,ISR<ISP,SI1<SF2,NS*,CH0<ST,ST<INIT,IS1D*,RO1<RO,RO1*,RO<IS1D,IS1D<SI2,SI2<SI1,BR<NS,NS<SI,SFB_SH*,SFB<SFB_SH,C,C*,SF2<SFB,LR*,OUT<LR,ISP<RO1,NZ*,SI<SI0,SI0<SF15,SF15<SF1,BR1<NZ,NZ<BR,SI1<RT,RT<SBI,SBI<SI,BUF<FT,SF1<HD1,SF1<HD1,FT<SP,SP<OUT,OUT<SI1,SI1<SI,SFB_SH<BR1,BR1<BR,HD1<HD,OUT*,BR1*,SI1*,CH0*")
+@LATTICE("SI0*,INIT*,ISR*,ISP*,HD<CH0,LR<ISR,ISR<ISP,SI1<SF2,NS*,CH0<ST,ST<INIT,IS1D*,RO1<RO,RO1*,RO<IS1D,IS1D<SI2,SI2<SI1,BR<NS,NS<SI,SFB_SH*,SFB<SFB_SH,C,C*,SF2<SFB,LR*,TSOUT*,OUT1<PREV,PREV<RAWFULL,RAWFULL<RAWOUT,RAWOUT<TSOUT,TSOUT<OUT0,OUT0<LR,ISP<RO1,NZ*,SI<SI0,SI0<SF15,SF15<SF1,BR1<NZ,NZ<BR,SI1<RT,RT<SBI,SBI<SI,BUF<FT,SF1<HD1,SF1<HD1,FT<SP,SP<OUT1,SI1<SI,SFB_SH<BR1,BR1<BR,HD1<HD,OUT0*,OUT1*,BR1*,SI1*,CH0*")
@METHODDEFAULT("OUT<V,V<THIS,THIS<SH,SH<IN,SH*,THISLOC=THIS,GLOBALLOC=IN,RETURNLOC=OUT")
final class LayerIIIDecoder implements FrameDecoder {
static final double d43 = (4.0 / 3.0);
private float[][][] ro;
@LOC("LR")
private float[][][] lr;
- @LOC("OUT")
+ @LOC("OUT0")
private float[] inter; // 576 samples
- @LOC("OUT")
+ @LOC("OUT1")
private float[] out_1d; // 576 samples
- @LOC("OUT")
+ @LOC("PREV")
private float[][] prevblck;
+
@LOC("LR")
private float[][] k;
@LOC("NZ")
@LOC("INIT")
private boolean initialized = false;
+ @LOC("RAWFULL")
+ float[][] raw_full; // 18 left shfited since it will be copied into prevblck!
+
// constructor for the linear type system
public LayerIIIDecoder(Header h, @DELEGATE @LOC("VAR") SynthesisFilter filtera,
@DELEGATE @LOC("VAR") SynthesisFilter filterb, @LOC("VAR") int which_ch0) {
+ filter_pos = 11;
+ raw_full = new float[2][SBLIMIT * SSLIMIT];
+
filter1 = filtera;
filter2 = filterb;
private float[] samples1 = new float[32];
@LOC("SP")
private float[] samples2 = new float[32];
+ @LOC("SI1")
+ private int filter_pos;
/*
* location hierarchy of decode() {header} {stream} {si} {br, flush_main,
SSJAVA.arrayinit(inter, 0);
SSJAVA.arrayinit(k, 2, SBLIMIT * SSLIMIT, 0);
SSJAVA.arrayinit(is_1d, 0);
+ SSJAVA.arrayinit(tsOutCopy, 0);
+ SSJAVA.arrayinit(scalefac_buffer, 0);
+ SSJAVA.arrayinit(nonzero, 576);
+ SSJAVA.arrayinit(new_slen, 0);
+ SSJAVA.arrayinit(rawout,0);
+
CheckSumHuff = 0;
// prevblck = new float[2][SBLIMIT * SSLIMIT];
si = new III_side_info_t();
@LOC("THIS,LayerIIIDecoder.HD1") int version = header.version();
+ // additional codes for the definitely written property
+ filter_pos = (filter_pos + 4) & 0xf;
+ filter1.vidx = 1;
+ filter2.vidx = 1;
+ filter1.actual_write_pos = filter_pos;
+ filter2.actual_write_pos = filter_pos;
+ //
+
+ // System.out.println("filter1="+filter1.vidx+" "+filter1.actual_write_pos);
+ // System.out.println("filter1="+filter2.vidx+" "+filter2.actual_write_pos);
+
// here 'gr' and 'max_gr' should be higher than 'ch','channels', and more
for (gr = 0; gr < max_gr; gr++) { // two granules per channel
// in the loop body, access set={part2_start}
// 'first_channel' >
// the body
- // in the body
- // read set= lr,ch,gr,out_1d, sb18, ss, SSLIMIT, out_1d
- // write set= out_1d
-
reorder(/* lr[ch], */ch, gr);
antialias(ch, gr);
sb++; // sb should be loc*
}
filter1.input_samples(samples1);
+ // System.out.println("filter1 writepos=" + filter1.actual_write_pos
+ // + " vidx=" + filter1.vidx);
filter1.calculate_pcm_samples();
}
} else {
filter2.input_samples(samples2);
filter2.calculate_pcm_samples();
}
-
}
+ // System.out.println("#END CH=" + ch + " actual_write_pos=" +
+ // filter1.actual_write_pos);
} // channels
+
+ // TODO
+ // init prev
+ SSJAVA.arrayinit(prevblck, 2, SBLIMIT * SSLIMIT, 0);
+ // copy from raw_full to prev
+ SSJAVA.arraycopy(prevblck, raw_full, 2, SBLIMIT * SSLIMIT);
+ // for (int chidx = 0; chidx < 2; chidx++) {
+ // for (int sidx = 0; sidx < SBLIMIT * SSLIMIT; sidx++) {
+ // prevblck[chidx][sidx] = raw_full[chidx][sidx];
+ // }
+ // }
+ // System.out.println("#END GR=" + gr + " actual_write_pos=" +
+ // filter1.actual_write_pos);
} // granule
+ // System.out.println("#END FRAME actual_write_pos=" +
+ // filter1.actual_write_pos);
+
+ filter1.clear();
+ filter2.clear();
+
// System.out.println("Counter = ................................."+counter);
// if (counter < 609)
// {
// MDM: new_slen is fully initialized before use, no need
// to reallocate array.
@LOC("NS")
- private final int[] new_slen = new int[4];
+ private int[] new_slen = new int[4];
// ssjava
@LATTICE("M<THIS,THIS<IN,THIS<C,C*,M*,THISLOC=THIS,GLOBALLOC=THIS")
}
}
- for (@LOC("THIS,LayerIIIDecoder.NS") int x = 0; x < 45; x++)
- // why 45, not 54?
- scalefac_buffer[x] = 0;
+ // for (@LOC("THIS,LayerIIIDecoder.NS") int x = 0; x < 45; x++)
+ // // why 45, not 54?
+ // scalefac_buffer[x] = 0;
m = 0;
for (@LOC("THIS,LayerIIIDecoder.NS") int i = 0; i < 4; i++) {
for (ss = 0; ss < 8; ss++) {
@LOC("THIS,LayerIIIDecoder.SI1") int src_idx1 = sb18 + 17 - ss;
@LOC("THIS,LayerIIIDecoder.SI1") int src_idx2 = sb18 + 18 + ss;
- @LOC("THIS,LayerIIIDecoder.OUT") float bu = inter[src_idx1];
- @LOC("THIS,LayerIIIDecoder.OUT") float bd = inter[src_idx2];
+ @LOC("THIS,LayerIIIDecoder.OUT0") float bu = inter[src_idx1];
+ @LOC("THIS,LayerIIIDecoder.OUT0") float bd = inter[src_idx2];
inter[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);
inter[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);
}
// MDM: tsOutCopy and rawout do not need initializing, so the arrays
// can be reused.
- @LOC("OUT")
+ @LOC("TSOUT")
float[] tsOutCopy = new float[18];
- @LOC("OUT")
+ @LOC("RAWOUT")
float[] rawout = new float[36];
@LATTICE("THIS<SB,SB*,THISLOC=THIS")
// tsOut = out_1d;
// Modif E.B 02/22/99
- for (@LOC("THIS,LayerIIIDecoder.SI1") int cc = 0; cc < 18; cc++)
- tsOutCopy[cc] = out_1d[cc + sb18];
+ for (@LOC("THIS,LayerIIIDecoder.SI1") int cc = 0; cc < 18; cc++) {
+ // tsOutCopy[cc] = out_1d[cc + sb18];
+ tsOutCopy[cc] = inter[cc + sb18];
+ }
inv_mdct(bt);
- for (@LOC("THIS,LayerIIIDecoder.SI1") int cc = 0; cc < 18; cc++)
+ for (@LOC("THIS,LayerIIIDecoder.SI1") int cc = 0; cc < 18; cc++) {
out_1d[cc + sb18] = tsOutCopy[cc];
+ }
+
// Fin Modif
// overlap addition
out_1d[0 + sb18] = rawout[0] + prevblck[ch][sb18 + 0];
- prevblck[ch][sb18 + 0] = rawout[18];
out_1d[1 + sb18] = rawout[1] + prevblck[ch][sb18 + 1];
- prevblck[ch][sb18 + 1] = rawout[19];
out_1d[2 + sb18] = rawout[2] + prevblck[ch][sb18 + 2];
- prevblck[ch][sb18 + 2] = rawout[20];
out_1d[3 + sb18] = rawout[3] + prevblck[ch][sb18 + 3];
- prevblck[ch][sb18 + 3] = rawout[21];
out_1d[4 + sb18] = rawout[4] + prevblck[ch][sb18 + 4];
- prevblck[ch][sb18 + 4] = rawout[22];
out_1d[5 + sb18] = rawout[5] + prevblck[ch][sb18 + 5];
- prevblck[ch][sb18 + 5] = rawout[23];
out_1d[6 + sb18] = rawout[6] + prevblck[ch][sb18 + 6];
- prevblck[ch][sb18 + 6] = rawout[24];
out_1d[7 + sb18] = rawout[7] + prevblck[ch][sb18 + 7];
- prevblck[ch][sb18 + 7] = rawout[25];
out_1d[8 + sb18] = rawout[8] + prevblck[ch][sb18 + 8];
- prevblck[ch][sb18 + 8] = rawout[26];
out_1d[9 + sb18] = rawout[9] + prevblck[ch][sb18 + 9];
- prevblck[ch][sb18 + 9] = rawout[27];
out_1d[10 + sb18] = rawout[10] + prevblck[ch][sb18 + 10];
- prevblck[ch][sb18 + 10] = rawout[28];
out_1d[11 + sb18] = rawout[11] + prevblck[ch][sb18 + 11];
- prevblck[ch][sb18 + 11] = rawout[29];
out_1d[12 + sb18] = rawout[12] + prevblck[ch][sb18 + 12];
- prevblck[ch][sb18 + 12] = rawout[30];
out_1d[13 + sb18] = rawout[13] + prevblck[ch][sb18 + 13];
- prevblck[ch][sb18 + 13] = rawout[31];
out_1d[14 + sb18] = rawout[14] + prevblck[ch][sb18 + 14];
- prevblck[ch][sb18 + 14] = rawout[32];
out_1d[15 + sb18] = rawout[15] + prevblck[ch][sb18 + 15];
- prevblck[ch][sb18 + 15] = rawout[33];
out_1d[16 + sb18] = rawout[16] + prevblck[ch][sb18 + 16];
- prevblck[ch][sb18 + 16] = rawout[34];
out_1d[17 + sb18] = rawout[17] + prevblck[ch][sb18 + 17];
- prevblck[ch][sb18 + 17] = rawout[35];
+ raw_full[ch][sb18 + 0] = rawout[18];
+ raw_full[ch][sb18 + 1] = rawout[19];
+ raw_full[ch][sb18 + 2] = rawout[20];
+ raw_full[ch][sb18 + 3] = rawout[21];
+ raw_full[ch][sb18 + 4] = rawout[22];
+ raw_full[ch][sb18 + 5] = rawout[23];
+ raw_full[ch][sb18 + 6] = rawout[24];
+ raw_full[ch][sb18 + 7] = rawout[25];
+ raw_full[ch][sb18 + 8] = rawout[26];
+ raw_full[ch][sb18 + 9] = rawout[27];
+ raw_full[ch][sb18 + 10] = rawout[28];
+ raw_full[ch][sb18 + 11] = rawout[29];
+ raw_full[ch][sb18 + 12] = rawout[30];
+ raw_full[ch][sb18 + 13] = rawout[31];
+ raw_full[ch][sb18 + 14] = rawout[32];
+ raw_full[ch][sb18 + 15] = rawout[33];
+ raw_full[ch][sb18 + 16] = rawout[34];
+ raw_full[ch][sb18 + 17] = rawout[35];
+
+ // original implementation:
+ // out_1d[0 + sb18] = rawout[0] + prevblck[ch][sb18 + 0];
+ // prevblck[ch][sb18 + 0] = rawout[18];
+ // out_1d[1 + sb18] = rawout[1] + prevblck[ch][sb18 + 1];
+ // prevblck[ch][sb18 + 1] = rawout[19];
+ // out_1d[2 + sb18] = rawout[2] + prevblck[ch][sb18 + 2];
+ // prevblck[ch][sb18 + 2] = rawout[20];
+ // out_1d[3 + sb18] = rawout[3] + prevblck[ch][sb18 + 3];
+ // prevblck[ch][sb18 + 3] = rawout[21];
+ // out_1d[4 + sb18] = rawout[4] + prevblck[ch][sb18 + 4];
+ // prevblck[ch][sb18 + 4] = rawout[22];
+ // out_1d[5 + sb18] = rawout[5] + prevblck[ch][sb18 + 5];
+ // prevblck[ch][sb18 + 5] = rawout[23];
+ // out_1d[6 + sb18] = rawout[6] + prevblck[ch][sb18 + 6];
+ // prevblck[ch][sb18 + 6] = rawout[24];
+ // out_1d[7 + sb18] = rawout[7] + prevblck[ch][sb18 + 7];
+ // prevblck[ch][sb18 + 7] = rawout[25];
+ // out_1d[8 + sb18] = rawout[8] + prevblck[ch][sb18 + 8];
+ // prevblck[ch][sb18 + 8] = rawout[26];
+ // out_1d[9 + sb18] = rawout[9] + prevblck[ch][sb18 + 9];
+ // prevblck[ch][sb18 + 9] = rawout[27];
+ // out_1d[10 + sb18] = rawout[10] + prevblck[ch][sb18 + 10];
+ // prevblck[ch][sb18 + 10] = rawout[28];
+ // out_1d[11 + sb18] = rawout[11] + prevblck[ch][sb18 + 11];
+ // prevblck[ch][sb18 + 11] = rawout[29];
+ // out_1d[12 + sb18] = rawout[12] + prevblck[ch][sb18 + 12];
+ // prevblck[ch][sb18 + 12] = rawout[30];
+ // out_1d[13 + sb18] = rawout[13] + prevblck[ch][sb18 + 13];
+ // prevblck[ch][sb18 + 13] = rawout[31];
+ // out_1d[14 + sb18] = rawout[14] + prevblck[ch][sb18 + 14];
+ // prevblck[ch][sb18 + 14] = rawout[32];
+ // out_1d[15 + sb18] = rawout[15] + prevblck[ch][sb18 + 15];
+ // prevblck[ch][sb18 + 15] = rawout[33];
+ // out_1d[16 + sb18] = rawout[16] + prevblck[ch][sb18 + 16];
+ // prevblck[ch][sb18 + 16] = rawout[34];
+ // out_1d[17 + sb18] = rawout[17] + prevblck[ch][sb18 + 17];
+ // prevblck[ch][sb18 + 17] = rawout[35];
+
}
}
// @LOC("IN") int block_type) {//remove alias
// ssjava
@LATTICE("THIS,THISLOC=THIS")
- public void inv_mdct(@LOC("THIS,LayerIIIDecoder.OUT") int block_type) {
+ public void inv_mdct(@LOC("THIS,LayerIIIDecoder.TSOUT") int block_type) {
// float[] win_bt;
- @LOC("THIS,LayerIIIDecoder.OUT") int i;
-
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_0;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_1;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_2;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_3;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_4;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_5;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_6;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_7;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_8;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_9;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_10;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_11;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_12;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_13;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_14;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_15;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_16;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmpf_17;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") int i;
+
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_0;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_1;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_2;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_3;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_4;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_5;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_6;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_7;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_8;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_9;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_10;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_11;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_12;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_13;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_14;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_15;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_16;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmpf_17;
tmpf_0 =
tmpf_1 =
rawout[34] = 0.0f;
rawout[35] = 0.0f;
- @LOC("THIS,LayerIIIDecoder.OUT") int six_i = 0;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") int six_i = 0;
for (i = 0; i < 3; i++) {
// 12 point IMDCT
tsOutCopy[9 + i] += tsOutCopy[3 + i];
// 3 point IDCT on even indices
- @LOC("THIS,LayerIIIDecoder.OUT") float pp1;
- @LOC("THIS,LayerIIIDecoder.OUT") float pp2;
- @LOC("THIS,LayerIIIDecoder.OUT") float sum;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float pp1;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float pp2;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float sum;
pp2 = tsOutCopy[12 + i] * 0.500000000f;
pp1 = tsOutCopy[6 + i] * 0.866025403f;
sum = tsOutCopy[0 + i] + pp2;
tmpf_5 *= 0.517638090f;
// Output butterflies on 2 3 point IDCT's (for 6 point IDCT)
- @LOC("THIS,LayerIIIDecoder.OUT") float save = tmpf_0;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float save = tmpf_0;
tmpf_0 += tmpf_5;
tmpf_5 = save - tmpf_5;
save = tmpf_1;
tsOutCopy[5] += tsOutCopy[3];
tsOutCopy[3] += tsOutCopy[1];
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp0;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp1;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp2;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp3;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp4;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp0_;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp1_;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp2_;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp3_;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp0o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp1o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp2o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp3o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp4o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp0_o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp1_o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp2_o;
- @LOC("THIS,LayerIIIDecoder.OUT") float tmp3_o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp0;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp1;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp2;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp3;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp4;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp0_;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp1_;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp2_;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp3_;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp0o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp1o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp2o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp3o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp4o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp0_o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp1_o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp2_o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float tmp3_o;
// Fast 9 Point Inverse Discrete Cosine Transform
//
// 9 point IDCT on even indices
// 5 points on odd indices (not realy an IDCT)
- @LOC("THIS,LayerIIIDecoder.OUT") float i00 = tsOutCopy[0] + tsOutCopy[0];
- @LOC("THIS,LayerIIIDecoder.OUT") float iip12 = i00 + tsOutCopy[12];
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float i00 = tsOutCopy[0] + tsOutCopy[0];
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float iip12 = i00 + tsOutCopy[12];
tmp0 =
iip12 + tsOutCopy[4] * 1.8793852415718f + tsOutCopy[8] * 1.532088886238f + tsOutCopy[16]
tmp4 = tsOutCopy[0] - tsOutCopy[4] + tsOutCopy[8] - tsOutCopy[12] + tsOutCopy[16];
// 4 points on even indices
- @LOC("THIS,LayerIIIDecoder.OUT") float i66_ = tsOutCopy[6] * 1.732050808f; // Sqrt[3]
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float i66_ = tsOutCopy[6] * 1.732050808f; // Sqrt[3]
tmp0_ =
tsOutCopy[2] * 1.9696155060244f + i66_ + tsOutCopy[10] * 1.2855752193731f + tsOutCopy[14]
// 9 point IDCT on odd indices
// 5 points on odd indices (not realy an IDCT)
- @LOC("THIS,LayerIIIDecoder.OUT") float i0 = tsOutCopy[0 + 1] + tsOutCopy[0 + 1];
- @LOC("THIS,LayerIIIDecoder.OUT") float i0p12 = i0 + tsOutCopy[12 + 1];
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float i0 = tsOutCopy[0 + 1] + tsOutCopy[0 + 1];
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float i0p12 = i0 + tsOutCopy[12 + 1];
tmp0o =
i0p12 + tsOutCopy[4 + 1] * 1.8793852415718f + tsOutCopy[8 + 1] * 1.532088886238f
(tsOutCopy[0 + 1] - tsOutCopy[4 + 1] + tsOutCopy[8 + 1] - tsOutCopy[12 + 1] + tsOutCopy[16 + 1]) * 0.707106781f; // Twiddled
// 4 points on even indices
- @LOC("THIS,LayerIIIDecoder.OUT") float i6_ = tsOutCopy[6 + 1] * 1.732050808f; // Sqrt[3]
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float i6_ = tsOutCopy[6 + 1] * 1.732050808f; // Sqrt[3]
tmp0_o =
tsOutCopy[2 + 1] * 1.9696155060244f + i6_ + tsOutCopy[10 + 1] * 1.2855752193731f
// and
// twiddle factors for 36 point IDCT
- @LOC("THIS,LayerIIIDecoder.OUT") float e;
- @LOC("THIS,LayerIIIDecoder.OUT") float o;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float e;
+ @LOC("THIS,LayerIIIDecoder.TSOUT") float o;
e = tmp0 + tmp0_;
o = (tmp0o + tmp0_o) * 0.501909918f;
tmpf_0 = e + o;
projects / IRC.git / blobdiff