sbc/sbc.c

   1 /*
   2  *
   3  *  Bluetooth low-complexity, subband codec (SBC) library
   4  *
   5  *  Copyright (C) 2008-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *  Copyright (C) 2004-2005  Henryk Ploetz <henryk@ploetzli.ch>
   8  *  Copyright (C) 2005-2008  Brad Midgley <bmidgley@xmission.com>
   9  *
  10  *
  11  *  This library is free software; you can redistribute it and/or
  12  *  modify it under the terms of the GNU Lesser General Public
  13  *  License as published by the Free Software Foundation; either
  14  *  version 2.1 of the License, or (at your option) any later version.
  15  *
  16  *  This library is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *  Lesser General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU Lesser General Public
  22  *  License along with this library; if not, write to the Free Software
  23  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  24  *
  25  */
  26
  27 /* todo items:
  28
  29   use a log2 table for byte integer scale factors calculation (sum log2 results
  30   for high and low bytes) fill bitpool by 16 bits instead of one at a time in
  31   bits allocation/bitpool generation port to the dsp
  32
  33 */
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38
  39 #include <stdio.h>
  40 #include <errno.h>
  41 #include <string.h>
  42 #include <stdlib.h>
  43 #include <sys/types.h>
  44 #include <limits.h>
  45
  46 #include "sbc_math.h"
  47 #include "sbc_tables.h"
  48
  49 #include "sbc.h"
  50 #include "sbc_primitives.h"
  51
  52 #define SBC_SYNCWORD    0x9C
  53
  54 /* This structure contains an unpacked SBC frame.
  55    Yes, there is probably quite some unused space herein */
  56 struct sbc_frame {
  57         uint8_t frequency;
  58         uint8_t block_mode;
  59         uint8_t blocks;
  60         enum {
  61                 MONO            = SBC_MODE_MONO,
  62                 DUAL_CHANNEL    = SBC_MODE_DUAL_CHANNEL,
  63                 STEREO          = SBC_MODE_STEREO,
  64                 JOINT_STEREO    = SBC_MODE_JOINT_STEREO
  65         } mode;
  66         uint8_t channels;
  67         enum {
  68                 LOUDNESS        = SBC_AM_LOUDNESS,
  69                 SNR             = SBC_AM_SNR
  70         } allocation;
  71         uint8_t subband_mode;
  72         uint8_t subbands;
  73         uint8_t bitpool;
  74         uint16_t codesize;
  75         uint8_t length;
  76
  77         /* bit number x set means joint stereo has been used in subband x */
  78         uint8_t joint;
  79
  80         /* only the lower 4 bits of every element are to be used */
  81         uint32_t SBC_ALIGNED scale_factor[2][8];
  82
  83         /* raw integer subband samples in the frame */
  84         int32_t SBC_ALIGNED sb_sample_f[16][2][8];
  85
  86         /* modified subband samples */
  87         int32_t SBC_ALIGNED sb_sample[16][2][8];
  88
  89         /* original pcm audio samples */
  90         int16_t SBC_ALIGNED pcm_sample[2][16*8];
  91 };
  92
  93 struct sbc_decoder_state {
  94         int subbands;
  95         int32_t V[2][170];
  96         int offset[2][16];
  97 };
  98
  99 /*
 100  * Calculates the CRC-8 of the first len bits in data
 101  */
 102 static const uint8_t crc_table[256] = {
 103         0x00, 0x1D, 0x3A, 0x27, 0x74, 0x69, 0x4E, 0x53,
 104         0xE8, 0xF5, 0xD2, 0xCF, 0x9C, 0x81, 0xA6, 0xBB,
 105         0xCD, 0xD0, 0xF7, 0xEA, 0xB9, 0xA4, 0x83, 0x9E,
 106         0x25, 0x38, 0x1F, 0x02, 0x51, 0x4C, 0x6B, 0x76,
 107         0x87, 0x9A, 0xBD, 0xA0, 0xF3, 0xEE, 0xC9, 0xD4,
 108         0x6F, 0x72, 0x55, 0x48, 0x1B, 0x06, 0x21, 0x3C,
 109         0x4A, 0x57, 0x70, 0x6D, 0x3E, 0x23, 0x04, 0x19,
 110         0xA2, 0xBF, 0x98, 0x85, 0xD6, 0xCB, 0xEC, 0xF1,
 111         0x13, 0x0E, 0x29, 0x34, 0x67, 0x7A, 0x5D, 0x40,
 112         0xFB, 0xE6, 0xC1, 0xDC, 0x8F, 0x92, 0xB5, 0xA8,
 113         0xDE, 0xC3, 0xE4, 0xF9, 0xAA, 0xB7, 0x90, 0x8D,
 114         0x36, 0x2B, 0x0C, 0x11, 0x42, 0x5F, 0x78, 0x65,
 115         0x94, 0x89, 0xAE, 0xB3, 0xE0, 0xFD, 0xDA, 0xC7,
 116         0x7C, 0x61, 0x46, 0x5B, 0x08, 0x15, 0x32, 0x2F,
 117         0x59, 0x44, 0x63, 0x7E, 0x2D, 0x30, 0x17, 0x0A,
 118         0xB1, 0xAC, 0x8B, 0x96, 0xC5, 0xD8, 0xFF, 0xE2,
 119         0x26, 0x3B, 0x1C, 0x01, 0x52, 0x4F, 0x68, 0x75,
 120         0xCE, 0xD3, 0xF4, 0xE9, 0xBA, 0xA7, 0x80, 0x9D,
 121         0xEB, 0xF6, 0xD1, 0xCC, 0x9F, 0x82, 0xA5, 0xB8,
 122         0x03, 0x1E, 0x39, 0x24, 0x77, 0x6A, 0x4D, 0x50,
 123         0xA1, 0xBC, 0x9B, 0x86, 0xD5, 0xC8, 0xEF, 0xF2,
 124         0x49, 0x54, 0x73, 0x6E, 0x3D, 0x20, 0x07, 0x1A,
 125         0x6C, 0x71, 0x56, 0x4B, 0x18, 0x05, 0x22, 0x3F,
 126         0x84, 0x99, 0xBE, 0xA3, 0xF0, 0xED, 0xCA, 0xD7,
 127         0x35, 0x28, 0x0F, 0x12, 0x41, 0x5C, 0x7B, 0x66,
 128         0xDD, 0xC0, 0xE7, 0xFA, 0xA9, 0xB4, 0x93, 0x8E,
 129         0xF8, 0xE5, 0xC2, 0xDF, 0x8C, 0x91, 0xB6, 0xAB,
 130         0x10, 0x0D, 0x2A, 0x37, 0x64, 0x79, 0x5E, 0x43,
 131         0xB2, 0xAF, 0x88, 0x95, 0xC6, 0xDB, 0xFC, 0xE1,
 132         0x5A, 0x47, 0x60, 0x7D, 0x2E, 0x33, 0x14, 0x09,
 133         0x7F, 0x62, 0x45, 0x58, 0x0B, 0x16, 0x31, 0x2C,
 134         0x97, 0x8A, 0xAD, 0xB0, 0xE3, 0xFE, 0xD9, 0xC4
 135 };
 136
 137 static uint8_t sbc_crc8(const uint8_t *data, size_t len)
 138 {
 139         uint8_t crc = 0x0f;
 140         size_t i;
 141         uint8_t octet;
 142
 143         for (i = 0; i < len / 8; i++)
 144                 crc = crc_table[crc ^ data[i]];
 145
 146         octet = data[i];
 147         for (i = 0; i < len % 8; i++) {
 148                 char bit = ((octet ^ crc) & 0x80) >> 7;
 149
 150                 crc = ((crc & 0x7f) << 1) ^ (bit ? 0x1d : 0);
 151
 152                 octet = octet << 1;
 153         }
 154
 155         return crc;
 156 }
 157
 158 /*
 159  * Code straight from the spec to calculate the bits array
 160  * Takes a pointer to the frame in question, a pointer to the bits array and
 161  * the sampling frequency (as 2 bit integer)
 162  */
 163 static SBC_ALWAYS_INLINE void sbc_calculate_bits_internal(
 164                 const struct sbc_frame *frame, int (*bits)[8], int subbands)
 165 {
 166         uint8_t sf = frame->frequency;
 167
 168         if (frame->mode == MONO || frame->mode == DUAL_CHANNEL) {
 169                 int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
 170                 int ch, sb;
 171
 172                 for (ch = 0; ch < frame->channels; ch++) {
 173                         max_bitneed = 0;
 174                         if (frame->allocation == SNR) {
 175                                 for (sb = 0; sb < subbands; sb++) {
 176                                         bitneed[ch][sb] = frame->scale_factor[ch][sb];
 177                                         if (bitneed[ch][sb] > max_bitneed)
 178                                                 max_bitneed = bitneed[ch][sb];
 179                                 }
 180                         } else {
 181                                 for (sb = 0; sb < subbands; sb++) {
 182                                         if (frame->scale_factor[ch][sb] == 0)
 183                                                 bitneed[ch][sb] = -5;
 184                                         else {
 185                                                 if (subbands == 4)
 186                                                         loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
 187                                                 else
 188                                                         loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
 189                                                 if (loudness > 0)
 190                                                         bitneed[ch][sb] = loudness / 2;
 191                                                 else
 192                                                         bitneed[ch][sb] = loudness;
 193                                         }
 194                                         if (bitneed[ch][sb] > max_bitneed)
 195                                                 max_bitneed = bitneed[ch][sb];
 196                                 }
 197                         }
 198
 199                         bitcount = 0;
 200                         slicecount = 0;
 201                         bitslice = max_bitneed + 1;
 202                         do {
 203                                 bitslice--;
 204                                 bitcount += slicecount;
 205                                 slicecount = 0;
 206                                 for (sb = 0; sb < subbands; sb++) {
 207                                         if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
 208                                                 slicecount++;
 209                                         else if (bitneed[ch][sb] == bitslice + 1)
 210                                                 slicecount += 2;
 211                                 }
 212                         } while (bitcount + slicecount < frame->bitpool);
 213
 214                         if (bitcount + slicecount == frame->bitpool) {
 215                                 bitcount += slicecount;
 216                                 bitslice--;
 217                         }
 218
 219                         for (sb = 0; sb < subbands; sb++) {
 220                                 if (bitneed[ch][sb] < bitslice + 2)
 221                                         bits[ch][sb] = 0;
 222                                 else {
 223                                         bits[ch][sb] = bitneed[ch][sb] - bitslice;
 224                                         if (bits[ch][sb] > 16)
 225                                                 bits[ch][sb] = 16;
 226                                 }
 227                         }
 228
 229                         for (sb = 0; bitcount < frame->bitpool &&
 230                                                         sb < subbands; sb++) {
 231                                 if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
 232                                         bits[ch][sb]++;
 233                                         bitcount++;
 234                                 } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
 235                                         bits[ch][sb] = 2;
 236                                         bitcount += 2;
 237                                 }
 238                         }
 239
 240                         for (sb = 0; bitcount < frame->bitpool &&
 241                                                         sb < subbands; sb++) {
 242                                 if (bits[ch][sb] < 16) {
 243                                         bits[ch][sb]++;
 244                                         bitcount++;
 245                                 }
 246                         }
 247
 248                 }
 249
 250         } else if (frame->mode == STEREO || frame->mode == JOINT_STEREO) {
 251                 int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
 252                 int ch, sb;
 253
 254                 max_bitneed = 0;
 255                 if (frame->allocation == SNR) {
 256                         for (ch = 0; ch < 2; ch++) {
 257                                 for (sb = 0; sb < subbands; sb++) {
 258                                         bitneed[ch][sb] = frame->scale_factor[ch][sb];
 259                                         if (bitneed[ch][sb] > max_bitneed)
 260                                                 max_bitneed = bitneed[ch][sb];
 261                                 }
 262                         }
 263                 } else {
 264                         for (ch = 0; ch < 2; ch++) {
 265                                 for (sb = 0; sb < subbands; sb++) {
 266                                         if (frame->scale_factor[ch][sb] == 0)
 267                                                 bitneed[ch][sb] = -5;
 268                                         else {
 269                                                 if (subbands == 4)
 270                                                         loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
 271                                                 else
 272                                                         loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
 273                                                 if (loudness > 0)
 274                                                         bitneed[ch][sb] = loudness / 2;
 275                                                 else
 276                                                         bitneed[ch][sb] = loudness;
 277                                         }
 278                                         if (bitneed[ch][sb] > max_bitneed)
 279                                                 max_bitneed = bitneed[ch][sb];
 280                                 }
 281                         }
 282                 }
 283
 284                 bitcount = 0;
 285                 slicecount = 0;
 286                 bitslice = max_bitneed + 1;
 287                 do {
 288                         bitslice--;
 289                         bitcount += slicecount;
 290                         slicecount = 0;
 291                         for (ch = 0; ch < 2; ch++) {
 292                                 for (sb = 0; sb < subbands; sb++) {
 293                                         if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
 294                                                 slicecount++;
 295                                         else if (bitneed[ch][sb] == bitslice + 1)
 296                                                 slicecount += 2;
 297                                 }
 298                         }
 299                 } while (bitcount + slicecount < frame->bitpool);
 300
 301                 if (bitcount + slicecount == frame->bitpool) {
 302                         bitcount += slicecount;
 303                         bitslice--;
 304                 }
 305
 306                 for (ch = 0; ch < 2; ch++) {
 307                         for (sb = 0; sb < subbands; sb++) {
 308                                 if (bitneed[ch][sb] < bitslice + 2) {
 309                                         bits[ch][sb] = 0;
 310                                 } else {
 311                                         bits[ch][sb] = bitneed[ch][sb] - bitslice;
 312                                         if (bits[ch][sb] > 16)
 313                                                 bits[ch][sb] = 16;
 314                                 }
 315                         }
 316                 }
 317
 318                 ch = 0;
 319                 sb = 0;
 320                 while (bitcount < frame->bitpool) {
 321                         if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
 322                                 bits[ch][sb]++;
 323                                 bitcount++;
 324                         } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
 325                                 bits[ch][sb] = 2;
 326                                 bitcount += 2;
 327                         }
 328                         if (ch == 1) {
 329                                 ch = 0;
 330                                 sb++;
 331                                 if (sb >= subbands)
 332                                         break;
 333                         } else
 334                                 ch = 1;
 335                 }
 336
 337                 ch = 0;
 338                 sb = 0;
 339                 while (bitcount < frame->bitpool) {
 340                         if (bits[ch][sb] < 16) {
 341                                 bits[ch][sb]++;
 342                                 bitcount++;
 343                         }
 344                         if (ch == 1) {
 345                                 ch = 0;
 346                                 sb++;
 347                                 if (sb >= subbands)
 348                                         break;
 349                         } else
 350                                 ch = 1;
 351                 }
 352
 353         }
 354
 355 }
 356
 357 static void sbc_calculate_bits(const struct sbc_frame *frame, int (*bits)[8])
 358 {
 359         if (frame->subbands == 4)
 360                 sbc_calculate_bits_internal(frame, bits, 4);
 361         else
 362                 sbc_calculate_bits_internal(frame, bits, 8);
 363 }
 364
 365 /*
 366  * Unpacks a SBC frame at the beginning of the stream in data,
 367  * which has at most len bytes into frame.
 368  * Returns the length in bytes of the packed frame, or a negative
 369  * value on error. The error codes are:
 370  *
 371  *  -1   Data stream too short
 372  *  -2   Sync byte incorrect
 373  *  -3   CRC8 incorrect
 374  *  -4   Bitpool value out of bounds
 375  */
 376 static int sbc_unpack_frame(const uint8_t *data, struct sbc_frame *frame,
 377                                                                 size_t len)
 378 {
 379         unsigned int consumed;
 380         /* Will copy the parts of the header that are relevant to crc
 381          * calculation here */
 382         uint8_t crc_header[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 383         int crc_pos = 0;
 384         int32_t temp;
 385
 386         uint32_t audio_sample;
 387         int ch, sb, blk, bit;   /* channel, subband, block and bit standard
 388                                    counters */
 389         int bits[2][8];         /* bits distribution */
 390         uint32_t levels[2][8];  /* levels derived from that */
 391
 392         if (len < 4)
 393                 return -1;
 394
 395         if (data[0] != SBC_SYNCWORD)
 396                 return -2;
 397
 398         frame->frequency = (data[1] >> 6) & 0x03;
 399
 400         frame->block_mode = (data[1] >> 4) & 0x03;
 401         switch (frame->block_mode) {
 402         case SBC_BLK_4:
 403                 frame->blocks = 4;
 404                 break;
 405         case SBC_BLK_8:
 406                 frame->blocks = 8;
 407                 break;
 408         case SBC_BLK_12:
 409                 frame->blocks = 12;
 410                 break;
 411         case SBC_BLK_16:
 412                 frame->blocks = 16;
 413                 break;
 414         }
 415
 416         frame->mode = (data[1] >> 2) & 0x03;
 417         switch (frame->mode) {
 418         case MONO:
 419                 frame->channels = 1;
 420                 break;
 421         case DUAL_CHANNEL:      /* fall-through */
 422         case STEREO:
 423         case JOINT_STEREO:
 424                 frame->channels = 2;
 425                 break;
 426         }
 427
 428         frame->allocation = (data[1] >> 1) & 0x01;
 429
 430         frame->subband_mode = (data[1] & 0x01);
 431         frame->subbands = frame->subband_mode ? 8 : 4;
 432
 433         frame->bitpool = data[2];
 434
 435         if ((frame->mode == MONO || frame->mode == DUAL_CHANNEL) &&
 436                         frame->bitpool > 16 * frame->subbands)
 437                 return -4;
 438
 439         if ((frame->mode == STEREO || frame->mode == JOINT_STEREO) &&
 440                         frame->bitpool > 32 * frame->subbands)
 441                 return -4;
 442
 443         /* data[3] is crc, we're checking it later */
 444
 445         consumed = 32;
 446
 447         crc_header[0] = data[1];
 448         crc_header[1] = data[2];
 449         crc_pos = 16;
 450
 451         if (frame->mode == JOINT_STEREO) {
 452                 if (len * 8 < consumed + frame->subbands)
 453                         return -1;
 454
 455                 frame->joint = 0x00;
 456                 for (sb = 0; sb < frame->subbands - 1; sb++)
 457                         frame->joint |= ((data[4] >> (7 - sb)) & 0x01) << sb;
 458                 if (frame->subbands == 4)
 459                         crc_header[crc_pos / 8] = data[4] & 0xf0;
 460                 else
 461                         crc_header[crc_pos / 8] = data[4];
 462
 463                 consumed += frame->subbands;
 464                 crc_pos += frame->subbands;
 465         }
 466
 467         if (len * 8 < consumed + (4 * frame->subbands * frame->channels))
 468                 return -1;
 469
 470         for (ch = 0; ch < frame->channels; ch++) {
 471                 for (sb = 0; sb < frame->subbands; sb++) {
 472                         /* FIXME assert(consumed % 4 == 0); */
 473                         frame->scale_factor[ch][sb] =
 474                                 (data[consumed >> 3] >> (4 - (consumed & 0x7))) & 0x0F;
 475                         crc_header[crc_pos >> 3] |=
 476                                 frame->scale_factor[ch][sb] << (4 - (crc_pos & 0x7));
 477
 478                         consumed += 4;
 479                         crc_pos += 4;
 480                 }
 481         }
 482
 483         if (data[3] != sbc_crc8(crc_header, crc_pos))
 484                 return -3;
 485
 486         sbc_calculate_bits(frame, bits);
 487
 488         for (ch = 0; ch < frame->channels; ch++) {
 489                 for (sb = 0; sb < frame->subbands; sb++)
 490                         levels[ch][sb] = (1 << bits[ch][sb]) - 1;
 491         }
 492
 493         for (blk = 0; blk < frame->blocks; blk++) {
 494                 for (ch = 0; ch < frame->channels; ch++) {
 495                         for (sb = 0; sb < frame->subbands; sb++) {
 496                                 uint32_t shift;
 497
 498                                 if (levels[ch][sb] == 0) {
 499                                         frame->sb_sample[blk][ch][sb] = 0;
 500                                         continue;
 501                                 }
 502
 503                                 shift = frame->scale_factor[ch][sb] +
 504                                                 1 + SBCDEC_FIXED_EXTRA_BITS;
 505
 506                                 audio_sample = 0;
 507                                 for (bit = 0; bit < bits[ch][sb]; bit++) {
 508                                         if (consumed > len * 8)
 509                                                 return -1;
 510
 511                                         if ((data[consumed >> 3] >> (7 - (consumed & 0x7))) & 0x01)
 512                                                 audio_sample |= 1 << (bits[ch][sb] - bit - 1);
 513
 514                                         consumed++;
 515                                 }
 516
 517                                 frame->sb_sample[blk][ch][sb] = (int32_t)
 518                                         (((((uint64_t) audio_sample << 1) | 1) << shift) /
 519                                         levels[ch][sb]) - (1 << shift);
 520                         }
 521                 }
 522         }
 523
 524         if (frame->mode == JOINT_STEREO) {
 525                 for (blk = 0; blk < frame->blocks; blk++) {
 526                         for (sb = 0; sb < frame->subbands; sb++) {
 527                                 if (frame->joint & (0x01 << sb)) {
 528                                         temp = frame->sb_sample[blk][0][sb] +
 529                                                 frame->sb_sample[blk][1][sb];
 530                                         frame->sb_sample[blk][1][sb] =
 531                                                 frame->sb_sample[blk][0][sb] -
 532                                                 frame->sb_sample[blk][1][sb];
 533                                         frame->sb_sample[blk][0][sb] = temp;
 534                                 }
 535                         }
 536                 }
 537         }
 538
 539         if ((consumed & 0x7) != 0)
 540                 consumed += 8 - (consumed & 0x7);
 541
 542         return consumed >> 3;
 543 }
 544
 545 static void sbc_decoder_init(struct sbc_decoder_state *state,
 546                                         const struct sbc_frame *frame)
 547 {
 548         int i, ch;
 549
 550         memset(state->V, 0, sizeof(state->V));
 551         state->subbands = frame->subbands;
 552
 553         for (ch = 0; ch < 2; ch++)
 554                 for (i = 0; i < frame->subbands * 2; i++)
 555                         state->offset[ch][i] = (10 * i + 10);
 556 }
 557
 558 static SBC_ALWAYS_INLINE int16_t sbc_clip16(int32_t s)
 559 {
 560         if (s > 0x7FFF)
 561                 return 0x7FFF;
 562         else if (s < -0x8000)
 563                 return -0x8000;
 564         else
 565                 return s;
 566 }
 567
 568 static inline void sbc_synthesize_four(struct sbc_decoder_state *state,
 569                                 struct sbc_frame *frame, int ch, int blk)
 570 {
 571         int i, k, idx;
 572         int32_t *v = state->V[ch];
 573         int *offset = state->offset[ch];
 574
 575         for (i = 0; i < 8; i++) {
 576                 /* Shifting */
 577                 offset[i]--;
 578                 if (offset[i] < 0) {
 579                         offset[i] = 79;
 580                         memcpy(v + 80, v, 9 * sizeof(*v));
 581                 }
 582
 583                 /* Distribute the new matrix value to the shifted position */
 584                 v[offset[i]] = SCALE4_STAGED1(
 585                         MULA(synmatrix4[i][0], frame->sb_sample[blk][ch][0],
 586                         MULA(synmatrix4[i][1], frame->sb_sample[blk][ch][1],
 587                         MULA(synmatrix4[i][2], frame->sb_sample[blk][ch][2],
 588                         MUL (synmatrix4[i][3], frame->sb_sample[blk][ch][3])))));
 589         }
 590
 591         /* Compute the samples */
 592         for (idx = 0, i = 0; i < 4; i++, idx += 5) {
 593                 k = (i + 4) & 0xf;
 594
 595                 /* Store in output, Q0 */
 596                 frame->pcm_sample[ch][blk * 4 + i] = sbc_clip16(SCALE4_STAGED1(
 597                         MULA(v[offset[i] + 0], sbc_proto_4_40m0[idx + 0],
 598                         MULA(v[offset[k] + 1], sbc_proto_4_40m1[idx + 0],
 599                         MULA(v[offset[i] + 2], sbc_proto_4_40m0[idx + 1],
 600                         MULA(v[offset[k] + 3], sbc_proto_4_40m1[idx + 1],
 601                         MULA(v[offset[i] + 4], sbc_proto_4_40m0[idx + 2],
 602                         MULA(v[offset[k] + 5], sbc_proto_4_40m1[idx + 2],
 603                         MULA(v[offset[i] + 6], sbc_proto_4_40m0[idx + 3],
 604                         MULA(v[offset[k] + 7], sbc_proto_4_40m1[idx + 3],
 605                         MULA(v[offset[i] + 8], sbc_proto_4_40m0[idx + 4],
 606                         MUL( v[offset[k] + 9], sbc_proto_4_40m1[idx + 4]))))))))))));
 607         }
 608 }
 609
 610 static inline void sbc_synthesize_eight(struct sbc_decoder_state *state,
 611                                 struct sbc_frame *frame, int ch, int blk)
 612 {
 613         int i, j, k, idx;
 614         int *offset = state->offset[ch];
 615
 616         for (i = 0; i < 16; i++) {
 617                 /* Shifting */
 618                 offset[i]--;
 619                 if (offset[i] < 0) {
 620                         offset[i] = 159;
 621                         for (j = 0; j < 9; j++)
 622                                 state->V[ch][j + 160] = state->V[ch][j];
 623                 }
 624
 625                 /* Distribute the new matrix value to the shifted position */
 626                 state->V[ch][offset[i]] = SCALE8_STAGED1(
 627                         MULA(synmatrix8[i][0], frame->sb_sample[blk][ch][0],
 628                         MULA(synmatrix8[i][1], frame->sb_sample[blk][ch][1],
 629                         MULA(synmatrix8[i][2], frame->sb_sample[blk][ch][2],
 630                         MULA(synmatrix8[i][3], frame->sb_sample[blk][ch][3],
 631                         MULA(synmatrix8[i][4], frame->sb_sample[blk][ch][4],
 632                         MULA(synmatrix8[i][5], frame->sb_sample[blk][ch][5],
 633                         MULA(synmatrix8[i][6], frame->sb_sample[blk][ch][6],
 634                         MUL( synmatrix8[i][7], frame->sb_sample[blk][ch][7])))))))));
 635         }
 636
 637         /* Compute the samples */
 638         for (idx = 0, i = 0; i < 8; i++, idx += 5) {
 639                 k = (i + 8) & 0xf;
 640
 641                 /* Store in output, Q0 */
 642                 frame->pcm_sample[ch][blk * 8 + i] = sbc_clip16(SCALE8_STAGED1(
 643                         MULA(state->V[ch][offset[i] + 0], sbc_proto_8_80m0[idx + 0],
 644                         MULA(state->V[ch][offset[k] + 1], sbc_proto_8_80m1[idx + 0],
 645                         MULA(state->V[ch][offset[i] + 2], sbc_proto_8_80m0[idx + 1],
 646                         MULA(state->V[ch][offset[k] + 3], sbc_proto_8_80m1[idx + 1],
 647                         MULA(state->V[ch][offset[i] + 4], sbc_proto_8_80m0[idx + 2],
 648                         MULA(state->V[ch][offset[k] + 5], sbc_proto_8_80m1[idx + 2],
 649                         MULA(state->V[ch][offset[i] + 6], sbc_proto_8_80m0[idx + 3],
 650                         MULA(state->V[ch][offset[k] + 7], sbc_proto_8_80m1[idx + 3],
 651                         MULA(state->V[ch][offset[i] + 8], sbc_proto_8_80m0[idx + 4],
 652                         MUL( state->V[ch][offset[k] + 9], sbc_proto_8_80m1[idx + 4]))))))))))));
 653         }
 654 }
 655
 656 static int sbc_synthesize_audio(struct sbc_decoder_state *state,
 657                                                 struct sbc_frame *frame)
 658 {
 659         int ch, blk;
 660
 661         switch (frame->subbands) {
 662         case 4:
 663                 for (ch = 0; ch < frame->channels; ch++) {
 664                         for (blk = 0; blk < frame->blocks; blk++)
 665                                 sbc_synthesize_four(state, frame, ch, blk);
 666                 }
 667                 return frame->blocks * 4;
 668
 669         case 8:
 670                 for (ch = 0; ch < frame->channels; ch++) {
 671                         for (blk = 0; blk < frame->blocks; blk++)
 672                                 sbc_synthesize_eight(state, frame, ch, blk);
 673                 }
 674                 return frame->blocks * 8;
 675
 676         default:
 677                 return -EIO;
 678         }
 679 }
 680
 681 static int sbc_analyze_audio(struct sbc_encoder_state *state,
 682                                                 struct sbc_frame *frame)
 683 {
 684         int ch, blk;
 685         int16_t *x;
 686
 687         switch (frame->subbands) {
 688         case 4:
 689                 for (ch = 0; ch < frame->channels; ch++) {
 690                         x = &state->X[ch][state->position - 16 +
 691                                                         frame->blocks * 4];
 692                         for (blk = 0; blk < frame->blocks; blk += 4) {
 693                                 state->sbc_analyze_4b_4s(
 694                                         x,
 695                                         frame->sb_sample_f[blk][ch],
 696                                         frame->sb_sample_f[blk + 1][ch] -
 697                                         frame->sb_sample_f[blk][ch]);
 698                                 x -= 16;
 699                         }
 700                 }
 701                 return frame->blocks * 4;
 702
 703         case 8:
 704                 for (ch = 0; ch < frame->channels; ch++) {
 705                         x = &state->X[ch][state->position - 32 +
 706                                                         frame->blocks * 8];
 707                         for (blk = 0; blk < frame->blocks; blk += 4) {
 708                                 state->sbc_analyze_4b_8s(
 709                                         x,
 710                                         frame->sb_sample_f[blk][ch],
 711                                         frame->sb_sample_f[blk + 1][ch] -
 712                                         frame->sb_sample_f[blk][ch]);
 713                                 x -= 32;
 714                         }
 715                 }
 716                 return frame->blocks * 8;
 717
 718         default:
 719                 return -EIO;
 720         }
 721 }
 722
 723 /* Supplementary bitstream writing macros for 'sbc_pack_frame' */
 724
 725 #define PUT_BITS(data_ptr, bits_cache, bits_count, v, n)                \
 726         do {                                                            \
 727                 bits_cache = (v) | (bits_cache << (n));                 \
 728                 bits_count += (n);                                      \
 729                 if (bits_count >= 16) {                                 \
 730                         bits_count -= 8;                                \
 731                         *data_ptr++ = (uint8_t)                         \
 732                                 (bits_cache >> bits_count);             \
 733                         bits_count -= 8;                                \
 734                         *data_ptr++ = (uint8_t)                         \
 735                                 (bits_cache >> bits_count);             \
 736                 }                                                       \
 737         } while (0)
 738
 739 #define FLUSH_BITS(data_ptr, bits_cache, bits_count)                    \
 740         do {                                                            \
 741                 while (bits_count >= 8) {                               \
 742                         bits_count -= 8;                                \
 743                         *data_ptr++ = (uint8_t)                         \
 744                                 (bits_cache >> bits_count);             \
 745                 }                                                       \
 746                 if (bits_count > 0)                                     \
 747                         *data_ptr++ = (uint8_t)                         \
 748                                 (bits_cache << (8 - bits_count));       \
 749         } while (0)
 750
 751 /*
 752  * Packs the SBC frame from frame into the memory at data. At most len
 753  * bytes will be used, should more memory be needed an appropriate
 754  * error code will be returned. Returns the length of the packed frame
 755  * on success or a negative value on error.
 756  *
 757  * The error codes are:
 758  * -1 Not enough memory reserved
 759  * -2 Unsupported sampling rate
 760  * -3 Unsupported number of blocks
 761  * -4 Unsupported number of subbands
 762  * -5 Bitpool value out of bounds
 763  * -99 not implemented
 764  */
 765
 766 static SBC_ALWAYS_INLINE ssize_t sbc_pack_frame_internal(uint8_t *data,
 767                                         struct sbc_frame *frame, size_t len,
 768                                         int frame_subbands, int frame_channels,
 769                                         int joint)
 770 {
 771         /* Bitstream writer starts from the fourth byte */
 772         uint8_t *data_ptr = data + 4;
 773         uint32_t bits_cache = 0;
 774         uint32_t bits_count = 0;
 775
 776         /* Will copy the header parts for CRC-8 calculation here */
 777         uint8_t crc_header[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 778         int crc_pos = 0;
 779
 780         uint32_t audio_sample;
 781
 782         int ch, sb, blk;        /* channel, subband, block and bit counters */
 783         int bits[2][8];         /* bits distribution */
 784         uint32_t levels[2][8];  /* levels are derived from that */
 785         uint32_t sb_sample_delta[2][8];
 786
 787         data[0] = SBC_SYNCWORD;
 788
 789         data[1] = (frame->frequency & 0x03) << 6;
 790
 791         data[1] |= (frame->block_mode & 0x03) << 4;
 792
 793         data[1] |= (frame->mode & 0x03) << 2;
 794
 795         data[1] |= (frame->allocation & 0x01) << 1;
 796
 797         switch (frame_subbands) {
 798         case 4:
 799                 /* Nothing to do */
 800                 break;
 801         case 8:
 802                 data[1] |= 0x01;
 803                 break;
 804         default:
 805                 return -4;
 806                 break;
 807         }
 808
 809         data[2] = frame->bitpool;
 810
 811         if ((frame->mode == MONO || frame->mode == DUAL_CHANNEL) &&
 812                         frame->bitpool > frame_subbands << 4)
 813                 return -5;
 814
 815         if ((frame->mode == STEREO || frame->mode == JOINT_STEREO) &&
 816                         frame->bitpool > frame_subbands << 5)
 817                 return -5;
 818
 819         /* Can't fill in crc yet */
 820
 821         crc_header[0] = data[1];
 822         crc_header[1] = data[2];
 823         crc_pos = 16;
 824
 825         if (frame->mode == JOINT_STEREO) {
 826                 PUT_BITS(data_ptr, bits_cache, bits_count,
 827                         joint, frame_subbands);
 828                 crc_header[crc_pos >> 3] = joint;
 829                 crc_pos += frame_subbands;
 830         }
 831
 832         for (ch = 0; ch < frame_channels; ch++) {
 833                 for (sb = 0; sb < frame_subbands; sb++) {
 834                         PUT_BITS(data_ptr, bits_cache, bits_count,
 835                                 frame->scale_factor[ch][sb] & 0x0F, 4);
 836                         crc_header[crc_pos >> 3] <<= 4;
 837                         crc_header[crc_pos >> 3] |= frame->scale_factor[ch][sb] & 0x0F;
 838                         crc_pos += 4;
 839                 }
 840         }
 841
 842         /* align the last crc byte */
 843         if (crc_pos % 8)
 844                 crc_header[crc_pos >> 3] <<= 8 - (crc_pos % 8);
 845
 846         data[3] = sbc_crc8(crc_header, crc_pos);
 847
 848         sbc_calculate_bits(frame, bits);
 849
 850         for (ch = 0; ch < frame_channels; ch++) {
 851                 for (sb = 0; sb < frame_subbands; sb++) {
 852                         levels[ch][sb] = ((1 << bits[ch][sb]) - 1) <<
 853                                 (32 - (frame->scale_factor[ch][sb] +
 854                                         SCALE_OUT_BITS + 2));
 855                         sb_sample_delta[ch][sb] = (uint32_t) 1 <<
 856                                 (frame->scale_factor[ch][sb] +
 857                                         SCALE_OUT_BITS + 1);
 858                 }
 859         }
 860
 861         for (blk = 0; blk < frame->blocks; blk++) {
 862                 for (ch = 0; ch < frame_channels; ch++) {
 863                         for (sb = 0; sb < frame_subbands; sb++) {
 864
 865                                 if (bits[ch][sb] == 0)
 866                                         continue;
 867
 868                                 audio_sample = ((uint64_t) levels[ch][sb] *
 869                                         (sb_sample_delta[ch][sb] +
 870                                         frame->sb_sample_f[blk][ch][sb])) >> 32;
 871
 872                                 PUT_BITS(data_ptr, bits_cache, bits_count,
 873                                         audio_sample, bits[ch][sb]);
 874                         }
 875                 }
 876         }
 877
 878         FLUSH_BITS(data_ptr, bits_cache, bits_count);
 879
 880         return data_ptr - data;
 881 }
 882
 883 static ssize_t sbc_pack_frame(uint8_t *data, struct sbc_frame *frame, size_t len,
 884                                                                 int joint)
 885 {
 886         if (frame->subbands == 4) {
 887                 if (frame->channels == 1)
 888                         return sbc_pack_frame_internal(
 889                                 data, frame, len, 4, 1, joint);
 890                 else
 891                         return sbc_pack_frame_internal(
 892                                 data, frame, len, 4, 2, joint);
 893         } else {
 894                 if (frame->channels == 1)
 895                         return sbc_pack_frame_internal(
 896                                 data, frame, len, 8, 1, joint);
 897                 else
 898                         return sbc_pack_frame_internal(
 899                                 data, frame, len, 8, 2, joint);
 900         }
 901 }
 902
 903 static void sbc_encoder_init(struct sbc_encoder_state *state,
 904                                         const struct sbc_frame *frame)
 905 {
 906         memset(&state->X, 0, sizeof(state->X));
 907         state->position = (SBC_X_BUFFER_SIZE - frame->subbands * 9) & ~7;
 908
 909         sbc_init_primitives(state);
 910 }
 911
 912 struct sbc_priv {
 913         int init;
 914         struct SBC_ALIGNED sbc_frame frame;
 915         struct SBC_ALIGNED sbc_decoder_state dec_state;
 916         struct SBC_ALIGNED sbc_encoder_state enc_state;
 917 };
 918
 919 static void sbc_set_defaults(sbc_t *sbc, unsigned long flags)
 920 {
 921         sbc->frequency = SBC_FREQ_44100;
 922         sbc->mode = SBC_MODE_STEREO;
 923         sbc->subbands = SBC_SB_8;
 924         sbc->blocks = SBC_BLK_16;
 925         sbc->bitpool = 32;
 926 #if __BYTE_ORDER == __LITTLE_ENDIAN
 927         sbc->endian = SBC_LE;
 928 #elif __BYTE_ORDER == __BIG_ENDIAN
 929         sbc->endian = SBC_BE;
 930 #else
 931 #error "Unknown byte order"
 932 #endif
 933 }
 934
 935 int sbc_init(sbc_t *sbc, unsigned long flags)
 936 {
 937         if (!sbc)
 938                 return -EIO;
 939
 940         memset(sbc, 0, sizeof(sbc_t));
 941
 942         sbc->priv_alloc_base = malloc(sizeof(struct sbc_priv) + SBC_ALIGN_MASK);
 943         if (!sbc->priv_alloc_base)
 944                 return -ENOMEM;
 945
 946         sbc->priv = (void *) (((uintptr_t) sbc->priv_alloc_base +
 947                         SBC_ALIGN_MASK) & ~((uintptr_t) SBC_ALIGN_MASK));
 948
 949         memset(sbc->priv, 0, sizeof(struct sbc_priv));
 950
 951         sbc_set_defaults(sbc, flags);
 952
 953         return 0;
 954 }
 955
 956 ssize_t sbc_parse(sbc_t *sbc, const void *input, size_t input_len)
 957 {
 958         return sbc_decode(sbc, input, input_len, NULL, 0, NULL);
 959 }
 960
 961 ssize_t sbc_decode(sbc_t *sbc, const void *input, size_t input_len,
 962                         void *output, size_t output_len, size_t *written)
 963 {
 964         struct sbc_priv *priv;
 965         char *ptr;
 966         int i, ch, framelen, samples;
 967
 968         if (!sbc || !input)
 969                 return -EIO;
 970
 971         priv = sbc->priv;
 972
 973         framelen = sbc_unpack_frame(input, &priv->frame, input_len);
 974
 975         if (!priv->init) {
 976                 sbc_decoder_init(&priv->dec_state, &priv->frame);
 977                 priv->init = 1;
 978
 979                 sbc->frequency = priv->frame.frequency;
 980                 sbc->mode = priv->frame.mode;
 981                 sbc->subbands = priv->frame.subband_mode;
 982                 sbc->blocks = priv->frame.block_mode;
 983                 sbc->allocation = priv->frame.allocation;
 984                 sbc->bitpool = priv->frame.bitpool;
 985
 986                 priv->frame.codesize = sbc_get_codesize(sbc);
 987                 priv->frame.length = framelen;
 988         } else if (priv->frame.bitpool != sbc->bitpool) {
 989                 priv->frame.length = framelen;
 990                 sbc->bitpool = priv->frame.bitpool;
 991         }
 992
 993         if (!output)
 994                 return framelen;
 995
 996         if (written)
 997                 *written = 0;
 998
 999         if (framelen <= 0)
1000                 return framelen;
1001
1002         samples = sbc_synthesize_audio(&priv->dec_state, &priv->frame);
1003
1004         ptr = output;
1005
1006         if (output_len < (size_t) (samples * priv->frame.channels * 2))
1007                 samples = output_len / (priv->frame.channels * 2);
1008
1009         for (i = 0; i < samples; i++) {
1010                 for (ch = 0; ch < priv->frame.channels; ch++) {
1011                         int16_t s;
1012                         s = priv->frame.pcm_sample[ch][i];
1013
1014                         if (sbc->endian == SBC_BE) {
1015                                 *ptr++ = (s & 0xff00) >> 8;
1016                                 *ptr++ = (s & 0x00ff);
1017                         } else {
1018                                 *ptr++ = (s & 0x00ff);
1019                                 *ptr++ = (s & 0xff00) >> 8;
1020                         }
1021                 }
1022         }
1023
1024         if (written)
1025                 *written = samples * priv->frame.channels * 2;
1026
1027         return framelen;
1028 }
1029
1030 ssize_t sbc_encode(sbc_t *sbc, const void *input, size_t input_len,
1031                         void *output, size_t output_len, ssize_t *written)
1032 {
1033         struct sbc_priv *priv;
1034         int samples;
1035         ssize_t framelen;
1036         int (*sbc_enc_process_input)(int position,
1037                         const uint8_t *pcm, int16_t X[2][SBC_X_BUFFER_SIZE],
1038                         int nsamples, int nchannels);
1039
1040         if (!sbc || !input)
1041                 return -EIO;
1042
1043         priv = sbc->priv;
1044
1045         if (written)
1046                 *written = 0;
1047
1048         if (!priv->init) {
1049                 priv->frame.frequency = sbc->frequency;
1050                 priv->frame.mode = sbc->mode;
1051                 priv->frame.channels = sbc->mode == SBC_MODE_MONO ? 1 : 2;
1052                 priv->frame.allocation = sbc->allocation;
1053                 priv->frame.subband_mode = sbc->subbands;
1054                 priv->frame.subbands = sbc->subbands ? 8 : 4;
1055                 priv->frame.block_mode = sbc->blocks;
1056                 priv->frame.blocks = 4 + (sbc->blocks * 4);
1057                 priv->frame.bitpool = sbc->bitpool;
1058                 priv->frame.codesize = sbc_get_codesize(sbc);
1059                 priv->frame.length = sbc_get_frame_length(sbc);
1060
1061                 sbc_encoder_init(&priv->enc_state, &priv->frame);
1062                 priv->init = 1;
1063         } else if (priv->frame.bitpool != sbc->bitpool) {
1064                 priv->frame.length = sbc_get_frame_length(sbc);
1065                 priv->frame.bitpool = sbc->bitpool;
1066         }
1067
1068         /* input must be large enough to encode a complete frame */
1069         if (input_len < priv->frame.codesize)
1070                 return 0;
1071
1072         /* output must be large enough to receive the encoded frame */
1073         if (!output || output_len < priv->frame.length)
1074                 return -ENOSPC;
1075
1076         /* Select the needed input data processing function and call it */
1077         if (priv->frame.subbands == 8) {
1078                 if (sbc->endian == SBC_BE)
1079                         sbc_enc_process_input =
1080                                 priv->enc_state.sbc_enc_process_input_8s_be;
1081                 else
1082                         sbc_enc_process_input =
1083                                 priv->enc_state.sbc_enc_process_input_8s_le;
1084         } else {
1085                 if (sbc->endian == SBC_BE)
1086                         sbc_enc_process_input =
1087                                 priv->enc_state.sbc_enc_process_input_4s_be;
1088                 else
1089                         sbc_enc_process_input =
1090                                 priv->enc_state.sbc_enc_process_input_4s_le;
1091         }
1092
1093         priv->enc_state.position = sbc_enc_process_input(
1094                 priv->enc_state.position, (const uint8_t *) input,
1095                 priv->enc_state.X, priv->frame.subbands * priv->frame.blocks,
1096                 priv->frame.channels);
1097
1098         samples = sbc_analyze_audio(&priv->enc_state, &priv->frame);
1099
1100         if (priv->frame.mode == JOINT_STEREO) {
1101                 int j = priv->enc_state.sbc_calc_scalefactors_j(
1102                         priv->frame.sb_sample_f, priv->frame.scale_factor,
1103                         priv->frame.blocks, priv->frame.subbands);
1104                 framelen = sbc_pack_frame(output, &priv->frame, output_len, j);
1105         } else {
1106                 priv->enc_state.sbc_calc_scalefactors(
1107                         priv->frame.sb_sample_f, priv->frame.scale_factor,
1108                         priv->frame.blocks, priv->frame.channels,
1109                         priv->frame.subbands);
1110                 framelen = sbc_pack_frame(output, &priv->frame, output_len, 0);
1111         }
1112
1113         if (written)
1114                 *written = framelen;
1115
1116         return samples * priv->frame.channels * 2;
1117 }
1118
1119 void sbc_finish(sbc_t *sbc)
1120 {
1121         if (!sbc)
1122                 return;
1123
1124         free(sbc->priv_alloc_base);
1125
1126         memset(sbc, 0, sizeof(sbc_t));
1127 }
1128
1129 size_t sbc_get_frame_length(sbc_t *sbc)
1130 {
1131         int ret;
1132         uint8_t subbands, channels, blocks, joint, bitpool;
1133         struct sbc_priv *priv;
1134
1135         priv = sbc->priv;
1136         if (priv->init && priv->frame.bitpool == sbc->bitpool)
1137                 return priv->frame.length;
1138
1139         subbands = sbc->subbands ? 8 : 4;
1140         blocks = 4 + (sbc->blocks * 4);
1141         channels = sbc->mode == SBC_MODE_MONO ? 1 : 2;
1142         joint = sbc->mode == SBC_MODE_JOINT_STEREO ? 1 : 0;
1143         bitpool = sbc->bitpool;
1144
1145         ret = 4 + (4 * subbands * channels) / 8;
1146         /* This term is not always evenly divide so we round it up */
1147         if (channels == 1)
1148                 ret += ((blocks * channels * bitpool) + 7) / 8;
1149         else
1150                 ret += (((joint ? subbands : 0) + blocks * bitpool) + 7) / 8;
1151
1152         return ret;
1153 }
1154
1155 unsigned sbc_get_frame_duration(sbc_t *sbc)
1156 {
1157         uint8_t subbands, blocks;
1158         uint16_t frequency;
1159         struct sbc_priv *priv;
1160
1161         priv = sbc->priv;
1162         if (!priv->init) {
1163                 subbands = sbc->subbands ? 8 : 4;
1164                 blocks = 4 + (sbc->blocks * 4);
1165         } else {
1166                 subbands = priv->frame.subbands;
1167                 blocks = priv->frame.blocks;
1168         }
1169
1170         switch (sbc->frequency) {
1171         case SBC_FREQ_16000:
1172                 frequency = 16000;
1173                 break;
1174
1175         case SBC_FREQ_32000:
1176                 frequency = 32000;
1177                 break;
1178
1179         case SBC_FREQ_44100:
1180                 frequency = 44100;
1181                 break;
1182
1183         case SBC_FREQ_48000:
1184                 frequency = 48000;
1185                 break;
1186         default:
1187                 return 0;
1188         }
1189
1190         return (1000000 * blocks * subbands) / frequency;
1191 }
1192
1193 size_t sbc_get_codesize(sbc_t *sbc)
1194 {
1195         uint16_t subbands, channels, blocks;
1196         struct sbc_priv *priv;
1197
1198         priv = sbc->priv;
1199         if (!priv->init) {
1200                 subbands = sbc->subbands ? 8 : 4;
1201                 blocks = 4 + (sbc->blocks * 4);
1202                 channels = sbc->mode == SBC_MODE_MONO ? 1 : 2;
1203         } else {
1204                 subbands = priv->frame.subbands;
1205                 blocks = priv->frame.blocks;
1206                 channels = priv->frame.channels;
1207         }
1208
1209         return subbands * blocks * channels * 2;
1210 }
1211
1212 const char *sbc_get_implementation_info(sbc_t *sbc)
1213 {
1214         struct sbc_priv *priv;
1215
1216         if (!sbc)
1217                 return NULL;
1218
1219         priv = sbc->priv;
1220         if (!priv)
1221                 return NULL;
1222
1223         return priv->enc_state.implementation_info;
1224 }
1225
1226 int sbc_reinit(sbc_t *sbc, unsigned long flags)
1227 {
1228         struct sbc_priv *priv;
1229
1230         if (!sbc || !sbc->priv)
1231                 return -EIO;
1232
1233         priv = sbc->priv;
1234
1235         if (priv->init == 1)
1236                 memset(sbc->priv, 0, sizeof(struct sbc_priv));
1237
1238         sbc_set_defaults(sbc, flags);
1239
1240         return 0;
1241 }