2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or
8 ** (at your option) any later version.
10 ** This program is distributed in the hope that it will be useful,
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 ** GNU General Public License for more details.
15 ** You should have received a copy of the GNU General Public License
16 ** along with this program; if not, write to the Free Software
17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 ** Any non-GPL usage of this software or parts of this software is strictly
22 ** The "appropriate copyright message" mentioned in section 2c of the GPLv2
23 ** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
25 ** Commercial non-GPL licensing of this software is possible.
26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
28 ** $Id: hcr.c,v 1.26 2009/01/26 23:51:15 menno Exp $
40 /* ISO/IEC 14496-3/Amd.1
41 * 8.5.3.3: Huffman Codeword Reordering for AAC spectral data (HCR)
43 * HCR devides the spectral data in known fixed size segments, and
44 * sorts it by the importance of the data. The importance is firstly
45 * the (lower) position in the spectrum, and secondly the largest
46 * value in the used codebook.
47 * The most important data is written at the start of each segment
48 * (at known positions), the remaining data is interleaved inbetween,
49 * with the writing direction alternating.
50 * Data length is not increased.
53 #ifdef ERROR_RESILIENCE
55 /* 8.5.3.3.1 Pre-sorting */
60 #define VCB11_FIRST 16
63 static const uint8_t PreSortCB_STD[NUM_CB] =
66 static const uint8_t PreSortCB_ER[NUM_CB_ER] =
67 { 11, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 9, 7, 5, 3, 1};
69 /* 8.5.3.3.2 Derivation of segment width */
71 static const uint8_t maxCwLen[MAX_CB] = {0, 11, 9, 20, 16, 13, 11, 14, 12, 17, 14, 49,
72 0, 0, 0, 0, 14, 17, 21, 21, 25, 25, 29, 29, 29, 29, 33, 33, 33, 37, 37, 41};
74 #define segmentWidth(cb) min(maxCwLen[cb], ics->length_of_longest_codeword)
76 /* bit-twiddling helpers */
77 static const uint8_t S[] = {1, 2, 4, 8, 16};
78 static const uint32_t B[] = {0x55555555, 0x33333333, 0x0F0F0F0F, 0x00FF00FF, 0x0000FFFF};
88 /* rewind and reverse */
90 static uint32_t rewrev_word(uint32_t v, const uint8_t len)
93 v = ((v >> S[0]) & B[0]) | ((v << S[0]) & ~B[0]);
94 v = ((v >> S[1]) & B[1]) | ((v << S[1]) & ~B[1]);
95 v = ((v >> S[2]) & B[2]) | ((v << S[2]) & ~B[2]);
96 v = ((v >> S[3]) & B[3]) | ((v << S[3]) & ~B[3]);
97 v = ((v >> S[4]) & B[4]) | ((v << S[4]) & ~B[4]);
99 /* shift off low bits */
106 static void rewrev_lword(uint32_t *hi, uint32_t *lo, const uint8_t len)
110 *lo = rewrev_word(*lo, len);
113 uint32_t t = *hi, v = *lo;
115 /* double 32 bit reverse */
116 v = ((v >> S[0]) & B[0]) | ((v << S[0]) & ~B[0]);
117 t = ((t >> S[0]) & B[0]) | ((t << S[0]) & ~B[0]);
118 v = ((v >> S[1]) & B[1]) | ((v << S[1]) & ~B[1]);
119 t = ((t >> S[1]) & B[1]) | ((t << S[1]) & ~B[1]);
120 v = ((v >> S[2]) & B[2]) | ((v << S[2]) & ~B[2]);
121 t = ((t >> S[2]) & B[2]) | ((t << S[2]) & ~B[2]);
122 v = ((v >> S[3]) & B[3]) | ((v << S[3]) & ~B[3]);
123 t = ((t >> S[3]) & B[3]) | ((t << S[3]) & ~B[3]);
124 v = ((v >> S[4]) & B[4]) | ((v << S[4]) & ~B[4]);
125 t = ((t >> S[4]) & B[4]) | ((t << S[4]) & ~B[4]);
127 /* last 32<>32 bit swap is implicit below */
129 /* shift off low bits (this is really only one 64 bit shift) */
130 *lo = (t >> (64 - len)) | (v << (len - 32));
131 *hi = v >> (64 - len);
137 static void rewrev_bits(bits_t *bits)
139 if (bits->len == 0) return;
140 rewrev_lword(&bits->bufb, &bits->bufa, bits->len);
144 /* merge bits of a to b */
145 static void concat_bits(bits_t *b, bits_t *a)
147 uint32_t bl, bh, al, ah;
149 if (a->len == 0) return;
156 /* maskoff superfluous high b bits */
158 bh = b->bufb & ((1 << (b->len-32)) - 1);
159 /* left shift a b->len bits */
160 ah = al << (b->len - 32);
163 bl = b->bufa & ((1 << (b->len)) - 1);
165 ah = (ah << (b->len)) | (al >> (32 - b->len));
176 static uint8_t is_good_cb(uint8_t this_CB, uint8_t this_sec_CB)
178 /* only want spectral data CB's */
179 if ((this_sec_CB > ZERO_HCB && this_sec_CB <= ESC_HCB) || (this_sec_CB >= VCB11_FIRST && this_sec_CB <= VCB11_LAST))
181 if (this_CB < ESC_HCB)
183 /* normal codebook pairs */
184 return ((this_sec_CB == this_CB) || (this_sec_CB == this_CB + 1));
187 /* escape codebook */
188 return (this_sec_CB == this_CB);
194 static void read_segment(bits_t *segment, uint8_t segwidth, bitfile *ld)
196 segment->len = segwidth;
200 segment->bufb = faad_getbits(ld, segwidth - 32);
201 segment->bufa = faad_getbits(ld, 32);
204 segment->bufa = faad_getbits(ld, segwidth);
209 static void fill_in_codeword(codeword_t *codeword, uint16_t index, uint16_t sp, uint8_t cb)
211 codeword[index].sp_offset = sp;
212 codeword[index].cb = cb;
213 codeword[index].decoded = 0;
214 codeword[index].bits.len = 0;
217 uint8_t reordered_spectral_data(NeAACDecStruct *hDecoder, ic_stream *ics,
218 bitfile *ld, int16_t *spectral_data)
221 uint16_t numberOfSegments, numberOfSets, numberOfCodewords;
223 codeword_t codeword[512];
226 uint16_t sp_offset[8];
227 uint16_t g, i, sortloop, set, bitsread;
228 uint16_t bitsleft, codewordsleft;
229 uint8_t w_idx, sfb, this_CB, last_CB, this_sec_CB;
231 const uint16_t nshort = hDecoder->frameLength/8;
232 const uint16_t sp_data_len = ics->length_of_reordered_spectral_data;
234 const uint8_t *PreSortCb;
236 /* no data (e.g. silence) */
237 if (sp_data_len == 0)
240 /* since there is spectral data, at least one codeword has nonzero length */
241 if (ics->length_of_longest_codeword == 0)
244 if (sp_data_len < ics->length_of_longest_codeword)
248 for (g = 1; g < ics->num_window_groups; g++)
250 sp_offset[g] = sp_offset[g-1] + nshort*ics->window_group_length[g-1];
254 numberOfSegments = 0;
255 numberOfCodewords = 0;
258 /* VCB11 code books in use */
259 if (hDecoder->aacSectionDataResilienceFlag)
261 PreSortCb = PreSortCB_ER;
265 PreSortCb = PreSortCB_STD;
269 /* step 1: decode PCW's (set 0), and stuff data in easier-to-use format */
270 for (sortloop = 0; sortloop < last_CB; sortloop++)
272 /* select codebook to process this pass */
273 this_CB = PreSortCb[sortloop];
276 for (sfb = 0; sfb < ics->max_sfb; sfb++)
278 /* loop over all in this sfb, 4 lines per loop */
279 for (w_idx = 0; 4*w_idx < (min(ics->swb_offset[sfb+1], ics->swb_offset_max) - ics->swb_offset[sfb]); w_idx++)
281 for(g = 0; g < ics->num_window_groups; g++)
283 for (i = 0; i < ics->num_sec[g]; i++)
285 /* check whether sfb used here is the one we want to process */
286 if ((ics->sect_start[g][i] <= sfb) && (ics->sect_end[g][i] > sfb))
288 /* check whether codebook used here is the one we want to process */
289 this_sec_CB = ics->sect_cb[g][i];
291 if (is_good_cb(this_CB, this_sec_CB))
293 /* precalculate some stuff */
294 uint16_t sect_sfb_size = ics->sect_sfb_offset[g][sfb+1] - ics->sect_sfb_offset[g][sfb];
295 uint8_t inc = (this_sec_CB < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN;
296 uint16_t group_cws_count = (4*ics->window_group_length[g])/inc;
297 uint8_t segwidth = segmentWidth(this_sec_CB);
300 /* read codewords until end of sfb or end of window group (shouldn't only 1 trigger?) */
301 for (cws = 0; (cws < group_cws_count) && ((cws + w_idx*group_cws_count) < sect_sfb_size); cws++)
303 uint16_t sp = sp_offset[g] + ics->sect_sfb_offset[g][sfb] + inc * (cws + w_idx*group_cws_count);
305 /* read and decode PCW */
308 /* read in normal segments */
309 if (bitsread + segwidth <= sp_data_len)
311 read_segment(&segment[numberOfSegments], segwidth, ld);
312 bitsread += segwidth;
314 huffman_spectral_data_2(this_sec_CB, &segment[numberOfSegments], &spectral_data[sp]);
316 /* keep leftover bits */
317 rewrev_bits(&segment[numberOfSegments]);
321 /* remaining stuff after last segment, we unfortunately couldn't read
322 this in earlier because it might not fit in 64 bits. since we already
323 decoded (and removed) the PCW it is now guaranteed to fit */
324 if (bitsread < sp_data_len)
326 const uint8_t additional_bits = sp_data_len - bitsread;
328 read_segment(&segment[numberOfSegments], additional_bits, ld);
329 segment[numberOfSegments].len += segment[numberOfSegments-1].len;
330 rewrev_bits(&segment[numberOfSegments]);
332 if (segment[numberOfSegments-1].len > 32)
334 segment[numberOfSegments-1].bufb = segment[numberOfSegments].bufb +
335 showbits_hcr(&segment[numberOfSegments-1], segment[numberOfSegments-1].len - 32);
336 segment[numberOfSegments-1].bufa = segment[numberOfSegments].bufa +
337 showbits_hcr(&segment[numberOfSegments-1], 32);
339 segment[numberOfSegments-1].bufa = segment[numberOfSegments].bufa +
340 showbits_hcr(&segment[numberOfSegments-1], segment[numberOfSegments-1].len);
341 segment[numberOfSegments-1].bufb = segment[numberOfSegments].bufb;
343 segment[numberOfSegments-1].len += additional_bits;
345 bitsread = sp_data_len;
348 fill_in_codeword(codeword, 0, sp, this_sec_CB);
351 fill_in_codeword(codeword, numberOfCodewords - numberOfSegments, sp, this_sec_CB);
363 if (numberOfSegments == 0)
366 numberOfSets = numberOfCodewords / numberOfSegments;
368 /* step 2: decode nonPCWs */
369 for (set = 1; set <= numberOfSets; set++)
373 for (trial = 0; trial < numberOfSegments; trial++)
375 uint16_t codewordBase;
377 for (codewordBase = 0; codewordBase < numberOfSegments; codewordBase++)
379 const uint16_t segment_idx = (trial + codewordBase) % numberOfSegments;
380 const uint16_t codeword_idx = codewordBase + set*numberOfSegments - numberOfSegments;
383 if (codeword_idx >= numberOfCodewords - numberOfSegments) break;
385 if (!codeword[codeword_idx].decoded && segment[segment_idx].len > 0)
389 if (codeword[codeword_idx].bits.len != 0)
390 concat_bits(&segment[segment_idx], &codeword[codeword_idx].bits);
392 tmplen = segment[segment_idx].len;
394 if (huffman_spectral_data_2(codeword[codeword_idx].cb, &segment[segment_idx],
395 &spectral_data[codeword[codeword_idx].sp_offset]) >= 0)
397 codeword[codeword_idx].decoded = 1;
400 codeword[codeword_idx].bits = segment[segment_idx];
401 codeword[codeword_idx].bits.len = tmplen;
407 for (i = 0; i < numberOfSegments; i++)
408 rewrev_bits(&segment[i]);
411 #if 0 // Seems to give false errors
414 for (i = 0; i < numberOfSegments && !bitsleft; i++)
415 bitsleft += segment[i].len;
417 if (bitsleft) return 10;
421 for (i = 0; (i < numberOfCodewords - numberOfSegments) && (!codewordsleft); i++)
422 if (!codeword[i].decoded)
425 if (codewordsleft) return 10;