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