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