← Back to branch summary

~ubuntu-branches/ubuntu/precise/csound/precise

« back to all changes in this revision

Viewing changes to InOut/libmpadec/layer3.c

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2012-04-19 09:26:46 UTC
  • mfrom: (3.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20120419092646-96xbj1n6atuqosk2
Tags: 1:5.17.6~dfsg-1
* New upstream release
 - Do not build the wiimote opcodes (we need wiiuse).
* Add new API function to symbols file
* Disable lua opcodes, they were broken. Requires OpenMP to be enabled.
* Backport fixes from upstream:
  - Link dssi4cs with dl. Backport
  - Fix building of CsoundAC

Show diffs side-by-side

added added

removed removed

Lines of Context:
InOut/libmpadec/layer3.c
 
1
 
 
2
/*
 
3
 *  mpadec - MPEG audio decoder
 
4
 *  Copyright (C) 2002-2004 Dmitriy Startsev (dstartsev@rambler.ru)
 
5
 *
 
6
 *  This library is free software; you can redistribute it and/or
 
7
 *  modify it under the terms of the GNU Lesser General Public
 
8
 *  License as published by the Free Software Foundation; either
 
9
 *  version 2.1 of the License, or (at your option) any later version.
 
10
 *
 
11
 *  This library is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 *  Lesser General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU Lesser General Public
 
17
 *  License along with this library; if not, write to the Free Software
 
18
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 */
 
20
 
 
21
/* $Id: layer3.c,v 1.3 2009/03/01 15:27:05 jpff Exp $ */
 
22
 
 
23
#include "mpadec_internal.h"
 
24
 
 
25
extern const uint32_t bitmask[17];
 
26
extern bandinfo_t band_info[];
 
27
extern newhuff_t hufft[], hufftc[];
 
28
extern const MYFLT newcos[8];
 
29
extern const MYFLT tfcos36[9];
 
30
extern const MYFLT tfcos12[3];
 
31
extern const MYFLT cs[8];
 
32
extern const MYFLT ca[8];
 
33
 
 
34
extern uint32_t getbits(mpadec_t mpadec, unsigned n);
 
35
extern uint16_t update_crc(uint16_t init, uint8_t *buf, int length);
 
36
 
 
37
static int decode_layer3_sideinfo(mpadec_t mpadec)
 
38
{
 
39
    register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
 
40
    int ch, gr, ms_stereo, powdiff, databits = 0;
 
41
    static const uint8_t tabs[2][5] = { { 2, 9, 5, 3, 4 }, { 1, 8, 1, 2, 9 } };
 
42
    const uint8_t *tab = tabs[mpa->frame.LSF];
 
43
 
 
44
    ms_stereo = ((mpa->frame.mode == MPG_MD_JOINT_STEREO) &&
 
45
                 (mpa->frame.mode_ext & 2));
 
46
    powdiff = ((mpa->frame.channels > 1) &&
 
47
               (mpa->config.mode == MPADEC_CONFIG_MONO)) ? 4 : 0;
 
48
    mpa->sideinfo.main_data_begin = GETBITS(tab[1]);
 
49
    if (mpa->frame.channels == 1) mpa->sideinfo.private_bits = GETBITS(tab[2]);
 
50
    else mpa->sideinfo.private_bits = GETBITS(tab[3]);
 
51
    if (!mpa->frame.LSF) {
 
52
      for (ch = 0; ch < mpa->frame.channels; ch++) {
 
53
        mpa->sideinfo.ch[ch].gr[0].scfsi = -1;
 
54
        mpa->sideinfo.ch[ch].gr[1].scfsi = GETBITS(4);
 
55
      }
 
56
    }
 
57
    for (gr = 0; gr < tab[0]; gr++) {
 
58
      for (ch = 0; ch < mpa->frame.channels; ch++) {
 
59
        register grinfo_t *grinfo = &mpa->sideinfo.ch[ch].gr[gr];
 
60
        grinfo->part2_3_length = GETBITS(12);
 
61
        grinfo->big_values = GETBITS(9);
 
62
        databits += grinfo->part2_3_length;
 
63
        if (grinfo->big_values > 288) grinfo->big_values = 288;
 
64
        grinfo->pow2gain = mpa->tables.gainpow2 + 256 - GETBITS(8) + powdiff;
 
65
        if (ms_stereo) grinfo->pow2gain += 2;
 
66
        grinfo->scalefac_compress = GETBITS(tab[4]);
 
67
        if (GETBITS(1)) {
 
68
          grinfo->block_type = (uint8_t)GETBITS(2);
 
69
          grinfo->mixed_block_flag = (uint8_t)GETBITS(1);
 
70
          grinfo->table_select[0] = GETBITS(5);
 
71
          grinfo->table_select[1] = GETBITS(5);
 
72
          grinfo->table_select[2] = 0;
 
73
          grinfo->full_gain[0] = grinfo->pow2gain + (GETBITS(3) << 3);
 
74
          grinfo->full_gain[1] = grinfo->pow2gain + (GETBITS(3) << 3);
 
75
          grinfo->full_gain[2] = grinfo->pow2gain + (GETBITS(3) << 3);
 
76
          if (!grinfo->block_type) {
 
77
            mpa->error = TRUE;
 
78
            return 0;
 
79
          } else mpa->error = FALSE;
 
80
          if (mpa->frame.LSF) {
 
81
            if (grinfo->block_type == 2) {
 
82
              if (grinfo->mixed_block_flag) {
 
83
                if (mpa->frame.frequency_index == 8) grinfo->region1start = 48;
 
84
                else grinfo->region1start = 48 >> 1;
 
85
              } else {
 
86
                if (mpa->frame.frequency_index == 8) grinfo->region1start = 36;
 
87
                else grinfo->region1start = 36 >> 1;
 
88
              }
 
89
            } else {
 
90
              if (mpa->frame.frequency_index == 8) grinfo->region1start = 54;
 
91
              else grinfo->region1start = 54 >> 1;
 
92
            }
 
93
          } else grinfo->region1start = 36 >> 1;
 
94
          grinfo->region2start = 576 >> 1;
 
95
        } else {
 
96
          grinfo->block_type = 0;
 
97
          grinfo->mixed_block_flag = 0;
 
98
          grinfo->table_select[0] = GETBITS(5);
 
99
          grinfo->table_select[1] = GETBITS(5);
 
100
          grinfo->table_select[2] = GETBITS(5);
 
101
          {
 
102
            register int tmp = GETBITS(4);
 
103
            grinfo->region1start =
 
104
              band_info[mpa->frame.frequency_index].long_idx[tmp + 1] >> 1;
 
105
            tmp += GETBITS(3);
 
106
            grinfo->region2start =
 
107
              band_info[mpa->frame.frequency_index].long_idx[tmp + 2] >> 1;
 
108
          }
 
109
        }
 
110
        if (!mpa->frame.LSF) grinfo->preflag = (uint8_t)GETBITS(1);
 
111
        grinfo->scalefac_scale = (uint8_t)GETBITS(1);
 
112
        grinfo->count1table_select = (uint8_t)GETBITS(1);
 
113
      }
 
114
    }
 
115
    databits -= 8*mpa->sideinfo.main_data_begin;
 
116
    return databits;
 
117
}
 
118
 
 
119
static int III_get_scale_factors(mpadec_t mpadec, grinfo_t *gr_info, int32_t *scf)
 
120
{
 
121
    register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
 
122
    register grinfo_t *grinfo = gr_info;
 
123
    int numbits = 0;
 
124
    static uint8_t slen[2][16] = 
 
125
      { {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
 
126
        {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3} };
 
127
    static uint8_t stab[3][6][4] =
 
128
      { { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
 
129
          { 7, 7, 7,0 } , { 6, 6, 6,3 } , {  8, 8,5,0} } ,
 
130
        { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
 
131
          {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
 
132
        { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
 
133
          { 6,15,12,0 } , { 6,12, 9,6 } , {  6,18,9,0} } };
 
134
    
 
135
    if (!mpa->frame.LSF) {
 
136
      int i, num0 = slen[0][grinfo->scalefac_compress],
 
137
              num1 = slen[1][grinfo->scalefac_compress];
 
138
      if (grinfo->block_type == 2) {
 
139
        i = 18; numbits = 18*(num0 + num1);
 
140
        if (grinfo->mixed_block_flag) {
 
141
          i--;
 
142
          numbits -= num0;
 
143
        }
 
144
        for (; i; i--) *scf++ = GETBITS(num0);
 
145
        for (i = 18; i; i--) *scf++ = GETBITS(num1);
 
146
        scf[0] = scf[1] = scf[2] = 0;
 
147
      } else {
 
148
        if (grinfo->scfsi < 0) {
 
149
          for (i = 11; i; i--) *scf++ = GETBITS(num0);
 
150
          for (i = 10; i; i--) *scf++ = GETBITS(num1);
 
151
          numbits = 10*(num0 + num1) + num0;
 
152
          *scf = 0;
 
153
        } else {
 
154
          numbits = 0;
 
155
          if (!(grinfo->scfsi & 8)) {
 
156
            for (i = 6; i; i--) *scf++ = GETBITS(num0);
 
157
            numbits += 6*num0;
 
158
          } else scf += 6;
 
159
          if (!(grinfo->scfsi & 4)) {
 
160
            for (i = 5; i; i--) *scf++ = GETBITS(num0);
 
161
            numbits += 5*num0;
 
162
          } else scf += 5;
 
163
          if (!(grinfo->scfsi & 2)) {
 
164
            for (i = 5; i; i--) *scf++ = GETBITS(num1);
 
165
            numbits += 5*num1;
 
166
          } else scf += 5;
 
167
          if (!(grinfo->scfsi & 1)) {
 
168
            for (i = 5; i; i--) *scf++ = GETBITS(num1);
 
169
            numbits += 5*num1;
 
170
          } else scf += 5;
 
171
          *scf = 0;
 
172
        }
 
173
      }
 
174
    } else {
 
175
      int i, j, n = 0;
 
176
      unsigned s_len; uint8_t *pnt;
 
177
      if ((mpa->frame.mode == MPG_MD_JOINT_STEREO) && (mpa->frame.mode_ext & 1)) {
 
178
        s_len = mpa->tables.i_slen2[grinfo->scalefac_compress >> 1];
 
179
      } else s_len = mpa->tables.n_slen2[grinfo->scalefac_compress];
 
180
      grinfo->preflag = (uint8_t)((s_len >> 15) & 1);
 
181
      if (grinfo->block_type == 2) n = grinfo->mixed_block_flag ? 2 : 1;
 
182
      pnt = stab[n][(s_len >> 12) & 7];
 
183
      for (i = 0; i < 4; i++) {
 
184
        int num = s_len & 7;
 
185
        s_len >>= 3;
 
186
        if (num) {
 
187
          for (j = 0; j < (int)pnt[i]; j++) *scf++ = GETBITS(num);
 
188
          numbits += pnt[i]*num;
 
189
        } else for (j = 0; j < (int)pnt[i]; j++) *scf++ = 0;
 
190
      }
 
191
      for (i = (n << 1) + 1; i; i--) *scf++ = 0;
 
192
    }
 
193
    return numbits;
 
194
}
 
195
 
 
196
static int III_decode_samples(mpadec_t mpadec, grinfo_t *gr_info, MYFLT xr[SBLIMIT][SSLIMIT], int32_t *scf, int part2bits)
 
197
{
 
198
    register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
 
199
    register grinfo_t *grinfo = gr_info;
 
200
    int shift = 1 + grinfo->scalefac_scale, l[3], l3;
 
201
    int part2remain = grinfo->part2_3_length - part2bits;
 
202
    MYFLT *xrptr = (MYFLT *)xr; int32_t *me;
 
203
    static uint8_t pretab1[22] = 
 
204
      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 };
 
205
    static uint8_t pretab2[22] =
 
206
      { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
207
 
 
208
    l3 = ((576 >> 1) - grinfo->big_values) >> 1;
 
209
    if (grinfo->big_values <= grinfo->region1start) {
 
210
      l[0] = grinfo->big_values;
 
211
      l[1] = l[2] = 0;
 
212
    } else {
 
213
      l[0] = grinfo->region1start;
 
214
      if (grinfo->big_values <= grinfo->region2start) {
 
215
        l[1] = grinfo->big_values - l[0]; l[2] = 0;
 
216
      } else {
 
217
        l[1] = grinfo->region2start - l[0];
 
218
        l[2] = grinfo->big_values - grinfo->region2start;
 
219
      }
 
220
    }
 
221
    if (grinfo->block_type == 2) {
 
222
      int32_t i, max[4], step = 0, lwin = 0, cb = 0;
 
223
      register MYFLT v = 0.0;
 
224
      register int32_t *m, mc;
 
225
 
 
226
      if (grinfo->mixed_block_flag) {
 
227
        max[3] = -1;
 
228
        max[0] = max[1] = max[2] = 2;
 
229
        m = mpa->tables.map[mpa->frame.frequency_index][0];
 
230
        me = mpa->tables.mapend[mpa->frame.frequency_index][0];
 
231
      } else {
 
232
        max[0] = max[1] = max[2] = max[3] = -1;
 
233
        m = mpa->tables.map[mpa->frame.frequency_index][1];
 
234
        me = mpa->tables.mapend[mpa->frame.frequency_index][1];
 
235
      }
 
236
      mc = 0;
 
237
      for (i = 0; i < 2; i++) {
 
238
        int lp = l[i];
 
239
        newhuff_t *h = hufft + grinfo->table_select[i];
 
240
        for (; lp; lp--, mc--) {
 
241
          register int x, y;
 
242
          if (!mc) {
 
243
            mc = *m++;
 
244
            xrptr = ((MYFLT *)xr) + (*m++);
 
245
            lwin = *m++;
 
246
            cb = *m++;
 
247
            if (lwin == 3) {
 
248
              v = grinfo->pow2gain[(*scf++) << shift];
 
249
              step = 1;
 
250
            } else {
 
251
              v = grinfo->full_gain[lwin][(*scf++) << shift];
 
252
              step = 3;
 
253
            }
 
254
          }
 
255
          {
 
256
            register int16_t *val = h->table;
 
257
            while ((y = *val++) < 0) {
 
258
              if (GETBITS(1)) val -= y;
 
259
              part2remain--;
 
260
            }
 
261
            x = y >> 4;
 
262
            y &= 0x0F;
 
263
          }
 
264
          if ((x == 15) && h->linbits) {
 
265
            max[lwin] = cb;
 
266
            part2remain -= h->linbits + 1;
 
267
            x += GETBITS(h->linbits);
 
268
            if (GETBITS(1)) *xrptr = -mpa->tables.ispow[x]*v;
 
269
            else *xrptr = mpa->tables.ispow[x]*v;
 
270
          } else if (x) {
 
271
            max[lwin] = cb;
 
272
            if (GETBITS(1)) *xrptr = -mpa->tables.ispow[x]*v;
 
273
            else *xrptr = mpa->tables.ispow[x]*v;
 
274
            part2remain--;
 
275
          } else *xrptr = 0.0;
 
276
          xrptr += step;
 
277
          if ((y == 15) && h->linbits) {
 
278
            max[lwin] = cb;
 
279
            part2remain -= h->linbits + 1;
 
280
            y += GETBITS(h->linbits);
 
281
            if (GETBITS(1)) *xrptr = -mpa->tables.ispow[y]*v;
 
282
            else *xrptr = mpa->tables.ispow[y]*v;
 
283
          } else if (y) {
 
284
            max[lwin] = cb;
 
285
            if (GETBITS(1)) *xrptr = -mpa->tables.ispow[y]*v;
 
286
            else *xrptr = mpa->tables.ispow[y]*v;
 
287
            part2remain--;
 
288
          } else *xrptr = 0.0;
 
289
          xrptr += step;
 
290
        }
 
291
      }
 
292
      for (; l3 && (part2remain > 0); l3--) {
 
293
        newhuff_t *h = hufftc + grinfo->count1table_select;
 
294
        register int16_t *val = h->table, a;
 
295
        while ((a = *val++) < 0) {
 
296
          part2remain--;
 
297
          if (part2remain < 0) {
 
298
            part2remain++;
 
299
            a = 0;
 
300
            break;
 
301
          }
 
302
          if (GETBITS(1)) val -= a;
 
303
        }
 
304
        for (i = 0; i < 4; i++) {
 
305
          if (!(i & 1)) {
 
306
            if (!mc) {
 
307
              mc = *m++;
 
308
              xrptr = ((MYFLT *)xr) + (*m++);
 
309
              lwin = *m++;
 
310
              cb = *m++;
 
311
              if (lwin == 3) {
 
312
                v = grinfo->pow2gain[(*scf++) << shift];
 
313
                step = 1;
 
314
              } else {
 
315
                v = grinfo->full_gain[lwin][(*scf++) << shift];
 
316
                step = 3;
 
317
              }
 
318
            }
 
319
            mc--;
 
320
          }
 
321
          if (a & (8 >> i)) {
 
322
            max[lwin] = cb;
 
323
            part2remain--;
 
324
            if (part2remain < 0) {
 
325
              part2remain++;
 
326
              break;
 
327
            }
 
328
            if (GETBITS(1)) *xrptr = -v;
 
329
            else *xrptr = v;
 
330
          } else *xrptr = 0.0;
 
331
          xrptr += step;
 
332
        }
 
333
      }
 
334
      if (lwin < 3) {
 
335
        while (1) {
 
336
          for (; mc > 0; mc--) {
 
337
            xrptr[0] = xrptr[3] = 0.0;
 
338
            xrptr += 6;
 
339
          }
 
340
          if (m >= me) break;
 
341
          mc = *m++;
 
342
          xrptr = ((MYFLT *)xr) + (*m++);
 
343
          if ((*m++) == 0) break;
 
344
          m++;
 
345
        }
 
346
      }
 
347
      grinfo->maxband[0] = max[0] + 1;
 
348
      grinfo->maxband[1] = max[1] + 1;
 
349
      grinfo->maxband[2] = max[2] + 1;
 
350
      grinfo->maxbandl = max[3] + 1;
 
351
      {
 
352
        int rmax = max[0] > max[1] ? max[0] : max[1];
 
353
        rmax = (rmax > max[2] ? rmax : max[2]) + 1;
 
354
        grinfo->maxb =
 
355
          rmax ? mpa->tables.short_limit[mpa->frame.frequency_index][rmax] :
 
356
                 mpa->tables.long_limit[mpa->frame.frequency_index][max[3] + 1];
 
357
      }
 
358
    } else {
 
359
      uint8_t *pretab = grinfo->preflag ? pretab1 : pretab2;
 
360
      int32_t i, max = -1, cb = 0, mc = 0;
 
361
      int32_t *m = mpa->tables.map[mpa->frame.frequency_index][2];
 
362
      register MYFLT v = 0.0;
 
363
 
 
364
      for (i = 0; i < 3; i++) {
 
365
        int lp = l[i];
 
366
        newhuff_t *h = hufft + grinfo->table_select[i];
 
367
        for (; lp; lp--, mc--) {
 
368
          register int x, y;
 
369
          if (!mc) {
 
370
            mc = *m++;
 
371
            cb = *m++;
 
372
            if (cb == 21) v = 0.0;
 
373
            else v = grinfo->pow2gain[((*scf++) + (*pretab++)) << shift];
 
374
          }
 
375
          {
 
376
            register int16_t *val = h->table;
 
377
            while ((y = *val++) < 0) {
 
378
              if (GETBITS(1)) val -= y;
 
379
              part2remain--;
 
380
            }
 
381
            x = y >> 4;
 
382
            y &= 0x0F;
 
383
          }
 
384
          if ((x == 15) && h->linbits) {
 
385
            max = cb;
 
386
            part2remain -= h->linbits + 1;
 
387
            x += GETBITS(h->linbits);
 
388
            if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[x]*v;
 
389
            else *xrptr++ = mpa->tables.ispow[x]*v;
 
390
          } else if (x) {
 
391
            max = cb;
 
392
            if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[x]*v;
 
393
            else *xrptr++ = mpa->tables.ispow[x]*v;
 
394
            part2remain--;
 
395
          } else *xrptr++ = 0.0;
 
396
          if ((y == 15) && h->linbits) {
 
397
            max = cb;
 
398
            part2remain -= h->linbits + 1;
 
399
            y += GETBITS(h->linbits);
 
400
            if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[y]*v;
 
401
            else *xrptr++ = mpa->tables.ispow[y]*v;
 
402
          } else if (y) {
 
403
            max = cb;
 
404
            if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[y]*v;
 
405
            else *xrptr++ = mpa->tables.ispow[y]*v;
 
406
            part2remain--;
 
407
          } else *xrptr++ = 0.0;
 
408
        }
 
409
      }
 
410
      for (; l3 && (part2remain > 0); l3--) {
 
411
        newhuff_t *h = hufftc + grinfo->count1table_select;
 
412
        register int16_t *val = h->table, a;
 
413
        while ((a = *val++) < 0) {
 
414
          part2remain--;
 
415
          if (part2remain < 0) {
 
416
            part2remain++;
 
417
            a = 0;
 
418
            break;
 
419
          }
 
420
          if (GETBITS(1)) val -= a;
 
421
        }
 
422
        for (i = 0; i < 4; i++) {
 
423
          if (!(i & 1)) {
 
424
            if (!mc) {
 
425
              mc = *m++;
 
426
              cb = *m++;
 
427
              v = grinfo->pow2gain[((*scf++) + (*pretab++)) << shift];
 
428
            }
 
429
            mc--;
 
430
          }
 
431
          if (a & (8 >> i)) {
 
432
            max = cb;
 
433
            part2remain--;
 
434
            if (part2remain < 0) {
 
435
              part2remain++;
 
436
              break;
 
437
            }
 
438
            if (GETBITS(1)) *xrptr++ = -v;
 
439
            else *xrptr++ = v;
 
440
          } else *xrptr++ = 0.0;
 
441
        }
 
442
      }
 
443
      grinfo->maxbandl = max + 1;
 
444
      grinfo->maxb = mpa->tables.long_limit[mpa->frame.frequency_index][max + 1];
 
445
    }
 
446
    while (xrptr < &xr[SBLIMIT][0]) *xrptr++ = 0.0;
 
447
    while (part2remain > 0) {
 
448
      register unsigned tmp, i = (part2remain > 16) ? 16 : part2remain;
 
449
      tmp = GETBITS(i);
 
450
      part2remain -= i;
 
451
      i = tmp;
 
452
    }
 
453
    mpa->error = (uint8_t)((part2remain < 0) ? TRUE : FALSE);
 
454
    return mpa->error;
 
455
}
 
456
 
 
457
static void III_i_stereo(mpadec_t mpadec, grinfo_t *gr_info,
 
458
                         MYFLT xrbuf[2][SBLIMIT][SSLIMIT], int32_t *scalefac)
 
459
{
 
460
    register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
 
461
    register grinfo_t *grinfo = gr_info;
 
462
    MYFLT (*xr)[SBLIMIT*SSLIMIT] = (MYFLT (*)[SBLIMIT*SSLIMIT])xrbuf;
 
463
    bandinfo_t *bi = &band_info[mpa->frame.frequency_index];
 
464
    int tab = mpa->frame.LSF + (grinfo->scalefac_compress & mpa->frame.LSF);
 
465
    int ms_stereo = ((mpa->frame.mode == MPG_MD_JOINT_STEREO) &&
 
466
                     (mpa->frame.mode_ext & 2)) ? TRUE : FALSE;
 
467
    const MYFLT *tab1, *tab2;
 
468
 
 
469
    tab1 = mpa->tables.istabs[tab][ms_stereo][0];
 
470
    tab2 = mpa->tables.istabs[tab][ms_stereo][1];
 
471
    if (grinfo->block_type == 2) {
 
472
      int lwin, do_l = grinfo->mixed_block_flag;
 
473
      for (lwin = 0; lwin < 3; lwin++) {
 
474
        int32_t is_p, sb, idx, sfb = grinfo->maxband[lwin];
 
475
        if (sfb > 3) do_l = FALSE;
 
476
        for (; sfb < 12; sfb++) {
 
477
          is_p = scalefac[3*sfb + lwin - grinfo->mixed_block_flag];
 
478
          if (is_p != 7) {
 
479
            MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
 
480
            sb = bi->short_diff[sfb];
 
481
            idx = bi->short_idx[sfb] + lwin;
 
482
            for (; sb; sb--, idx += 3) {
 
483
              register MYFLT v = xr[0][idx];
 
484
              xr[0][idx] = v*t1;
 
485
              xr[1][idx] = v*t2;
 
486
            }
 
487
          }
 
488
        }
 
489
        is_p = scalefac[3*11 + lwin - grinfo->mixed_block_flag];
 
490
        sb = bi->short_diff[12];
 
491
        idx = bi->short_idx[12] + lwin;
 
492
        if (is_p != 7) {
 
493
          MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
 
494
          for (; sb; sb--, idx += 3) {
 
495
            register MYFLT v = xr[0][idx];
 
496
            xr[0][idx] = v*t1;
 
497
            xr[1][idx] = v*t2;
 
498
          }
 
499
        }
 
500
      }
 
501
      if (do_l) {
 
502
        int sfb = grinfo->maxbandl;
 
503
        int idx = bi->long_idx[sfb];
 
504
        for (; sfb < 8; sfb++) {
 
505
          int sb = bi->long_diff[sfb];
 
506
          int is_p = scalefac[sfb];
 
507
          if (is_p != 7) {
 
508
            MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
 
509
            for (; sb; sb--, idx++) {
 
510
              register MYFLT v = xr[0][idx];
 
511
              xr[0][idx] = v*t1;
 
512
              xr[1][idx] = v*t2;
 
513
            }
 
514
          } else idx += sb;
 
515
        }
 
516
      }
 
517
    } else {
 
518
      int sfb = grinfo->maxbandl;
 
519
      int is_p, idx = bi->long_idx[sfb];
 
520
      for (; sfb < 21; sfb++) {
 
521
        int sb = bi->long_diff[sfb];
 
522
        is_p = scalefac[sfb];
 
523
        if (is_p != 7) {
 
524
          MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
 
525
          for (; sb; sb--, idx++) {
 
526
            register MYFLT v = xr[0][idx];
 
527
            xr[0][idx] = v*t1;
 
528
            xr[1][idx] = v*t2;
 
529
          }
 
530
        } else idx += sb;
 
531
      }
 
532
      is_p = scalefac[20];
 
533
      if (is_p != 7) {
 
534
        int sb = bi->long_diff[21];
 
535
        MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
 
536
        for (; sb; sb--, idx++) {
 
537
          register MYFLT v = xr[0][idx];
 
538
          xr[0][idx] = v*t1;
 
539
          xr[1][idx] = v*t2;
 
540
        }
 
541
      }
 
542
    }
 
543
}
 
544
 
 
545
static void III_antialias(grinfo_t *gr_info, MYFLT xr[SBLIMIT][SSLIMIT])
 
546
{
 
547
    register grinfo_t *grinfo = gr_info;
 
548
    int sblim;
 
549
 
 
550
    if (grinfo->block_type == 2) {
 
551
      if (!grinfo->mixed_block_flag) return;
 
552
      sblim = 1;
 
553
    } else sblim = grinfo->maxb - 1;
 
554
    {
 
555
      int sb;
 
556
      MYFLT *xr1 = (MYFLT *)xr[1];
 
557
      for (sb = sblim; sb; sb--, xr1 += 10) {
 
558
        int ss;
 
559
        MYFLT *xr2 = xr1;
 
560
        for (ss = 0; ss < 8; ss++) {
 
561
          register MYFLT bu = *--xr2, bd = *xr1;
 
562
          *xr2 = bu*cs[ss] - bd*ca[ss];
 
563
          *xr1++ = bd*cs[ss] + bu*ca[ss];
 
564
        }
 
565
      }
 
566
    }
 
567
}
 
568
 
 
569
static void dct36(register MYFLT *in, register MYFLT *out1,
 
570
                  register MYFLT *out2, register MYFLT *w, register MYFLT *ts)
 
571
{
 
572
    MYFLT tmp[18];
 
573
 
 
574
    {
 
575
      in[17] += in[16]; in[16] += in[15]; in[15] += in[14];
 
576
      in[14] += in[13]; in[13] += in[12]; in[12] += in[11];
 
577
      in[11] += in[10]; in[10] += in[9];  in[9]  += in[8];
 
578
      in[8]  += in[7];  in[7]  += in[6];  in[6]  += in[5];
 
579
      in[5]  += in[4];  in[4]  += in[3];  in[3]  += in[2];
 
580
      in[2]  += in[1];  in[1]  += in[0];
 
581
 
 
582
      in[17] += in[15]; in[15] += in[13]; in[13] += in[11]; in[11] += in[9];
 
583
      in[9]  += in[7];  in[7]  += in[5];  in[5]  += in[3];  in[3]  += in[1];
 
584
 
 
585
      {
 
586
        MYFLT t3;
 
587
        {
 
588
          MYFLT t0, t1, t2;
 
589
 
 
590
          t0 = newcos[7]*(in[8] + in[16] - in[4]);
 
591
          t1 = newcos[7]*in[12];
 
592
          t3 = in[0];
 
593
          t2 = t3 - t1 - t1;
 
594
          tmp[1] = tmp[7] = t2 - t0;
 
595
          tmp[4] = t2 + t0 + t0;
 
596
          t3 += t1;
 
597
          t2 = newcos[6]*(in[10] + in[14] - in[2]);
 
598
          tmp[1] -= t2;
 
599
          tmp[7] += t2;
 
600
        }
 
601
        {
 
602
          MYFLT t0, t1, t2;
 
603
 
 
604
          t0 = newcos[0]*(in[4] + in[8]);
 
605
          t1 = newcos[1]*(in[8] - in[16]);
 
606
          t2 = newcos[2]*(in[4] + in[16]);
 
607
          tmp[2] = tmp[6] = t3 - t0 - t2;
 
608
          tmp[0] = tmp[8] = t3 + t0 + t1;
 
609
          tmp[3] = tmp[5] = t3 - t1 + t2;
 
610
        }
 
611
      }
 
612
      {
 
613
        MYFLT t1, t2, t3;
 
614
 
 
615
        t1 = newcos[3]*(in[2] + in[10]);
 
616
        t2 = newcos[4]*(in[10] - in[14]);
 
617
        t3 = newcos[6]*in[6];
 
618
        {
 
619
          MYFLT t0 = t1 + t2 + t3;
 
620
          tmp[0] += t0;
 
621
          tmp[8] -= t0;
 
622
        }
 
623
        t2 -= t3;
 
624
        t1 -= t3;
 
625
        t3 = newcos[5]*(in[2] + in[14]);
 
626
        t1 += t3;
 
627
        tmp[3] += t1;
 
628
        tmp[5] -= t1;
 
629
        t2 -= t3;
 
630
        tmp[2] += t2;
 
631
        tmp[6] -= t2;
 
632
      }
 
633
      {
 
634
        MYFLT t0, t1, t2, t3, t4, t5, t6, t7;
 
635
 
 
636
        t1 = newcos[7]*in[13];
 
637
        t2 = newcos[7]*(in[9] + in[17] - in[5]);
 
638
        t3 = in[1] + t1;
 
639
        t4 = in[1] - t1 - t1;
 
640
        t5 = t4 - t2;
 
641
        t0 = newcos[0]*(in[5] + in[9]);
 
642
        t1 = newcos[1]*(in[9] - in[17]);
 
643
        tmp[13] = (t4 + t2 + t2)*tfcos36[17 - 13];
 
644
        t2 = newcos[2]*(in[5] + in[17]);
 
645
        t6 = t3 - t0 - t2;
 
646
        t0 += t3 + t1;
 
647
        t3 += t2 - t1;
 
648
        t2 = newcos[3]*(in[3] + in[11]);
 
649
        t4 = newcos[4]*(in[11] - in[15]);
 
650
        t7 = newcos[6]*in[7];
 
651
        t1 = t2 + t4 + t7;
 
652
        tmp[17] = (t0 + t1)*tfcos36[17 - 17];
 
653
        tmp[9] = (t0 - t1)*tfcos36[17 - 9];
 
654
        t1 = newcos[5]*(in[3] + in[15]);
 
655
        t2 += t1 - t7;
 
656
        tmp[14] = (t3 + t2)*tfcos36[17 - 14];
 
657
        t0 = newcos[6]*(in[11] + in[15] - in[3]);
 
658
        tmp[12] = (t3 - t2)*tfcos36[17 - 12];
 
659
        t4 -= t1 + t7;
 
660
        tmp[16] = (t5 - t0)*tfcos36[17 - 16];
 
661
        tmp[10] = (t5 + t0)*tfcos36[17 - 10];
 
662
        tmp[15] = (t6 + t4)*tfcos36[17 - 15];
 
663
        tmp[11] = (t6 - t4)*tfcos36[17 - 11];
 
664
      }
 
665
    }
 
666
#define DCT36_MACRO(v) {                                                \
 
667
      register MYFLT tmpval = tmp[(v)] + tmp[17 - (v)];                 \
 
668
      out2[9 + (v)] = tmpval*w[27 + (v)];                               \
 
669
      out2[8 - (v)] = tmpval*w[26 - (v)];                               \
 
670
      tmpval = tmp[(v)] - tmp[17 - (v)];                                \
 
671
      ts[SBLIMIT*(8 - (v))] = out1[8 - (v)] + tmpval*w[8 - (v)];        \
 
672
      ts[SBLIMIT*(9 + (v))] = out1[9 + (v)] + tmpval*w[9 + (v)];        \
 
673
    }
 
674
    {
 
675
      DCT36_MACRO(0);
 
676
      DCT36_MACRO(1);
 
677
      DCT36_MACRO(2);
 
678
      DCT36_MACRO(3);
 
679
      DCT36_MACRO(4);
 
680
      DCT36_MACRO(5);
 
681
      DCT36_MACRO(6);
 
682
      DCT36_MACRO(7);
 
683
      DCT36_MACRO(8);
 
684
    }
 
685
#undef DCT36_MACRO
 
686
}
 
687
 
 
688
 
 
689
static void dct12(register MYFLT *in, register MYFLT *out1,
 
690
                  register MYFLT *out2, register MYFLT *w, register MYFLT *ts)
 
691
{
 
692
#define DCT12_PART1 in5 = in[5*3];              \
 
693
    in5 += (in4 = in[4*3]);                     \
 
694
    in4 += (in3 = in[3*3]);                     \
 
695
    in3 += (in2 = in[2*3]);                     \
 
696
    in2 += (in1 = in[1*3]);                     \
 
697
    in1 += (in0 = in[0*3]);                     \
 
698
    in5 += in3; in3 += in1;                     \
 
699
    in2 *= newcos[6];                           \
 
700
    in3 *= newcos[6];
 
701
 
 
702
#define DCT12_PART2 in0 += in4*newcos[7];       \
 
703
    in4 = in0 + in2;                            \
 
704
    in0 -= in2;                                 \
 
705
    in1 += in5*newcos[7];                       \
 
706
    in5 = (in1 + in3)*tfcos12[0];               \
 
707
    in1 = (in1 - in3)*tfcos12[2];               \
 
708
    in3 = in4 + in5;                            \
 
709
    in4 -= in5;                                 \
 
710
    in2 = in0 + in1;                            \
 
711
    in0 -= in1;
 
712
 
 
713
    {
 
714
      MYFLT in0, in1, in2, in3, in4, in5;
 
715
 
 
716
      ts[0*SBLIMIT] = out1[0]; ts[1*SBLIMIT] = out1[1]; ts[2*SBLIMIT] = out1[2];
 
717
      ts[3*SBLIMIT] = out1[3]; ts[4*SBLIMIT] = out1[4]; ts[5*SBLIMIT] = out1[5];
 
718
 
 
719
      DCT12_PART1
 
720
 
 
721
        {
 
722
          register MYFLT tmp0, tmp1 = in0 - in4;
 
723
          {
 
724
            register MYFLT tmp2 = (in1 - in5)*tfcos12[1];
 
725
            tmp0 = tmp1 + tmp2;
 
726
            tmp1 -= tmp2;
 
727
          }
 
728
          ts[(17 - 1)*SBLIMIT] = out1[17 - 1] + tmp0*w[11 - 1];
 
729
          ts[(12 + 1)*SBLIMIT] = out1[12 + 1] + tmp0*w[6 + 1];
 
730
          ts[(6 + 1)*SBLIMIT] = out1[6 + 1] + tmp1*w[1];
 
731
          ts[(11 - 1)*SBLIMIT] = out1[11 - 1] + tmp1*w[5 - 1];
 
732
        }
 
733
 
 
734
      DCT12_PART2
 
735
 
 
736
        ts[(17 - 0)*SBLIMIT] = out1[17 - 0] + in2*w[11 - 0];
 
737
      ts[(12 + 0)*SBLIMIT] = out1[12 + 0] + in2*w[6 + 0];
 
738
      ts[(12 + 2)*SBLIMIT] = out1[12 + 2] + in3*w[6 + 2];
 
739
      ts[(17 - 2)*SBLIMIT] = out1[17 - 2] + in3*w[11 - 2];
 
740
      ts[(6 + 0)*SBLIMIT]  = out1[6 + 0] + in0*w[0];
 
741
      ts[(11 - 0)*SBLIMIT] = out1[11 - 0] + in0*w[5 - 0];
 
742
      ts[(6 + 2)*SBLIMIT]  = out1[6 + 2] + in4*w[2];
 
743
      ts[(11 - 2)*SBLIMIT] = out1[11 - 2] + in4*w[5 - 2];
 
744
    }
 
745
    in++;
 
746
    {
 
747
      MYFLT in0, in1, in2, in3, in4, in5;
 
748
 
 
749
      DCT12_PART1
 
750
 
 
751
        {
 
752
          register MYFLT tmp0, tmp1 = in0 - in4;
 
753
          {
 
754
            register MYFLT tmp2 = (in1 - in5)*tfcos12[1];
 
755
            tmp0 = tmp1 + tmp2;
 
756
            tmp1 -= tmp2;
 
757
          }
 
758
          out2[5 - 1] = tmp0*w[11 - 1];
 
759
          out2[0 + 1] = tmp0*w[6 + 1];
 
760
          ts[(12 + 1)*SBLIMIT] += tmp1*w[0 + 1];
 
761
          ts[(17 - 1)*SBLIMIT] += tmp1*w[5 - 1];
 
762
        }
 
763
 
 
764
      DCT12_PART2
 
765
 
 
766
        out2[5 - 0] = in2*w[11 - 0];
 
767
      out2[0 + 0] = in2*w[6 + 0];
 
768
      out2[0 + 2] = in3*w[6 + 2];
 
769
      out2[5 - 2] = in3*w[11 - 2];
 
770
      ts[(12 + 0)*SBLIMIT] += in0*w[0];
 
771
      ts[(17 - 0)*SBLIMIT] += in0*w[5 - 0];
 
772
      ts[(12 + 2)*SBLIMIT] += in4*w[2];
 
773
      ts[(17 - 2)*SBLIMIT] += in4*w[5 - 2];
 
774
    }
 
775
    in++;
 
776
    {
 
777
      MYFLT in0, in1, in2, in3, in4, in5;
 
778
 
 
779
      out2[12] = out2[13] = out2[14] = out2[15] = out2[16] = out2[17] = 0.0;
 
780
 
 
781
      DCT12_PART1
 
782
 
 
783
        {
 
784
          register MYFLT tmp0, tmp1 = in0 - in4;
 
785
          {
 
786
            register MYFLT tmp2 = (in1 - in5)*tfcos12[1];
 
787
            tmp0 = tmp1 + tmp2;
 
788
            tmp1 -= tmp2;
 
789
          }
 
790
          out2[11 - 1] = tmp0*w[11 - 1];
 
791
          out2[6 + 1] = tmp0*w[6 + 1];
 
792
          out2[0 + 1] += tmp1*w[1];
 
793
          out2[5 - 1] += tmp1*w[5 - 1];
 
794
        }
 
795
 
 
796
      DCT12_PART2
 
797
 
 
798
        out2[11 - 0] = in2*w[11 - 0];
 
799
      out2[6 + 0] = in2*w[6 + 0];
 
800
      out2[6 + 2] = in3*w[6 + 2];
 
801
      out2[11 - 2] = in3*w[11 - 2];
 
802
      out2[0 + 0] += in0*w[0];
 
803
      out2[5 - 0] += in0*w[5 - 0];
 
804
      out2[0 + 2] += in4*w[2];
 
805
      out2[5 - 2] += in4*w[5 - 2];
 
806
    }
 
807
#undef DCT12_PART1
 
808
#undef DCT12_PART2
 
809
}
 
810
 
 
811
static void III_hybrid(mpadec_t mpadec, grinfo_t *gr_info,
 
812
                       MYFLT fs_in[SBLIMIT][SSLIMIT], 
 
813
                       MYFLT ts_out[SSLIMIT][SBLIMIT], int channel)
 
814
{
 
815
    register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
 
816
    register grinfo_t *grinfo = gr_info;
 
817
    MYFLT *tsptr = (MYFLT *)ts_out;
 
818
    MYFLT *out1, *out2;
 
819
    unsigned bt = grinfo->block_type, sb = 0;
 
820
 
 
821
    {
 
822
      register unsigned b = mpa->hybrid_block[channel];
 
823
      out1 = mpa->hybrid_buffers[b][channel];
 
824
      b ^= 1;
 
825
      out2 = mpa->hybrid_buffers[b][channel];
 
826
      mpa->hybrid_block[channel] = (uint8_t)b;
 
827
    }
 
828
    if (grinfo->mixed_block_flag) {
 
829
      sb = 2;
 
830
      dct36(fs_in[0], out1, out2, mpa->tables.win[0][0], tsptr);
 
831
      dct36(fs_in[1], out1 + SSLIMIT, out2 + SSLIMIT,
 
832
            mpa->tables.win[1][0], tsptr + 1);
 
833
      out1 += 36; out2 += 36; tsptr += 2;
 
834
    }
 
835
    if (bt == 2) {
 
836
      for (; sb < grinfo->maxb; sb += 2, out1 += 36, out2 += 36, tsptr += 2) {
 
837
        dct12(fs_in[sb], out1, out2, mpa->tables.win[0][2], tsptr);
 
838
        dct12(fs_in[sb + 1], out1 + SSLIMIT, out2 + SSLIMIT,
 
839
              mpa->tables.win[1][2], tsptr + 1);
 
840
      }
 
841
    } else {
 
842
      for (; sb < grinfo->maxb; sb += 2, out1 += 36, out2 += 36, tsptr += 2) {
 
843
        dct36(fs_in[sb], out1, out2, mpa->tables.win[0][bt], tsptr);
 
844
        dct36(fs_in[sb + 1], out1 + SSLIMIT, out2 + SSLIMIT,
 
845
              mpa->tables.win[1][bt], tsptr + 1);
 
846
      }
 
847
    }
 
848
    for (; sb < SBLIMIT; sb++, tsptr++) {
 
849
      register int i;
 
850
      for (i = 0; i < SSLIMIT; i++) {
 
851
        tsptr[i*SBLIMIT] = *out1++;
 
852
        *out2++ = 0.0;
 
853
      }
 
854
    }
 
855
}
 
856
 
 
857
void decode_layer3(mpadec_t mpadec, uint8_t *buffer)
 
858
{
 
859
    register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
 
860
    uint8_t *saved_next_byte = mpa->next_byte;
 
861
    uint32_t saved_bytes_left = mpa->bytes_left;
 
862
    int32_t dbits, scalefacs[2][39];
 
863
    int ch, gr, ss, i_stereo, ms_stereo, single, channels, 
 
864
      granules = mpa->frame.LSF ? 1 : 2;
 
865
 
 
866
    mpa->error = FALSE;
 
867
    mpa->bits_left = 0;
 
868
    if (mpa->config.crc && mpa->frame.CRC) {
 
869
      mpa->crc = update_crc(mpa->crc, mpa->next_byte, mpa->ssize << 3);
 
870
      if (mpa->crc != mpa->frame.crc) mpa->error = TRUE;
 
871
    }
 
872
    dbits = decode_layer3_sideinfo(mpa);
 
873
    mpa->dsize = (((dbits < 0) ? 0 : dbits) + 7) >> 3;
 
874
    mpa->next_byte = saved_next_byte + mpa->ssize;
 
875
    mpa->bytes_left = saved_bytes_left - mpa->ssize;
 
876
    mpa->bits_left = 0;
 
877
    saved_next_byte = NULL;
 
878
    saved_bytes_left = mpa->bytes_left;
 
879
    if (mpa->error) mpa->sideinfo.main_data_begin = mpa->reservoir_size + 1;
 
880
    if (mpa->sideinfo.main_data_begin) {
 
881
      if (mpa->sideinfo.main_data_begin <= mpa->reservoir_size) {
 
882
        uint8_t *ptr = mpa->reservoir + mpa->reservoir_size;
 
883
        uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
 
884
        if (tmp > (sizeof(mpa->reservoir) - mpa->reservoir_size))
 
885
          tmp = sizeof(mpa->reservoir) - mpa->reservoir_size;
 
886
        saved_next_byte = mpa->next_byte;
 
887
        memcpy(ptr, mpa->next_byte, tmp);
 
888
        mpa->next_byte = ptr - mpa->sideinfo.main_data_begin;
 
889
        mpa->bytes_left = mpa->sideinfo.main_data_begin + tmp;
 
890
      } else {
 
891
        uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
 
892
        if (tmp > 512) {
 
893
          mpa->next_byte += tmp - 512;
 
894
          mpa->bytes_left -= tmp - 512;
 
895
          tmp = 512;
 
896
        }
 
897
        if ((mpa->reservoir_size) && (mpa->reservoir_size > 512)) {
 
898
          memmove(mpa->reservoir, mpa->reservoir + mpa->reservoir_size - 512, 512);
 
899
          mpa->reservoir_size = 512;
 
900
        }
 
901
        memcpy(mpa->reservoir + mpa->reservoir_size, mpa->next_byte, tmp);
 
902
        mpa->reservoir_size += tmp;
 
903
        mpa->next_byte += tmp;
 
904
        mpa->bytes_left -= tmp;
 
905
        memset(buffer, 0, mpa->frame.decoded_size);
 
906
        mpa->error = TRUE;
 
907
        return;
 
908
      }
 
909
    }
 
910
    if (mpa->frame.mode == MPG_MD_JOINT_STEREO) {
 
911
      i_stereo = mpa->frame.mode_ext & 1;
 
912
      ms_stereo = (mpa->frame.mode_ext & 2) >> 1;
 
913
    } else i_stereo = ms_stereo = 0;
 
914
    if (mpa->frame.channels > 1) switch (mpa->config.mode) {
 
915
      case MPADEC_CONFIG_MONO:     single = 0; break;
 
916
      case MPADEC_CONFIG_CHANNEL1: single = 1; break;
 
917
      case MPADEC_CONFIG_CHANNEL2: single = 2; break;
 
918
      default:                     single = -1; break;
 
919
      } else single = 1;
 
920
    channels = (single < 0) ? 2 : 1;
 
921
    for (gr = 0; gr < granules; gr++) {
 
922
      grinfo_t *grinfo = &mpa->sideinfo.ch[0].gr[gr];
 
923
      int32_t part2bits = III_get_scale_factors(mpa, grinfo, scalefacs[0]);
 
924
      if (III_decode_samples(mpa, grinfo, mpa->hybrid_in[0], scalefacs[0],
 
925
                             part2bits)) {
 
926
        unsigned size = mpa->frame.decoded_size;
 
927
        if (!mpa->frame.LSF && gr) size >>= 1;
 
928
        memset(buffer, 0, size);
 
929
        mpa->error = TRUE;
 
930
        goto done;
 
931
      }
 
932
      if (mpa->frame.channels > 1) {
 
933
        grinfo = &mpa->sideinfo.ch[1].gr[gr];
 
934
        part2bits = III_get_scale_factors(mpa, grinfo, scalefacs[1]);
 
935
        if (III_decode_samples(mpa, grinfo, mpa->hybrid_in[1], scalefacs[1],
 
936
                               part2bits)) {
 
937
          unsigned size = mpa->frame.decoded_size;
 
938
          if (!mpa->frame.LSF && gr) size >>= 1;
 
939
          memset(buffer, 0, size);
 
940
          mpa->error = TRUE;
 
941
          goto done;
 
942
        }
 
943
        if (ms_stereo) {
 
944
          MYFLT *in0 = (MYFLT *)(mpa->hybrid_in[0]),
 
945
                *in1 = (MYFLT *)(mpa->hybrid_in[1]);
 
946
          unsigned i, maxb = mpa->sideinfo.ch[0].gr[gr].maxb;
 
947
          if (mpa->sideinfo.ch[1].gr[gr].maxb > maxb)
 
948
            maxb = mpa->sideinfo.ch[1].gr[gr].maxb;
 
949
          for (i = 0; i < SSLIMIT*maxb; i++) {
 
950
            register MYFLT tmp0 = in0[i];
 
951
            register MYFLT tmp1 = in1[i];
 
952
            in0[i] = tmp0 + tmp1;
 
953
            in1[i] = tmp0 - tmp1;
 
954
          }
 
955
        }
 
956
        if (i_stereo) III_i_stereo(mpa, grinfo, mpa->hybrid_in, scalefacs[1]);
 
957
        if (i_stereo || ms_stereo || !single) {
 
958
          if (grinfo->maxb > mpa->sideinfo.ch[0].gr[gr].maxb)
 
959
            mpa->sideinfo.ch[0].gr[gr].maxb = grinfo->maxb;
 
960
          else grinfo->maxb = mpa->sideinfo.ch[0].gr[gr].maxb;
 
961
        }
 
962
        if (!single) {
 
963
          register unsigned i;
 
964
          MYFLT *in0 = (MYFLT *)(mpa->hybrid_in[0]), 
 
965
                *in1 = (MYFLT *)(mpa->hybrid_in[1]);
 
966
          for (i = 0; i < SSLIMIT*grinfo->maxb; i++, in0++)
 
967
            *in0 = (*in0 + *in1++);
 
968
        } else if (single == 2) {
 
969
          register unsigned i;
 
970
          MYFLT *in0 = (MYFLT *)(mpa->hybrid_in[0]), 
 
971
                *in1 = (MYFLT *)(mpa->hybrid_in[1]);
 
972
          for (i = 0; i < SSLIMIT*grinfo->maxb; i++, in0++) *in0 = *in1++;
 
973
        }
 
974
      }
 
975
      for (ch = 0; ch < channels; ch++) {
 
976
        grinfo = &mpa->sideinfo.ch[ch].gr[gr];
 
977
        III_antialias(grinfo, mpa->hybrid_in[ch]);
 
978
        III_hybrid(mpa, grinfo, mpa->hybrid_in[ch], mpa->hybrid_out[ch], ch);
 
979
      }
 
980
      if (single < 0) {
 
981
        for (ss = 0; ss < SSLIMIT; ss++, buffer += mpa->synth_size) {
 
982
          mpa->synth_func(mpa, mpa->hybrid_out[0][ss], 0, buffer);
 
983
          mpa->synth_func(mpa, mpa->hybrid_out[1][ss], 1, buffer);
 
984
        }
 
985
      } else {
 
986
        for (ss = 0; ss < SSLIMIT; ss++, buffer += mpa->synth_size) {
 
987
          mpa->synth_func(mpa, mpa->hybrid_out[0][ss], 0, buffer);
 
988
        }
 
989
      }
 
990
    }
 
991
 done:
 
992
    {
 
993
      register unsigned n = mpa->bits_left >> 3;
 
994
      mpa->next_byte -= n;
 
995
      mpa->bytes_left += n;
 
996
      if (saved_next_byte) {
 
997
        uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
 
998
        if (mpa->bytes_left) {
 
999
          if (mpa->bytes_left > 512) {
 
1000
            mpa->next_byte += mpa->bytes_left - 512;
 
1001
            mpa->bytes_left = 512;
 
1002
          }
 
1003
          memmove(mpa->reservoir, mpa->next_byte, mpa->bytes_left);
 
1004
          mpa->reservoir_size = mpa->bytes_left;
 
1005
        } else mpa->reservoir_size = 0;
 
1006
        mpa->next_byte = saved_next_byte + tmp;
 
1007
        mpa->bytes_left = saved_bytes_left - tmp;
 
1008
      } else {
 
1009
        uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
 
1010
        mpa->reservoir_size = 0;
 
1011
        if (tmp > (saved_bytes_left - mpa->bytes_left)) {
 
1012
          tmp -= saved_bytes_left - mpa->bytes_left;
 
1013
          if (tmp > 512) {
 
1014
            mpa->next_byte += tmp - 512;
 
1015
            mpa->bytes_left -= tmp - 512;
 
1016
            tmp = 512;
 
1017
          }
 
1018
          memcpy(mpa->reservoir, mpa->next_byte, tmp);
 
1019
          mpa->reservoir_size = tmp;
 
1020
          mpa->next_byte += tmp;
 
1021
          mpa->bytes_left -= tmp;
 
1022
        }
 
1023
      }
 
1024
    }
 
1025
}
 
1026