1 /*
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
4 **
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.
9 **
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.
14 **
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.
18 **
19 ** Any non-GPL usage of this software or parts of this software is strictly
20 ** forbidden.
21 **
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"
24 **
25 ** Commercial non-GPL licensing of this software is possible.
26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
27 **
28 ** $Id: hcr.c,v 1.26 2009/01/26 23:51:15 menno Exp $
29 **/
30
31 #include "common.h"
32 #include "structs.h"
33
34 #include <stdlib.h>
35 #include <string.h>
36
37 #include "specrec.h"
38 #include "huffman.h"
39
40 /* ISO/IEC 14496-3/Amd.1
41 * 8.5.3.3: Huffman Codeword Reordering for AAC spectral data (HCR)
42 *
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.
51 */
52
53 #ifdef ERROR_RESILIENCE
54
55 /* 8.5.3.3.1 Pre-sorting */
56
57 #define NUM_CB 6
58 #define NUM_CB_ER 22
59 #define MAX_CB 32
60 #define VCB11_FIRST 16
61 #define VCB11_LAST 31
62
63 static const uint8_t PreSortCB_STD[NUM_CB] =
64 { 11, 9, 7, 5, 3, 1};
65
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};
68
69 /* 8.5.3.3.2 Derivation of segment width */
70
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};
73
74 #define segmentWidth(cb) min(maxCwLen[cb], ics->length_of_longest_codeword)
75
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};
79
80 typedef struct
81 {
82 uint8_t cb;
83 uint8_t decoded;
84 uint16_t sp_offset;
85 bits_t bits;
86 } codeword_t;
87
88 /* rewind and reverse */
89 /* 32 bit version */
rewrev_word(uint32_t v,const uint8_t len)90 static uint32_t rewrev_word(uint32_t v, const uint8_t len)
91 {
92 /* 32 bit reverse */
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]);
98
99 /* shift off low bits */
100 v >>= (32 - len);
101
102 return v;
103 }
104
105 /* 64 bit version */
rewrev_lword(uint32_t * hi,uint32_t * lo,const uint8_t len)106 static void rewrev_lword(uint32_t *hi, uint32_t *lo, const uint8_t len)
107 {
108 if (len <= 32) {
109 *hi = 0;
110 *lo = rewrev_word(*lo, len);
111 } else
112 {
113 uint32_t t = *hi, v = *lo;
114
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]);
126
127 /* last 32<>32 bit swap is implicit below */
128
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);
132 }
133 }
134
135
136 /* bits_t version */
rewrev_bits(bits_t * bits)137 static void rewrev_bits(bits_t *bits)
138 {
139 if (bits->len == 0) return;
140 rewrev_lword(&bits->bufb, &bits->bufa, bits->len);
141 }
142
143
144 /* merge bits of a to b */
concat_bits(bits_t * b,bits_t * a)145 static void concat_bits(bits_t *b, bits_t *a)
146 {
147 uint32_t bl, bh, al, ah;
148
149 if (a->len == 0) return;
150
151 al = a->bufa;
152 ah = a->bufb;
153
154 if (b->len > 32)
155 {
156 /* maskoff superfluous high b bits */
157 bl = b->bufa;
158 bh = b->bufb & ((1 << (b->len-32)) - 1);
159 /* left shift a b->len bits */
160 ah = al << (b->len - 32);
161 al = 0;
162 } else {
163 bl = b->bufa & ((1 << (b->len)) - 1);
164 bh = 0;
165 ah = (ah << (b->len)) | (al >> (32 - b->len));
166 al = al << b->len;
167 }
168
169 /* merge */
170 b->bufa = bl | al;
171 b->bufb = bh | ah;
172
173 b->len += a->len;
174 }
175
is_good_cb(uint8_t this_CB,uint8_t this_sec_CB)176 static uint8_t is_good_cb(uint8_t this_CB, uint8_t this_sec_CB)
177 {
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))
180 {
181 if (this_CB < ESC_HCB)
182 {
183 /* normal codebook pairs */
184 return ((this_sec_CB == this_CB) || (this_sec_CB == this_CB + 1));
185 } else
186 {
187 /* escape codebook */
188 return (this_sec_CB == this_CB);
189 }
190 }
191 return 0;
192 }
193
read_segment(bits_t * segment,uint8_t segwidth,bitfile * ld)194 static void read_segment(bits_t *segment, uint8_t segwidth, bitfile *ld)
195 {
196 segment->len = segwidth;
197
198 if (segwidth > 32)
199 {
200 segment->bufb = faad_getbits(ld, segwidth - 32);
201 segment->bufa = faad_getbits(ld, 32);
202
203 } else {
204 segment->bufa = faad_getbits(ld, segwidth);
205 segment->bufb = 0;
206 }
207 }
208
fill_in_codeword(codeword_t * codeword,uint16_t index,uint16_t sp,uint8_t cb)209 static void fill_in_codeword(codeword_t *codeword, uint16_t index, uint16_t sp, uint8_t cb)
210 {
211 codeword[index].sp_offset = sp;
212 codeword[index].cb = cb;
213 codeword[index].decoded = 0;
214 codeword[index].bits.len = 0;
215 }
216
reordered_spectral_data(NeAACDecStruct * hDecoder,ic_stream * ics,bitfile * ld,int16_t * spectral_data)217 uint8_t reordered_spectral_data(NeAACDecStruct *hDecoder, ic_stream *ics,
218 bitfile *ld, int16_t *spectral_data)
219 {
220 uint16_t PCWs_done;
221 uint16_t numberOfSegments, numberOfSets, numberOfCodewords;
222
223 codeword_t codeword[512];
224 bits_t segment[512];
225
226 uint16_t sp_offset[8];
227 uint16_t g, i, sortloop, set, bitsread;
228 #ifdef HCR_CWCOUNT
229 uint16_t bitsleft, codewordsleft;
230 #endif
231 uint8_t w_idx, sfb, this_CB, last_CB, this_sec_CB;
232
233 const uint16_t nshort = hDecoder->frameLength/8;
234 const uint16_t sp_data_len = ics->length_of_reordered_spectral_data;
235
236 const uint8_t *PreSortCb;
237
238 /* no data (e.g. silence) */
239 if (sp_data_len == 0)
240 return 0;
241
242 /* since there is spectral data, at least one codeword has nonzero length */
243 if (ics->length_of_longest_codeword == 0)
244 return 10;
245
246 if (sp_data_len < ics->length_of_longest_codeword)
247 return 10;
248
249 sp_offset[0] = 0;
250 for (g = 1; g < ics->num_window_groups; g++)
251 {
252 sp_offset[g] = sp_offset[g-1] + nshort*ics->window_group_length[g-1];
253 }
254
255 PCWs_done = 0;
256 numberOfSegments = 0;
257 numberOfCodewords = 0;
258 bitsread = 0;
259
260 /* VCB11 code books in use */
261 if (hDecoder->aacSectionDataResilienceFlag)
262 {
263 PreSortCb = PreSortCB_ER;
264 last_CB = NUM_CB_ER;
265 } else
266 {
267 PreSortCb = PreSortCB_STD;
268 last_CB = NUM_CB;
269 }
270
271 /* step 1: decode PCW's (set 0), and stuff data in easier-to-use format */
272 for (sortloop = 0; sortloop < last_CB; sortloop++)
273 {
274 /* select codebook to process this pass */
275 this_CB = PreSortCb[sortloop];
276
277 /* loop over sfbs */
278 for (sfb = 0; sfb < ics->max_sfb; sfb++)
279 {
280 /* loop over all in this sfb, 4 lines per loop */
281 for (w_idx = 0; 4*w_idx < (min(ics->swb_offset[sfb+1], ics->swb_offset_max) - ics->swb_offset[sfb]); w_idx++)
282 {
283 for(g = 0; g < ics->num_window_groups; g++)
284 {
285 for (i = 0; i < ics->num_sec[g]; i++)
286 {
287 /* check whether sfb used here is the one we want to process */
288 if ((ics->sect_start[g][i] <= sfb) && (ics->sect_end[g][i] > sfb))
289 {
290 /* check whether codebook used here is the one we want to process */
291 this_sec_CB = ics->sect_cb[g][i];
292
293 if (is_good_cb(this_CB, this_sec_CB))
294 {
295 /* precalculate some stuff */
296 uint16_t sect_sfb_size = ics->sect_sfb_offset[g][sfb+1] - ics->sect_sfb_offset[g][sfb];
297 uint8_t inc = (this_sec_CB < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN;
298 uint16_t group_cws_count = (4*ics->window_group_length[g])/inc;
299 uint8_t segwidth = segmentWidth(this_sec_CB);
300 uint16_t cws;
301
302 /* read codewords until end of sfb or end of window group (shouldn't only 1 trigger?) */
303 for (cws = 0; (cws < group_cws_count) && ((cws + w_idx*group_cws_count) < sect_sfb_size); cws++)
304 {
305 uint16_t sp = sp_offset[g] + ics->sect_sfb_offset[g][sfb] + inc * (cws + w_idx*group_cws_count);
306
307 /* read and decode PCW */
308 if (!PCWs_done)
309 {
310 /* read in normal segments */
311 if (bitsread + segwidth <= sp_data_len)
312 {
313 read_segment(&segment[numberOfSegments], segwidth, ld);
314 bitsread += segwidth;
315
316 huffman_spectral_data_2(this_sec_CB, &segment[numberOfSegments], &spectral_data[sp]);
317
318 /* keep leftover bits */
319 rewrev_bits(&segment[numberOfSegments]);
320
321 numberOfSegments++;
322 } else {
323 /* remaining stuff after last segment, we unfortunately couldn't read
324 this in earlier because it might not fit in 64 bits. since we already
325 decoded (and removed) the PCW it is now guaranteed to fit */
326 if (bitsread < sp_data_len)
327 {
328 const uint8_t additional_bits = sp_data_len - bitsread;
329
330 read_segment(&segment[numberOfSegments], additional_bits, ld);
331 segment[numberOfSegments].len += segment[numberOfSegments-1].len;
332 rewrev_bits(&segment[numberOfSegments]);
333
334 if (segment[numberOfSegments-1].len > 32)
335 {
336 segment[numberOfSegments-1].bufb = segment[numberOfSegments].bufb +
337 showbits_hcr(&segment[numberOfSegments-1], segment[numberOfSegments-1].len - 32);
338 segment[numberOfSegments-1].bufa = segment[numberOfSegments].bufa +
339 showbits_hcr(&segment[numberOfSegments-1], 32);
340 } else {
341 segment[numberOfSegments-1].bufa = segment[numberOfSegments].bufa +
342 showbits_hcr(&segment[numberOfSegments-1], segment[numberOfSegments-1].len);
343 segment[numberOfSegments-1].bufb = segment[numberOfSegments].bufb;
344 }
345 segment[numberOfSegments-1].len += additional_bits;
346 }
347 bitsread = sp_data_len;
348 PCWs_done = 1;
349
350 fill_in_codeword(codeword, 0, sp, this_sec_CB);
351 }
352 } else {
353 fill_in_codeword(codeword, numberOfCodewords - numberOfSegments, sp, this_sec_CB);
354 }
355 numberOfCodewords++;
356 }
357 }
358 }
359 }
360 }
361 }
362 }
363 }
364
365 if (numberOfSegments == 0)
366 return 10;
367
368 numberOfSets = numberOfCodewords / numberOfSegments;
369
370 /* step 2: decode nonPCWs */
371 for (set = 1; set <= numberOfSets; set++)
372 {
373 uint16_t trial;
374
375 for (trial = 0; trial < numberOfSegments; trial++)
376 {
377 uint16_t codewordBase;
378
379 for (codewordBase = 0; codewordBase < numberOfSegments; codewordBase++)
380 {
381 const uint16_t segment_idx = (trial + codewordBase) % numberOfSegments;
382 const uint16_t codeword_idx = codewordBase + set*numberOfSegments - numberOfSegments;
383
384 /* data up */
385 if (codeword_idx >= numberOfCodewords - numberOfSegments) break;
386
387 if (!codeword[codeword_idx].decoded && segment[segment_idx].len > 0)
388 {
389 uint8_t tmplen;
390
391 if (codeword[codeword_idx].bits.len != 0)
392 concat_bits(&segment[segment_idx], &codeword[codeword_idx].bits);
393
394 tmplen = segment[segment_idx].len;
395
396 if (huffman_spectral_data_2(codeword[codeword_idx].cb, &segment[segment_idx],
397 &spectral_data[codeword[codeword_idx].sp_offset]) >= 0)
398 {
399 codeword[codeword_idx].decoded = 1;
400 } else
401 {
402 codeword[codeword_idx].bits = segment[segment_idx];
403 codeword[codeword_idx].bits.len = tmplen;
404 }
405
406 }
407 }
408 }
409 for (i = 0; i < numberOfSegments; i++)
410 rewrev_bits(&segment[i]);
411 }
412
413 #ifdef HCR_CWCOUNT // Seems to give false errors
414 bitsleft = 0;
415
416 for (i = 0; i < numberOfSegments && !bitsleft; i++)
417 bitsleft += segment[i].len;
418
419 if (bitsleft) return 10;
420
421 codewordsleft = 0;
422
423 for (i = 0; (i < numberOfCodewords - numberOfSegments) && (!codewordsleft); i++)
424 if (!codeword[i].decoded)
425 codewordsleft++;
426
427 if (codewordsleft) return 10;
428 #endif
429
430
431 return 0;
432
433 }
434 #endif
435