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 /*uint16_t bitsleft, codewordsleft*/;
229 uint8_t w_idx, sfb, this_CB, last_CB, this_sec_CB;
230
231 const uint16_t nshort = hDecoder->frameLength/8;
232 const uint16_t sp_data_len = ics->length_of_reordered_spectral_data;
233
234 const uint8_t *PreSortCb;
235
236 /* no data (e.g. silence) */
237 if (sp_data_len == 0)
238 return 0;
239
240 /* since there is spectral data, at least one codeword has nonzero length */
241 if (ics->length_of_longest_codeword == 0)
242 return 10;
243
244 if (sp_data_len < ics->length_of_longest_codeword)
245 return 10;
246
247 sp_offset[0] = 0;
248 for (g = 1; g < ics->num_window_groups; g++)
249 {
250 sp_offset[g] = sp_offset[g-1] + nshort*ics->window_group_length[g-1];
251 }
252
253 PCWs_done = 0;
254 numberOfSegments = 0;
255 numberOfCodewords = 0;
256 bitsread = 0;
257
258 /* VCB11 code books in use */
259 if (hDecoder->aacSectionDataResilienceFlag)
260 {
261 PreSortCb = PreSortCB_ER;
262 last_CB = NUM_CB_ER;
263 } else
264 {
265 PreSortCb = PreSortCB_STD;
266 last_CB = NUM_CB;
267 }
268
269 /* step 1: decode PCW's (set 0), and stuff data in easier-to-use format */
270 for (sortloop = 0; sortloop < last_CB; sortloop++)
271 {
272 /* select codebook to process this pass */
273 this_CB = PreSortCb[sortloop];
274
275 /* loop over sfbs */
276 for (sfb = 0; sfb < ics->max_sfb; sfb++)
277 {
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++)
280 {
281 for(g = 0; g < ics->num_window_groups; g++)
282 {
283 for (i = 0; i < ics->num_sec[g]; i++)
284 {
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))
287 {
288 /* check whether codebook used here is the one we want to process */
289 this_sec_CB = ics->sect_cb[g][i];
290
291 if (is_good_cb(this_CB, this_sec_CB))
292 {
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);
298 uint16_t cws;
299
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++)
302 {
303 uint16_t sp = sp_offset[g] + ics->sect_sfb_offset[g][sfb] + inc * (cws + w_idx*group_cws_count);
304
305 /* read and decode PCW */
306 if (!PCWs_done)
307 {
308 /* read in normal segments */
309 if (bitsread + segwidth <= sp_data_len)
310 {
311 read_segment(&segment[numberOfSegments], segwidth, ld);
312 bitsread += segwidth;
313
314 huffman_spectral_data_2(this_sec_CB, &segment[numberOfSegments], &spectral_data[sp]);
315
316 /* keep leftover bits */
317 rewrev_bits(&segment[numberOfSegments]);
318
319 numberOfSegments++;
320 } else {
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)
325 {
326 const uint8_t additional_bits = sp_data_len - bitsread;
327
328 read_segment(&segment[numberOfSegments], additional_bits, ld);
329 segment[numberOfSegments].len += segment[numberOfSegments-1].len;
330 rewrev_bits(&segment[numberOfSegments]);
331
332 if (segment[numberOfSegments-1].len > 32)
333 {
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);
338 } else {
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;
342 }
343 segment[numberOfSegments-1].len += additional_bits;
344 }
345 bitsread = sp_data_len;
346 PCWs_done = 1;
347
348 fill_in_codeword(codeword, 0, sp, this_sec_CB);
349 }
350 } else {
351 fill_in_codeword(codeword, numberOfCodewords - numberOfSegments, sp, this_sec_CB);
352 }
353 numberOfCodewords++;
354 }
355 }
356 }
357 }
358 }
359 }
360 }
361 }
362
363 if (numberOfSegments == 0)
364 return 10;
365
366 numberOfSets = numberOfCodewords / numberOfSegments;
367
368 /* step 2: decode nonPCWs */
369 for (set = 1; set <= numberOfSets; set++)
370 {
371 uint16_t trial;
372
373 for (trial = 0; trial < numberOfSegments; trial++)
374 {
375 uint16_t codewordBase;
376
377 for (codewordBase = 0; codewordBase < numberOfSegments; codewordBase++)
378 {
379 const uint16_t segment_idx = (trial + codewordBase) % numberOfSegments;
380 const uint16_t codeword_idx = codewordBase + set*numberOfSegments - numberOfSegments;
381
382 /* data up */
383 if (codeword_idx >= numberOfCodewords - numberOfSegments) break;
384
385 if (!codeword[codeword_idx].decoded && segment[segment_idx].len > 0)
386 {
387 uint8_t tmplen;
388
389 if (codeword[codeword_idx].bits.len != 0)
390 concat_bits(&segment[segment_idx], &codeword[codeword_idx].bits);
391
392 tmplen = segment[segment_idx].len;
393
394 if (huffman_spectral_data_2(codeword[codeword_idx].cb, &segment[segment_idx],
395 &spectral_data[codeword[codeword_idx].sp_offset]) >= 0)
396 {
397 codeword[codeword_idx].decoded = 1;
398 } else
399 {
400 codeword[codeword_idx].bits = segment[segment_idx];
401 codeword[codeword_idx].bits.len = tmplen;
402 }
403
404 }
405 }
406 }
407 for (i = 0; i < numberOfSegments; i++)
408 rewrev_bits(&segment[i]);
409 }
410
411 #if 0 // Seems to give false errors
412 bitsleft = 0;
413
414 for (i = 0; i < numberOfSegments && !bitsleft; i++)
415 bitsleft += segment[i].len;
416
417 if (bitsleft) return 10;
418
419 codewordsleft = 0;
420
421 for (i = 0; (i < numberOfCodewords - numberOfSegments) && (!codewordsleft); i++)
422 if (!codeword[i].decoded)
423 codewordsleft++;
424
425 if (codewordsleft) return 10;
426 #endif
427
428
429 return 0;
430
431 }
432 #endif
433