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 */ 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 */ 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 */ 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 */ 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 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 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 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 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