* \r
* @since 0.0\r
*/\r
+@LATTICE("FS<BR,BR<SF,LR<IR,IR<IP,IP<SF,LR<K,K<F,LR<VAR,LR<RO,RO<F,VAR<F,VAR<RAW,CSH<F,SAM<O,O<F,\r
+SF<SI,SI<CH,SFREQ<H,MAX<H,H<CH,FLCH<CH,FLCH<WCH,SF<SFT,SFT<NS,NS<C,TS<RAW,O<TS,LY<F,\r
+C*,FS*,SI*,IP*,IR*,LR*,K*,O*,TS*,\r
+TS<BT,BT<GR,GR<SI,\r
+LR<S,S<ME,ME<CH,K<SH,K<LSF,LSF<H,LSF<CH,IP<SH,SH<J,J<S,S<ME,SH<SFREQ,SH<RO,IP<TMP2,LSF<H,TMP2<F,J*,SH*,\r
+O<RO2,RO2<RO3,RO3<RO4,RO4<RO5,O<RO1,RO1<RO5,RO5<RO6,RO6<RO7,RO7<RO8,RO8<RO9,RO9<SFREQ,RO9<F,RO1*,RO4*,RO5*,RO6*,RO9*")\r
+//4th: added for hybrid.\r
+//5th added for stereo\r
+//6th added for reorder method\r
+\r
+@METHODDEFAULT("OUT<V,V<THIS,THIS<SH,SH<IN,SH*,THISLOC=THIS,GLOBALLOC=IN")\r
final class LayerIIIDecoder implements FrameDecoder {\r
- final double d43 = (4.0 / 3.0);\r
-\r
- public int[] scalefac_buffer;\r
+ @LOC("F") final double d43 = (4.0 / 3.0);\r
+ @LOC("SFT") public int[] scalefac_buffer;\r
\r
// MDM: removed, as this wasn't being used.\r
// private float CheckSumOut1d = 0.0f;\r
- private int CheckSumHuff = 0;\r
- private int[] is_1d;\r
- private float[][][] ro;\r
- private float[][][] lr;\r
- private float[] out_1d; // 576 samples\r
- private float[][] prevblck;\r
- private float[][] k;\r
- private int[] nonzero;\r
- private Bitstream stream;\r
- private Header header;\r
- private SynthesisFilter filter1, filter2;\r
- private Obuffer buffer; // output buffer\r
- private int which_channels;\r
- private BitReserve br;\r
- private III_side_info_t si;\r
-\r
- private temporaire2[] III_scalefac_t;\r
- private temporaire2[] scalefac;\r
+ @LOC("CSH") private int CheckSumHuff = 0;\r
+ @LOC("VAR") private int[] is_1d;\r
+ @LOC("VAR") private float[][][] ro;\r
+ @LOC("LR") private float[][][] lr;\r
+ @LOC("O") private float[] out_1d; // 576 samples\r
+ @LOC("VAR") private float[][] prevblck;\r
+ @LOC("K") private float[][] k;\r
+ @LOC("F") private int[] nonzero;\r
+ @LOC("F")private Bitstream stream;\r
+ @LOC("H") private Header header;\r
+ @LOC("F") private SynthesisFilter filter1;\r
+ @LOC("F") private SynthesisFilter filter2;\r
+ @LOC("F") private Obuffer buffer; // output buffer\r
+ @LOC("WC") private int which_channels;\r
+ @LOC("BR") private BitReserve br;\r
+ @LOC("SI") private III_side_info_t si;\r
+\r
+ @LOC("SBT") private temporaire2[] III_scalefac_t;\r
+ @LOC("SF") private temporaire2[] scalefac;\r
// private III_scalefac_t scalefac;\r
\r
- private int max_gr;\r
- private int frame_start;\r
- private int part2_start;\r
- private int channels;\r
- private int first_channel;\r
- private int last_channel;\r
- private int sfreq;\r
+ @LOC("MAX") private int max_gr;\r
+ @LOC("FS") private int frame_start;\r
+ @LOC("F") private int part2_start;\r
+ @LOC("CH") private int channels;\r
+ @LOC("FLCH") private int first_channel;\r
+ @LOC("FLCH") private int last_channel;\r
+ @LOC("SFREQ") private int sfreq;\r
\r
/**\r
* Constructor.\r
\r
// subband samples are buffered and passed to the\r
// SynthesisFilter in one go.\r
- private float[] samples1 = new float[32];\r
- private float[] samples2 = new float[32];\r
+ @LOC("SAM") private float[] samples1 = new float[32];\r
+ @LOC("SAM") private float[] samples2 = new float[32];\r
\r
/* location hierarchy of decode()\r
{header} {stream} {si}\r
*/\r
// MDM: new_slen is fully initialized before use, no need\r
// to reallocate array.\r
- private final int[] new_slen = new int[4];\r
+ @LOC("NS") private final int[] new_slen = new int[4];\r
\r
private void get_LSF_scale_data(int ch, int gr) {\r
\r
/**\r
*\r
*/\r
- int[] x = { 0 };\r
- int[] y = { 0 };\r
- int[] v = { 0 };\r
- int[] w = { 0 };\r
+ @LOC("LY") int[] x = { 0 };\r
+ @LOC("F") int[] y = { 0 };\r
+ @LOC("LY") int[] v = { 0 };\r
+ @LOC("LY") int[] w = { 0 };\r
\r
private void huffman_decode(int ch, int gr) {\r
x[0] = 0;\r
int region2Start;\r
int index;\r
\r
- int buf, buf1;\r
+ int buf;\r
+ int buf1;\r
\r
huffcodetab h;\r
\r
/**\r
*\r
*/\r
- private void i_stereo_k_values(int is_pos, int io_type, int i) {\r
+ private void i_stereo_k_values(@LOC("IN") int is_pos, @LOC("IN") int io_type, @LOC("IN") int i) {\r
if (is_pos == 0) {\r
k[0][i] = 1.0f;\r
k[1][i] = 1.0f;\r
/**\r
*\r
*/\r
- private void dequantize_sample(float xr[][], int ch, int gr) {\r
- gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
- int cb = 0;\r
- int next_cb_boundary;\r
- int cb_begin = 0;\r
- int cb_width = 0;\r
- int index = 0, t_index, j;\r
- float g_gain;\r
- float[][] xr_1d = xr;\r
+ @LATTICE("OUT<QUO,QUO<REST,REST<IDX,IDX<VAR,VAR<CB,CB<J,CB<GR,GR<IN,J<IN,QUO*,REST*,IDX*,CB*,J*,THISLOC=IN,GLOBALLOC=IN")\r
+ private void dequantize_sample(@LOC("OUT") float xr[][], @LOC("IN") int ch, @LOC("IN") int gr) {\r
+ @LOC("GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
+ @LOC("CB") int cb = 0;\r
+ @LOC("CB") int next_cb_boundary;\r
+ @LOC("CB") int cb_begin = 0;\r
+ @LOC("CB") int cb_width = 0;\r
+ @LOC("IN") int index = 0;\r
+ @LOC("VAR") int t_index;\r
+ @LOC("J") int j;\r
+ @LOC("VAR") float g_gain;\r
+ //float[][] xr_1d = xr;//substituted xr for instances of xr_1d to decrease number of areas\r
\r
// choose correct scalefactor band per block type, initalize boundary\r
\r
\r
for (j = 0; j < nonzero[ch]; j++) {\r
// Modif E.B 02/22/99\r
- int reste = j % SSLIMIT;\r
- int quotien = (int) ((j - reste) / SSLIMIT);\r
+ @LOC("REST") int reste = j % SSLIMIT;\r
+ @LOC("QUO") int quotien = (int) ((j - reste) / SSLIMIT);\r
if (is_1d[j] == 0)\r
- xr_1d[quotien][reste] = 0.0f;\r
+ xr[quotien][reste] = 0.0f;\r
else {\r
- int abv = is_1d[j];\r
+ @LOC("VAR") int abv = is_1d[j];\r
// Pow Array fix (11/17/04)\r
if (abv < t_43.length) {\r
if (is_1d[j] > 0)\r
- xr_1d[quotien][reste] = g_gain * t_43[abv];\r
+ xr[quotien][reste] = g_gain * t_43[abv];\r
else {\r
if (-abv < t_43.length)\r
- xr_1d[quotien][reste] = -g_gain * t_43[-abv];\r
+ xr[quotien][reste] = -g_gain * t_43[-abv];\r
else\r
- xr_1d[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);\r
+ xr[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);\r
}\r
} else {\r
if (is_1d[j] > 0)\r
- xr_1d[quotien][reste] = g_gain * (float) Math.pow(abv, d43);\r
+ xr[quotien][reste] = g_gain * (float) Math.pow(abv, d43);\r
else\r
- xr_1d[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);\r
+ xr[quotien][reste] = -g_gain * (float) Math.pow(-abv, d43);\r
}\r
}\r
}\r
// apply formula per block type\r
for (j = 0; j < nonzero[ch]; j++) {\r
// Modif E.B 02/22/99\r
- int reste = j % SSLIMIT;\r
- int quotien = (int) ((j - reste) / SSLIMIT);\r
+ @LOC("REST") int reste = j % SSLIMIT;\r
+ @LOC("QUO") int quotien = (int) ((j - reste) / SSLIMIT);\r
\r
if (index == next_cb_boundary) { /* Adjust critical band boundary */\r
if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {\r
* xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info.subblock_gain[t_index]) -(0.5\r
* * (1.0 + gr_info.scalefac_scale) scalefac[ch].s[t_index][cb])));\r
*/\r
- int idx = scalefac[ch].s[t_index][cb] << gr_info.scalefac_scale;\r
+ @LOC("IDX") int idx = scalefac[ch].s[t_index][cb] << gr_info.scalefac_scale;\r
idx += (gr_info.subblock_gain[t_index] << 2);\r
\r
- xr_1d[quotien][reste] *= two_to_negative_half_pow[idx];\r
+ xr[quotien][reste] *= two_to_negative_half_pow[idx];\r
\r
} else { // LONG block types 0,1,3 & 1st 2 subbands of switched blocks\r
/*\r
* xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info.scalefac_scale)\r
* (scalefac[ch].l[cb] + gr_info.preflag * pretab[cb]));\r
*/\r
- int idx = scalefac[ch].l[cb];\r
+ @LOC("IDX") int idx = scalefac[ch].l[cb];\r
\r
if (gr_info.preflag != 0)\r
idx += pretab[cb];\r
\r
idx = idx << gr_info.scalefac_scale;\r
- xr_1d[quotien][reste] *= two_to_negative_half_pow[idx];\r
+ xr[quotien][reste] *= two_to_negative_half_pow[idx];\r
}\r
index++;\r
}\r
\r
for (j = nonzero[ch]; j < 576; j++) {\r
// Modif E.B 02/22/99\r
- int reste = j % SSLIMIT;\r
- int quotien = (int) ((j - reste) / SSLIMIT);\r
+ @LOC("REST") int reste = j % SSLIMIT;\r
+ @LOC("QUO") int quotien = (int) ((j - reste) / SSLIMIT);\r
if (reste < 0)\r
reste = 0;\r
if (quotien < 0)\r
quotien = 0;\r
- xr_1d[quotien][reste] = 0.0f;\r
+ xr[quotien][reste] = 0.0f;\r
}\r
\r
return;\r
/**\r
*\r
*/\r
- private void reorder(float xr[][], int ch, int gr) {\r
+ @LATTICE("THIS<I,I<GR,GR<IN,I*,THISLOC=THIS,GLOBALLOC=IN")\r
+ private void reorder(@LOC("IN") float xr[][], @LOC("IN") int ch, @LOC("IN") int gr) {\r
// the purpose of reordering: move 'short samples' back to their original position\r
// after reorder, the samples are no long ordered by frequency\r
\r
// the format of input data to reorder: \r
// three small chunks of 192 samples each are combined to 576 samples ordered by frequency \r
\r
- gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
- int freq, freq3;\r
- int index;\r
- int sfb, sfb_start, sfb_lines;\r
- int src_line, des_line;\r
- float[][] xr_1d = xr;\r
+ @LOC("GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
+ @LOC("THIS,LayerIIIDecoder.RO6") int freq;\r
+ @LOC("THIS,LayerIIIDecoder.RO5") int freq3;\r
+ @LOC("I") int index;\r
+ @LOC("THIS,LayerIIIDecoder.RO9") int sfb;\r
+ @LOC("THIS,LayerIIIDecoder.RO8") int sfb_start;\r
+ @LOC("THIS,LayerIIIDecoder.RO7") int sfb_lines;\r
+ @LOC("THIS,LayerIIIDecoder.RO4") int src_line;\r
+ @LOC("THIS,LayerIIIDecoder.RO1") int des_line;\r
+ //float[][] xr_1d = xr; subbed in xr for xr_1d so as not to create extra areas\r
\r
if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {\r
\r
// NO REORDER FOR LOW 2 SUBBANDS\r
for (index = 0; index < 36; index++) {\r
// Modif E.B 02/22/99\r
- int reste = index % SSLIMIT;\r
- int quotien = (int) ((index - reste) / SSLIMIT);\r
- out_1d[index] = xr_1d[quotien][reste];\r
+ @LOC("THIS,LayerIIIDecoder.RO3") int reste = index % SSLIMIT;\r
+ @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((index - reste) / SSLIMIT);\r
+ out_1d[index] = xr[quotien][reste];\r
}\r
// REORDERING FOR REST SWITCHED SHORT\r
/*\r
sfb_start = sfBandIndex[sfreq].s[sfb];\r
sfb_lines = sfBandIndex[sfreq].s[sfb + 1] - sfb_start;\r
\r
- int sfb_start3 = (sfb_start << 2) - sfb_start;\r
+ @LOC("THIS,LayerIIIDecoder.RO7") int sfb_start3 = (sfb_start << 2) - sfb_start;\r
\r
for (freq = 0, freq3 = 0; freq < sfb_lines; freq++, freq3 += 3) {\r
\r
src_line = sfb_start3 + freq;\r
des_line = sfb_start3 + freq3;\r
// Modif E.B 02/22/99\r
- int reste = src_line % SSLIMIT;\r
- int quotien = (int) ((src_line - reste) / SSLIMIT);\r
+ @LOC("THIS,LayerIIIDecoder.RO3") int reste = src_line % SSLIMIT;\r
+ @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((src_line - reste) / SSLIMIT);\r
\r
- out_1d[des_line] = xr_1d[quotien][reste];\r
+ out_1d[des_line] = xr[quotien][reste];\r
src_line += sfb_lines;\r
des_line++;\r
\r
reste = src_line % SSLIMIT;\r
quotien = (int) ((src_line - reste) / SSLIMIT);\r
\r
- out_1d[des_line] = xr_1d[quotien][reste];\r
+ out_1d[des_line] = xr[quotien][reste];\r
src_line += sfb_lines;\r
des_line++;\r
\r
reste = src_line % SSLIMIT;\r
quotien = (int) ((src_line - reste) / SSLIMIT);\r
\r
- out_1d[des_line] = xr_1d[quotien][reste];\r
+ out_1d[des_line] = xr[quotien][reste];\r
}\r
}\r
\r
} else { // pure short\r
for (index = 0; index < 576; index++) {\r
- int j = reorder_table[sfreq][index];\r
- int reste = j % SSLIMIT;\r
- int quotien = (int) ((j - reste) / SSLIMIT);\r
- out_1d[index] = xr_1d[quotien][reste];\r
+ @LOC("THIS,LayerIIIDecoder.RO8") int j = reorder_table[sfreq][index];\r
+ @LOC("THIS,LayerIIIDecoder.RO3") int reste = j % SSLIMIT;\r
+ @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((j - reste) / SSLIMIT);\r
+ out_1d[index] = xr[quotien][reste];\r
}\r
}\r
} else { // long blocks\r
for (index = 0; index < 576; index++) {\r
// Modif E.B 02/22/99\r
- int reste = index % SSLIMIT;\r
- int quotien = (int) ((index - reste) / SSLIMIT);\r
- out_1d[index] = xr_1d[quotien][reste];\r
+ @LOC("THIS,LayerIIIDecoder.RO3") int reste = index % SSLIMIT;\r
+ @LOC("THIS,LayerIIIDecoder.RO2") int quotien = (int) ((index - reste) / SSLIMIT);\r
+ out_1d[index] = xr[quotien][reste];\r
}\r
}\r
}\r
*\r
*/\r
\r
- int[] is_pos = new int[576];\r
- float[] is_ratio = new float[576];\r
+ @LOC("IP") int[] is_pos = new int[576];\r
+ @LOC("IR") float[] is_ratio = new float[576];\r
\r
- private void stereo(int gr) {\r
- int sb, ss;\r
+ @LATTICE("IO<THIS,THIS<IN,THISLOC=THIS,GLOBALLOC=IN") \r
+ private void stereo(@LOC("IN") int gr) {\r
+ @LOC("SH") int sb;\r
+ @LOC("SH") int ss;\r
\r
if (channels == 1) { // mono , bypass xr[0][][] to lr[0][][]\r
\r
\r
} else {\r
\r
- gr_info_s gr_info = (si.ch[0].gr[gr]);\r
- int mode_ext = header.mode_extension();\r
- int sfb;\r
- int i;\r
- int lines, temp, temp2;\r
-\r
- boolean ms_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x2) != 0));\r
- boolean i_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x1) != 0));\r
- boolean lsf =\r
+ @LOC("THIS,LayerIIIDecoder.ME") gr_info_s gr_info = (si.ch[0].gr[gr]);\r
+ @LOC("THIS,LayerIIIDecoder.ME") int mode_ext = header.mode_extension();\r
+ @LOC("THIS,LayerIIIDecoder.SH") int sfb;\r
+ @LOC("THIS,LayerIIIDecoder.SH") int i;\r
+ @LOC("THIS,LayerIIIDecoder.SH") int line;\r
+ @LOC("THIS,LayerIIIDecoder.SH") int temp;\r
+ @LOC("THIS,LayerIIIDecoder.TMP2") int temp2;\r
+\r
+ @LOC("THIS,LayerIIIDecoder.S") boolean ms_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x2) != 0));\r
+ @LOC("THIS,LayerIIIDecoder.S") boolean i_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x1) != 0));\r
+ @LOC("THIS,LayerIIIDecoder.LSF") boolean lsf =\r
((header.version() == Header.MPEG2_LSF || header.version() == Header.MPEG25_LSF)); // SZD\r
\r
- int io_type = (gr_info.scalefac_compress & 1);\r
+ @LOC("IO") int io_type = (gr_info.scalefac_compress & 1);\r
\r
// initialization\r
\r
if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {\r
if (gr_info.mixed_block_flag != 0) {\r
\r
- int max_sfb = 0;\r
+ @LOC("THIS,LayerIIIDecoder.SH") int max_sfb = 0;\r
\r
- for (int j = 0; j < 3; j++) {\r
- int sfbcnt;\r
+ for (@LOC("THIS,LayerIIIDecoder.J") int j = 0; j < 3; j++) {\r
+ @LOC("THIS,LayerIIIDecoder.SH") int sfbcnt;\r
sfbcnt = 2;\r
for (sfb = 12; sfb >= 3; sfb--) {\r
i = sfBandIndex[sfreq].s[sfb];\r
} // for (; sfb<8 ...\r
} // for (j=0 ...\r
} else { // if (gr_info.mixed_block_flag)\r
- for (int j = 0; j < 3; j++) {\r
- int sfbcnt;\r
+ for (@LOC("THIS,LayerIIIDecoder.J") int j = 0; j < 3; j++) {\r
+ @LOC("THIS,LayerIIIDecoder.SH") int sfbcnt;\r
sfbcnt = -1;\r
for (sfb = 12; sfb >= 0; sfb--) {\r
temp = sfBandIndex[sfreq].s[sfb];\r
/**\r
*\r
*/\r
- private void antialias(int ch, int gr) {\r
- int sb18, ss, sb18lim;\r
- gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
+ @LATTICE("THIS<SRC<SS,SS<SB18,SB18<SB18LIM,SB18LIM<GR,GR<IN,SB18*,SS*,THISLOC=THIS")\r
+ private void antialias(@LOC("IN") int ch, @LOC("IN") int gr) {\r
+ @LOC("SB18") int sb18;\r
+ @LOC("SS") int ss;\r
+ @LOC("SB18LIM") int sb18lim;\r
+ @LOC("GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
// 31 alias-reduction operations between each pair of sub-bands\r
// with 8 butterflies between each pair\r
\r
\r
for (sb18 = 0; sb18 < sb18lim; sb18 += 18) {\r
for (ss = 0; ss < 8; ss++) {\r
- int src_idx1 = sb18 + 17 - ss;\r
- int src_idx2 = sb18 + 18 + ss;\r
- float bu = out_1d[src_idx1];\r
- float bd = out_1d[src_idx2];\r
+ @LOC("SRC") int src_idx1 = sb18 + 17 - ss;\r
+ @LOC("SRC") int src_idx2 = sb18 + 18 + ss;\r
+ @LOC("THIS,LayerIIIDecoder.O") float bu = out_1d[src_idx1];\r
+ @LOC("THIS,LayerIIIDecoder.0") float bd = out_1d[src_idx2];\r
out_1d[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);\r
out_1d[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);\r
}\r
\r
// MDM: tsOutCopy and rawout do not need initializing, so the arrays\r
// can be reused.\r
- float[] tsOutCopy = new float[18];\r
- float[] rawout = new float[36];\r
-\r
- private void hybrid(int ch, int gr) {\r
- int bt;\r
- int sb18;\r
- gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
- float[] tsOut;\r
-\r
- float[][] prvblk;\r
+ @LOC("TS") float[] tsOutCopy = new float[18];\r
+ @LOC("RAW") float[] rawout = new float[36];\r
+ \r
+@LATTICE("THIS<SB,THIS<SH,SH<IN,IN<GLOBAL,SB*,SH*,THISLOC=THIS,GLOBALLOC=GLOBAL")\r
+ private void hybrid(@LOC("IN") int ch, @LOC("IN") int gr) {\r
+ @LOC("THIS,LayerIIIDecoder.BT") int bt;\r
+ @LOC("SB") int sb18;\r
+ @LOC("THIS,LayerIIIDecoder.GR") gr_info_s gr_info = (si.ch[ch].gr[gr]);\r
+ @LOC("THIS,LayerIIIDecoder.TS") float[] tsOut;\r
+\r
+ //float[][] prvblk;\r
\r
for (sb18 = 0; sb18 < 576; sb18 += 18) {\r
bt =\r
\r
tsOut = out_1d;\r
// Modif E.B 02/22/99\r
- for (int cc = 0; cc < 18; cc++)\r
+ for (@LOC("SH") int cc = 0; cc < 18; cc++)\r
tsOutCopy[cc] = tsOut[cc + sb18];\r
\r
inv_mdct(tsOutCopy, rawout, bt);\r
\r
- for (int cc = 0; cc < 18; cc++)\r
+ for (@LOC("SH") int cc = 0; cc < 18; cc++)\r
tsOut[cc + sb18] = tsOutCopy[cc];\r
// Fin Modif\r
\r
// overlap addition\r
- prvblk = prevblck;\r
-\r
- tsOut[0 + sb18] = rawout[0] + prvblk[ch][sb18 + 0];\r
- prvblk[ch][sb18 + 0] = rawout[18];\r
- tsOut[1 + sb18] = rawout[1] + prvblk[ch][sb18 + 1];\r
- prvblk[ch][sb18 + 1] = rawout[19];\r
- tsOut[2 + sb18] = rawout[2] + prvblk[ch][sb18 + 2];\r
- prvblk[ch][sb18 + 2] = rawout[20];\r
- tsOut[3 + sb18] = rawout[3] + prvblk[ch][sb18 + 3];\r
- prvblk[ch][sb18 + 3] = rawout[21];\r
- tsOut[4 + sb18] = rawout[4] + prvblk[ch][sb18 + 4];\r
- prvblk[ch][sb18 + 4] = rawout[22];\r
- tsOut[5 + sb18] = rawout[5] + prvblk[ch][sb18 + 5];\r
- prvblk[ch][sb18 + 5] = rawout[23];\r
- tsOut[6 + sb18] = rawout[6] + prvblk[ch][sb18 + 6];\r
- prvblk[ch][sb18 + 6] = rawout[24];\r
- tsOut[7 + sb18] = rawout[7] + prvblk[ch][sb18 + 7];\r
- prvblk[ch][sb18 + 7] = rawout[25];\r
- tsOut[8 + sb18] = rawout[8] + prvblk[ch][sb18 + 8];\r
- prvblk[ch][sb18 + 8] = rawout[26];\r
- tsOut[9 + sb18] = rawout[9] + prvblk[ch][sb18 + 9];\r
- prvblk[ch][sb18 + 9] = rawout[27];\r
- tsOut[10 + sb18] = rawout[10] + prvblk[ch][sb18 + 10];\r
- prvblk[ch][sb18 + 10] = rawout[28];\r
- tsOut[11 + sb18] = rawout[11] + prvblk[ch][sb18 + 11];\r
- prvblk[ch][sb18 + 11] = rawout[29];\r
- tsOut[12 + sb18] = rawout[12] + prvblk[ch][sb18 + 12];\r
- prvblk[ch][sb18 + 12] = rawout[30];\r
- tsOut[13 + sb18] = rawout[13] + prvblk[ch][sb18 + 13];\r
- prvblk[ch][sb18 + 13] = rawout[31];\r
- tsOut[14 + sb18] = rawout[14] + prvblk[ch][sb18 + 14];\r
- prvblk[ch][sb18 + 14] = rawout[32];\r
- tsOut[15 + sb18] = rawout[15] + prvblk[ch][sb18 + 15];\r
- prvblk[ch][sb18 + 15] = rawout[33];\r
- tsOut[16 + sb18] = rawout[16] + prvblk[ch][sb18 + 16];\r
- prvblk[ch][sb18 + 16] = rawout[34];\r
- tsOut[17 + sb18] = rawout[17] + prvblk[ch][sb18 + 17];\r
- prvblk[ch][sb18 + 17] = rawout[35];\r
+ //prvblk = prevblck; //eliminated unnecessary areas\r
+\r
+ tsOut[0 + sb18] = rawout[0] + prevblk[ch][sb18 + 0];\r
+ prevblk[ch][sb18 + 0] = rawout[18];\r
+ tsOut[1 + sb18] = rawout[1] + prevblk[ch][sb18 + 1];\r
+ prevblk[ch][sb18 + 1] = rawout[19];\r
+ tsOut[2 + sb18] = rawout[2] + prevblk[ch][sb18 + 2];\r
+ prevblk[ch][sb18 + 2] = rawout[20];\r
+ tsOut[3 + sb18] = rawout[3] + prevblk[ch][sb18 + 3];\r
+ prevblk[ch][sb18 + 3] = rawout[21];\r
+ tsOut[4 + sb18] = rawout[4] + prevblk[ch][sb18 + 4];\r
+ prevblk[ch][sb18 + 4] = rawout[22];\r
+ tsOut[5 + sb18] = rawout[5] + prevblk[ch][sb18 + 5];\r
+ prevblk[ch][sb18 + 5] = rawout[23];\r
+ tsOut[6 + sb18] = rawout[6] + prevblk[ch][sb18 + 6];\r
+ prevblk[ch][sb18 + 6] = rawout[24];\r
+ tsOut[7 + sb18] = rawout[7] + prevblk[ch][sb18 + 7];\r
+ prevblk[ch][sb18 + 7] = rawout[25];\r
+ tsOut[8 + sb18] = rawout[8] + prevblk[ch][sb18 + 8];\r
+ prevblk[ch][sb18 + 8] = rawout[26];\r
+ tsOut[9 + sb18] = rawout[9] + prevblk[ch][sb18 + 9];\r
+ prevblk[ch][sb18 + 9] = rawout[27];\r
+ tsOut[10 + sb18] = rawout[10] + prevblk[ch][sb18 + 10];\r
+ prevblk[ch][sb18 + 10] = rawout[28];\r
+ tsOut[11 + sb18] = rawout[11] + prevblk[ch][sb18 + 11];\r
+ prevblk[ch][sb18 + 11] = rawout[29];\r
+ tsOut[12 + sb18] = rawout[12] + prevblk[ch][sb18 + 12];\r
+ prevblk[ch][sb18 + 12] = rawout[30];\r
+ tsOut[13 + sb18] = rawout[13] + prevblk[ch][sb18 + 13];\r
+ prevblk[ch][sb18 + 13] = rawout[31];\r
+ tsOut[14 + sb18] = rawout[14] + prevblk[ch][sb18 + 14];\r
+ prevblk[ch][sb18 + 14] = rawout[32];\r
+ tsOut[15 + sb18] = rawout[15] + prevblk[ch][sb18 + 15];\r
+ prevblk[ch][sb18 + 15] = rawout[33];\r
+ tsOut[16 + sb18] = rawout[16] + prevblk[ch][sb18 + 16];\r
+ prevblk[ch][sb18 + 16] = rawout[34];\r
+ tsOut[17 + sb18] = rawout[17] + prevblk[ch][sb18 + 17];\r
+ prevblk[ch][sb18 + 17] = rawout[35];\r
}\r
}\r
\r
/**\r
*\r
*/\r
+ @LATTICE("THIS<SB,THIS<SS,SB<GLOBAL,SS<GLOBAL,SS*,SB*,THISLOC=THIS,GLOBALLOC=GLOBAL")\r
private void do_downmix() {\r
- for (int sb = 0; sb < SSLIMIT; sb++) {\r
- for (int ss = 0; ss < SSLIMIT; ss += 3) {\r
+ for (@LOC("SB") int sb = 0; sb < SSLIMIT; sb++) {\r
+ for (@LOC("SS") int ss = 0; ss < SSLIMIT; ss += 3) {\r
lr[0][sb][ss] = (lr[0][sb][ss] + lr[1][sb][ss]) * 0.5f;\r
lr[0][sb][ss + 1] = (lr[0][sb][ss + 1] + lr[1][sb][ss + 1]) * 0.5f;\r
lr[0][sb][ss + 2] = (lr[0][sb][ss + 2] + lr[1][sb][ss + 2]) * 0.5f;\r
/**\r
* Fast INV_MDCT.\r
*/\r
-\r
- public void inv_mdct(float[] in, float[] out, int block_type) {\r
- float[] win_bt;\r
- int i;\r
-\r
- float tmpf_0, tmpf_1, tmpf_2, tmpf_3, tmpf_4, tmpf_5, tmpf_6, tmpf_7, tmpf_8, tmpf_9;\r
- float tmpf_10, tmpf_11, tmpf_12, tmpf_13, tmpf_14, tmpf_15, tmpf_16, tmpf_17;\r
+@LATTICE("OUT<6I,OUT<TMPF,TMPF<EO,EO<TMP,TMP<SUM,TMP<IIP,IIP<I00,I00<SH,SUM<PP,PP<SH,SH<I,I<IN,TMPF*,SH*,I*,6I*,GLOBALLOC=IN")\r
+public void inv_mdct(@LOC("SH") float[] in, @LOC("OUT") float[] out, @LOC("IN") int block_type) {\r
+ //float[] win_bt;\r
+ @LOC("I") int i;\r
+\r
+ @LOC("TMPF") float tmpf_0;\r
+ @LOC("TMPF") float tmpf_1;\r
+ @LOC("TMPF") float tmpf_2;\r
+ @LOC("TMPF") float tmpf_3;\r
+ @LOC("TMPF") float tmpf_4;\r
+ @LOC("TMPF") float tmpf_5;\r
+ @LOC("TMPF") float tmpf_6;\r
+ @LOC("TMPF") float tmpf_7;\r
+ @LOC("TMPF") float tmpf_8;\r
+ @LOC("TMPF") float tmpf_9;\r
+ @LOC("TMPF") float tmpf_10;\r
+ @LOC("TMPF") float tmpf_11;\r
+ @LOC("TMPF") float tmpf_12;\r
+ @LOC("TMPF") float tmpf_13;\r
+ @LOC("TMPF") float tmpf_14;\r
+ @LOC("TMPF") float tmpf_15;\r
+ @LOC("TMPF") float tmpf_16;\r
+ @LOC("TMPF") float tmpf_17;\r
\r
tmpf_0 =\r
tmpf_1 =\r
out[34] = 0.0f;\r
out[35] = 0.0f;\r
\r
- int six_i = 0;\r
+ @LOC("6I") int six_i = 0;\r
\r
for (i = 0; i < 3; i++) {\r
// 12 point IMDCT\r
in[9 + i] += in[3 + i];\r
\r
// 3 point IDCT on even indices\r
- float pp1, pp2, sum;\r
+ @LOC("PP") float pp1;\r
+ @LOC("PP") float pp2;\r
+ @LOC("SUM") float sum;\r
pp2 = in[12 + i] * 0.500000000f;\r
pp1 = in[6 + i] * 0.866025403f;\r
sum = in[0 + i] + pp2;\r
tmpf_5 *= 0.517638090f;\r
\r
// Output butterflies on 2 3 point IDCT's (for 6 point IDCT)\r
- float save = tmpf_0;\r
+ @LOC("SH") float save = tmpf_0;\r
tmpf_0 += tmpf_5;\r
tmpf_5 = save - tmpf_5;\r
save = tmpf_1;\r
in[5] += in[3];\r
in[3] += in[1];\r
\r
- float tmp0, tmp1, tmp2, tmp3, tmp4, tmp0_, tmp1_, tmp2_, tmp3_;\r
- float tmp0o, tmp1o, tmp2o, tmp3o, tmp4o, tmp0_o, tmp1_o, tmp2_o, tmp3_o;\r
+ @LOC("TMP") float tmp0;\r
+ @LOC("TMP") float tmp1;\r
+ @LOC("TMP") float tmp2;\r
+ @LOC("TMP") float tmp3;\r
+ @LOC("TMP") float tmp4;\r
+ @LOC("TMP") float tmp0_;\r
+ @LOC("TMP") float tmp1_;\r
+ @LOC("TMP") float tmp2_;\r
+ @LOC("TMP") float tmp3_;\r
+ @LOC("TMP") float tmp0o;\r
+ @LOC("TMP") float tmp1o;\r
+ @LOC("TMP") float tmp2o;\r
+ @LOC("TMP") float tmp3o;\r
+ @LOC("TMP") float tmp4o;\r
+ @LOC("TMP") float tmp0_o;\r
+ @LOC("TMP") float tmp1_o;\r
+ @LOC("TMP") float tmp2_o;\r
+ @LOC("TMP") float tmp3_o;\r
\r
// Fast 9 Point Inverse Discrete Cosine Transform\r
//\r
// 9 point IDCT on even indices\r
\r
// 5 points on odd indices (not realy an IDCT)\r
- float i00 = in[0] + in[0];\r
- float iip12 = i00 + in[12];\r
+ @LOC("I00") float i00 = in[0] + in[0];\r
+ @LOC("IIP") float iip12 = i00 + in[12];\r
\r
tmp0 =\r
iip12 + in[4] * 1.8793852415718f + in[8] * 1.532088886238f + in[16] * 0.34729635533386f;\r
tmp4 = in[0] - in[4] + in[8] - in[12] + in[16];\r
\r
// 4 points on even indices\r
- float i66_ = in[6] * 1.732050808f; // Sqrt[3]\r
+ @LOC("I00") float i66_ = in[6] * 1.732050808f; // Sqrt[3]\r
\r
tmp0_ =\r
in[2] * 1.9696155060244f + i66_ + in[10] * 1.2855752193731f + in[14] * 0.68404028665134f;\r
\r
// 9 point IDCT on odd indices\r
// 5 points on odd indices (not realy an IDCT)\r
- float i0 = in[0 + 1] + in[0 + 1];\r
- float i0p12 = i0 + in[12 + 1];\r
+ @LOC("I00") float i0 = in[0 + 1] + in[0 + 1];\r
+ @LOC("IIP") float i0p12 = i0 + in[12 + 1];\r
\r
tmp0o =\r
i0p12 + in[4 + 1] * 1.8793852415718f + in[8 + 1] * 1.532088886238f + in[16 + 1]\r
tmp4o = (in[0 + 1] - in[4 + 1] + in[8 + 1] - in[12 + 1] + in[16 + 1]) * 0.707106781f; // Twiddled\r
\r
// 4 points on even indices\r
- float i6_ = in[6 + 1] * 1.732050808f; // Sqrt[3]\r
+ @LOC("I00") float i6_ = in[6 + 1] * 1.732050808f; // Sqrt[3]\r
\r
tmp0_o =\r
in[2 + 1] * 1.9696155060244f + i6_ + in[10 + 1] * 1.2855752193731f + in[14 + 1]\r
// and\r
// twiddle factors for 36 point IDCT\r
\r
- float e, o;\r
+ @LOC("EO") float e;\r
+ @LOC("EO") float o;\r
e = tmp0 + tmp0_;\r
o = (tmp0o + tmp0_o) * 0.501909918f;\r
tmpf_0 = e + o;\r
\r
// end 36 point IDCT */\r
// shift to modified IDCT\r
- win_bt = win[block_type];\r
-\r
- out[0] = -tmpf_9 * win_bt[0];\r
- out[1] = -tmpf_10 * win_bt[1];\r
- out[2] = -tmpf_11 * win_bt[2];\r
- out[3] = -tmpf_12 * win_bt[3];\r
- out[4] = -tmpf_13 * win_bt[4];\r
- out[5] = -tmpf_14 * win_bt[5];\r
- out[6] = -tmpf_15 * win_bt[6];\r
- out[7] = -tmpf_16 * win_bt[7];\r
- out[8] = -tmpf_17 * win_bt[8];\r
- out[9] = tmpf_17 * win_bt[9];\r
- out[10] = tmpf_16 * win_bt[10];\r
- out[11] = tmpf_15 * win_bt[11];\r
- out[12] = tmpf_14 * win_bt[12];\r
- out[13] = tmpf_13 * win_bt[13];\r
- out[14] = tmpf_12 * win_bt[14];\r
- out[15] = tmpf_11 * win_bt[15];\r
- out[16] = tmpf_10 * win_bt[16];\r
- out[17] = tmpf_9 * win_bt[17];\r
- out[18] = tmpf_8 * win_bt[18];\r
- out[19] = tmpf_7 * win_bt[19];\r
- out[20] = tmpf_6 * win_bt[20];\r
- out[21] = tmpf_5 * win_bt[21];\r
- out[22] = tmpf_4 * win_bt[22];\r
- out[23] = tmpf_3 * win_bt[23];\r
- out[24] = tmpf_2 * win_bt[24];\r
- out[25] = tmpf_1 * win_bt[25];\r
- out[26] = tmpf_0 * win_bt[26];\r
- out[27] = tmpf_0 * win_bt[27];\r
- out[28] = tmpf_1 * win_bt[28];\r
- out[29] = tmpf_2 * win_bt[29];\r
- out[30] = tmpf_3 * win_bt[30];\r
- out[31] = tmpf_4 * win_bt[31];\r
- out[32] = tmpf_5 * win_bt[32];\r
- out[33] = tmpf_6 * win_bt[33];\r
- out[34] = tmpf_7 * win_bt[34];\r
- out[35] = tmpf_8 * win_bt[35];\r
+ //win_bt = win[block_type]; //substituted this so that a new area does not become created\r
+\r
+ out[0] = -tmpf_9 * win[block_type][0];\r
+ out[1] = -tmpf_10 * win[block_type][1];\r
+ out[2] = -tmpf_11 * win[block_type][2];\r
+ out[3] = -tmpf_12 * win[block_type][3];\r
+ out[4] = -tmpf_13 * win[block_type][4];\r
+ out[5] = -tmpf_14 * win[block_type][5];\r
+ out[6] = -tmpf_15 * win[block_type][6];\r
+ out[7] = -tmpf_16 * win[block_type][7];\r
+ out[8] = -tmpf_17 * win[block_type][8];\r
+ out[9] = tmpf_17 * win[block_type][9];\r
+ out[10] = tmpf_16 * win[block_type][10];\r
+ out[11] = tmpf_15 * win[block_type][11];\r
+ out[12] = tmpf_14 * win[block_type][12];\r
+ out[13] = tmpf_13 * win[block_type][13];\r
+ out[14] = tmpf_12 * win[block_type][14];\r
+ out[15] = tmpf_11 * win[block_type][15];\r
+ out[16] = tmpf_10 * win[block_type][16];\r
+ out[17] = tmpf_9 * win[block_type][17];\r
+ out[18] = tmpf_8 * win[block_type][18];\r
+ out[19] = tmpf_7 * win[block_type][19];\r
+ out[20] = tmpf_6 * win[block_type][20];\r
+ out[21] = tmpf_5 * win[block_type][21];\r
+ out[22] = tmpf_4 * win[block_type][22];\r
+ out[23] = tmpf_3 * win[block_type][23];\r
+ out[24] = tmpf_2 * win[block_type][24];\r
+ out[25] = tmpf_1 * win[block_type][25];\r
+ out[26] = tmpf_0 * win[block_type][26];\r
+ out[27] = tmpf_0 * win[block_type][27];\r
+ out[28] = tmpf_1 * win[block_type][28];\r
+ out[29] = tmpf_2 * win[block_type][29];\r
+ out[30] = tmpf_3 * win[block_type][30];\r
+ out[31] = tmpf_4 * win[block_type][31];\r
+ out[32] = tmpf_5 * win[block_type][32];\r
+ out[33] = tmpf_6 * win[block_type][33];\r
+ out[34] = tmpf_7 * win[block_type][34];\r
+ out[35] = tmpf_8 * win[block_type][35];\r
}\r
}\r
\r
- private int counter = 0;\r
- private static final int SSLIMIT = 18;\r
- private static final int SBLIMIT = 32;\r
+ @LOC("C") private int counter = 0;\r
+ @LOC("F") private static final int SSLIMIT = 18;\r
+ @LOC("F") private static final int SBLIMIT = 32;\r
\r
// Size of the table of whole numbers raised to 4/3 power.\r
// This may be adjusted for performance without any problems.\r
// }\r
// }\r
\r
- private static final int slen[][] = { { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },\r
+ @LOC("F") private static final int slen[][] = { { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },\r
{ 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 } };\r
\r
- public static final int pretab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3,\r
+ @LOC("F") public static final int pretab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3,\r
2, 0 };\r
\r
- private SBI[] sfBandIndex; // Init in the constructor.\r
+ @LOC("F") private SBI[] sfBandIndex; // Init in the constructor.\r
\r
- public static final float two_to_negative_half_pow[] = { 1.0000000000E+00f, 7.0710678119E-01f,\r
+ @LOC("F") public static final float two_to_negative_half_pow[] = { 1.0000000000E+00f, 7.0710678119E-01f,\r
5.0000000000E-01f, 3.5355339059E-01f, 2.5000000000E-01f, 1.7677669530E-01f,\r
1.2500000000E-01f, 8.8388347648E-02f, 6.2500000000E-02f, 4.4194173824E-02f,\r
3.1250000000E-02f, 2.2097086912E-02f, 1.5625000000E-02f, 1.1048543456E-02f,\r
1.8626451492E-09f, 1.3170890160E-09f, 9.3132257462E-10f, 6.5854450798E-10f,\r
4.6566128731E-10f, 3.2927225399E-10f };\r
\r
- public static final float t_43[] = create_t_43();\r
+ @LOC("F") public static final float t_43[] = create_t_43();\r
\r
+ @RETURNLOC("OUT")\r
static private float[] create_t_43() {\r
- float[] t43 = new float[8192];\r
+ @LOC("OUT") float[] t43 = new float[8192];\r
final double d43 = (4.0 / 3.0);\r
\r
- for (int i = 0; i < 8192; i++) {\r
+ for (@LOC("SH") int i = 0; i < 8192; i++) {\r
t43[i] = (float) Math.pow(i, d43);\r
}\r
return t43;\r
}\r
\r
- public static final float io[][] = {\r
+ @LOC("F") public static final float io[][] = {\r
{ 1.0000000000E+00f, 8.4089641526E-01f, 7.0710678119E-01f, 5.9460355751E-01f,\r
5.0000000001E-01f, 4.2044820763E-01f, 3.5355339060E-01f, 2.9730177876E-01f,\r
2.5000000001E-01f, 2.1022410382E-01f, 1.7677669530E-01f, 1.4865088938E-01f,\r
2.4414062501E-04f, 1.7263349151E-04f, 1.2207031251E-04f, 8.6316745755E-05f,\r
6.1035156254E-05f, 4.3158372878E-05f, 3.0517578127E-05f, 2.1579186439E-05f } };\r
\r
- public static final float TAN12[] = { 0.0f, 0.26794919f, 0.57735027f, 1.0f, 1.73205081f,\r
+ @LOC("F") public static final float TAN12[] = { 0.0f, 0.26794919f, 0.57735027f, 1.0f, 1.73205081f,\r
3.73205081f, 9.9999999e10f, -3.73205081f, -1.73205081f, -1.0f, -0.57735027f, -0.26794919f,\r
0.0f, 0.26794919f, 0.57735027f, 1.0f };\r
\r
* 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,\r
* 12, 13, 14, 15, 16, 17 };\r
*/\r
- private static/* final */int reorder_table[][]/* = loadReorderTable() */; // SZD:\r
+ @LOC("F") private static/* final */int reorder_table[][]/* = loadReorderTable() */; // SZD:\r
// will\r
// be\r
// generated\r
* return (int[][])o; } catch (IOException ex) { throw new\r
* ExceptionInInitializerError(ex); } }\r
*/\r
-\r
- static int[] reorder(int scalefac_band[]) { // SZD: converted from LAME\r
- int j = 0;\r
- int ix[] = new int[576];\r
+ @LATTICE("OUT<J,J<I,I<SE,I<WIN,SE<SF,SE<SFB,WIN<SFB,J*,I*,WIN*,SFB*")\r
+ static int[] reorder(@LOC("SF") int scalefac_band[]) { // SZD: converted from LAME\r
+ @LOC("J") int j = 0;\r
+ @LOC("OUT") int ix[] = new int[576];\r
for (int sfb = 0; sfb < 13; sfb++) {\r
int start = scalefac_band[sfb];\r
int end = scalefac_band[sfb + 1];\r
* 570,547,559,571,548,560,572,549,561,573,550,562,574,551,563,575} };\r
*/\r
\r
- private static final float cs[] = { 0.857492925712f, 0.881741997318f, 0.949628649103f,\r
+ @LOC("F") private static final float cs[] = { 0.857492925712f, 0.881741997318f, 0.949628649103f,\r
0.983314592492f, 0.995517816065f, 0.999160558175f, 0.999899195243f, 0.999993155067f };\r
\r
- private static final float ca[] = { -0.5144957554270f, -0.4717319685650f, -0.3133774542040f,\r
+ @LOC("F") private static final float ca[] = { -0.5144957554270f, -0.4717319685650f, -0.3133774542040f,\r
-0.1819131996110f, -0.0945741925262f, -0.0409655828852f, -0.0141985685725f,\r
-0.00369997467375f };\r
\r
/***************************************************************/\r
/* INV_MDCT */\r
/***************************************************************/\r
- public static final float win[][] = {\r
+ @LOC("F") public static final float win[][] = {\r
{ -1.6141214951E-02f, -5.3603178919E-02f, -1.0070713296E-01f, -1.6280817573E-01f,\r
-4.9999999679E-01f, -3.8388735032E-01f, -6.2061144372E-01f, -1.1659756083E+00f,\r
-3.8720752656E+00f, -4.2256286556E+00f, -1.5195289984E+00f, -9.7416483388E-01f,\r
}\r
}\r
\r
- public Sftable sftable;\r
+ @LOC("F") public Sftable sftable;\r
\r
- public static final int nr_of_sfb_block[][][] = {\r
+ @LOC("F") public static final int nr_of_sfb_block[][][] = {\r
{ { 6, 5, 5, 5 }, { 9, 9, 9, 9 }, { 6, 9, 9, 9 } },\r
{ { 6, 5, 7, 3 }, { 9, 9, 12, 6 }, { 6, 9, 12, 6 } },\r
{ { 11, 10, 0, 0 }, { 18, 18, 0, 0 }, { 15, 18, 0, 0 } },\r
projects / IRC.git / blobdiff