/*
 *
 *  Bluetooth low-complexity, subband codec (SBC) library
 *
 *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
 *  Copyright (C) 2004-2005  Henryk Ploetz <henryk@ploetzli.ch>
 *
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <errno.h>
#include <malloc.h>
#include <string.h>
#include <sys/types.h>

#include "sbc.h"

/* A2DP specification: Appendix B, page 69 */
static const int sbc_offset4[4][4] = {
	{ -1, 0, 0, 0 },
	{ -2, 0, 0, 1 },
	{ -2, 0, 0, 1 },
	{ -2, 0, 0, 1 }
};

/* A2DP specification: Appendix B, page 69 */
static const int sbc_offset8[4][8] = {
	{ -2, 0, 0, 0, 0, 0, 0, 1 },
	{ -3, 0, 0, 0, 0, 0, 1, 2 },
	{ -4, 0, 0, 0, 0, 0, 1, 2 },
	{ -4, 0, 0, 0, 0, 0, 1, 2 }
};

/* A2DP specification: Appendix B, page 70 */
static const float sbc_proto_4_40[40] = {
	 0.00000000E+00,  5.36548976E-04,  1.49188357E-03,  2.73370904E-03,
	 3.83720193E-03,  3.89205149E-03,  1.86581691E-03, -3.06012286E-03,
	 1.09137620E-02,  2.04385087E-02,  2.88757392E-02,  3.21939290E-02,
	 2.58767811E-02,  6.13245186E-03, -2.88217274E-02, -7.76463494E-02,
	 1.35593274E-01,  1.94987841E-01,  2.46636662E-01,  2.81828203E-01,
	 2.94315332E-01,  2.81828203E-01,  2.46636662E-01,  1.94987841E-01,
	-1.35593274E-01, -7.76463494E-02, -2.88217274E-02,  6.13245186E-03,
	 2.58767811E-02,  3.21939290E-02,  2.88757392E-02,  2.04385087E-02,
	-1.09137620E-02, -3.06012286E-03,  1.86581691E-03,  3.89205149E-03,
	 3.83720193E-03,  2.73370904E-03,  1.49188357E-03,  5.36548976E-04
};

/* A2DP specification: Appendix B, page 70 */
static const float sbc_proto_8_80[80] = {
	 0.00000000E+00,  1.56575398E-04,  3.43256425E-04,  5.54620202E-04,
	 8.23919506E-04,  1.13992507E-03,  1.47640169E-03,  1.78371725E-03,
	 2.01182542E-03,  2.10371989E-03,  1.99454554E-03,  1.61656283E-03,
	 9.02154502E-04, -1.78805361E-04, -1.64973098E-03, -3.49717454E-03,
	 5.65949473E-03,  8.02941163E-03,  1.04584443E-02,  1.27472335E-02,
	 1.46525263E-02,  1.59045603E-02,  1.62208471E-02,  1.53184106E-02,
	 1.29371806E-02,  8.85757540E-03,  2.92408442E-03, -4.91578024E-03,
	-1.46404076E-02, -2.61098752E-02, -3.90751381E-02, -5.31873032E-02,
	 6.79989431E-02,  8.29847578E-02,  9.75753918E-02,  1.11196689E-01,
	 1.23264548E-01,  1.33264415E-01,  1.40753505E-01,  1.45389847E-01,
	 1.46955068E-01,  1.45389847E-01,  1.40753505E-01,  1.33264415E-01,
	 1.23264548E-01,  1.11196689E-01,  9.75753918E-02,  8.29847578E-02,
	-6.79989431E-02, -5.31873032E-02, -3.90751381E-02, -2.61098752E-02,
	-1.46404076E-02, -4.91578024E-03,  2.92408442E-03,  8.85757540E-03,
	 1.29371806E-02,  1.53184106E-02,  1.62208471E-02,  1.59045603E-02,
	 1.46525263E-02,  1.27472335E-02,  1.04584443E-02,  8.02941163E-03,
	-5.65949473E-03, -3.49717454E-03, -1.64973098E-03, -1.78805361E-04,
	 9.02154502E-04,  1.61656283E-03,  1.99454554E-03,  2.10371989E-03,
	 2.01182542E-03,  1.78371725E-03,  1.47640169E-03,  1.13992507E-03,
	 8.23919506E-04,  5.54620202E-04,  3.43256425E-04,  1.56575398E-04
};

/* Precomputed: synmatrix4[k][i] = cos( (i+0.5) * (k+2.0) * pi/4.0 ) */
static const float synmatrix4[8][4] =  {
	{  0.707106781186548, -0.707106781186547, -0.707106781186548,  0.707106781186547 },
	{  0.38268343236509,  -0.923879532511287,  0.923879532511287, -0.38268343236509  },
	{  0,                  0,                  0,                  0                 },
	{ -0.38268343236509,   0.923879532511287, -0.923879532511287,  0.382683432365091 },
	{ -0.707106781186547,  0.707106781186548,  0.707106781186547, -0.707106781186547 },
	{ -0.923879532511287, -0.38268343236509,   0.382683432365091,  0.923879532511288 },
	{ -1,                 -1,                 -1,                 -1                 },
	{ -0.923879532511287, -0.382683432365091,  0.38268343236509,   0.923879532511287 }
};

/* Precomputed: synmatrix8[k][i] = cos( (i+0.5) * (k+4.0) * pi/8.0 ) */
static const float synmatrix8[16][8] = {
	{  0.707106781186548, -0.707106781186547, -0.707106781186548,  0.707106781186547,
	   0.707106781186548, -0.707106781186547, -0.707106781186547,  0.707106781186547 },
	{  0.555570233019602, -0.98078528040323,   0.195090322016128,  0.831469612302545,
	  -0.831469612302545, -0.195090322016128,  0.980785280403231, -0.555570233019602 },
	{  0.38268343236509,  -0.923879532511287,  0.923879532511287, -0.38268343236509,
	  -0.382683432365091,  0.923879532511287, -0.923879532511286,  0.38268343236509  },
	{  0.195090322016128, -0.555570233019602,  0.831469612302545, -0.980785280403231,
	   0.98078528040323,  -0.831469612302545,  0.555570233019602, -0.195090322016129 },
	{  0,                  0,                  0,                  0,
	   0,                  0,                  0,                  0                 },
	{ -0.195090322016128,  0.555570233019602, -0.831469612302545,  0.98078528040323,
	  -0.980785280403231,  0.831469612302545, -0.555570233019603,  0.19509032201613  },
	{ -0.38268343236509,   0.923879532511287, -0.923879532511287,  0.382683432365091,
	   0.38268343236509,  -0.923879532511287,  0.923879532511288, -0.382683432365091 },
	{ -0.555570233019602,  0.98078528040323,  -0.195090322016128, -0.831469612302545,
	   0.831469612302545,  0.195090322016128, -0.98078528040323,   0.555570233019606 },
	{ -0.707106781186547,  0.707106781186548,  0.707106781186547, -0.707106781186547,
	  -0.707106781186546,  0.707106781186548,  0.707106781186546, -0.707106781186548 },
	{ -0.831469612302545,  0.195090322016129,  0.980785280403231,  0.555570233019602,
	  -0.555570233019603, -0.98078528040323,  -0.195090322016128,  0.831469612302547 },
	{ -0.923879532511287, -0.38268343236509,   0.382683432365091,  0.923879532511288,
	   0.923879532511287,  0.382683432365089, -0.382683432365091, -0.923879532511287 },
	{ -0.98078528040323,  -0.831469612302545, -0.555570233019602, -0.195090322016129,
	   0.19509032201613,   0.555570233019606,  0.831469612302547,  0.980785280403231 },
	{ -1,                 -1,                 -1,                 -1,
	  -1,                 -1,                 -1,                 -1                 },
	{ -0.98078528040323,  -0.831469612302546, -0.555570233019603, -0.19509032201613,
	   0.195090322016128,  0.555570233019604,  0.831469612302545,  0.98078528040323  },
	{ -0.923879532511287, -0.382683432365091,  0.38268343236509,   0.923879532511287,
	   0.923879532511288,  0.382683432365088, -0.382683432365089, -0.923879532511285 },
	{ -0.831469612302545,  0.195090322016127,  0.98078528040323,   0.555570233019603,
	  -0.555570233019601, -0.98078528040323,  -0.195090322016131,  0.831469612302545 }
};

/* Precomputed: anamatrix4[i][k] = cos( (i+0.5) * (k-2) * pi/4 ) */
static const float anamatrix4[4][8] = {
	{  0.707106781186548,  0.923879532511287,  1,                  0.923879532511287,
	   0.707106781186548,  0.38268343236509,   0,                 -0.38268343236509  },
	{ -0.707106781186547,  0.38268343236509,   1,                  0.38268343236509,
	  -0.707106781186547, -0.923879532511287,  0,                  0.923879532511287 },
	{ -0.707106781186548, -0.38268343236509,   1,                 -0.38268343236509,
	  -0.707106781186548,  0.923879532511287,  0,                 -0.923879532511287 },
	{  0.707106781186547, -0.923879532511287,  1,                 -0.923879532511287,
	   0.707106781186547, -0.38268343236509,   0,                  0.382683432365091 }
};

/* Precomputed: anamatrix8[i][k] = cos( (i+0.5) * (k-4) * pi/8) */
static const float anamatrix8[8][16] = {
	{  0.923879532511287,  0.98078528040323,   1,                  0.98078528040323,
	   0.923879532511287,  0.831469612302545,  0.707106781186548,  0.555570233019602,
	   0.38268343236509,   0.195090322016128,  0,                 -0.195090322016128,
	  -0.38268343236509,  -0.555570233019602, -0.707106781186547, -0.831469612302545 },
	{  0.38268343236509,   0.831469612302545,  1,                  0.831469612302545,
	   0.38268343236509,  -0.195090322016128, -0.707106781186547, -0.98078528040323,
	  -0.923879532511287, -0.555570233019602,  0,                  0.555570233019602,
	   0.923879532511287,  0.98078528040323,   0.707106781186548,  0.195090322016129 },
	{ -0.38268343236509,   0.555570233019602,  1,                  0.555570233019602,
	  -0.38268343236509,  -0.98078528040323,  -0.707106781186548,  0.195090322016128,
	   0.923879532511287,  0.831469612302545,  0,                 -0.831469612302545,
	  -0.923879532511287, -0.195090322016128,  0.707106781186547,  0.980785280403231 },
	{ -0.923879532511287,  0.195090322016128,  1,                  0.195090322016128,
	  -0.923879532511287, -0.555570233019602,  0.707106781186547,  0.831469612302545,
	  -0.38268343236509,  -0.980785280403231,  0,                  0.98078528040323,
	   0.382683432365091, -0.831469612302545, -0.707106781186547,  0.555570233019602 },
	{ -0.923879532511287, -0.195090322016128,  1,                 -0.195090322016128,
	  -0.923879532511287,  0.555570233019602,  0.707106781186548, -0.831469612302545,
	  -0.382683432365091,  0.98078528040323,   0,                 -0.980785280403231,
	   0.38268343236509,   0.831469612302545, -0.707106781186546, -0.555570233019603 },
	{ -0.38268343236509,  -0.555570233019602,  1,                 -0.555570233019602,
	  -0.38268343236509,   0.98078528040323,  -0.707106781186547, -0.195090322016128,
	   0.923879532511287, -0.831469612302545,  0,                  0.831469612302545,
	  -0.923879532511287,  0.195090322016128,  0.707106781186548, -0.98078528040323  },
	{  0.38268343236509,  -0.831469612302545,  1,                 -0.831469612302545,
	   0.38268343236509,   0.195090322016129, -0.707106781186547,  0.980785280403231,
	  -0.923879532511286,  0.555570233019602,  0,                 -0.555570233019603,
	   0.923879532511288, -0.98078528040323,   0.707106781186546, -0.195090322016128 },
	{  0.923879532511287, -0.98078528040323,   1,                 -0.98078528040323,
	   0.923879532511287, -0.831469612302545,  0.707106781186547, -0.555570233019602,
	   0.38268343236509,  -0.195090322016129,  0,                  0.19509032201613,
	  -0.382683432365091,  0.555570233019606, -0.707106781186548,  0.831469612302547 }
};

#define fabs(x) ((x) < 0 ? (-x) : (x))

#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 {
	double sampling_frequency;	/* in kHz */
	u_int8_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;
	u_int8_t channels;
	enum {
		LOUDNESS	= SBC_AM_LOUDNESS,
		SNR		= SBC_AM_SNR
	} allocation_method;
	u_int8_t subbands;
	u_int8_t bitpool;
	u_int8_t join;				/* bit number x set means joint stereo has been used in subband x */
	u_int8_t scale_factor[2][8];		/* only the lower 4 bits of every element are to be used */
	u_int16_t audio_sample[16][2][8];	/* raw integer subband samples in the frame */
	double sb_sample[16][2][8];		/* modified subband samples */
	double pcm_sample[2][16*8];		/* original pcm audio samples */
};

struct sbc_decoder_state {
	int subbands;
	float S[2][8];				/* Subband samples */
	float X[2][8];				/* Audio samples */
	float V[2][160], U[2][80], W[2][80];	/* Vectors */
};

struct sbc_encoder_state {
	int subbands;
	float S[2][8];				/* Subband samples */
	float X[2][80], Y[2][16], Z[2][80];	/* Vectors */
};

/*
 * Calculates the CRC-8 of the first len bits in data
 */
static const u_int8_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 u_int8_t sbc_crc8(const u_int8_t * data, size_t len)
{
	u_int8_t crc = 0x0f;
	size_t i;
	u_int8_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], u_int8_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 u_int8_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 */
	u_int8_t crc_header[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	int crc_pos = 0;

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

	double scalefactor[2][8];	/* derived from frame->scale_factors */

	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 = 16;
		break;
	case SBC_FS_32:
		frame->sampling_frequency = 32;
		break;
	case SBC_FS_44:
		frame->sampling_frequency = 44.1;
		break;
	case SBC_FS_48:
		frame->sampling_frequency = 48;
		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;
		} else {
			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;
	} else {
		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 / 8] >> (4 - (consumed % 8))) & 0x0F;
				crc_header[crc_pos / 8] |= frame->scale_factor[ch][sb] << (4 - (crc_pos % 8));

				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) {
					for (bit = 0; bit < bits[ch][sb]; bit++) {
						int b;	/* A bit */
						if (consumed > len * 8) {
							return -1;
						}

						b = (data[consumed / 8] >> (7 - (consumed % 8))) & 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;
			scalefactor[ch][sb] = 2 << frame->scale_factor[ch][sb];
		}
	}

	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] =
					    scalefactor[ch][sb] * ((frame->audio_sample[blk][ch][sb] * 2.0 + 1.0) /
								   levels[ch][sb] - 1.0);
				} 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)) {
					frame->sb_sample[blk][0][sb] =
					    frame->sb_sample[blk][0][sb] + frame->sb_sample[blk][1][sb];
					frame->sb_sample[blk][1][sb] =
					    frame->sb_sample[blk][0][sb] - 2 * frame->sb_sample[blk][1][sb];
				}
			}
		}
	}

	if (consumed % 8 != 0)
		consumed += 8 - (consumed % 8);

	return consumed / 8;
}

static void sbc_decoder_init(struct sbc_decoder_state *state, const struct sbc_frame *frame)
{
	memset(&state->S, 0, sizeof(state->S));
	memset(&state->X, 0, sizeof(state->X));
	memset(&state->V, 0, sizeof(state->V));
	memset(&state->U, 0, sizeof(state->U));
	memset(&state->W, 0, sizeof(state->W));
	state->subbands = frame->subbands;
}

static inline void sbc_synthesize_four(struct sbc_decoder_state *state,
				struct sbc_frame *frame, int ch, int blk)
{
	int i, j, k;

	/* Input 4 New Subband Samples */
	for (i = 0; i < 4; i++)
		state->S[ch][i] = frame->sb_sample[blk][ch][i];

	/* Shifting */
	for (i = 79; i >= 8; i--)
		state->V[ch][i] = state->V[ch][i - 8];

	/* Matrixing */
	for (k = 0; k < 8; k++) {
		state->V[ch][k] = 0;
		for (i = 0; i < 4; i++)
			state->V[ch][k] += synmatrix4[k][i] * state->S[ch][i];
	}

	/* Build a 40 values vector U */
	for (i = 0; i <= 4; i++) {
		for (j = 0; j < 4; j++) {
			state->U[ch][i * 8 + j] = state->V[ch][i * 16 + j];
			state->U[ch][i * 8 + j + 4] = state->V[ch][i * 16 + j + 12];
		}
	}

	/* Window by 40 coefficients */
	for (i = 0; i < 40; i++)
		state->W[ch][i] = state->U[ch][i] * sbc_proto_4_40[i] * (-4);

	/* Calculate 4 audio samples */
	for (j = 0; j < 4; j++) {
		state->X[ch][j] = 0;
		for (i = 0; i < 10; i++)
			state->X[ch][j] += state->W[ch][j + 4 * i];
	}

	/* Output 4 reconstructed Audio Samples */
	for (i = 0; i < 4; i++)
		frame->pcm_sample[ch][blk * 4 + i] = state->X[ch][i];
}

static inline void sbc_synthesize_eight(struct sbc_decoder_state *state,
				struct sbc_frame *frame, int ch, int blk)
{
	int i, j, k;

	/* Input 8 New Subband Samples */
	for (i = 0; i < 8; i++)
		state->S[ch][i] = frame->sb_sample[blk][ch][i];

	/* Shifting */
	for (i = 159; i >= 16; i--)
		state->V[ch][i] = state->V[ch][i - 16];

	/* Matrixing */
	for (k = 0; k < 16; k++) {
		state->V[ch][k] = 0;
		for (i = 0; i < 8; i++) {
			state->V[ch][k] += synmatrix8[k][i] * state->S[ch][i];
		}
	}

	/* Build a 80 values vector U */
	for (i = 0; i <= 4; i++) {
		for (j = 0; j < 8; j++) {
			state->U[ch][i * 16 + j] = state->V[ch][i * 32 + j];
			state->U[ch][i * 16 + j + 8] = state->V[ch][i * 32 + j + 24];
		}
	}

	/* Window by 80 coefficients */
	for (i = 0; i < 80; i++)
		state->W[ch][i] = state->U[ch][i] * sbc_proto_8_80[i] * (-4);

	/* Calculate 8 audio samples */
	for (j = 0; j < 8; j++) {
		state->X[ch][j] = 0;
		for (i = 0; i < 10; i++)
			state->X[ch][j] += state->W[ch][j + 8 * i];
	}

	/* Ouput 8 reconstructed Audio Samples */
	for (i = 0; i < 8; i++)
		frame->pcm_sample[ch][blk * 8 + i] = state->X[ch][i];
}

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++) {
			memset(frame->pcm_sample[ch], 0,
				sizeof(frame->pcm_sample[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++) {
			memset(frame->pcm_sample[ch], 0,
				sizeof(frame->pcm_sample[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->S, 0, sizeof(state->S));
	memset(&state->X, 0, sizeof(state->X));
	memset(&state->Y, 0, sizeof(state->Y));
	memset(&state->Z, 0, sizeof(state->Z));
	state->subbands = frame->subbands;
}

static inline void sbc_analyze_four(struct sbc_encoder_state *state,
				struct sbc_frame *frame, int ch, int blk)
{
	int i, k;

	/* 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)];

	/* Windowing by 40 coefficients */
	for (i = 0; i < 40; i++)
		state->Z[ch][i] = sbc_proto_4_40[i] * state->X[ch][i];

	/* Partial calculation */
	for (i = 0; i < 8; i++) {
		state->Y[ch][i] = 0;
		for (k = 0; k < 5; k++)
			state->Y[ch][i] += state->Z[ch][i + k * 8];
	}

	/* Calculate 4 subband samples by Matrixing */
	for (i = 0; i < 4; i++) {
		state->S[ch][i] = 0;
		for (k = 0; k < 8; k++)
			state->S[ch][i] += anamatrix4[i][k] * state->Y[ch][k];
	}

	/* Output 4 Subband Samples */
	for (i = 0; i < 4; i++)
		frame->sb_sample[blk][ch][i] = state->S[ch][i];
}

static inline void sbc_analyze_eight(struct sbc_encoder_state *state,
				struct sbc_frame *frame, int ch, int blk)
{
	int i, k;

	/* 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)];

	/* Windowing by 80 coefficients */
	for (i = 0; i < 80; i++)
		state->Z[ch][i] = sbc_proto_8_80[i] * state->X[ch][i];

	/* Partial calculation */
	for (i = 0; i < 16; i++) {
		state->Y[ch][i] = 0;
		for (k = 0; k < 5; k++)
			state->Y[ch][i] += state->Z[ch][i + k * 16];
	}

	/* Calculate 8 subband samples by Matrixing */
	for (i = 0; i < 8; i++) {
		state->S[ch][i] = 0;
		for (k = 0; k < 16; k++)
			state->S[ch][i] += anamatrix8[i][k] * state->Y[ch][k];
	}

	/* Output 8 Subband Samples */
	for (i = 0; i < 8; i++)
		frame->sb_sample[blk][ch][i] = state->S[ch][i];
}

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++) {
				memset(frame->sb_sample[blk][ch], 0,
					sizeof(frame->sb_sample[blk][ch]));
				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++) {
				memset(frame->sb_sample[blk][ch], 0,
					sizeof(frame->sb_sample[blk][ch]));
				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(u_int8_t * data, struct sbc_frame *frame, size_t len)
{
	int produced;
	/* Will copy the header parts for CRC-8 calculation here */
	u_int8_t crc_header[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	int crc_pos = 0;

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

	double 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 == 16) {
		data[1] |= (SBC_FS_16 & 0x03) << 6;
		sf = SBC_FS_16;
	} else if (frame->sampling_frequency == 32) {
		data[1] |= (SBC_FS_32 & 0x03) << 6;
		sf = SBC_FS_32;
	} else if (frame->sampling_frequency == 44.1) {
		data[1] |= (SBC_FS_44 & 0x03) << 6;
		sf = SBC_FS_44;
	} else if (frame->sampling_frequency == 48) {
		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[blk][ch][sb])) {
					frame->scale_factor[ch][sb]++;
					scalefactor[ch][sb] *= 2;
				}
			}
		}
	}

	if (frame->channel_mode == JOINT_STEREO) {
		float 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[blk][0][sb] 
							   + frame->sb_sample[blk][1][sb]) / 2;
				sb_sample_j[blk][1][sb] = (frame->sb_sample[blk][0][sb] 
							   - frame->sb_sample[blk][1][sb]) / 2;
			}
		}

		/* 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[blk][0][sb] = sb_sample_j[blk][0][sb];
					frame->sb_sample[blk][1][sb] = sb_sample_j[blk][1][sb];
				}
			}
		}
  
		if (len * 8 < produced + frame->subbands) {
			return -1;
		} else {
			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;
	} else {
		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] =
					    (u_int16_t) (((frame->sb_sample[blk][ch][sb] / scalefactor[ch][sb] +
							   1.0) * levels[ch][sb]) / 2.0);
				} 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->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 * 1000;
		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 = (int16_t)(priv->frame.pcm_sample[ch][i]);
			*ptr++ = (s & 0xff00) >> 8;
			*ptr++ = (s & 0x00ff);
		}
	}

	sbc->len = samples * priv->frame.channels * 2;

	sbc->duration = (1000000 * priv->frame.subbands * priv->frame.blocks) / sbc->rate;

	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 = ((double) sbc->rate) / 1000;
		priv->frame.channels = sbc->channels;

		if (sbc->channels > 1)
			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);
			int16_t s = (ptr[1] & 0xff) << 8 | (ptr[2] & 0xff);
			ptr += 2;
			priv->frame.pcm_sample[ch][i] = ((double) 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));
}