@LOC("LR")
private float[][][] lr;
@LOC("OUT")
+ private float[] inter; // 576 samples
+ @LOC("OUT")
private float[] out_1d; // 576 samples
@LOC("OUT")
private float[][] prevblck;
+
@LOC("LR")
private float[][] k;
@LOC("NZ")
// @LOC("SBT") private temporaire2[] III_scalefac_t;
@LOC("SF2")
- private temporaire2[] scalefac;
+ private final temporaire2[] scalefac;
// private III_scalefac_t scalefac;
@LOC("CH0")
private int frame_start;
// @LOC("SI1") private int part2_start;
@LOC("CH0")
- private int channels;
+ private final int channels;
@LOC("CH0")
private int first_channel;
@LOC("CH0")
@LOC("INIT")
private boolean initialized = false;
+ @LOC("OUT")
+ float[][] raw_full; // 18 left shfited since it will be copied into prevblck!
+
// constructor for the linear type system
- public LayerIIIDecoder(@DELEGATE @LOC("VAR") SynthesisFilter filtera,
+ public LayerIIIDecoder(Header h, @DELEGATE @LOC("VAR") SynthesisFilter filtera,
@DELEGATE @LOC("VAR") SynthesisFilter filterb, @LOC("VAR") int which_ch0) {
+ raw_full = new float[2][SBLIMIT * SSLIMIT];
+
filter1 = filtera;
filter2 = filterb;
ro = new float[2][SBLIMIT][SSLIMIT];
lr = new float[2][SBLIMIT][SSLIMIT];
out_1d = new float[SBLIMIT * SSLIMIT];
+ inter = new float[SBLIMIT * SSLIMIT];
prevblck = new float[2][SBLIMIT * SSLIMIT];
k = new float[2][SBLIMIT * SSLIMIT];
nonzero = new int[2];
scalefac_buffer = new int[54];
// END OF scalefac_buffer
+ init(h);
}
@LATTICE("THIS<C,THIS<IN,C*,THISLOC=THIS")
nonzero[0] = nonzero[1] = 576;
- br = new BitReserve();
si = new III_side_info_t();
initialized = true;
@LATTICE("HEADER<VAR,VAR<THIS,C<THIS,THIS<IN,THISLOC=THIS,C*,VAR*")
public void decode(@LOC("THIS,LayerIIIDecoder.HD") Header header) {
- if (!initialized) {
- init(header);
- }
+ // if (!initialized) {
+ // init(header);
+ // }
+
+ // overwrites once per a loop
+ SSJAVA.arrayinit(samples1, 0);
+ SSJAVA.arrayinit(samples2, 0);
+ SSJAVA.arrayinit(ro, 2, SBLIMIT, SSLIMIT, 0);
+ SSJAVA.arrayinit(lr, 2, SBLIMIT, SSLIMIT, 0);
+ SSJAVA.arrayinit(is_pos, 7);
+ SSJAVA.arrayinit(is_ratio, 0);
+ SSJAVA.arrayinit(out_1d, 0);
+ SSJAVA.arrayinit(inter, 0);
+ SSJAVA.arrayinit(k, 2, SBLIMIT * SSLIMIT, 0);
+ SSJAVA.arrayinit(is_1d, 0);
+ SSJAVA.arrayinit(tsOutCopy, 0);
+ CheckSumHuff = 0;
+ // prevblck = new float[2][SBLIMIT * SSLIMIT];
+ si = new III_side_info_t();
+ //
@LOC("THIS,LayerIIIDecoder.HD1") int nSlots = header.slots();
@LOC("THIS,LayerIIIDecoder.HD1") int version = header.version();
+ // additional codes for the definitely written property
+ filter1.vidx = 1;
+ filter2.vidx = 1;
+ // filter1.actual_write_pos=0;
+ // filter2.actual_write_pos=0;
+ //
+
+ // 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}
// }
// System.out.println("CheckSumOut1d = "+CheckSumOut1d);
+ for (@LOC("THIS,LayerIIIDecoder.SI1") int index = 0; index < 576; index++) {
+ out_1d[index] = inter[index];
+ }
+
hybrid(ch, gr);
// float CheckSumOut1d=0;
filter2.input_samples(samples2);
filter2.calculate_pcm_samples();
}
-
}
+
} // 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];
+ // }
+ // }
+
} // granule
// System.out.println("Counter = ................................."+counter);
m = 0;
for (@LOC("THIS,LayerIIIDecoder.NS") int i = 0; i < 4; i++) {
- for (@LOC("THIS,LayerIIIDecoder.NS") int j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i]; j++) {
+ @LOC("THIS,LayerIIIDecoder.NS") int jmax = nr_of_sfb_block[blocknumber][blocktypenumber][i];
+ for (@LOC("THIS,LayerIIIDecoder.NS") int j = 0; j < jmax; j++) {
scalefac_buffer[m] = (new_slen[i] == 0) ? 0 : br.hgetbits(new_slen[i]);
m++;
index = 0;
// Read bigvalues area
- for (@LOC("THIS,LayerIIIDecoder.BR,BitReserve.BIT") int i = 0; i < (si.ch[ch].gr[gr].big_values << 1); i +=
+ TERMINATE: for (@LOC("THIS,LayerIIIDecoder.BR,BitReserve.BIT") int i = 0; i < (si.ch[ch].gr[gr].big_values << 1); i +=
2) {
@LOC("THIS,LayerIIIDecoder.SI2") int htIdx;
// h = huffcodetab.ht[si.ch[ch].gr[gr].count1table_select + 32];
num_bits = br.hsstell();
- while ((num_bits < part2_3_end) && (index < 576)) {
+ TERMINATE: while ((num_bits < part2_3_end) && (index < 576)) {
huffcodetab.huffman_decoder(htIdx, x, y, v, w, br);
if ((si.ch[ch].gr[gr].window_switching_flag != 0) && (si.ch[ch].gr[gr].block_type == 2)) {
- for (index = 0; index < 576; index++) {
- out_1d[index] = 0.0f;
- }
+ // for (index = 0; index < 576; index++) {
+ // inter[index] = 0.0f;
+ // }
if (si.ch[ch].gr[gr].mixed_block_flag != 0) {
// NO REORDER FOR LOW 2 SUBBANDS
// Modif E.B 02/22/99
@LOC("THIS,LayerIIIDecoder.SI1") int reste = index % SSLIMIT;
@LOC("THIS,LayerIIIDecoder.SI1") int quotien = (int) ((index - reste) / SSLIMIT);
- out_1d[index] = lr[ch][quotien][reste];
+ inter[index] = lr[ch][quotien][reste];
}
// REORDERING FOR REST SWITCHED SHORT
/*
@LOC("THIS,LayerIIIDecoder.SI1") int reste = src_line % SSLIMIT;
@LOC("THIS,LayerIIIDecoder.SI1") int quotien = (int) ((src_line - reste) / SSLIMIT);
- out_1d[des_line] = lr[ch][quotien][reste];
+ inter[des_line] = lr[ch][quotien][reste];
src_line += sfb_lines;
des_line++;
reste = src_line % SSLIMIT;
quotien = (int) ((src_line - reste) / SSLIMIT);
- out_1d[des_line] = lr[ch][quotien][reste];
+ inter[des_line] = lr[ch][quotien][reste];
src_line += sfb_lines;
des_line++;
reste = src_line % SSLIMIT;
quotien = (int) ((src_line - reste) / SSLIMIT);
- out_1d[des_line] = lr[ch][quotien][reste];
+ inter[des_line] = lr[ch][quotien][reste];
}
}
@LOC("THIS,LayerIIIDecoder.SI1") int j = reorder_table[sfreq][index];
@LOC("THIS,LayerIIIDecoder.SI1") int reste = j % SSLIMIT;
@LOC("THIS,LayerIIIDecoder.SI1") int quotien = (int) ((j - reste) / SSLIMIT);
- out_1d[index] = lr[ch][quotien][reste];
+ inter[index] = lr[ch][quotien][reste];
}
}
} else { // long blocks
// Modif E.B 02/22/99
@LOC("THIS,LayerIIIDecoder.SI1") int reste = index % SSLIMIT;
@LOC("THIS,LayerIIIDecoder.SI1") int quotien = (int) ((index - reste) / SSLIMIT);
- out_1d[index] = lr[ch][quotien][reste];
+ inter[index] = lr[ch][quotien][reste];
}
}
}
@LOC("THIS,LayerIIIDecoder.LR") int io_type = (si.ch[0].gr[gr].scalefac_compress & 1);
// initialization
-
- for (i = 0; i < 576; i++) {
- is_pos[i] = 7;
-
- is_ratio[i] = 0.0f;
- }
+ // for (i = 0; i < 576; i++) {
+ // is_pos[i] = 7;
+ // is_ratio[i] = 0.0f;
+ // }
if (i_stereo) {
if ((si.ch[0].gr[gr].window_switching_flag != 0) && (si.ch[0].gr[gr].block_type == 2)) {
for (@LOC("THIS,LayerIIIDecoder.RO1") int j = 0; j < 3; j++) {
@LOC("THIS,LayerIIIDecoder.RO1") int sfbcnt;
sfbcnt = 2;
- for (sfb = 12; sfb >= 3; sfb--) {
+ TERMINATE: for (sfb = 12; sfb >= 3; sfb--) {
i = sfBandIndex[sfreq].s[sfb];
lines = sfBandIndex[sfreq].s[sfb + 1] - i;
i = (i << 2) - i + (j + 1) * lines - 1;
-
- while (lines > 0) {
+ TERMINATE: while (lines > 0) {
if (ro[1][i / 18][i % 18] != 0.0f) {
// MDM: in java, array access is very slow.
// Is quicker to compute div and mod values.
sb = sfBandIndex[sfreq].s[sfb + 1] - temp;
i = (temp << 2) - temp + j * sb;
- for (; sb > 0; sb--) {
+ TERMINATE: for (; sb > 0; sb--) {
is_pos[i] = scalefac[1].s[j][sfb];
if (is_pos[i] != 7)
if (lsf)
temp = sfBandIndex[sfreq].s[11];
sb = sfBandIndex[sfreq].s[12] - temp;
i = (temp << 2) - temp + j * sb;
-
- for (; sb > 0; sb--) {
+ TERMINATE: for (; sb > 0; sb--) {
is_pos[i] = is_pos[sfb];
if (lsf) {
i = 2;
ss = 17;
sb = -1;
- while (i >= 0) {
+ TERMINATE: while (i >= 0) {
if (ro[1][i][ss] != 0.0f) {
sb = (i << 4) + (i << 1) + ss;
i = -1;
i = sfBandIndex[sfreq].l[i];
for (; sfb < 8; sfb++) {
sb = sfBandIndex[sfreq].l[sfb + 1] - sfBandIndex[sfreq].l[sfb];
- for (; sb > 0; sb--) {
+ TERMINATE: for (; sb > 0; sb--) {
is_pos[i] = scalefac[1].l[sfb];
if (is_pos[i] != 7)
if (lsf)
for (@LOC("THIS,LayerIIIDecoder.RO1") int j = 0; j < 3; j++) {
@LOC("THIS,LayerIIIDecoder.RO1") int sfbcnt;
sfbcnt = -1;
- for (sfb = 12; sfb >= 0; sfb--) {
+ TERMINATE: for (sfb = 12; sfb >= 0; sfb--) {
temp = sfBandIndex[sfreq].s[sfb];
lines = sfBandIndex[sfreq].s[sfb + 1] - temp;
i = (temp << 2) - temp + (j + 1) * lines - 1;
-
- while (lines > 0) {
+ TERMINATE: while (lines > 0) {
if (ro[1][i / 18][i % 18] != 0.0f) {
// MDM: in java, array access is very slow.
// Is quicker to compute div and mod values.
temp = sfBandIndex[sfreq].s[sfb];
sb = sfBandIndex[sfreq].s[sfb + 1] - temp;
i = (temp << 2) - temp + j * sb;
- for (; sb > 0; sb--) {
+ TERMINATE: for (; sb > 0; sb--) {
is_pos[i] = scalefac[1].s[j][sfb];
if (is_pos[i] != 7)
if (lsf)
sfb = (temp << 2) - temp + j * sb;
sb = sfBandIndex[sfreq].s[12] - temp2;
i = (temp2 << 2) - temp2 + j * sb;
-
- for (; sb > 0; sb--) {
+ TERMINATE: for (; sb > 0; sb--) {
is_pos[i] = is_pos[sfb];
if (lsf) {
i = 31;
ss = 17;
sb = 0;
- while (i >= 0) {
+ TERMINATE: while (i >= 0) {
if (ro[1][i][ss] != 0.0f) {
sb = (i << 4) + (i << 1) + ss;
i = -1;
i = sfBandIndex[sfreq].l[i];
for (; sfb < 21; sfb++) {
sb = sfBandIndex[sfreq].l[sfb + 1] - sfBandIndex[sfreq].l[sfb];
- for (; sb > 0; sb--) {
+ TERMINATE: for (; sb > 0; sb--) {
is_pos[i] = scalefac[1].l[sfb];
if (is_pos[i] != 7)
if (lsf)
}
}
sfb = sfBandIndex[sfreq].l[20];
- for (sb = 576 - sfBandIndex[sfreq].l[21]; (sb > 0) && (i < 576); sb--) {
+ TERMINATE: for (sb = 576 - sfBandIndex[sfreq].l[21]; (sb > 0) && (i < 576); sb--) {
is_pos[i] = is_pos[sfb]; // error here : i >=576
if (lsf) {
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 = out_1d[src_idx1];
- @LOC("THIS,LayerIIIDecoder.OUT") float bd = out_1d[src_idx2];
- out_1d[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);
- out_1d[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);
+ @LOC("THIS,LayerIIIDecoder.OUT") float bu = inter[src_idx1];
+ @LOC("THIS,LayerIIIDecoder.OUT") float bd = inter[src_idx2];
+ inter[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);
+ inter[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);
}
}
}
// Fin Modif
// overlap addition
- // prvblk = prevblck; //eliminated unnecessary areas
-
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];
+
}
}
projects / IRC.git / blobdiff