From ad868bd4137e86fbf141175f411898796287ff2a Mon Sep 17 00:00:00 2001 From: Brad Midgley Date: Sat, 17 Mar 2007 13:37:31 +0000 Subject: update the sbc encoder from the working fixed-point code in the sbc project I also tagged the sbc project with "copied-to-bluez-utils" at the same time. We will do sbc work under bluez and sync it with the old sbc project if necessary. --- sbc/sbc.c | 1398 +++++++++++++++++++++++++++++++++++++++++++++++++++++- sbc/sbc.h | 30 +- sbc/sbc_math.h | 44 +- sbc/sbc_tables.h | 4 +- 4 files changed, 1453 insertions(+), 23 deletions(-) (limited to 'sbc') diff --git a/sbc/sbc.c b/sbc/sbc.c index f14f59a9..1f16d70a 100644 --- a/sbc/sbc.c +++ b/sbc/sbc.c @@ -2,7 +2,9 @@ * * Bluetooth low-complexity, subband codec (SBC) library * - * Copyright (C) 2004-2007 Marcel Holtmann + * Copyright (C) 2004-2006 Marcel Holtmann + * Copyright (C) 2004-2005 Henryk Ploetz + * Copyright (C) 2005-2006 Brad Midgley * * * This library is free software; you can redistribute it and/or @@ -21,13 +23,1407 @@ * */ +/* todo items: + + use a log2 table for byte integer scale factors calculation (sum log2 results for high and low bytes) + fill bitpool by 16 bits instead of one at a time in bits allocation/bitpool generation + port to the dsp + don't consume more bytes than passed into the encoder + +*/ + #ifdef HAVE_CONFIG_H #include #endif +#include +#include #include +#include +#include +#include +#include + #include "sbc_math.h" #include "sbc_tables.h" #include "sbc.h" + +#define SBC_SYNCWORD 0x9C + +/* sampling frequency */ +#define SBC_FS_16 0x00 +#define SBC_FS_32 0x01 +#define SBC_FS_44 0x02 +#define SBC_FS_48 0x03 + +/* nrof_blocks */ +#define SBC_NB_4 0x00 +#define SBC_NB_8 0x01 +#define SBC_NB_12 0x02 +#define SBC_NB_16 0x03 + +/* channel mode */ +#define SBC_CM_MONO 0x00 +#define SBC_CM_DUAL_CHANNEL 0x01 +#define SBC_CM_STEREO 0x02 +#define SBC_CM_JOINT_STEREO 0x03 + +/* allocation mode */ +#define SBC_AM_LOUDNESS 0x00 +#define SBC_AM_SNR 0x01 + +/* subbands */ +#define SBC_SB_4 0x00 +#define SBC_SB_8 0x01 + +/* This structure contains an unpacked SBC frame. + Yes, there is probably quite some unused space herein */ +struct sbc_frame { + uint16_t sampling_frequency; /* in kHz */ + uint8_t blocks; + enum { + MONO = SBC_CM_MONO, + DUAL_CHANNEL = SBC_CM_DUAL_CHANNEL, + STEREO = SBC_CM_STEREO, + JOINT_STEREO = SBC_CM_JOINT_STEREO + } channel_mode; + uint8_t channels; + enum { + LOUDNESS = SBC_AM_LOUDNESS, + SNR = SBC_AM_SNR + } allocation_method; + uint8_t subbands; + uint8_t bitpool; + uint8_t join; /* bit number x set means joint stereo has been used in subband x */ + uint8_t scale_factor[2][8]; /* only the lower 4 bits of every element are to be used */ + uint16_t audio_sample[16][2][8]; /* raw integer subband samples in the frame */ + + int32_t sb_sample_f[16][2][8]; + int32_t sb_sample[16][2][8]; /* modified subband samples */ + int16_t pcm_sample[2][16*8]; /* original pcm audio samples */ +}; + +struct sbc_decoder_state { + int subbands; + int32_t V[2][170]; + int offset[2][16]; +}; + +struct sbc_encoder_state { + int subbands; + int32_t X[2][80]; +}; + +/* + * Calculates the CRC-8 of the first len bits in data + */ +static const uint8_t crc_table[256] = { + 0x00, 0x1D, 0x3A, 0x27, 0x74, 0x69, 0x4E, 0x53, + 0xE8, 0xF5, 0xD2, 0xCF, 0x9C, 0x81, 0xA6, 0xBB, + 0xCD, 0xD0, 0xF7, 0xEA, 0xB9, 0xA4, 0x83, 0x9E, + 0x25, 0x38, 0x1F, 0x02, 0x51, 0x4C, 0x6B, 0x76, + 0x87, 0x9A, 0xBD, 0xA0, 0xF3, 0xEE, 0xC9, 0xD4, + 0x6F, 0x72, 0x55, 0x48, 0x1B, 0x06, 0x21, 0x3C, + 0x4A, 0x57, 0x70, 0x6D, 0x3E, 0x23, 0x04, 0x19, + 0xA2, 0xBF, 0x98, 0x85, 0xD6, 0xCB, 0xEC, 0xF1, + 0x13, 0x0E, 0x29, 0x34, 0x67, 0x7A, 0x5D, 0x40, + 0xFB, 0xE6, 0xC1, 0xDC, 0x8F, 0x92, 0xB5, 0xA8, + 0xDE, 0xC3, 0xE4, 0xF9, 0xAA, 0xB7, 0x90, 0x8D, + 0x36, 0x2B, 0x0C, 0x11, 0x42, 0x5F, 0x78, 0x65, + 0x94, 0x89, 0xAE, 0xB3, 0xE0, 0xFD, 0xDA, 0xC7, + 0x7C, 0x61, 0x46, 0x5B, 0x08, 0x15, 0x32, 0x2F, + 0x59, 0x44, 0x63, 0x7E, 0x2D, 0x30, 0x17, 0x0A, + 0xB1, 0xAC, 0x8B, 0x96, 0xC5, 0xD8, 0xFF, 0xE2, + 0x26, 0x3B, 0x1C, 0x01, 0x52, 0x4F, 0x68, 0x75, + 0xCE, 0xD3, 0xF4, 0xE9, 0xBA, 0xA7, 0x80, 0x9D, + 0xEB, 0xF6, 0xD1, 0xCC, 0x9F, 0x82, 0xA5, 0xB8, + 0x03, 0x1E, 0x39, 0x24, 0x77, 0x6A, 0x4D, 0x50, + 0xA1, 0xBC, 0x9B, 0x86, 0xD5, 0xC8, 0xEF, 0xF2, + 0x49, 0x54, 0x73, 0x6E, 0x3D, 0x20, 0x07, 0x1A, + 0x6C, 0x71, 0x56, 0x4B, 0x18, 0x05, 0x22, 0x3F, + 0x84, 0x99, 0xBE, 0xA3, 0xF0, 0xED, 0xCA, 0xD7, + 0x35, 0x28, 0x0F, 0x12, 0x41, 0x5C, 0x7B, 0x66, + 0xDD, 0xC0, 0xE7, 0xFA, 0xA9, 0xB4, 0x93, 0x8E, + 0xF8, 0xE5, 0xC2, 0xDF, 0x8C, 0x91, 0xB6, 0xAB, + 0x10, 0x0D, 0x2A, 0x37, 0x64, 0x79, 0x5E, 0x43, + 0xB2, 0xAF, 0x88, 0x95, 0xC6, 0xDB, 0xFC, 0xE1, + 0x5A, 0x47, 0x60, 0x7D, 0x2E, 0x33, 0x14, 0x09, + 0x7F, 0x62, 0x45, 0x58, 0x0B, 0x16, 0x31, 0x2C, + 0x97, 0x8A, 0xAD, 0xB0, 0xE3, 0xFE, 0xD9, 0xC4 +}; + +static uint8_t sbc_crc8(const uint8_t * data, size_t len) +{ + uint8_t crc = 0x0f; + size_t i; + uint8_t octet; + + for (i = 0; i < len / 8; i++) + crc = crc_table[crc ^ data[i]]; + + octet = data[i]; + for (i = 0; i < len % 8; i++) { + char bit = ((octet ^ crc) & 0x80) >> 7; + + crc = ((crc & 0x7f) << 1) ^ (bit ? 0x1d : 0); + + octet = octet << 1; + } + + return crc; +} + +/* + * Code straight from the spec to calculate the bits array + * Takes a pointer to the frame in question, a pointer to the bits array and the sampling frequency (as 2 bit integer) + */ +static void sbc_calculate_bits(const struct sbc_frame *frame, int (*bits)[8], uint8_t sf) +{ + if (frame->channel_mode == MONO || frame->channel_mode == DUAL_CHANNEL) { + int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice; + int ch, sb; + + for (ch = 0; ch < frame->channels; ch++) { + if (frame->allocation_method == SNR) { + for (sb = 0; sb < frame->subbands; sb++) { + bitneed[ch][sb] = frame->scale_factor[ch][sb]; + } + } else { + for (sb = 0; sb < frame->subbands; sb++) { + if (frame->scale_factor[ch][sb] == 0) { + bitneed[ch][sb] = -5; + } else { + if (frame->subbands == 4) { + loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb]; + } else { + loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb]; + } + if (loudness > 0) { + bitneed[ch][sb] = loudness / 2; + } else { + bitneed[ch][sb] = loudness; + } + } + } + } + + max_bitneed = 0; + for (sb = 0; sb < frame->subbands; sb++) { + if (bitneed[ch][sb] > max_bitneed) + max_bitneed = bitneed[ch][sb]; + } + + bitcount = 0; + slicecount = 0; + bitslice = max_bitneed + 1; + do { + bitslice--; + bitcount += slicecount; + slicecount = 0; + for (sb = 0; sb < frame->subbands; sb++) { + if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16)) { + slicecount++; + } else if (bitneed[ch][sb] == bitslice + 1) { + slicecount += 2; + } + } + } while (bitcount + slicecount < frame->bitpool); + + if (bitcount + slicecount == frame->bitpool) { + bitcount += slicecount; + bitslice--; + } + + for (sb = 0; sb < frame->subbands; sb++) { + if (bitneed[ch][sb] < bitslice + 2) { + bits[ch][sb] = 0; + } else { + bits[ch][sb] = bitneed[ch][sb] - bitslice; + if (bits[ch][sb] > 16) + bits[ch][sb] = 16; + } + } + + sb = 0; + while (bitcount < frame->bitpool && sb < frame->subbands) { + if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) { + bits[ch][sb]++; + bitcount++; + } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) { + bits[ch][sb] = 2; + bitcount += 2; + } + sb++; + } + + sb = 0; + while (bitcount < frame->bitpool && sb < frame->subbands) { + if (bits[ch][sb] < 16) { + bits[ch][sb]++; + bitcount++; + } + sb++; + } + + } + + } else if (frame->channel_mode == STEREO || frame->channel_mode == JOINT_STEREO) { + int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice; + int ch, sb; + + if (frame->allocation_method == SNR) { + for (ch = 0; ch < 2; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + bitneed[ch][sb] = frame->scale_factor[ch][sb]; + } + } + } else { + for (ch = 0; ch < 2; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (frame->scale_factor[ch][sb] == 0) { + bitneed[ch][sb] = -5; + } else { + if (frame->subbands == 4) { + loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb]; + } else { + loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb]; + } + if (loudness > 0) { + bitneed[ch][sb] = loudness / 2; + } else { + bitneed[ch][sb] = loudness; + } + } + } + } + } + + max_bitneed = 0; + for (ch = 0; ch < 2; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (bitneed[ch][sb] > max_bitneed) + max_bitneed = bitneed[ch][sb]; + } + } + + bitcount = 0; + slicecount = 0; + bitslice = max_bitneed + 1; + do { + bitslice--; + bitcount += slicecount; + slicecount = 0; + for (ch = 0; ch < 2; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16)) { + slicecount++; + } else if (bitneed[ch][sb] == bitslice + 1) { + slicecount += 2; + } + } + } + } while (bitcount + slicecount < frame->bitpool); + if (bitcount + slicecount == frame->bitpool) { + bitcount += slicecount; + bitslice--; + } + + for (ch = 0; ch < 2; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (bitneed[ch][sb] < bitslice + 2) { + bits[ch][sb] = 0; + } else { + bits[ch][sb] = bitneed[ch][sb] - bitslice; + if (bits[ch][sb] > 16) + bits[ch][sb] = 16; + } + } + } + + ch = 0; + sb = 0; + while ((bitcount < frame->bitpool) && (sb < frame->subbands)) { + if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) { + bits[ch][sb]++; + bitcount++; + } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) { + bits[ch][sb] = 2; + bitcount += 2; + } + if (ch == 1) { + ch = 0; + sb++; + } else { + ch = 1; + } + } + + ch = 0; + sb = 0; + while ((bitcount < frame->bitpool) && (sb < frame->subbands)) { + if (bits[ch][sb] < 16) { + bits[ch][sb]++; + bitcount++; + } + if (ch == 1) { + ch = 0; + sb++; + } else { + ch = 1; + } + } + + } + +} + +/* + * Unpacks a SBC frame at the beginning of the stream in data, + * which has at most len bytes into frame. + * Returns the length in bytes of the packed frame, or a negative + * value on error. The error codes are: + * + * -1 Data stream too short + * -2 Sync byte incorrect + * -3 CRC8 incorrect + * -4 Bitpool value out of bounds + */ +static int sbc_unpack_frame(const uint8_t * data, struct sbc_frame *frame, size_t len) +{ + int consumed; + /* Will copy the parts of the header that are relevant to crc calculation here */ + uint8_t crc_header[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + int crc_pos = 0; + int32_t temp; + + uint8_t sf; /* sampling_frequency, temporarily needed as array index */ + + int ch, sb, blk, bit; /* channel, subband, block and bit standard counters */ + int bits[2][8]; /* bits distribution */ + int levels[2][8]; /* levels derived from that */ + + if (len < 4) + return -1; + + if (data[0] != SBC_SYNCWORD) + return -2; + + sf = (data[1] >> 6) & 0x03; + switch (sf) { + case SBC_FS_16: + frame->sampling_frequency = 16000; + break; + case SBC_FS_32: + frame->sampling_frequency = 32000; + break; + case SBC_FS_44: + frame->sampling_frequency = 44100; + break; + case SBC_FS_48: + frame->sampling_frequency = 48000; + break; + } + + switch ((data[1] >> 4) & 0x03) { + case SBC_NB_4: + frame->blocks = 4; + break; + case SBC_NB_8: + frame->blocks = 8; + break; + case SBC_NB_12: + frame->blocks = 12; + break; + case SBC_NB_16: + frame->blocks = 16; + break; + } + + frame->channel_mode = (data[1] >> 2) & 0x03; + switch (frame->channel_mode) { + case MONO: + frame->channels = 1; + break; + case DUAL_CHANNEL: /* fall-through */ + case STEREO: + case JOINT_STEREO: + frame->channels = 2; + break; + } + + frame->allocation_method = (data[1] >> 1) & 0x01; + + frame->subbands = (data[1] & 0x01) ? 8 : 4; + + frame->bitpool = data[2]; + + if (((frame->channel_mode == MONO || frame->channel_mode == DUAL_CHANNEL) + && frame->bitpool > 16 * frame->subbands) + || ((frame->channel_mode == STEREO || frame->channel_mode == JOINT_STEREO) + && frame->bitpool > 32 * frame->subbands)) + return -4; + + /* data[3] is crc, we're checking it later */ + + consumed = 32; + + crc_header[0] = data[1]; + crc_header[1] = data[2]; + crc_pos = 16; + + if (frame->channel_mode == JOINT_STEREO) { + if (len * 8 < consumed + frame->subbands) + return -1; + + frame->join = 0x00; + for (sb = 0; sb < frame->subbands - 1; sb++) { + frame->join |= ((data[4] >> (7 - sb)) & 0x01) << sb; + } + if (frame->subbands == 4) { + crc_header[crc_pos / 8] = data[4] & 0xf0; + } else { + crc_header[crc_pos / 8] = data[4]; + } + + consumed += frame->subbands; + crc_pos += frame->subbands; + } + + if (len * 8 < consumed + (4 * frame->subbands * frame->channels)) + return -1; + + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + /* FIXME assert(consumed % 4 == 0); */ + frame->scale_factor[ch][sb] = (data[consumed >> 3] >> (4 - (consumed & 0x7))) & 0x0F; + crc_header[crc_pos >> 3] |= frame->scale_factor[ch][sb] << (4 - (crc_pos & 0x7)); + + consumed += 4; + crc_pos += 4; + } + } + + if (data[3] != sbc_crc8(crc_header, crc_pos)) + return -3; + + sbc_calculate_bits(frame, bits, sf); + + for (blk = 0; blk < frame->blocks; blk++) { + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + frame->audio_sample[blk][ch][sb] = 0; + if (bits[ch][sb] == 0) + continue; + + for (bit = 0; bit < bits[ch][sb]; bit++) { + int b; /* A bit */ + if (consumed > len * 8) + return -1; + + b = (data[consumed >> 3] >> (7 - (consumed & 0x7))) & 0x01; + frame->audio_sample[blk][ch][sb] |= b << (bits[ch][sb] - bit - 1); + + consumed++; + } + } + } + } + + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + levels[ch][sb] = (1 << bits[ch][sb]) - 1; + } + } + + for (blk = 0; blk < frame->blocks; blk++) { + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (levels[ch][sb] > 0) { + frame->sb_sample[blk][ch][sb] = + (((frame->audio_sample[blk][ch][sb] << 16) | 0x8000) / levels[ch][sb]) - 0x8000; + + frame->sb_sample[blk][ch][sb] >>= 3; + frame->sb_sample[blk][ch][sb] = (frame->sb_sample[blk][ch][sb] << (frame->scale_factor[ch][sb] + 1)); // Q13 + + } else { + frame->sb_sample[blk][ch][sb] = 0; + } + } + } + } + + if (frame->channel_mode == JOINT_STEREO) { + for (blk = 0; blk < frame->blocks; blk++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (frame->join & (0x01 << sb)) { + temp = frame->sb_sample[blk][0][sb] + frame->sb_sample[blk][1][sb]; + frame->sb_sample[blk][1][sb] = frame->sb_sample[blk][0][sb] - frame->sb_sample[blk][1][sb]; + frame->sb_sample[blk][0][sb] = temp; + } + } + } + } + + if ((consumed & 0x7) != 0) + consumed += 8 - (consumed & 0x7); + + + return consumed >> 3; +} + +static void sbc_decoder_init(struct sbc_decoder_state *state, const struct sbc_frame *frame) +{ + int i, ch; + + memset(state->V, 0, sizeof(state->V)); + state->subbands = frame->subbands; + + for (ch = 0; ch < 2; ch++) + for (i = 0; i < frame->subbands * 2; i++) + state->offset[ch][i] = (10 * i + 10); +} + +static inline void sbc_synthesize_four(struct sbc_decoder_state *state, + struct sbc_frame *frame, int ch, int blk) +{ + int i, j, k, idx; + sbc_extended_t res; + + for(i = 0; i < 8; i++) { + /* Shifting */ + state->offset[ch][i]--; + if(state->offset[ch][i] < 0) { + state->offset[ch][i] = 79; + for(j = 0; j < 9; j++) { + state->V[ch][j+80] = state->V[ch][j]; + } + } + } + + + for(i = 0; i < 8; i++) { + /* Distribute the new matrix value to the shifted position */ + SBC_FIXED_0(res); + for (j = 0; j < 4; j++) { + MULA(res, synmatrix4[i][j], frame->sb_sample[blk][ch][j]); + } + state->V[ch][state->offset[ch][i]] = SCALE4_STAGED1(res); + } + + /* Compute the samples */ + for(idx = 0, i = 0; i < 4; i++) { + k = (i + 4) & 0xf; + SBC_FIXED_0(res); + for(j = 0; j < 10; idx++) { + MULA(res, state->V[ch][state->offset[ch][i]+j++], sbc_proto_4_40m0[idx]); + MULA(res, state->V[ch][state->offset[ch][k]+j++], sbc_proto_4_40m1[idx]); + } + /* Store in output */ + frame->pcm_sample[ch][blk * 4 + i] = SCALE4_STAGED2(res); // Q0 + } +} + +static inline void sbc_synthesize_eight(struct sbc_decoder_state *state, + struct sbc_frame *frame, int ch, int blk) +{ + int i, j, k, idx; + sbc_extended_t res; + + for(i = 0; i < 16; i++) { + /* Shifting */ + state->offset[ch][i]--; + if(state->offset[ch][i] < 0) { + state->offset[ch][i] = 159; + for(j = 0; j < 9; j++) { + state->V[ch][j+160] = state->V[ch][j]; + } + } + } + + for(i = 0; i < 16; i++) { + /* Distribute the new matrix value to the shifted position */ + SBC_FIXED_0(res); + for (j = 0; j < 8; j++) { + MULA(res, synmatrix8[i][j], frame->sb_sample[blk][ch][j]); // Q28 = Q15 * Q13 + } + state->V[ch][state->offset[ch][i]] = SCALE8_STAGED1(res); // Q10 + } + + + /* Compute the samples */ + for(idx = 0, i = 0; i < 8; i++) { + k = (i + 8) & 0xf; + SBC_FIXED_0(res); + for(j = 0; j < 10; idx++) { + MULA(res, state->V[ch][state->offset[ch][i]+j++], sbc_proto_8_80m0[idx]); + MULA(res, state->V[ch][state->offset[ch][k]+j++], sbc_proto_8_80m1[idx]); + } + /* Store in output */ + frame->pcm_sample[ch][blk * 8 + i] = SCALE8_STAGED2(res); // Q0 + + } +} + +static int sbc_synthesize_audio(struct sbc_decoder_state *state, struct sbc_frame *frame) +{ + int ch, blk; + + switch (frame->subbands) { + case 4: + for (ch = 0; ch < frame->channels; ch++) { + for (blk = 0; blk < frame->blocks; blk++) + sbc_synthesize_four(state, frame, ch, blk); + } + return frame->blocks * 4; + + case 8: + for (ch = 0; ch < frame->channels; ch++) { + for (blk = 0; blk < frame->blocks; blk++) + sbc_synthesize_eight(state, frame, ch, blk); + } + return frame->blocks * 8; + + default: + return -EIO; + } +} + +static void sbc_encoder_init(struct sbc_encoder_state *state, const struct sbc_frame *frame) +{ + memset(&state->X, 0, sizeof(state->X)); + state->subbands = frame->subbands; +} + +static inline void _sbc_analyze_four(const int32_t *in, int32_t *out) +{ + + sbc_extended_t res; + sbc_extended_t t[8]; + + out[0] = out[1] = out[2] = out[3] = 0; + + MUL(res, _sbc_proto_4[0], (in[8] - in[32])); // Q18 + MULA(res, _sbc_proto_4[1], (in[16] - in[24])); + t[0] = SCALE4_STAGE1(res); // Q8 + + MUL(res, _sbc_proto_4[2], in[1]); + MULA(res, _sbc_proto_4[3], in[9]); + MULA(res, _sbc_proto_4[4], in[17]); + MULA(res, _sbc_proto_4[5], in[25]); + MULA(res, _sbc_proto_4[6], in[33]); + t[1] = SCALE4_STAGE1(res); + + MUL(res, _sbc_proto_4[7], in[2]); + MULA(res, _sbc_proto_4[8], in[10]); + MULA(res, _sbc_proto_4[9], in[18]); + MULA(res, _sbc_proto_4[10], in[26]); + MULA(res, _sbc_proto_4[11], in[34]); + t[2] = SCALE4_STAGE1(res); + + MUL(res, _sbc_proto_4[12], in[3]); + MULA(res, _sbc_proto_4[13], in[11]); + MULA(res, _sbc_proto_4[14], in[19]); + MULA(res, _sbc_proto_4[15], in[27]); + MULA(res, _sbc_proto_4[16], in[35]); + t[3] = SCALE4_STAGE1(res); + + MUL(res, _sbc_proto_4[17], in[4]); + MULA(res, _sbc_proto_4[18], (in[12] + in[28])); + MULA(res, _sbc_proto_4[19], in[20]); + MULA(res, _sbc_proto_4[17], in[36]); + t[4] = SCALE4_STAGE1(res); + + MUL(res, _sbc_proto_4[16], in[5]); + MULA(res, _sbc_proto_4[15], in[13]); + MULA(res, _sbc_proto_4[14], in[21]); + MULA(res, _sbc_proto_4[13], in[29]); + MULA(res, _sbc_proto_4[12], in[37]); + t[5] = SCALE4_STAGE1(res); + + MUL(res, _sbc_proto_4[11], in[6]); + MULA(res, _sbc_proto_4[10], in[14]); + MULA(res, _sbc_proto_4[9], in[22]); + MULA(res, _sbc_proto_4[8], in[30]); + MULA(res, _sbc_proto_4[7], in[38]); + t[6] = SCALE4_STAGE1(res); + + MUL(res, _sbc_proto_4[6], in[7]); + MULA(res, _sbc_proto_4[5], in[15]); + MULA(res, _sbc_proto_4[4], in[23]); + MULA(res, _sbc_proto_4[3], in[31]); + MULA(res, _sbc_proto_4[2], in[39]); + t[7] = SCALE4_STAGE1(res); + + MUL(res, _anamatrix4[0], t[0]); + MULA(res, _anamatrix4[1], t[1]); + MULA(res, _anamatrix4[2], t[2]); + MULA(res, _anamatrix4[1], t[3]); + MULA(res, _anamatrix4[0], t[4]); + MULA(res, _anamatrix4[3], t[5]); + MULA(res, -_anamatrix4[3], t[7]); + out[0] = SCALE4_STAGE2(res); // Q0 + + MUL(res, -_anamatrix4[0], t[0]); + MULA(res, _anamatrix4[3], t[1]); + MULA(res, _anamatrix4[2], t[2]); + MULA(res, _anamatrix4[3], t[3]); + MULA(res, -_anamatrix4[0], t[4]); + MULA(res, -_anamatrix4[1], t[5]); + MULA(res, _anamatrix4[1], t[7]); + out[1] = SCALE4_STAGE2(res); + + + MUL(res, -_anamatrix4[0], t[0]); + MULA(res, -_anamatrix4[3], t[1]); + MULA(res, _anamatrix4[2], t[2]); + MULA(res, -_anamatrix4[3], t[3]); + MULA(res, -_anamatrix4[0], t[4]); + MULA(res, _anamatrix4[1], t[5]); + MULA(res, -_anamatrix4[1], t[7]); + out[2] = SCALE4_STAGE2(res); + + MUL(res, _anamatrix4[0], t[0]); + MULA(res, -_anamatrix4[1], t[1]); + MULA(res, _anamatrix4[2], t[2]); + MULA(res, -_anamatrix4[1], t[3]); + MULA(res, _anamatrix4[0], t[4]); + MULA(res, -_anamatrix4[3], t[5]); + MULA(res, _anamatrix4[3], t[7]); + out[3] = SCALE4_STAGE2(res); +} +static inline void sbc_analyze_four(struct sbc_encoder_state *state, + struct sbc_frame *frame, int ch, int blk) +{ + int i; + /* Input 4 New Audio Samples */ + for (i = 39; i >= 4; i--) + state->X[ch][i] = state->X[ch][i - 4]; + for (i = 3; i >= 0; i--) + state->X[ch][i] = frame->pcm_sample[ch][blk * 4 + (3 - i)]; + _sbc_analyze_four(state->X[ch], frame->sb_sample_f[blk][ch]); +} + +static inline void _sbc_analyze_eight(const int32_t *in, int32_t *out) +{ + sbc_extended_t res; + sbc_extended_t t[8]; + + out[0] = out[1] = out[2] = out[3] = out[4] = out[5] = out[6] = out[7] = 0; + + MUL(res, _sbc_proto_8[0], (in[16] - in[64])); // Q18 = Q18 * Q0 + MULA(res, _sbc_proto_8[1], (in[32] - in[48])); + MULA(res, _sbc_proto_8[2], in[4]); + MULA(res, _sbc_proto_8[3], in[20]); + MULA(res, _sbc_proto_8[4], in[36]); + MULA(res, _sbc_proto_8[5], in[52]); + t[0] = SCALE8_STAGE1(res); // Q10 + + MUL(res, _sbc_proto_8[6], in[2]); + MULA(res, _sbc_proto_8[7], in[18]); + MULA(res, _sbc_proto_8[8], in[34]); + MULA(res, _sbc_proto_8[9], in[50]); + MULA(res, _sbc_proto_8[10], in[66]); + t[1] = SCALE8_STAGE1(res); + + MUL(res, _sbc_proto_8[11], in[1]); + MULA(res, _sbc_proto_8[12], in[17]); + MULA(res, _sbc_proto_8[13], in[33]); + MULA(res, _sbc_proto_8[14], in[49]); + MULA(res, _sbc_proto_8[15], in[65]); + MULA(res, _sbc_proto_8[16], in[3]); + MULA(res, _sbc_proto_8[17], in[19]); + MULA(res, _sbc_proto_8[18], in[35]); + MULA(res, _sbc_proto_8[19], in[51]); + MULA(res, _sbc_proto_8[20], in[67]); + t[2] = SCALE8_STAGE1(res); + + MUL(res, _sbc_proto_8[21], in[5]); + MULA(res, _sbc_proto_8[22], in[21]); + MULA(res, _sbc_proto_8[23], in[37]); + MULA(res, _sbc_proto_8[24], in[53]); + MULA(res, _sbc_proto_8[25], in[69]); + MULA(res, -_sbc_proto_8[15], in[15]); + MULA(res, -_sbc_proto_8[14], in[31]); + MULA(res, -_sbc_proto_8[13], in[47]); + MULA(res, -_sbc_proto_8[12], in[63]); + MULA(res, -_sbc_proto_8[11], in[79]); + t[3] = SCALE8_STAGE1(res); + + MUL(res, _sbc_proto_8[26], in[6]); + MULA(res, _sbc_proto_8[27], in[22]); + MULA(res, _sbc_proto_8[28], in[38]); + MULA(res, _sbc_proto_8[29], in[54]); + MULA(res, _sbc_proto_8[30], in[70]); + MULA(res, -_sbc_proto_8[10], in[14]); + MULA(res, -_sbc_proto_8[9], in[30]); + MULA(res, -_sbc_proto_8[8], in[46]); + MULA(res, -_sbc_proto_8[7], in[62]); + MULA(res, -_sbc_proto_8[6], in[78]); + t[4] = SCALE8_STAGE1(res); + + MUL(res, _sbc_proto_8[31], in[7]); + MULA(res, _sbc_proto_8[32], in[23]); + MULA(res, _sbc_proto_8[33], in[39]); + MULA(res, _sbc_proto_8[34], in[55]); + MULA(res, _sbc_proto_8[35], in[71]); + MULA(res, -_sbc_proto_8[20], in[13]); + MULA(res, -_sbc_proto_8[19], in[29]); + MULA(res, -_sbc_proto_8[18], in[45]); + MULA(res, -_sbc_proto_8[17], in[61]); + MULA(res, -_sbc_proto_8[16], in[77]); + t[5] = SCALE8_STAGE1(res); + + MUL(res, _sbc_proto_8[36], (in[8] + in[72])); + MULA(res, _sbc_proto_8[37], in[24]); + MULA(res, _sbc_proto_8[38], in[40]); + MULA(res, _sbc_proto_8[37], in[56]); + MULA(res, -_sbc_proto_8[39], in[12]); + MULA(res, -_sbc_proto_8[5], in[28]); + MULA(res, -_sbc_proto_8[4], in[44]); + MULA(res, -_sbc_proto_8[3], in[60]); + MULA(res, -_sbc_proto_8[2], in[76]); + t[6] = SCALE8_STAGE1(res); + + MUL(res, _sbc_proto_8[35], in[9]); + MULA(res, _sbc_proto_8[34], in[25]); + MULA(res, _sbc_proto_8[33], in[41]); + MULA(res, _sbc_proto_8[32], in[57]); + MULA(res, _sbc_proto_8[31], in[73]); + MULA(res, -_sbc_proto_8[25], in[11]); + MULA(res, -_sbc_proto_8[24], in[27]); + MULA(res, -_sbc_proto_8[23], in[43]); + MULA(res, -_sbc_proto_8[22], in[59]); + MULA(res, -_sbc_proto_8[21], in[75]); + t[7] = SCALE8_STAGE1(res); + + MUL(res, _anamatrix8[0], t[0]); // = Q14 * Q10 + MULA(res, _anamatrix8[7], t[1]); + MULA(res, _anamatrix8[2], t[2]); + MULA(res, _anamatrix8[3], t[3]); + MULA(res, _anamatrix8[6], t[4]); + MULA(res, _anamatrix8[4], t[5]); + MULA(res, _anamatrix8[1], t[6]); + MULA(res, _anamatrix8[5], t[7]); + out[0] = SCALE8_STAGE2(res); // Q0 + + MUL(res, _anamatrix8[1], t[0]); + MULA(res, _anamatrix8[7], t[1]); + MULA(res, _anamatrix8[3], t[2]); + MULA(res, -_anamatrix8[5], t[3]); + MULA(res, -_anamatrix8[6], t[4]); + MULA(res, -_anamatrix8[2], t[5]); + MULA(res, -_anamatrix8[0], t[6]); + MULA(res, -_anamatrix8[4], t[7]); + out[1] = SCALE8_STAGE2(res); + + MUL(res, -_anamatrix8[1], t[0]); + MULA(res, _anamatrix8[7], t[1]); + MULA(res, _anamatrix8[4], t[2]); + MULA(res, -_anamatrix8[2], t[3]); + MULA(res, -_anamatrix8[6], t[4]); + MULA(res, _anamatrix8[5], t[5]); + MULA(res, _anamatrix8[0], t[6]); + MULA(res, _anamatrix8[3], t[7]); + out[2] = SCALE8_STAGE2(res); + + MUL(res, -_anamatrix8[0], t[0]); + MULA(res, _anamatrix8[7], t[1]); + MULA(res, _anamatrix8[5], t[2]); + MULA(res, -_anamatrix8[4], t[3]); + MULA(res, _anamatrix8[6], t[4]); + MULA(res, _anamatrix8[3], t[5]); + MULA(res, -_anamatrix8[1], t[6]); + MULA(res, -_anamatrix8[2], t[7]); + out[3] = SCALE8_STAGE2(res); + + MUL(res, -_anamatrix8[0], t[0]); + MULA(res, _anamatrix8[7], t[1]); + MULA(res, -_anamatrix8[5], t[2]); + MULA(res, _anamatrix8[4], t[3]); + MULA(res, _anamatrix8[6], t[4]); + MULA(res, -_anamatrix8[3], t[5]); + MULA(res, -_anamatrix8[1], t[6]); + MULA(res, _anamatrix8[2], t[7]); + out[4] = SCALE8_STAGE2(res); + + MUL(res, -_anamatrix8[1], t[0]); + MULA(res, _anamatrix8[7], t[1]); + MULA(res, -_anamatrix8[4], t[2]); + MULA(res, _anamatrix8[2], t[3]); + MULA(res, -_anamatrix8[6], t[4]); + MULA(res, -_anamatrix8[5], t[5]); + MULA(res, _anamatrix8[0], t[6]); + MULA(res, -_anamatrix8[3], t[7]); + out[5] = SCALE8_STAGE2(res); + + MUL(res, _anamatrix8[1], t[0]); + MULA(res, _anamatrix8[7], t[1]); + MULA(res, -_anamatrix8[3], t[2]); + MULA(res, _anamatrix8[5], t[3]); + MULA(res, -_anamatrix8[6], t[4]); + MULA(res, _anamatrix8[2], t[5]); + MULA(res, -_anamatrix8[0], t[6]); + MULA(res, _anamatrix8[4], t[7]); + out[6] = SCALE8_STAGE2(res); + + MUL(res, _anamatrix8[0], t[0]); + MULA(res, _anamatrix8[7], t[1]); + MULA(res, -_anamatrix8[2], t[2]); + MULA(res, -_anamatrix8[3], t[3]); + MULA(res, _anamatrix8[6], t[4]); + MULA(res, -_anamatrix8[4], t[5]); + MULA(res, _anamatrix8[1], t[6]); + MULA(res, -_anamatrix8[5], t[7]); + out[7] = SCALE8_STAGE2(res); +} + +static inline void sbc_analyze_eight(struct sbc_encoder_state *state, + struct sbc_frame *frame, int ch, int blk) +{ + int i; + + /* Input 8 Audio Samples */ + for (i = 79; i >= 8; i--) + state->X[ch][i] = state->X[ch][i - 8]; + for (i = 7; i >= 0; i--) + state->X[ch][i] = frame->pcm_sample[ch][blk * 8 + (7 - i)]; + _sbc_analyze_eight(state->X[ch], frame->sb_sample_f[blk][ch]); +} + +static int sbc_analyze_audio(struct sbc_encoder_state *state, struct sbc_frame *frame) +{ + int ch, blk; + + switch (frame->subbands) { + case 4: + for (ch = 0; ch < frame->channels; ch++) + for (blk = 0; blk < frame->blocks; blk++) { + sbc_analyze_four(state, frame, ch, blk); + } + return frame->blocks * 4; + + case 8: + for (ch = 0; ch < frame->channels; ch++) + for (blk = 0; blk < frame->blocks; blk++) { + sbc_analyze_eight(state, frame, ch, blk); + } + return frame->blocks * 8; + + default: + return -EIO; + } +} + +/* + * Packs the SBC frame from frame into the memory at data. At most len + * bytes will be used, should more memory be needed an appropriate + * error code will be returned. Returns the length of the packed frame + * on success or a negative value on error. + * + * The error codes are: + * -1 Not enough memory reserved + * -2 Unsupported sampling rate + * -3 Unsupported number of blocks + * -4 Unsupported number of subbands + * -5 Bitpool value out of bounds + * -99 not implemented + */ + +static int sbc_pack_frame(uint8_t * data, struct sbc_frame *frame, size_t len) +{ + int produced; + /* Will copy the header parts for CRC-8 calculation here */ + uint8_t crc_header[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + int crc_pos = 0; + + uint8_t sf; /* Sampling frequency as temporary value for table lookup */ + + int ch, sb, blk, bit; /* channel, subband, block and bit counters */ + int bits[2][8]; /* bits distribution */ + int levels[2][8]; /* levels are derived from that */ + + u_int32_t scalefactor[2][8]; /* derived from frame->scale_factor */ + + if (len < 4) { + return -1; + } + + /* Clear first 4 bytes of data (that's the constant length part of the SBC header) */ + memset(data, 0, 4); + + data[0] = SBC_SYNCWORD; + + if (frame->sampling_frequency == 16000) { + data[1] |= (SBC_FS_16 & 0x03) << 6; + sf = SBC_FS_16; + } else if (frame->sampling_frequency == 32000) { + data[1] |= (SBC_FS_32 & 0x03) << 6; + sf = SBC_FS_32; + } else if (frame->sampling_frequency == 44100) { + data[1] |= (SBC_FS_44 & 0x03) << 6; + sf = SBC_FS_44; + } else if (frame->sampling_frequency == 48000) { + data[1] |= (SBC_FS_48 & 0x03) << 6; + sf = SBC_FS_48; + } else { + return -2; + } + + switch (frame->blocks) { + case 4: + data[1] |= (SBC_NB_4 & 0x03) << 4; + break; + case 8: + data[1] |= (SBC_NB_8 & 0x03) << 4; + break; + case 12: + data[1] |= (SBC_NB_12 & 0x03) << 4; + break; + case 16: + data[1] |= (SBC_NB_16 & 0x03) << 4; + break; + default: + return -3; + break; + } + + data[1] |= (frame->channel_mode & 0x03) << 2; + + data[1] |= (frame->allocation_method & 0x01) << 1; + + switch (frame->subbands) { + case 4: + /* Nothing to do */ + break; + case 8: + data[1] |= 0x01; + break; + default: + return -4; + break; + } + + data[2] = frame->bitpool; + if (((frame->channel_mode == MONO || frame->channel_mode == DUAL_CHANNEL) + && frame->bitpool > 16 * frame->subbands) + || ((frame->channel_mode == STEREO || frame->channel_mode == JOINT_STEREO) + && frame->bitpool > 32 * frame->subbands)) { + return -5; + } + + /* Can't fill in crc yet */ + + produced = 32; + + crc_header[0] = data[1]; + crc_header[1] = data[2]; + crc_pos = 16; + + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + frame->scale_factor[ch][sb] = 0; + scalefactor[ch][sb] = 2; + for (blk = 0; blk < frame->blocks; blk++) { + while (scalefactor[ch][sb] < fabs(frame->sb_sample_f[blk][ch][sb])) { + frame->scale_factor[ch][sb]++; + scalefactor[ch][sb] *= 2; + } + } + } + } + + if (frame->channel_mode == JOINT_STEREO) { + int32_t sb_sample_j[16][2][7]; /* like frame->sb_sample but joint stereo */ + int scalefactor_j[2][7], scale_factor_j[2][7]; /* scalefactor and scale_factor in joint case */ + + /* Calculate joint stereo signal */ + for (sb = 0; sb < frame->subbands - 1; sb++) { + for (blk = 0; blk < frame->blocks; blk++) { + sb_sample_j[blk][0][sb] = (frame->sb_sample_f[blk][0][sb] + frame->sb_sample_f[blk][1][sb]) >> 1; + sb_sample_j[blk][1][sb] = (frame->sb_sample_f[blk][0][sb] - frame->sb_sample_f[blk][1][sb]) >> 1; + } + } + + /* calculate scale_factor_j and scalefactor_j for joint case */ + for (ch = 0; ch < 2; ch++) { + for (sb = 0; sb < frame->subbands - 1; sb++) { + scale_factor_j[ch][sb] = 0; + scalefactor_j[ch][sb] = 2; + for (blk = 0; blk < frame->blocks; blk++) { + while (scalefactor_j[ch][sb] < fabs(sb_sample_j[blk][ch][sb])) { + scale_factor_j[ch][sb]++; + scalefactor_j[ch][sb] *= 2; + } + } + } + } + + /* decide which subbands to join */ + frame->join = 0; + for (sb = 0; sb < frame->subbands - 1; sb++) { + if ((scalefactor[0][sb] + scalefactor[1][sb]) > + (scalefactor_j[0][sb] + scalefactor_j[1][sb]) ) { + /* use joint stereo for this subband */ + frame->join |= 1 << sb; + frame->scale_factor[0][sb] = scale_factor_j[0][sb]; + frame->scale_factor[1][sb] = scale_factor_j[1][sb]; + scalefactor[0][sb] = scalefactor_j[0][sb]; + scalefactor[1][sb] = scalefactor_j[1][sb]; + for (blk = 0; blk < frame->blocks; blk++) { + frame->sb_sample_f[blk][0][sb] = sb_sample_j[blk][0][sb]; + frame->sb_sample_f[blk][1][sb] = sb_sample_j[blk][1][sb]; + } + } + } + + if (len * 8 < produced + frame->subbands) + return -1; + + data[4] = 0; + for (sb = 0; sb < frame->subbands - 1; sb++) { + data[4] |= ((frame->join >> sb) & 0x01) << (7 - sb); + } + if (frame->subbands == 4) { + crc_header[crc_pos / 8] = data[4] & 0xf0; + } else { + crc_header[crc_pos / 8] = data[4]; + } + + produced += frame->subbands; + crc_pos += frame->subbands; + } + + if (len * 8 < produced + (4 * frame->subbands * frame->channels)) + return -1; + + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (produced % 8 == 0) + data[produced / 8] = 0; + data[produced / 8] |= ((frame->scale_factor[ch][sb] & 0x0F) << (4 - (produced % 8))); + crc_header[crc_pos / 8] |= ((frame->scale_factor[ch][sb] & 0x0F) << (4 - (crc_pos % 8))); + + produced += 4; + crc_pos += 4; + } + } + + data[3] = sbc_crc8(crc_header, crc_pos); + + sbc_calculate_bits(frame, bits, sf); + + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + levels[ch][sb] = (1 << bits[ch][sb]) - 1; + } + } + + for (blk = 0; blk < frame->blocks; blk++) { + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (levels[ch][sb] > 0) { + frame->audio_sample[blk][ch][sb] = + (uint16_t) ((((frame->sb_sample_f[blk][ch][sb]*levels[ch][sb]) >> (frame->scale_factor[ch][sb] + 1)) + + levels[ch][sb]) >> 1); + } else { + frame->audio_sample[blk][ch][sb] = 0; + } + } + } + } + + for (blk = 0; blk < frame->blocks; blk++) { + for (ch = 0; ch < frame->channels; ch++) { + for (sb = 0; sb < frame->subbands; sb++) { + if (bits[ch][sb] != 0) { + for (bit = 0; bit < bits[ch][sb]; bit++) { + int b; /* A bit */ + if (produced > len * 8) { + return -1; + } + if (produced % 8 == 0) { + data[produced / 8] = 0; + } + b = ((frame->audio_sample[blk][ch][sb]) >> (bits[ch][sb] - bit - + 1)) & 0x01; + data[produced / 8] |= b << (7 - (produced % 8)); + produced++; + } + } + } + } + } + + if (produced % 8 != 0) { + produced += 8 - (produced % 8); + } + + return produced / 8; +} + +struct sbc_priv { + int init; + struct sbc_frame frame; + struct sbc_decoder_state dec_state; + struct sbc_encoder_state enc_state; +}; + +int sbc_init(sbc_t *sbc, unsigned long flags) +{ + if (!sbc) + return -EIO; + + memset(sbc, 0, sizeof(sbc_t)); + + sbc->priv = malloc(sizeof(struct sbc_priv)); + if (!sbc->priv) + return -ENOMEM; + + memset(sbc->priv, 0, sizeof(struct sbc_priv)); + + sbc->rate = 44100; + sbc->channels = 2; + sbc->joint = 0; + sbc->subbands = 8; + sbc->blocks = 16; + sbc->bitpool = 32; + + return 0; +} + +int sbc_decode(sbc_t *sbc, void *data, int count) +{ + struct sbc_priv *priv; + char *ptr; + int i, ch, framelen, samples; + + if (!sbc) + return -EIO; + + priv = sbc->priv; + + framelen = sbc_unpack_frame(data, &priv->frame, count); + + + if (!priv->init) { + sbc_decoder_init(&priv->dec_state, &priv->frame); + priv->init = 1; + + sbc->rate = priv->frame.sampling_frequency; + sbc->channels = priv->frame.channels; + sbc->subbands = priv->frame.subbands; + sbc->blocks = priv->frame.blocks; + sbc->bitpool = priv->frame.bitpool; + } + + samples = sbc_synthesize_audio(&priv->dec_state, &priv->frame); + + if (!sbc->data) { + sbc->size = samples * priv->frame.channels * 2; + sbc->data = malloc(sbc->size); + } + + if (sbc->size < samples * priv->frame.channels * 2) { + sbc->size = samples * priv->frame.channels * 2; + sbc->data = realloc(sbc->data, sbc->size); + } + + if (!sbc->data) { + sbc->size = 0; + return -ENOMEM; + } + + ptr = sbc->data; + + for (i = 0; i < samples; i++) { + for (ch = 0; ch < priv->frame.channels; ch++) { + int16_t s; + s = priv->frame.pcm_sample[ch][i]; + *ptr++ = (s & 0xff00) >> 8; + *ptr++ = (s & 0x00ff); + } + } + + sbc->len = samples * priv->frame.channels * 2; + + return framelen; +} + +int sbc_encode(sbc_t *sbc, void *data, int count) +{ + struct sbc_priv *priv; + char *ptr; + int i, ch, framelen, samples; + + if (!sbc) + return -EIO; + + priv = sbc->priv; + + if (!priv->init) { + priv->frame.sampling_frequency = sbc->rate; + priv->frame.channels = sbc->channels; + + if (sbc->channels > 1) { + if (sbc->joint) + priv->frame.channel_mode = JOINT_STEREO; + else + priv->frame.channel_mode = STEREO; + } else + priv->frame.channel_mode = MONO; + + priv->frame.allocation_method = SNR; + priv->frame.subbands = sbc->subbands; + priv->frame.blocks = sbc->blocks; + priv->frame.bitpool = sbc->bitpool; + + sbc_encoder_init(&priv->enc_state, &priv->frame); + priv->init = 1; + } + + ptr = data; + + for (i = 0; i < priv->frame.subbands * priv->frame.blocks; i++) { + for (ch = 0; ch < sbc->channels; ch++) { + int16_t s = (ptr[0] & 0xff) << 8 | (ptr[1] & 0xff); + ptr += 2; + priv->frame.pcm_sample[ch][i] = s; + } + } + + samples = sbc_analyze_audio(&priv->enc_state, &priv->frame); + + if (!sbc->data) { + sbc->size = 1024; + sbc->data = malloc(sbc->size); + } + + if (!sbc->data) { + sbc->size = 0; + return -ENOMEM; + } + + framelen = sbc_pack_frame(sbc->data, &priv->frame, sbc->size); + + sbc->len = framelen; + + sbc->duration = (1000000 * priv->frame.subbands * priv->frame.blocks) / sbc->rate; + + return samples * sbc->channels * 2; +} + +void sbc_finish(sbc_t *sbc) +{ + if (!sbc) + return; + + if (sbc->data) + free(sbc->data); + + if (sbc->priv) + free(sbc->priv); + + memset(sbc, 0, sizeof(sbc_t)); +} diff --git a/sbc/sbc.h b/sbc/sbc.h index ae31af4c..99ccb3e4 100644 --- a/sbc/sbc.h +++ b/sbc/sbc.h @@ -2,7 +2,9 @@ * * Bluetooth low-complexity, subband codec (SBC) library * - * Copyright (C) 2004-2007 Marcel Holtmann + * Copyright (C) 2004-2006 Marcel Holtmann + * Copyright (C) 2004-2005 Henryk Ploetz + * Copyright (C) 2005-2006 Brad Midgley * * * This library is free software; you can redistribute it and/or @@ -28,6 +30,32 @@ extern "C" { #endif +struct sbc_struct { + unsigned long flags; + + int rate; + int channels; + int joint; + int blocks; + int subbands; + int bitpool; + + void *data; + int size; + int len; + + unsigned long duration; + + void *priv; +}; + +typedef struct sbc_struct sbc_t; + +int sbc_init(sbc_t *sbc, unsigned long flags); +int sbc_decode(sbc_t *sbc, void *data, int count); +int sbc_encode(sbc_t *sbc, void *data, int count); +void sbc_finish(sbc_t *sbc); + #ifdef __cplusplus } #endif diff --git a/sbc/sbc_math.h b/sbc/sbc_math.h index c427bee3..f6247ef8 100644 --- a/sbc/sbc_math.h +++ b/sbc/sbc_math.h @@ -2,7 +2,9 @@ * * Bluetooth low-complexity, subband codec (SBC) library * - * Copyright (C) 2004-2007 Marcel Holtmann + * Copyright (C) 2004-2006 Marcel Holtmann + * Copyright (C) 2004-2005 Henryk Ploetz + * Copyright (C) 2005-2006 Brad Midgley * * * This library is free software; you can redistribute it and/or @@ -22,11 +24,12 @@ */ #define fabs(x) ((x) < 0 ? -(x) : (x)) - /* C does not provide an explicit arithmetic shift right but this will always be correct and every compiler *should* generate optimal code */ #define ASR(val, bits) ((-2 >> 1 == -1) ? \ - ((int32_t) (val)) >> (bits) : ((int32_t) (val)) / (1 << (bits))) + ((int32_t)(val)) >> (bits) : ((int32_t) (val)) / (1 << (bits))) +#define ASR_64(val, bits) ((-2 >> 1 == -1) ? \ + ((long long)(val)) >> (bits) : ((long long) (val)) / (1 << (bits))) #define SCALE_PROTO4_TBL 15 #define SCALE_ANA4_TBL 16 @@ -37,29 +40,30 @@ #define SCALE_NPROTO4_TBL 10 #define SCALE_NPROTO8_TBL 12 #define SCALE_SAMPLES 14 -#define SCALE4_STAGE1_BITS 16 -#define SCALE4_STAGE2_BITS 18 -#define SCALE4_STAGED1_BITS 15 -#define SCALE4_STAGED2_BITS 15 -#define SCALE8_STAGE1_BITS 16 -#define SCALE8_STAGE2_BITS 18 -#define SCALE8_STAGED1_BITS 15 -#define SCALE8_STAGED2_BITS 15 +#define SCALE4_STAGE1_BITS 10 +#define SCALE4_STAGE2_BITS 21 +#define SCALE4_STAGED1_BITS 18 +#define SCALE4_STAGED2_BITS 23 +#define SCALE8_STAGE1_BITS 8 +#define SCALE8_STAGE2_BITS 24 +#define SCALE8_STAGED1_BITS 18 +#define SCALE8_STAGED2_BITS 23 typedef int32_t sbc_fixed_t; +typedef long long sbc_extended_t; -#define SCALE4_STAGE1(src) ASR(src, SCALE4_STAGE1_BITS) -#define SCALE4_STAGE2(src) ASR(src, SCALE4_STAGE2_BITS) -#define SCALE4_STAGED1(src) ASR(src, SCALE4_STAGED1_BITS) -#define SCALE4_STAGED2(src) ASR(src, SCALE4_STAGED2_BITS) -#define SCALE8_STAGE1(src) ASR(src, SCALE8_STAGE1_BITS) -#define SCALE8_STAGE2(src) ASR(src, SCALE8_STAGE2_BITS) -#define SCALE8_STAGED1(src) ASR(src, SCALE8_STAGED1_BITS) -#define SCALE8_STAGED2(src) ASR(src, SCALE8_STAGED2_BITS) +#define SCALE4_STAGE1(src) ASR_64(src, SCALE4_STAGE1_BITS) +#define SCALE4_STAGE2(src) ASR_64(src, SCALE4_STAGE2_BITS) +#define SCALE4_STAGED1(src) ASR_64(src, SCALE4_STAGED1_BITS) +#define SCALE4_STAGED2(src) ASR_64(src, SCALE4_STAGED2_BITS) +#define SCALE8_STAGE1(src) ASR_64(src, SCALE8_STAGE1_BITS) +#define SCALE8_STAGE2(src) ASR_64(src, SCALE8_STAGE2_BITS) +#define SCALE8_STAGED1(src) ASR_64(src, SCALE8_STAGED1_BITS) +#define SCALE8_STAGED2(src) ASR_64(src, SCALE8_STAGED2_BITS) #define SBC_FIXED_0(val) { val = 0; } #define ADD(dst, src) { dst += src; } #define SUB(dst, src) { dst -= src; } #define MUL(dst, a, b) { dst = (sbc_fixed_t) a * b; } -#define MULA(dst, a, b) { dst += (sbc_fixed_t) a * b; } +#define MULA(dst, a, b) { dst += (sbc_extended_t) a * b; } #define DIV2(dst, src) { dst = ASR(src, 1); } diff --git a/sbc/sbc_tables.h b/sbc/sbc_tables.h index a170704d..2712cf23 100644 --- a/sbc/sbc_tables.h +++ b/sbc/sbc_tables.h @@ -2,7 +2,9 @@ * * Bluetooth low-complexity, subband codec (SBC) library * - * Copyright (C) 2004-2007 Marcel Holtmann + * Copyright (C) 2004-2006 Marcel Holtmann + * Copyright (C) 2004-2005 Henryk Ploetz + * Copyright (C) 2005-2006 Brad Midgley * * * This library is free software; you can redistribute it and/or -- cgit