src/lib/doslib/ext/faad/hcr.c

   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