korg/bluez
0
0
Fork 0
mirror of https://git.kernel.org/pub/scm/bluetooth/bluez.git synced 2024-11-26 13:44:23 +08:00
Code Issues Packages Projects Releases Wiki Activity
9c0b5859e6
bluez/sbc/sbc.c

1230 lines
31 KiB
C
Raw Normal View History

Add skeleton for embedding SBC library
2007-01-31 16:52:52 +08:00
/*
*
* Bluetooth low-complexity, subband codec (SBC) library
*
Update copyright information
2009-01-02 02:33:20 +08:00
* Copyright (C) 2004-2009 Marcel Holtmann <marcel@holtmann.org>
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.
2007-03-17 21:37:31 +08:00
* Copyright (C) 2004-2005 Henryk Ploetz <henryk@ploetzli.ch>
update copyrights
2008-01-19 23:56:52 +08:00
* Copyright (C) 2005-2008 Brad Midgley <bmidgley@xmission.com>
Add skeleton for embedding SBC library
2007-01-31 16:52:52 +08:00
*
*
* 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
*
*/
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.
2007-03-17 21:37:31 +08:00
/* todo items:
Coding style cleanup
2007-11-01 23:27:38 +08:00
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
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.
2007-03-17 21:37:31 +08:00
*/
Add skeleton for embedding SBC library
2007-01-31 16:52:52 +08:00
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
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.
2007-03-17 21:37:31 +08:00
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
New SBC analysis filter function to replace current broken code This code is heavily based on the patch submitted by Jaska Uimonen. Additional changes include preserving extra bits in the output of filter function for better precision, support for both 16-bit and 32-bit fixed point implementation. Sign of some table values was changed in order to preserve a regular code structure and have multiply-accumulate oparations only. No additional optimizations were applied as this code is intended to be some kind of "reference" implementation. Platform specific optimizations may require different tricks and can be branched off from this implementation. Some extra information about this code can be found in linux-bluetooth mailing list archive for December 2008.
2008-12-28 09:22:59 +08:00
#include <limits.h>
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.
2007-03-17 21:37:31 +08:00
Add SBC helper includes
2007-02-21 22:23:25 +08:00
#include "sbc_math.h"
#include "sbc_tables.h"
Add skeleton for embedding SBC library
2007-01-31 16:52:52 +08:00
#include "sbc.h"
SIMD-friendly variant of SBC encoder analysis filter Added SIMD-friendly C implementation of SBC analysis filter (the structure of code had to be changed a bit and constants in the tables reordered). This code can be used as a reference for developing platform specific SIMD optimizations. These functions are put into a new file 'sbc_primitives.c', which is going to contain all the basic stuff for SBC codec.
2009-01-16 01:11:23 +08:00
#include "sbc_primitives.h"
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.
2007-03-17 21:37:31 +08:00
#define SBC_SYNCWORD 0x9C
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* This structure contains an unpacked SBC frame.
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.
2007-03-17 21:37:31 +08:00
Yes, there is probably quite some unused space herein */
struct sbc_frame {
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
uint8_t frequency;
uint8_t block_mode;
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.
2007-03-17 21:37:31 +08:00
uint8_t blocks;
enum {
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
MONO = SBC_MODE_MONO,
DUAL_CHANNEL = SBC_MODE_DUAL_CHANNEL,
STEREO = SBC_MODE_STEREO,
JOINT_STEREO = SBC_MODE_JOINT_STEREO
} mode;
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.
2007-03-17 21:37:31 +08:00
uint8_t channels;
enum {
LOUDNESS = SBC_AM_LOUDNESS,
SNR = SBC_AM_SNR
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
} allocation;
uint8_t subband_mode;
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.
2007-03-17 21:37:31 +08:00
uint8_t subbands;
uint8_t bitpool;
Fixed correct handling of frame sizes in the encoder
2009-01-05 20:26:08 +08:00
uint16_t codesize;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
uint8_t length;
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* bit number x set means joint stereo has been used in subband x */
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
uint8_t joint;
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* only the lower 4 bits of every element are to be used */
SBC encoder scale factors calculation optimized with __builtin_clz Count leading zeros operation is often implemented using a special instruction for it on various architectures (at least this is true for ARM and x86). Using __builtin_clz gcc intrinsic allows to eliminate innermost loop in scale factors calculation and improve performance. Also scale factors calculation can be optimized even more using SIMD instructions.
2009-01-29 08:17:36 +08:00
uint32_t scale_factor[2][8];
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* raw integer subband samples in the frame */
SBC arrays and constant tables aligned at 16 byte boundary for SIMD Most SIMD instruction sets benefit from data being naturally aligned. And even if it is not strictly required, performance is usually better with the aligned data. ARM NEON and SSE2 have different instruction variants for aligned/unaligned memory accesses.
2009-01-16 01:45:36 +08:00
int32_t SBC_ALIGNED sb_sample_f[16][2][8];
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.
2007-03-17 21:37:31 +08:00
SBC arrays and constant tables aligned at 16 byte boundary for SIMD Most SIMD instruction sets benefit from data being naturally aligned. And even if it is not strictly required, performance is usually better with the aligned data. ARM NEON and SSE2 have different instruction variants for aligned/unaligned memory accesses.
2009-01-16 01:45:36 +08:00
/* modified subband samples */
int32_t SBC_ALIGNED sb_sample[16][2][8];
/* original pcm audio samples */
int16_t SBC_ALIGNED pcm_sample[2][16*8];
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.
2007-03-17 21:37:31 +08:00
};
struct sbc_decoder_state {
int subbands;
int32_t V[2][170];
int offset[2][16];
};
/*
* 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
};
More coding style cleanup
2007-11-02 17:05:57 +08:00
static uint8_t sbc_crc8(const uint8_t *data, size_t len)
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.
2007-03-17 21:37:31 +08:00
{
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;
}
/*
Coding style cleanup
2007-11-01 23:27:38 +08:00
* 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)
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.
2007-03-17 21:37:31 +08:00
*/
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
static void sbc_calculate_bits(const struct sbc_frame *frame, int (*bits)[8])
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.
2007-03-17 21:37:31 +08:00
{
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
uint8_t sf = frame->frequency;
if (frame->mode == MONO || frame->mode == DUAL_CHANNEL) {
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.
2007-03-17 21:37:31 +08:00
int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
int ch, sb;
for (ch = 0; ch < frame->channels; ch++) {
eliminate extra loop for bitneed compute make a couple while loops easier to read as for loops
2007-11-27 14:22:48 +08:00
max_bitneed = 0;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (frame->allocation == SNR) {
eliminate extra loop for bitneed compute make a couple while loops easier to read as for loops
2007-11-27 14:22:48 +08:00
for (sb = 0; sb < frame->subbands; sb++) {
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = frame->scale_factor[ch][sb];
eliminate extra loop for bitneed compute make a couple while loops easier to read as for loops
2007-11-27 14:22:48 +08:00
if (bitneed[ch][sb] > max_bitneed)
max_bitneed = bitneed[ch][sb];
}
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.
2007-03-17 21:37:31 +08:00
} else {
for (sb = 0; sb < frame->subbands; sb++) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
if (frame->scale_factor[ch][sb] == 0)
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = -5;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else {
if (frame->subbands == 4)
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.
2007-03-17 21:37:31 +08:00
loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
Coding style cleanup
2007-11-01 23:27:38 +08:00
else
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.
2007-03-17 21:37:31 +08:00
loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
Coding style cleanup
2007-11-01 23:27:38 +08:00
if (loudness > 0)
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = loudness / 2;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = loudness;
}
eliminate extra loop for bitneed compute make a couple while loops easier to read as for loops
2007-11-27 14:22:48 +08:00
if (bitneed[ch][sb] > max_bitneed)
max_bitneed = bitneed[ch][sb];
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.
2007-03-17 21:37:31 +08:00
}
}
bitcount = 0;
slicecount = 0;
bitslice = max_bitneed + 1;
do {
bitslice--;
bitcount += slicecount;
slicecount = 0;
for (sb = 0; sb < frame->subbands; sb++) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
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.
2007-03-17 21:37:31 +08:00
slicecount++;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else if (bitneed[ch][sb] == bitslice + 1)
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.
2007-03-17 21:37:31 +08:00
slicecount += 2;
}
} while (bitcount + slicecount < frame->bitpool);
if (bitcount + slicecount == frame->bitpool) {
bitcount += slicecount;
bitslice--;
}
for (sb = 0; sb < frame->subbands; sb++) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
if (bitneed[ch][sb] < bitslice + 2)
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.
2007-03-17 21:37:31 +08:00
bits[ch][sb] = 0;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else {
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.
2007-03-17 21:37:31 +08:00
bits[ch][sb] = bitneed[ch][sb] - bitslice;
if (bits[ch][sb] > 16)
bits[ch][sb] = 16;
}
}
eliminate extra loop for bitneed compute make a couple while loops easier to read as for loops
2007-11-27 14:22:48 +08:00
for (sb = 0; bitcount < frame->bitpool && sb < frame->subbands; sb++) {
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.
2007-03-17 21:37:31 +08:00
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;
}
}
eliminate extra loop for bitneed compute make a couple while loops easier to read as for loops
2007-11-27 14:22:48 +08:00
for (sb = 0; bitcount < frame->bitpool && sb < frame->subbands; sb++) {
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.
2007-03-17 21:37:31 +08:00
if (bits[ch][sb] < 16) {
bits[ch][sb]++;
bitcount++;
}
}
}
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
} else if (frame->mode == STEREO || frame->mode == JOINT_STEREO) {
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.
2007-03-17 21:37:31 +08:00
int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
int ch, sb;
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
max_bitneed = 0;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (frame->allocation == SNR) {
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.
2007-03-17 21:37:31 +08:00
for (ch = 0; ch < 2; ch++) {
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
for (sb = 0; sb < frame->subbands; sb++) {
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = frame->scale_factor[ch][sb];
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
if (bitneed[ch][sb] > max_bitneed)
max_bitneed = bitneed[ch][sb];
}
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.
2007-03-17 21:37:31 +08:00
}
} else {
for (ch = 0; ch < 2; ch++) {
for (sb = 0; sb < frame->subbands; sb++) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
if (frame->scale_factor[ch][sb] == 0)
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = -5;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else {
if (frame->subbands == 4)
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.
2007-03-17 21:37:31 +08:00
loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
Coding style cleanup
2007-11-01 23:27:38 +08:00
else
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.
2007-03-17 21:37:31 +08:00
loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
Coding style cleanup
2007-11-01 23:27:38 +08:00
if (loudness > 0)
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = loudness / 2;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else
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.
2007-03-17 21:37:31 +08:00
bitneed[ch][sb] = loudness;
}
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
if (bitneed[ch][sb] > max_bitneed)
max_bitneed = bitneed[ch][sb];
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.
2007-03-17 21:37:31 +08:00
}
}
}
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++) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
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.
2007-03-17 21:37:31 +08:00
slicecount++;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else if (bitneed[ch][sb] == bitslice + 1)
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.
2007-03-17 21:37:31 +08:00
slicecount += 2;
}
}
} while (bitcount + slicecount < frame->bitpool);
More coding style cleanup
2007-11-02 17:05:57 +08:00
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.
2007-03-17 21:37:31 +08:00
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;
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
while (bitcount < frame->bitpool) {
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.
2007-03-17 21:37:31 +08:00
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++;
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
if (sb >= frame->subbands) break;
Coding style cleanup
2007-11-01 23:27:38 +08:00
} else
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.
2007-03-17 21:37:31 +08:00
ch = 1;
}
ch = 0;
sb = 0;
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
while (bitcount < frame->bitpool) {
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.
2007-03-17 21:37:31 +08:00
if (bits[ch][sb] < 16) {
bits[ch][sb]++;
bitcount++;
}
if (ch == 1) {
ch = 0;
sb++;
eliminate another max_bitneed loop, eliminate extraneous loop termination tests
2007-11-27 14:47:38 +08:00
if (sb >= frame->subbands) break;
Coding style cleanup
2007-11-01 23:27:38 +08:00
} else
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.
2007-03-17 21:37:31 +08:00
ch = 1;
}
}
}
Coding style cleanup
2007-11-01 23:27:38 +08:00
/*
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.
2007-03-17 21:37:31 +08:00
* 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
*/
More coding style cleanup
2007-11-02 17:05:57 +08:00
static int sbc_unpack_frame(const uint8_t *data, struct sbc_frame *frame,
Coding style cleanup
2007-11-01 23:27:38 +08:00
size_t len)
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.
2007-03-17 21:37:31 +08:00
{
int consumed;
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* Will copy the parts of the header that are relevant to crc
* calculation here */
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.
2007-03-17 21:37:31 +08:00
uint8_t crc_header[11] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int crc_pos = 0;
int32_t temp;
Cidorvan found another place where the spec had us saving a bunch of values that were used immediately. Just compute and use instead of saving. In the decoder.
2008-03-08 13:21:26 +08:00
int audio_sample;
Coding style cleanup
2007-11-01 23:27:38 +08:00
int ch, sb, blk, bit; /* channel, subband, block and bit standard
counters */
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.
2007-03-17 21:37:31 +08:00
int bits[2][8]; /* bits distribution */
Cidorvan's 4-subband overflow fixes
2008-02-29 11:56:22 +08:00
uint32_t levels[2][8]; /* levels derived from that */
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.
2007-03-17 21:37:31 +08:00
if (len < 4)
return -1;
if (data[0] != SBC_SYNCWORD)
return -2;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->frequency = (data[1] >> 6) & 0x03;
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.
2007-03-17 21:37:31 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->block_mode = (data[1] >> 4) & 0x03;
switch (frame->block_mode) {
case SBC_BLK_4:
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.
2007-03-17 21:37:31 +08:00
frame->blocks = 4;
break;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
case SBC_BLK_8:
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.
2007-03-17 21:37:31 +08:00
frame->blocks = 8;
break;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
case SBC_BLK_12:
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.
2007-03-17 21:37:31 +08:00
frame->blocks = 12;
break;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
case SBC_BLK_16:
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.
2007-03-17 21:37:31 +08:00
frame->blocks = 16;
break;
}
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->mode = (data[1] >> 2) & 0x03;
switch (frame->mode) {
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.
2007-03-17 21:37:31 +08:00
case MONO:
frame->channels = 1;
break;
case DUAL_CHANNEL: /* fall-through */
case STEREO:
case JOINT_STEREO:
frame->channels = 2;
break;
}
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->allocation = (data[1] >> 1) & 0x01;
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.
2007-03-17 21:37:31 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->subband_mode = (data[1] & 0x01);
frame->subbands = frame->subband_mode ? 8 : 4;
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.
2007-03-17 21:37:31 +08:00
frame->bitpool = data[2];
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if ((frame->mode == MONO || frame->mode == DUAL_CHANNEL) &&
More coding style cleanup
2007-11-02 17:05:57 +08:00
frame->bitpool > 16 * frame->subbands)
return -4;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if ((frame->mode == STEREO || frame->mode == JOINT_STEREO) &&
More coding style cleanup
2007-11-02 17:05:57 +08:00
frame->bitpool > 32 * frame->subbands)
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.
2007-03-17 21:37:31 +08:00
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;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (frame->mode == JOINT_STEREO) {
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.
2007-03-17 21:37:31 +08:00
if (len * 8 < consumed + frame->subbands)
return -1;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->joint = 0x00;
Coding style cleanup
2007-11-01 23:27:38 +08:00
for (sb = 0; sb < frame->subbands - 1; sb++)
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->joint |= ((data[4] >> (7 - sb)) & 0x01) << sb;
Coding style cleanup
2007-11-01 23:27:38 +08:00
if (frame->subbands == 4)
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.
2007-03-17 21:37:31 +08:00
crc_header[crc_pos / 8] = data[4] & 0xf0;
Coding style cleanup
2007-11-01 23:27:38 +08:00
else
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.
2007-03-17 21:37:31 +08:00
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); */
Coding style cleanup
2007-11-01 23:27:38 +08:00
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));
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.
2007-03-17 21:37:31 +08:00
consumed += 4;
crc_pos += 4;
}
}
if (data[3] != sbc_crc8(crc_header, crc_pos))
return -3;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
sbc_calculate_bits(frame, bits);
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.
2007-03-17 21:37:31 +08:00
for (ch = 0; ch < frame->channels; ch++) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
for (sb = 0; sb < frame->subbands; sb++)
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.
2007-03-17 21:37:31 +08:00
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) {
Cidorvan found another place where the spec had us saving a bunch of values that were used immediately. Just compute and use instead of saving. In the decoder.
2008-03-08 13:21:26 +08:00
audio_sample = 0;
for (bit = 0; bit < bits[ch][sb]; bit++) {
if (consumed > len * 8)
return -1;
if ((data[consumed >> 3] >> (7 - (consumed & 0x7))) & 0x01)
audio_sample |= 1 << (bits[ch][sb] - bit - 1);
consumed++;
}
Coding style cleanup
2007-11-01 23:27:38 +08:00
frame->sb_sample[blk][ch][sb] =
Cidorvan found another place where the spec had us saving a bunch of values that were used immediately. Just compute and use instead of saving. In the decoder.
2008-03-08 13:21:26 +08:00
(((audio_sample << 1) | 1) << frame->scale_factor[ch][sb]) /
fix for decoder noise at high bitpools
2008-02-16 02:06:32 +08:00
levels[ch][sb] - (1 << frame->scale_factor[ch][sb]);
Coding style cleanup
2007-11-01 23:27:38 +08:00
} else
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.
2007-03-17 21:37:31 +08:00
frame->sb_sample[blk][ch][sb] = 0;
}
}
}
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (frame->mode == JOINT_STEREO) {
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.
2007-03-17 21:37:31 +08:00
for (blk = 0; blk < frame->blocks; blk++) {
for (sb = 0; sb < frame->subbands; sb++) {
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (frame->joint & (0x01 << sb)) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
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];
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.
2007-03-17 21:37:31 +08:00
frame->sb_sample[blk][0][sb] = temp;
}
}
}
}
if ((consumed & 0x7) != 0)
consumed += 8 - (consumed & 0x7);
return consumed >> 3;
}
Coding style cleanup
2007-11-01 23:27:38 +08:00
static void sbc_decoder_init(struct sbc_decoder_state *state,
const struct sbc_frame *frame)
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.
2007-03-17 21:37:31 +08:00
{
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)
{
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
int i, k, idx;
int32_t *v = state->V[ch];
int *offset = state->offset[ch];
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.
2007-03-17 21:37:31 +08:00
More coding style cleanup
2007-11-02 17:05:57 +08:00
for (i = 0; i < 8; i++) {
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.
2007-03-17 21:37:31 +08:00
/* Shifting */
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
offset[i]--;
if (offset[i] < 0) {
offset[i] = 79;
memcpy(v + 80, v, 9 * sizeof(*v));
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.
2007-03-17 21:37:31 +08:00
}
/* Distribute the new matrix value to the shifted position */
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
v[offset[i]] = SCALE4_STAGED1(
MULA(synmatrix4[i][0], frame->sb_sample[blk][ch][0],
MULA(synmatrix4[i][1], frame->sb_sample[blk][ch][1],
MULA(synmatrix4[i][2], frame->sb_sample[blk][ch][2],
MUL (synmatrix4[i][3], frame->sb_sample[blk][ch][3])))));
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.
2007-03-17 21:37:31 +08:00
}
/* Compute the samples */
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
for (idx = 0, i = 0; i < 4; i++, idx += 5) {
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.
2007-03-17 21:37:31 +08:00
k = (i + 4) & 0xf;
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* Store in output, Q0 */
Fix SBC gain mismatch
2008-11-01 06:55:13 +08:00
frame->pcm_sample[ch][blk * 4 + i] = SCALE4_STAGED1(
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
MULA(v[offset[i] + 0], sbc_proto_4_40m0[idx + 0],
MULA(v[offset[k] + 1], sbc_proto_4_40m1[idx + 0],
MULA(v[offset[i] + 2], sbc_proto_4_40m0[idx + 1],
MULA(v[offset[k] + 3], sbc_proto_4_40m1[idx + 1],
MULA(v[offset[i] + 4], sbc_proto_4_40m0[idx + 2],
MULA(v[offset[k] + 5], sbc_proto_4_40m1[idx + 2],
MULA(v[offset[i] + 6], sbc_proto_4_40m0[idx + 3],
MULA(v[offset[k] + 7], sbc_proto_4_40m1[idx + 3],
MULA(v[offset[i] + 8], sbc_proto_4_40m0[idx + 4],
MUL( v[offset[k] + 9], sbc_proto_4_40m1[idx + 4])))))))))));
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.
2007-03-17 21:37:31 +08:00
}
}
static inline void sbc_synthesize_eight(struct sbc_decoder_state *state,
struct sbc_frame *frame, int ch, int blk)
{
int i, j, k, idx;
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
int *offset = state->offset[ch];
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.
2007-03-17 21:37:31 +08:00
More coding style cleanup
2007-11-02 17:05:57 +08:00
for (i = 0; i < 16; i++) {
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.
2007-03-17 21:37:31 +08:00
/* Shifting */
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
offset[i]--;
if (offset[i] < 0) {
offset[i] = 159;
More coding style cleanup
2007-11-02 17:05:57 +08:00
for (j = 0; j < 9; j++)
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
state->V[ch][j + 160] = state->V[ch][j];
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.
2007-03-17 21:37:31 +08:00
}
/* Distribute the new matrix value to the shifted position */
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
state->V[ch][offset[i]] = SCALE8_STAGED1(
MULA(synmatrix8[i][0], frame->sb_sample[blk][ch][0],
MULA(synmatrix8[i][1], frame->sb_sample[blk][ch][1],
MULA(synmatrix8[i][2], frame->sb_sample[blk][ch][2],
MULA(synmatrix8[i][3], frame->sb_sample[blk][ch][3],
MULA(synmatrix8[i][4], frame->sb_sample[blk][ch][4],
MULA(synmatrix8[i][5], frame->sb_sample[blk][ch][5],
MULA(synmatrix8[i][6], frame->sb_sample[blk][ch][6],
MUL( synmatrix8[i][7], frame->sb_sample[blk][ch][7])))))))));
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.
2007-03-17 21:37:31 +08:00
}
/* Compute the samples */
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
for (idx = 0, i = 0; i < 8; i++, idx += 5) {
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.
2007-03-17 21:37:31 +08:00
k = (i + 8) & 0xf;
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
/* Store in output */
Fix SBC gain mismatch
2008-11-01 06:55:13 +08:00
frame->pcm_sample[ch][blk * 8 + i] = SCALE8_STAGED1( // Q0
decoder optimization, now using nested multiply calls
2008-03-06 22:04:43 +08:00
MULA(state->V[ch][offset[i] + 0], sbc_proto_8_80m0[idx + 0],
MULA(state->V[ch][offset[k] + 1], sbc_proto_8_80m1[idx + 0],
MULA(state->V[ch][offset[i] + 2], sbc_proto_8_80m0[idx + 1],
MULA(state->V[ch][offset[k] + 3], sbc_proto_8_80m1[idx + 1],
MULA(state->V[ch][offset[i] + 4], sbc_proto_8_80m0[idx + 2],
MULA(state->V[ch][offset[k] + 5], sbc_proto_8_80m1[idx + 2],
MULA(state->V[ch][offset[i] + 6], sbc_proto_8_80m0[idx + 3],
MULA(state->V[ch][offset[k] + 7], sbc_proto_8_80m1[idx + 3],
MULA(state->V[ch][offset[i] + 8], sbc_proto_8_80m0[idx + 4],
MUL( state->V[ch][offset[k] + 9], sbc_proto_8_80m1[idx + 4])))))))))));
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.
2007-03-17 21:37:31 +08:00
}
}
Coding style cleanup
2007-11-01 23:27:38 +08:00
static int sbc_synthesize_audio(struct sbc_decoder_state *state,
struct sbc_frame *frame)
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.
2007-03-17 21:37:31 +08:00
{
int ch, blk;
Coding style cleanup
2007-11-01 23:27:38 +08:00
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.
2007-03-17 21:37:31 +08:00
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;
}
}
Coding style cleanup
2007-11-01 23:27:38 +08:00
static int sbc_analyze_audio(struct sbc_encoder_state *state,
struct sbc_frame *frame)
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.
2007-03-17 21:37:31 +08:00
{
int ch, blk;
switch (frame->subbands) {
case 4:
for (ch = 0; ch < frame->channels; ch++)
Added possibility to analyze 4 blocks at once in SBC encoder This change is needed for SIMD optimizations which will follow shortly. And even for non-SIMD capable platforms it still may be useful to have possibility to merge several analyzing functions together into one for better code scheduling or reusing loaded constants. Also analysis filter functions are now called using function pointers, which allows the default implementation to be overrided at runtime (with high precision variant or MMX/SSE2/NEON optimized code).
2008-12-31 15:14:25 +08:00
for (blk = 0; blk < frame->blocks; blk += 4) {
state->sbc_analyze_4b_4s(
Performance optimizations for input data processing in SBC encoder Channels deinterleaving, endian conversion and samples reordering is done in one pass, avoiding the use of intermediate buffer. Also this code is implemented as a new "performance primitive", which allows further platform specific optimizations (ARMv6 and ARM NEON should gain quite a lot from assembly optimizations here).
2009-01-28 00:57:35 +08:00
&state->X[ch][state->position +
48 - blk * 4],
Added possibility to analyze 4 blocks at once in SBC encoder This change is needed for SIMD optimizations which will follow shortly. And even for non-SIMD capable platforms it still may be useful to have possibility to merge several analyzing functions together into one for better code scheduling or reusing loaded constants. Also analysis filter functions are now called using function pointers, which allows the default implementation to be overrided at runtime (with high precision variant or MMX/SSE2/NEON optimized code).
2008-12-31 15:14:25 +08:00
frame->sb_sample_f[blk][ch],
frame->sb_sample_f[blk + 1][ch] -
frame->sb_sample_f[blk][ch]);
}
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.
2007-03-17 21:37:31 +08:00
return frame->blocks * 4;
case 8:
for (ch = 0; ch < frame->channels; ch++)
Added possibility to analyze 4 blocks at once in SBC encoder This change is needed for SIMD optimizations which will follow shortly. And even for non-SIMD capable platforms it still may be useful to have possibility to merge several analyzing functions together into one for better code scheduling or reusing loaded constants. Also analysis filter functions are now called using function pointers, which allows the default implementation to be overrided at runtime (with high precision variant or MMX/SSE2/NEON optimized code).
2008-12-31 15:14:25 +08:00
for (blk = 0; blk < frame->blocks; blk += 4) {
state->sbc_analyze_4b_8s(
Performance optimizations for input data processing in SBC encoder Channels deinterleaving, endian conversion and samples reordering is done in one pass, avoiding the use of intermediate buffer. Also this code is implemented as a new "performance primitive", which allows further platform specific optimizations (ARMv6 and ARM NEON should gain quite a lot from assembly optimizations here).
2009-01-28 00:57:35 +08:00
&state->X[ch][state->position +
96 - blk * 8],
Added possibility to analyze 4 blocks at once in SBC encoder This change is needed for SIMD optimizations which will follow shortly. And even for non-SIMD capable platforms it still may be useful to have possibility to merge several analyzing functions together into one for better code scheduling or reusing loaded constants. Also analysis filter functions are now called using function pointers, which allows the default implementation to be overrided at runtime (with high precision variant or MMX/SSE2/NEON optimized code).
2008-12-31 15:14:25 +08:00
frame->sb_sample_f[blk][ch],
frame->sb_sample_f[blk + 1][ch] -
frame->sb_sample_f[blk][ch]);
}
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.
2007-03-17 21:37:31 +08:00
return frame->blocks * 8;
default:
return -EIO;
}
}
Bitstream writing optimization for SBC encoder SBC encoder performance improvement up to 1.5x for ARM11 and almost twice faster for Intel Core2 in some cases.
2008-12-12 03:21:28 +08:00
/* Supplementary bitstream writing macros for 'sbc_pack_frame' */
Coding style fixes
2009-01-18 02:30:40 +08:00
#define PUT_BITS(data_ptr, bits_cache, bits_count, v, n) \
do { \
bits_cache = (v) | (bits_cache << (n)); \
bits_count += (n); \
if (bits_count >= 16) { \
bits_count -= 8; \
*data_ptr++ = (uint8_t) \
(bits_cache >> bits_count); \
bits_count -= 8; \
*data_ptr++ = (uint8_t) \
(bits_cache >> bits_count); \
} \
} while (0)
#define FLUSH_BITS(data_ptr, bits_cache, bits_count) \
do { \
while (bits_count >= 8) { \
bits_count -= 8; \
*data_ptr++ = (uint8_t) \
(bits_cache >> bits_count); \
} \
if (bits_count > 0) \
*data_ptr++ = (uint8_t) \
(bits_cache << (8 - bits_count)); \
} while (0)
Bitstream writing optimization for SBC encoder SBC encoder performance improvement up to 1.5x for ARM11 and almost twice faster for Intel Core2 in some cases.
2008-12-12 03:21:28 +08:00
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.
2007-03-17 21:37:31 +08:00
/*
* Packs the SBC frame from frame into the memory at data. At most len
Coding style cleanup
2007-11-01 23:27:38 +08:00
* bytes will be used, should more memory be needed an appropriate
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.
2007-03-17 21:37:31 +08:00
* error code will be returned. Returns the length of the packed frame
Coding style cleanup
2007-11-01 23:27:38 +08:00
* on success or a negative value on error.
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.
2007-03-17 21:37:31 +08:00
*
* 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
*/
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
static SBC_ALWAYS_INLINE int sbc_pack_frame_internal(
uint8_t *data, struct sbc_frame *frame, size_t len,
int frame_subbands, int frame_channels)
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.
2007-03-17 21:37:31 +08:00
{
Bitstream writing optimization for SBC encoder SBC encoder performance improvement up to 1.5x for ARM11 and almost twice faster for Intel Core2 in some cases.
2008-12-12 03:21:28 +08:00
/* Bitstream writer starts from the fourth byte */
uint8_t *data_ptr = data + 4;
uint32_t bits_cache = 0;
uint32_t bits_count = 0;
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.
2007-03-17 21:37:31 +08:00
/* 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;
Use of constant shift in SBC quantization code to make it faster The result of 32x32->64 unsigned long multiplication is returned in two registers (high and low 32-bit parts) for many 32-bit architectures. For these architectures constant right shift by 32 bits is optimized out by the compiler to just taking the high 32-bit part. Also some data needed at the quantization stage is precalculated beforehand to improve performance.
2009-01-04 09:11:12 +08:00
uint32_t audio_sample;
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.
2007-03-17 21:37:31 +08:00
Bitstream writing optimization for SBC encoder SBC encoder performance improvement up to 1.5x for ARM11 and almost twice faster for Intel Core2 in some cases.
2008-12-12 03:21:28 +08:00
int ch, sb, blk; /* channel, subband, block and bit counters */
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.
2007-03-17 21:37:31 +08:00
int bits[2][8]; /* bits distribution */
Use of constant shift in SBC quantization code to make it faster The result of 32x32->64 unsigned long multiplication is returned in two registers (high and low 32-bit parts) for many 32-bit architectures. For these architectures constant right shift by 32 bits is optimized out by the compiler to just taking the high 32-bit part. Also some data needed at the quantization stage is precalculated beforehand to improve performance.
2009-01-04 09:11:12 +08:00
uint32_t levels[2][8]; /* levels are derived from that */
uint32_t sb_sample_delta[2][8];
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.
2007-03-17 21:37:31 +08:00
data[0] = SBC_SYNCWORD;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
data[1] = (frame->frequency & 0x03) << 6;
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.
2007-03-17 21:37:31 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
data[1] |= (frame->block_mode & 0x03) << 4;
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.
2007-03-17 21:37:31 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
data[1] |= (frame->mode & 0x03) << 2;
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.
2007-03-17 21:37:31 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
data[1] |= (frame->allocation & 0x01) << 1;
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.
2007-03-17 21:37:31 +08:00
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
switch (frame_subbands) {
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.
2007-03-17 21:37:31 +08:00
case 4:
/* Nothing to do */
break;
case 8:
data[1] |= 0x01;
break;
default:
return -4;
break;
}
data[2] = frame->bitpool;
More coding style cleanup
2007-11-02 17:05:57 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if ((frame->mode == MONO || frame->mode == DUAL_CHANNEL) &&
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
frame->bitpool > frame_subbands << 4)
Coding style cleanup
2007-11-01 23:27:38 +08:00
return -5;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if ((frame->mode == STEREO || frame->mode == JOINT_STEREO) &&
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
frame->bitpool > frame_subbands << 5)
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.
2007-03-17 21:37:31 +08:00
return -5;
/* Can't fill in crc yet */
crc_header[0] = data[1];
crc_header[1] = data[2];
crc_pos = 16;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (frame->mode == JOINT_STEREO) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* like frame->sb_sample but joint stereo */
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
int32_t sb_sample_j[16][2];
Coding style cleanup
2007-11-01 23:27:38 +08:00
/* scalefactor and scale_factor in joint case */
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
u_int32_t scalefactor_j[2];
uint8_t scale_factor_j[2];
Bitstream writing optimization for SBC encoder SBC encoder performance improvement up to 1.5x for ARM11 and almost twice faster for Intel Core2 in some cases.
2008-12-12 03:21:28 +08:00
uint8_t joint = 0;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->joint = 0;
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.
2007-03-17 21:37:31 +08:00
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
for (sb = 0; sb < frame_subbands - 1; sb++) {
combine the blk loops inside the joint conditional
2007-11-27 11:15:36 +08:00
scale_factor_j[0] = 0;
New SBC analysis filter function to replace current broken code This code is heavily based on the patch submitted by Jaska Uimonen. Additional changes include preserving extra bits in the output of filter function for better precision, support for both 16-bit and 32-bit fixed point implementation. Sign of some table values was changed in order to preserve a regular code structure and have multiply-accumulate oparations only. No additional optimizations were applied as this code is intended to be some kind of "reference" implementation. Platform specific optimizations may require different tricks and can be branched off from this implementation. Some extra information about this code can be found in linux-bluetooth mailing list archive for December 2008.
2008-12-28 09:22:59 +08:00
scalefactor_j[0] = 2 << SCALE_OUT_BITS;
combine the blk loops inside the joint conditional
2007-11-27 11:15:36 +08:00
scale_factor_j[1] = 0;
New SBC analysis filter function to replace current broken code This code is heavily based on the patch submitted by Jaska Uimonen. Additional changes include preserving extra bits in the output of filter function for better precision, support for both 16-bit and 32-bit fixed point implementation. Sign of some table values was changed in order to preserve a regular code structure and have multiply-accumulate oparations only. No additional optimizations were applied as this code is intended to be some kind of "reference" implementation. Platform specific optimizations may require different tricks and can be branched off from this implementation. Some extra information about this code can be found in linux-bluetooth mailing list archive for December 2008.
2008-12-28 09:22:59 +08:00
scalefactor_j[1] = 2 << SCALE_OUT_BITS;
combine the blk loops inside the joint conditional
2007-11-27 11:15:36 +08:00
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.
2007-03-17 21:37:31 +08:00
for (blk = 0; blk < frame->blocks; blk++) {
combine the blk loops inside the joint conditional
2007-11-27 11:15:36 +08:00
/* Calculate joint stereo signal */
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
sb_sample_j[blk][0] =
New SBC analysis filter function to replace current broken code This code is heavily based on the patch submitted by Jaska Uimonen. Additional changes include preserving extra bits in the output of filter function for better precision, support for both 16-bit and 32-bit fixed point implementation. Sign of some table values was changed in order to preserve a regular code structure and have multiply-accumulate oparations only. No additional optimizations were applied as this code is intended to be some kind of "reference" implementation. Platform specific optimizations may require different tricks and can be branched off from this implementation. Some extra information about this code can be found in linux-bluetooth mailing list archive for December 2008.
2008-12-28 09:22:59 +08:00
ASR(frame->sb_sample_f[blk][0][sb], 1) +
ASR(frame->sb_sample_f[blk][1][sb], 1);
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
sb_sample_j[blk][1] =
New SBC analysis filter function to replace current broken code This code is heavily based on the patch submitted by Jaska Uimonen. Additional changes include preserving extra bits in the output of filter function for better precision, support for both 16-bit and 32-bit fixed point implementation. Sign of some table values was changed in order to preserve a regular code structure and have multiply-accumulate oparations only. No additional optimizations were applied as this code is intended to be some kind of "reference" implementation. Platform specific optimizations may require different tricks and can be branched off from this implementation. Some extra information about this code can be found in linux-bluetooth mailing list archive for December 2008.
2008-12-28 09:22:59 +08:00
ASR(frame->sb_sample_f[blk][0][sb], 1) -
ASR(frame->sb_sample_f[blk][1][sb], 1);
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.
2007-03-17 21:37:31 +08:00
combine the blk loops inside the joint conditional
2007-11-27 11:15:36 +08:00
/* calculate scale_factor_j and scalefactor_j for joint case */
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
while (scalefactor_j[0] < fabs(sb_sample_j[blk][0])) {
scale_factor_j[0]++;
scalefactor_j[0] *= 2;
}
while (scalefactor_j[1] < fabs(sb_sample_j[blk][1])) {
scale_factor_j[1]++;
scalefactor_j[1] *= 2;
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.
2007-03-17 21:37:31 +08:00
}
}
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
/* decide whether to join this subband */
Fixed subbands selection for joint-stereo in SBC encoder
2008-12-28 01:36:14 +08:00
if ((frame->scale_factor[0][sb] +
frame->scale_factor[1][sb]) >
(scale_factor_j[0] +
scale_factor_j[1])) {
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.
2007-03-17 21:37:31 +08:00
/* use joint stereo for this subband */
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
joint |= 1 << (frame_subbands - 1 - sb);
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
frame->joint |= 1 << sb;
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
frame->scale_factor[0][sb] = scale_factor_j[0];
frame->scale_factor[1][sb] = scale_factor_j[1];
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.
2007-03-17 21:37:31 +08:00
for (blk = 0; blk < frame->blocks; blk++) {
Coding style cleanup
2007-11-01 23:27:38 +08:00
frame->sb_sample_f[blk][0][sb] =
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
sb_sample_j[blk][0];
Coding style cleanup
2007-11-01 23:27:38 +08:00
frame->sb_sample_f[blk][1][sb] =
rework joint subband test--uses a lot less stack space, simplify multiple loops into one, unroll one tiny loop
2007-11-27 10:42:29 +08:00
sb_sample_j[blk][1];
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.
2007-03-17 21:37:31 +08:00
}
}
}
Coding style fixes
2009-01-18 02:30:40 +08:00
PUT_BITS(data_ptr, bits_cache, bits_count,
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
joint, frame_subbands);
Bitstream writing optimization for SBC encoder SBC encoder performance improvement up to 1.5x for ARM11 and almost twice faster for Intel Core2 in some cases.
2008-12-12 03:21:28 +08:00
crc_header[crc_pos >> 3] = joint;
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
crc_pos += frame_subbands;
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.
2007-03-17 21:37:31 +08:00
}
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
for (ch = 0; ch < frame_channels; ch++) {
for (sb = 0; sb < frame_subbands; sb++) {
Coding style fixes
2009-01-18 02:30:40 +08:00
PUT_BITS(data_ptr, bits_cache, bits_count,
frame->scale_factor[ch][sb] & 0x0F, 4);
push in-place-shift optimization up into scalefactors section
2007-12-14 14:43:06 +08:00
crc_header[crc_pos >> 3] <<= 4;
crc_header[crc_pos >> 3] |= frame->scale_factor[ch][sb] & 0x0F;
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.
2007-03-17 21:37:31 +08:00
crc_pos += 4;
}
}
push in-place-shift optimization up into scalefactors section
2007-12-14 14:43:06 +08:00
/* align the last crc byte */
Whitespace cleanup
2008-01-28 18:38:40 +08:00
if (crc_pos % 8)
push in-place-shift optimization up into scalefactors section
2007-12-14 14:43:06 +08:00
crc_header[crc_pos >> 3] <<= 8 - (crc_pos % 8);
shift-in-place opt is back in, with a bugfix for the 4-subband case
2007-12-14 14:07:52 +08:00
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.
2007-03-17 21:37:31 +08:00
data[3] = sbc_crc8(crc_header, crc_pos);
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
sbc_calculate_bits(frame, bits);
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.
2007-03-17 21:37:31 +08:00
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
for (ch = 0; ch < frame_channels; ch++) {
for (sb = 0; sb < frame_subbands; sb++) {
Use of constant shift in SBC quantization code to make it faster The result of 32x32->64 unsigned long multiplication is returned in two registers (high and low 32-bit parts) for many 32-bit architectures. For these architectures constant right shift by 32 bits is optimized out by the compiler to just taking the high 32-bit part. Also some data needed at the quantization stage is precalculated beforehand to improve performance.
2009-01-04 09:11:12 +08:00
levels[ch][sb] = ((1 << bits[ch][sb]) - 1) <<
(32 - (frame->scale_factor[ch][sb] +
SCALE_OUT_BITS + 2));
sb_sample_delta[ch][sb] = (uint32_t) 1 <<
(frame->scale_factor[ch][sb] +
SCALE_OUT_BITS + 1);
}
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.
2007-03-17 21:37:31 +08:00
}
for (blk = 0; blk < frame->blocks; blk++) {
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
for (ch = 0; ch < frame_channels; ch++) {
for (sb = 0; sb < frame_subbands; sb++) {
New SBC analysis filter function to replace current broken code This code is heavily based on the patch submitted by Jaska Uimonen. Additional changes include preserving extra bits in the output of filter function for better precision, support for both 16-bit and 32-bit fixed point implementation. Sign of some table values was changed in order to preserve a regular code structure and have multiply-accumulate oparations only. No additional optimizations were applied as this code is intended to be some kind of "reference" implementation. Platform specific optimizations may require different tricks and can be branched off from this implementation. Some extra information about this code can be found in linux-bluetooth mailing list archive for December 2008.
2008-12-28 09:22:59 +08:00
if (bits[ch][sb] == 0)
continue;
audio_sample = ((uint64_t) levels[ch][sb] *
Use of constant shift in SBC quantization code to make it faster The result of 32x32->64 unsigned long multiplication is returned in two registers (high and low 32-bit parts) for many 32-bit architectures. For these architectures constant right shift by 32 bits is optimized out by the compiler to just taking the high 32-bit part. Also some data needed at the quantization stage is precalculated beforehand to improve performance.
2009-01-04 09:11:12 +08:00
(sb_sample_delta[ch][sb] +
frame->sb_sample_f[blk][ch][sb])) >> 32;
New SBC analysis filter function to replace current broken code This code is heavily based on the patch submitted by Jaska Uimonen. Additional changes include preserving extra bits in the output of filter function for better precision, support for both 16-bit and 32-bit fixed point implementation. Sign of some table values was changed in order to preserve a regular code structure and have multiply-accumulate oparations only. No additional optimizations were applied as this code is intended to be some kind of "reference" implementation. Platform specific optimizations may require different tricks and can be branched off from this implementation. Some extra information about this code can be found in linux-bluetooth mailing list archive for December 2008.
2008-12-28 09:22:59 +08:00
Coding style fixes
2009-01-18 02:30:40 +08:00
PUT_BITS(data_ptr, bits_cache, bits_count,
audio_sample, bits[ch][sb]);
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.
2007-03-17 21:37:31 +08:00
}
}
}
shift-in-place opt is back in, with a bugfix for the 4-subband case
2007-12-14 14:07:52 +08:00
Coding style fixes
2009-01-18 02:30:40 +08:00
FLUSH_BITS(data_ptr, bits_cache, bits_count);
shift-in-place opt is back in, with a bugfix for the 4-subband case
2007-12-14 14:07:52 +08:00
Bitstream writing optimization for SBC encoder SBC encoder performance improvement up to 1.5x for ARM11 and almost twice faster for Intel Core2 in some cases.
2008-12-12 03:21:28 +08:00
return data_ptr - data;
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.
2007-03-17 21:37:31 +08:00
}
Use of -funroll-loops option to improve SBC encoder performance Added the use of -funroll-loops gcc option for SBC. Also in order to gain better effect, 'sbc_pack_frame' function body moved to an inline function, which gets instantiated for 4 different subbands/channels combinations. So that 'frame_subbands' and 'frame_channels' arguments become compile time constants and can be better optimized by the compiler.
2009-01-22 03:08:34 +08:00
static int sbc_pack_frame(uint8_t *data, struct sbc_frame *frame, size_t len)
{
if (frame->subbands == 4) {
if (frame->channels == 1)
return sbc_pack_frame_internal(data, frame, len, 4, 1);
else
return sbc_pack_frame_internal(data, frame, len, 4, 2);
} else {
if (frame->channels == 1)
return sbc_pack_frame_internal(data, frame, len, 8, 1);
else
return sbc_pack_frame_internal(data, frame, len, 8, 2);
}
}
Added possibility to analyze 4 blocks at once in SBC encoder This change is needed for SIMD optimizations which will follow shortly. And even for non-SIMD capable platforms it still may be useful to have possibility to merge several analyzing functions together into one for better code scheduling or reusing loaded constants. Also analysis filter functions are now called using function pointers, which allows the default implementation to be overrided at runtime (with high precision variant or MMX/SSE2/NEON optimized code).
2008-12-31 15:14:25 +08:00
static void sbc_encoder_init(struct sbc_encoder_state *state,
const struct sbc_frame *frame)
{
memset(&state->X, 0, sizeof(state->X));
Performance optimizations for input data processing in SBC encoder Channels deinterleaving, endian conversion and samples reordering is done in one pass, avoiding the use of intermediate buffer. Also this code is implemented as a new "performance primitive", which allows further platform specific optimizations (ARMv6 and ARM NEON should gain quite a lot from assembly optimizations here).
2009-01-28 00:57:35 +08:00
state->position = SBC_X_BUFFER_SIZE - frame->subbands * 9;
Added possibility to analyze 4 blocks at once in SBC encoder This change is needed for SIMD optimizations which will follow shortly. And even for non-SIMD capable platforms it still may be useful to have possibility to merge several analyzing functions together into one for better code scheduling or reusing loaded constants. Also analysis filter functions are now called using function pointers, which allows the default implementation to be overrided at runtime (with high precision variant or MMX/SSE2/NEON optimized code).
2008-12-31 15:14:25 +08:00
SIMD-friendly variant of SBC encoder analysis filter Added SIMD-friendly C implementation of SBC analysis filter (the structure of code had to be changed a bit and constants in the tables reordered). This code can be used as a reference for developing platform specific SIMD optimizations. These functions are put into a new file 'sbc_primitives.c', which is going to contain all the basic stuff for SBC codec.
2009-01-16 01:11:23 +08:00
sbc_init_primitives(state);
Added possibility to analyze 4 blocks at once in SBC encoder This change is needed for SIMD optimizations which will follow shortly. And even for non-SIMD capable platforms it still may be useful to have possibility to merge several analyzing functions together into one for better code scheduling or reusing loaded constants. Also analysis filter functions are now called using function pointers, which allows the default implementation to be overrided at runtime (with high precision variant or MMX/SSE2/NEON optimized code).
2008-12-31 15:14:25 +08:00
}
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.
2007-03-17 21:37:31 +08:00
struct sbc_priv {
int init;
SBC arrays and constant tables aligned at 16 byte boundary for SIMD Most SIMD instruction sets benefit from data being naturally aligned. And even if it is not strictly required, performance is usually better with the aligned data. ARM NEON and SSE2 have different instruction variants for aligned/unaligned memory accesses.
2009-01-16 01:45:36 +08:00
struct SBC_ALIGNED sbc_frame frame;
struct SBC_ALIGNED sbc_decoder_state dec_state;
struct SBC_ALIGNED sbc_encoder_state enc_state;
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.
2007-03-17 21:37:31 +08:00
};
Change name of sbc_fill_defaults to sbc_set_defaults.
2007-11-14 04:59:17 +08:00
static void sbc_set_defaults(sbc_t *sbc, unsigned long flags)
Add sbc_reinit.
2007-11-14 04:04:12 +08:00
{
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
sbc->frequency = SBC_FREQ_44100;
sbc->mode = SBC_MODE_STEREO;
sbc->subbands = SBC_SB_8;
sbc->blocks = SBC_BLK_16;
Add sbc_reinit.
2007-11-14 04:04:12 +08:00
sbc->bitpool = 32;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
#if __BYTE_ORDER == __LITTLE_ENDIAN
sbc->endian = SBC_LE;
#elif __BYTE_ORDER == __BIG_ENDIAN
sbc->endian = SBC_BE;
#else
#error "Unknown byte order"
#endif
Add sbc_reinit.
2007-11-14 04:04:12 +08:00
}
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.
2007-03-17 21:37:31 +08:00
int sbc_init(sbc_t *sbc, unsigned long flags)
{
if (!sbc)
return -EIO;
memset(sbc, 0, sizeof(sbc_t));
SBC arrays and constant tables aligned at 16 byte boundary for SIMD Most SIMD instruction sets benefit from data being naturally aligned. And even if it is not strictly required, performance is usually better with the aligned data. ARM NEON and SSE2 have different instruction variants for aligned/unaligned memory accesses.
2009-01-16 01:45:36 +08:00
sbc->priv_alloc_base = malloc(sizeof(struct sbc_priv) + SBC_ALIGN_MASK);
if (!sbc->priv_alloc_base)
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.
2007-03-17 21:37:31 +08:00
return -ENOMEM;
SBC arrays and constant tables aligned at 16 byte boundary for SIMD Most SIMD instruction sets benefit from data being naturally aligned. And even if it is not strictly required, performance is usually better with the aligned data. ARM NEON and SSE2 have different instruction variants for aligned/unaligned memory accesses.
2009-01-16 01:45:36 +08:00
sbc->priv = (void *) (((uintptr_t) sbc->priv_alloc_base +
SBC_ALIGN_MASK) & ~((uintptr_t) SBC_ALIGN_MASK));
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.
2007-03-17 21:37:31 +08:00
memset(sbc->priv, 0, sizeof(struct sbc_priv));
Change name of sbc_fill_defaults to sbc_set_defaults.
2007-11-14 04:59:17 +08:00
sbc_set_defaults(sbc, flags);
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.
2007-03-17 21:37:31 +08:00
return 0;
}
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
int sbc_parse(sbc_t *sbc, void *input, int input_len)
Add simple implementation of sbc_parse()
2007-08-26 21:54:24 +08:00
{
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
return sbc_decode(sbc, input, input_len, NULL, 0, NULL);
Add simple implementation of sbc_parse()
2007-08-26 21:54:24 +08:00
}
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
int sbc_decode(sbc_t *sbc, void *input, int input_len, void *output,
int output_len, int *written)
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.
2007-03-17 21:37:31 +08:00
{
struct sbc_priv *priv;
char *ptr;
int i, ch, framelen, samples;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (!sbc && !input)
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.
2007-03-17 21:37:31 +08:00
return -EIO;
priv = sbc->priv;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
framelen = sbc_unpack_frame(input, &priv->frame, input_len);
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.
2007-03-17 21:37:31 +08:00
if (!priv->init) {
sbc_decoder_init(&priv->dec_state, &priv->frame);
priv->init = 1;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
sbc->frequency = priv->frame.frequency;
sbc->mode = priv->frame.mode;
sbc->subbands = priv->frame.subband_mode;
sbc->blocks = priv->frame.block_mode;
sbc->allocation = priv->frame.allocation;
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.
2007-03-17 21:37:31 +08:00
sbc->bitpool = priv->frame.bitpool;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
priv->frame.codesize = sbc_get_codesize(sbc);
priv->frame.length = sbc_get_frame_length(sbc);
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.
2007-03-17 21:37:31 +08:00
}
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (!output)
return framelen;
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.
2007-03-17 21:37:31 +08:00
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (written)
*written = 0;
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.
2007-03-17 21:37:31 +08:00
Don't decode a frame if it is too small
2008-12-24 06:41:38 +08:00
if (framelen <= 0)
return framelen;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
samples = sbc_synthesize_audio(&priv->dec_state, &priv->frame);
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.
2007-03-17 21:37:31 +08:00
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
ptr = output;
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.
2007-03-17 21:37:31 +08:00
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (output_len < samples * priv->frame.channels * 2)
samples = output_len / (priv->frame.channels * 2);
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.
2007-03-17 21:37:31 +08:00
for (i = 0; i < samples; i++) {
for (ch = 0; ch < priv->frame.channels; ch++) {
int16_t s;
s = priv->frame.pcm_sample[ch][i];
Add swap member to sbc struct and fix pcm plugin to not swap the buffer.
2007-08-22 05:32:09 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (sbc->endian == SBC_BE) {
Add swap member to sbc struct and fix pcm plugin to not swap the buffer.
2007-08-22 05:32:09 +08:00
*ptr++ = (s & 0xff00) >> 8;
*ptr++ = (s & 0x00ff);
} else {
*ptr++ = (s & 0x00ff);
*ptr++ = (s & 0xff00) >> 8;
}
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.
2007-03-17 21:37:31 +08:00
}
}
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (written)
*written = samples * priv->frame.channels * 2;
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.
2007-03-17 21:37:31 +08:00
return framelen;
}
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
int sbc_encode(sbc_t *sbc, void *input, int input_len, void *output,
int output_len, int *written)
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.
2007-03-17 21:37:31 +08:00
{
struct sbc_priv *priv;
Performance optimizations for input data processing in SBC encoder Channels deinterleaving, endian conversion and samples reordering is done in one pass, avoiding the use of intermediate buffer. Also this code is implemented as a new "performance primitive", which allows further platform specific optimizations (ARMv6 and ARM NEON should gain quite a lot from assembly optimizations here).
2009-01-28 00:57:35 +08:00
int framelen, samples;
int (*sbc_enc_process_input)(int position,
const uint8_t *pcm, int16_t X[2][SBC_X_BUFFER_SIZE],
int nsamples, int nchannels);
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.
2007-03-17 21:37:31 +08:00
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (!sbc && !input)
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.
2007-03-17 21:37:31 +08:00
return -EIO;
priv = sbc->priv;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (written)
*written = 0;
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.
2007-03-17 21:37:31 +08:00
if (!priv->init) {
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
priv->frame.frequency = sbc->frequency;
priv->frame.mode = sbc->mode;
priv->frame.channels = sbc->mode == SBC_MODE_MONO ? 1 : 2;
priv->frame.allocation = sbc->allocation;
priv->frame.subband_mode = sbc->subbands;
priv->frame.subbands = sbc->subbands ? 8 : 4;
priv->frame.block_mode = sbc->blocks;
priv->frame.blocks = 4 + (sbc->blocks * 4);
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.
2007-03-17 21:37:31 +08:00
priv->frame.bitpool = sbc->bitpool;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
priv->frame.codesize = sbc_get_codesize(sbc);
priv->frame.length = sbc_get_frame_length(sbc);
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.
2007-03-17 21:37:31 +08:00
sbc_encoder_init(&priv->enc_state, &priv->frame);
priv->init = 1;
}
indicate 0 bytes consumed in encoder if input is too short. caller is responsible for filling the end of the input if it really wants the frame encoded (ie with silence at the end)
2007-08-26 09:05:25 +08:00
/* input must be large enough to encode a complete frame */
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (input_len < priv->frame.codesize)
indicate 0 bytes consumed in encoder if input is too short. caller is responsible for filling the end of the input if it really wants the frame encoded (ie with silence at the end)
2007-08-26 09:05:25 +08:00
return 0;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
/* output must be large enough to receive the encoded frame */
if (!output || output_len < priv->frame.length)
return -ENOSPC;
Performance optimizations for input data processing in SBC encoder Channels deinterleaving, endian conversion and samples reordering is done in one pass, avoiding the use of intermediate buffer. Also this code is implemented as a new "performance primitive", which allows further platform specific optimizations (ARMv6 and ARM NEON should gain quite a lot from assembly optimizations here).
2009-01-28 00:57:35 +08:00
/* Select the needed input data processing function and call it */
if (priv->frame.subbands == 8) {
if (sbc->endian == SBC_BE)
sbc_enc_process_input =
priv->enc_state.sbc_enc_process_input_8s_be;
else
sbc_enc_process_input =
priv->enc_state.sbc_enc_process_input_8s_le;
} else {
if (sbc->endian == SBC_BE)
sbc_enc_process_input =
priv->enc_state.sbc_enc_process_input_4s_be;
else
sbc_enc_process_input =
priv->enc_state.sbc_enc_process_input_4s_le;
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.
2007-03-17 21:37:31 +08:00
}
Performance optimizations for input data processing in SBC encoder Channels deinterleaving, endian conversion and samples reordering is done in one pass, avoiding the use of intermediate buffer. Also this code is implemented as a new "performance primitive", which allows further platform specific optimizations (ARMv6 and ARM NEON should gain quite a lot from assembly optimizations here).
2009-01-28 00:57:35 +08:00
priv->enc_state.position = sbc_enc_process_input(
priv->enc_state.position, (const uint8_t *) input,
priv->enc_state.X, priv->frame.subbands * priv->frame.blocks,
priv->frame.channels);
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.
2007-03-17 21:37:31 +08:00
samples = sbc_analyze_audio(&priv->enc_state, &priv->frame);
SBC encoder scale factors calculation optimized with __builtin_clz Count leading zeros operation is often implemented using a special instruction for it on various architectures (at least this is true for ARM and x86). Using __builtin_clz gcc intrinsic allows to eliminate innermost loop in scale factors calculation and improve performance. Also scale factors calculation can be optimized even more using SIMD instructions.
2009-01-29 08:17:36 +08:00
priv->enc_state.sbc_calc_scalefactors(
priv->frame.sb_sample_f, priv->frame.scale_factor,
priv->frame.blocks, priv->frame.channels, priv->frame.subbands);
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
framelen = sbc_pack_frame(output, &priv->frame, output_len);
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.
2007-03-17 21:37:31 +08:00
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
if (written)
*written = framelen;
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.
2007-03-17 21:37:31 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
return samples * priv->frame.channels * 2;
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.
2007-03-17 21:37:31 +08:00
}
void sbc_finish(sbc_t *sbc)
{
if (!sbc)
return;
SBC arrays and constant tables aligned at 16 byte boundary for SIMD Most SIMD instruction sets benefit from data being naturally aligned. And even if it is not strictly required, performance is usually better with the aligned data. ARM NEON and SSE2 have different instruction variants for aligned/unaligned memory accesses.
2009-01-16 01:45:36 +08:00
if (sbc->priv_alloc_base)
free(sbc->priv_alloc_base);
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.
2007-03-17 21:37:31 +08:00
memset(sbc, 0, sizeof(sbc_t));
}
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
int sbc_get_frame_length(sbc_t *sbc)
{
int ret;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
uint8_t subbands, channels, blocks, joint;
struct sbc_priv *priv;
priv = sbc->priv;
if (!priv->init) {
subbands = sbc->subbands ? 8 : 4;
blocks = 4 + (sbc->blocks * 4);
channels = sbc->mode == SBC_MODE_MONO ? 1 : 2;
joint = sbc->mode == SBC_MODE_JOINT_STEREO ? 1 : 0;
} else {
subbands = priv->frame.subbands;
blocks = priv->frame.blocks;
channels = priv->frame.channels;
joint = priv->frame.joint;
}
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
ret = 4 + (4 * subbands * channels) / 8;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
Add sbc_reinit.
2007-11-14 04:04:12 +08:00
/* This term is not always evenly divide so we round it up */
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
if (channels == 1)
ret += ((blocks * channels * sbc->bitpool) + 7) / 8;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
else
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
ret += (((joint ? subbands : 0) + blocks * sbc->bitpool) + 7)
/ 8;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
return ret;
}
Introduce sbc_get_frame_duration.
2007-11-23 22:24:23 +08:00
int sbc_get_frame_duration(sbc_t *sbc)
{
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
uint8_t subbands, blocks;
uint16_t frequency;
struct sbc_priv *priv;
priv = sbc->priv;
if (!priv->init) {
subbands = sbc->subbands ? 8 : 4;
blocks = 4 + (sbc->blocks * 4);
} else {
subbands = priv->frame.subbands;
blocks = priv->frame.blocks;
}
switch (sbc->frequency) {
case SBC_FREQ_16000:
frequency = 16000;
break;
case SBC_FREQ_32000:
frequency = 32000;
break;
case SBC_FREQ_44100:
frequency = 44100;
break;
case SBC_FREQ_48000:
frequency = 48000;
break;
default:
return 0;
}
return (1000000 * blocks * subbands) / frequency;
Introduce sbc_get_frame_duration.
2007-11-23 22:24:23 +08:00
}
Fixed correct handling of frame sizes in the encoder
2009-01-05 20:26:08 +08:00
uint16_t sbc_get_codesize(sbc_t *sbc)
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
{
Fixed correct handling of frame sizes in the encoder
2009-01-05 20:26:08 +08:00
uint16_t subbands, channels, blocks;
Introduce sbc new API.
2008-02-20 03:47:25 +08:00
struct sbc_priv *priv;
priv = sbc->priv;
if (!priv->init) {
subbands = sbc->subbands ? 8 : 4;
blocks = 4 + (sbc->blocks * 4);
channels = sbc->mode == SBC_MODE_MONO ? 1 : 2;
} else {
subbands = priv->frame.subbands;
blocks = priv->frame.blocks;
channels = priv->frame.channels;
}
return subbands * blocks * channels * 2;
Make sbc codec to write directly in application buffers and so avoiding memcpys.
2007-11-13 02:15:59 +08:00
}
Add sbc_reinit.
2007-11-14 04:04:12 +08:00
int sbc_reinit(sbc_t *sbc, unsigned long flags)
{
struct sbc_priv *priv;
if (!sbc || !sbc->priv)
return -EIO;
priv = sbc->priv;
if (priv->init == 1)
memset(sbc->priv, 0, sizeof(struct sbc_priv));
Change name of sbc_fill_defaults to sbc_set_defaults.
2007-11-14 04:59:17 +08:00
sbc_set_defaults(sbc, flags);
Add sbc_reinit.
2007-11-14 04:04:12 +08:00
return 0;
}
Reference in New Issue Copy Permalink