move to new cspot

components/spotify/cspot/bell/external/alac/codec/ALACAudioTypes.h

@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		ALACAudioTypes.h
+*/
+
+#ifndef ALACAUDIOTYPES_H
+#define ALACAUDIOTYPES_H
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=mac68k
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(push, 2)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack(2)
+#endif
+
+#include <stdint.h>
+
+#if defined(__ppc__)
+#define TARGET_RT_BIG_ENDIAN 1
+#elif defined(__ppc64__)
+#define TARGET_RT_BIG_ENDIAN 1
+#endif
+
+#define kChannelAtomSize 12
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmultichar"
+    
+enum 
+{
+    kALAC_UnimplementedError   = -4,
+    kALAC_FileNotFoundError    = -43,
+    kALAC_ParamError           = -50,
+    kALAC_MemFullError         = -108
+};
+
+enum
+{
+    kALACFormatAppleLossless = 'alac',
+    kALACFormatLinearPCM = 'lpcm'
+};
+
+enum
+{
+    kALACMaxChannels	= 8,
+    kALACMaxEscapeHeaderBytes = 8,
+    kALACMaxSearches	= 16,
+    kALACMaxCoefs		= 16,
+    kALACDefaultFramesPerPacket = 4096
+};
+
+typedef uint32_t ALACChannelLayoutTag;
+
+enum
+{
+    kALACFormatFlagIsFloat                     = (1 << 0),     // 0x1
+    kALACFormatFlagIsBigEndian                 = (1 << 1),     // 0x2
+    kALACFormatFlagIsSignedInteger             = (1 << 2),     // 0x4
+    kALACFormatFlagIsPacked                    = (1 << 3),     // 0x8
+    kALACFormatFlagIsAlignedHigh               = (1 << 4),     // 0x10
+};
+
+enum
+{
+#if TARGET_RT_BIG_ENDIAN
+    kALACFormatFlagsNativeEndian       = kALACFormatFlagIsBigEndian
+#else
+    kALACFormatFlagsNativeEndian       = 0
+#endif
+};
+
+// this is required to be an IEEE 64bit float
+typedef double alac_float64_t;
+
+// These are the Channel Layout Tags used in the Channel Layout Info portion of the ALAC magic cookie
+enum
+{
+    kALACChannelLayoutTag_Mono          = (100<<16) | 1,    // C
+    kALACChannelLayoutTag_Stereo        = (101<<16) | 2,	// L R
+    kALACChannelLayoutTag_MPEG_3_0_B    = (113<<16) | 3,	// C L R
+    kALACChannelLayoutTag_MPEG_4_0_B    = (116<<16) | 4,	// C L R Cs
+    kALACChannelLayoutTag_MPEG_5_0_D    = (120<<16) | 5,    // C L R Ls Rs
+    kALACChannelLayoutTag_MPEG_5_1_D    = (124<<16) | 6,	// C L R Ls Rs LFE
+    kALACChannelLayoutTag_AAC_6_1       = (142<<16) | 7,	// C L R Ls Rs Cs LFE
+    kALACChannelLayoutTag_MPEG_7_1_B	= (127<<16) | 8     // C Lc Rc L R Ls Rs LFE    (doc: IS-13818-7 MPEG2-AAC)
+};
+
+// ALAC currently only utilizes these channels layouts. There is a one for one correspondance between a
+// given number of channels and one of these layout tags
+static const ALACChannelLayoutTag	ALACChannelLayoutTags[kALACMaxChannels] =
+{
+    kALACChannelLayoutTag_Mono,         // C
+    kALACChannelLayoutTag_Stereo,		// L R
+    kALACChannelLayoutTag_MPEG_3_0_B,	// C L R
+    kALACChannelLayoutTag_MPEG_4_0_B,	// C L R Cs
+    kALACChannelLayoutTag_MPEG_5_0_D,	// C L R Ls Rs
+    kALACChannelLayoutTag_MPEG_5_1_D,	// C L R Ls Rs LFE
+    kALACChannelLayoutTag_AAC_6_1,		// C L R Ls Rs Cs LFE
+    kALACChannelLayoutTag_MPEG_7_1_B	// C Lc Rc L R Ls Rs LFE    (doc: IS-13818-7 MPEG2-AAC)
+};
+
+// AudioChannelLayout from CoreAudioTypes.h. We never need the AudioChannelDescription so we remove it
+struct ALACAudioChannelLayout
+{
+    ALACChannelLayoutTag          mChannelLayoutTag;
+    uint32_t                      mChannelBitmap;
+    uint32_t                      mNumberChannelDescriptions;
+};
+typedef struct ALACAudioChannelLayout ALACAudioChannelLayout;
+
+struct AudioFormatDescription
+{
+    alac_float64_t mSampleRate;
+    uint32_t  mFormatID;
+    uint32_t  mFormatFlags;
+    uint32_t  mBytesPerPacket;
+    uint32_t  mFramesPerPacket;
+    uint32_t  mBytesPerFrame;
+    uint32_t  mChannelsPerFrame;
+    uint32_t  mBitsPerChannel;
+    uint32_t  mReserved;
+};
+typedef struct AudioFormatDescription  AudioFormatDescription;
+
+/* Lossless Definitions */
+
+enum
+{
+	kALACCodecFormat		= 'alac',
+	kALACVersion			= 0,
+	kALACCompatibleVersion	= kALACVersion,
+	kALACDefaultFrameSize	= 4096
+};
+
+// note: this struct is wrapped in an 'alac' atom in the sample description extension area
+// note: in QT movies, it will be further wrapped in a 'wave' atom surrounded by 'frma' and 'term' atoms
+typedef struct ALACSpecificConfig
+{
+	uint32_t				frameLength;
+	uint8_t					compatibleVersion;
+	uint8_t					bitDepth;							// max 32
+	uint8_t					pb;									// 0 <= pb <= 255
+	uint8_t					mb;
+	uint8_t					kb;
+	uint8_t					numChannels;
+	uint16_t				maxRun;
+	uint32_t				maxFrameBytes;
+	uint32_t				avgBitRate;
+	uint32_t				sampleRate;
+
+} ALACSpecificConfig;
+
+
+// The AudioChannelLayout atom type is not exposed yet so define it here
+enum
+{
+	AudioChannelLayoutAID = 'chan'
+};
+
+#pragma GCC diagnostic pop
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=reset
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(pop)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack()
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* ALACAUDIOTYPES_H */

components/spotify/cspot/bell/external/alac/codec/ALACBitUtilities.c

@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*=============================================================================
+    File:		ALACBitUtilities.c
+
+	$NoKeywords: $
+=============================================================================*/
+
+#include <stdio.h>
+#include "ALACBitUtilities.h"
+
+// BitBufferInit
+//
+void BitBufferInit( BitBuffer * bits, uint8_t * buffer, uint32_t byteSize )
+{
+	bits->cur		= buffer;
+	bits->end		= bits->cur + byteSize;
+	bits->bitIndex	= 0;
+	bits->byteSize	= byteSize;
+}
+
+// BitBufferRead
+//
+uint32_t BitBufferRead( BitBuffer * bits, uint8_t numBits )
+{
+	uint32_t		returnBits;
+	
+	//Assert( numBits <= 16 );
+
+	returnBits = ((uint32_t)bits->cur[0] << 16) | ((uint32_t)bits->cur[1] << 8) | ((uint32_t)bits->cur[2]);
+	returnBits = returnBits << bits->bitIndex;
+	returnBits &= 0x00FFFFFF;
+	
+	bits->bitIndex += numBits;
+	
+	returnBits = returnBits >> (24 - numBits);
+	
+	bits->cur		+= (bits->bitIndex >> 3);
+	bits->bitIndex	&= 7;
+	
+	//Assert( bits->cur <= bits->end );
+	
+	return returnBits;
+}
+
+// BitBufferReadSmall
+//
+// Reads up to 8 bits
+uint8_t BitBufferReadSmall( BitBuffer * bits, uint8_t numBits )
+{
+	uint16_t		returnBits;
+	
+	//Assert( numBits <= 8 );
+	
+	returnBits = (bits->cur[0] << 8) | bits->cur[1];
+	returnBits = returnBits << bits->bitIndex;
+	
+	bits->bitIndex += numBits;
+	
+	returnBits = returnBits >> (16 - numBits);
+	
+	bits->cur		+= (bits->bitIndex >> 3);
+	bits->bitIndex	&= 7;
+	
+	//Assert( bits->cur <= bits->end );
+	
+	return (uint8_t)returnBits;
+}
+
+// BitBufferReadOne
+//
+// Reads one byte
+uint8_t BitBufferReadOne( BitBuffer * bits )
+{
+	uint8_t		returnBits;
+
+	returnBits = (bits->cur[0] >> (7 - bits->bitIndex)) & 1;
+
+	bits->bitIndex++;
+	
+	bits->cur		+= (bits->bitIndex >> 3);
+	bits->bitIndex	&= 7;
+	
+	//Assert( bits->cur <= bits->end );
+	
+	return returnBits;
+}
+
+// BitBufferPeek
+//
+uint32_t BitBufferPeek( BitBuffer * bits, uint8_t numBits )
+{
+	return ((((((uint32_t) bits->cur[0] << 16) | ((uint32_t) bits->cur[1] << 8) |
+			((uint32_t) bits->cur[2])) << bits->bitIndex) & 0x00FFFFFF) >> (24 - numBits));
+}
+
+// BitBufferPeekOne
+//
+uint32_t BitBufferPeekOne( BitBuffer * bits )
+{
+	return ((bits->cur[0] >> (7 - bits->bitIndex)) & 1);
+}
+
+// BitBufferUnpackBERSize
+//
+uint32_t BitBufferUnpackBERSize( BitBuffer * bits )
+{
+	uint32_t		size;
+	uint8_t		tmp;
+	
+	for ( size = 0, tmp = 0x80u; tmp &= 0x80u; size = (size << 7u) | (tmp & 0x7fu) )
+		tmp = (uint8_t) BitBufferReadSmall( bits, 8 );
+	
+	return size;
+}
+
+// BitBufferGetPosition
+//
+uint32_t BitBufferGetPosition( BitBuffer * bits )
+{
+	uint8_t *		begin;
+	
+	begin = bits->end - bits->byteSize;
+	
+	return ((uint32_t)(bits->cur - begin) * 8) + bits->bitIndex;
+}
+
+// BitBufferByteAlign
+//
+void BitBufferByteAlign( BitBuffer * bits, int32_t addZeros )
+{
+	// align bit buffer to next byte boundary, writing zeros if requested
+	if ( bits->bitIndex == 0 )
+		return;
+
+	if ( addZeros )
+		BitBufferWrite( bits, 0, 8 - bits->bitIndex );
+	else	
+		BitBufferAdvance( bits, 8 - bits->bitIndex );	
+}
+
+// BitBufferAdvance
+//
+void BitBufferAdvance( BitBuffer * bits, uint32_t numBits )
+{
+	if ( numBits )
+	{
+		bits->bitIndex += numBits;
+		bits->cur += (bits->bitIndex >> 3);
+		bits->bitIndex &= 7;
+	}
+}
+
+// BitBufferRewind
+//
+void BitBufferRewind( BitBuffer * bits, uint32_t numBits )
+{
+	uint32_t	numBytes;
+	
+	if ( numBits == 0 )
+		return;
+	
+	if ( bits->bitIndex >= numBits )
+	{
+		bits->bitIndex -= numBits;
+		return;
+	}
+	
+	numBits -= bits->bitIndex;
+	bits->bitIndex = 0;
+
+	numBytes	= numBits / 8;
+	numBits		= numBits % 8;
+	
+	bits->cur -= numBytes;
+	
+	if ( numBits > 0 )
+	{
+		bits->bitIndex = 8 - numBits;
+		bits->cur--;
+	}
+	
+	if ( bits->cur < (bits->end - bits->byteSize) )
+	{
+		//DebugCMsg("BitBufferRewind: Rewound too far.");
+
+		bits->cur		= (bits->end - bits->byteSize);
+		bits->bitIndex	= 0;
+	}
+}
+
+// BitBufferWrite
+//
+void BitBufferWrite( BitBuffer * bits, uint32_t bitValues, uint32_t numBits )
+{
+	uint32_t				invBitIndex;
+	
+	RequireAction( bits != nil, return; );
+	RequireActionSilent( numBits > 0, return; );
+
+	invBitIndex = 8 - bits->bitIndex;
+
+	while ( numBits > 0 )
+	{
+		uint32_t		tmp;
+		uint8_t		shift;
+		uint8_t		mask;
+		uint32_t		curNum;
+
+		curNum = MIN( invBitIndex, numBits );
+
+		tmp = bitValues >> (numBits - curNum);
+
+		shift  = (uint8_t)(invBitIndex - curNum);
+		mask   = 0xffu >> (8 - curNum);		// must be done in two steps to avoid compiler sequencing ambiguity
+		mask <<= shift;
+
+		bits->cur[0] = (bits->cur[0] & ~mask) | (((uint8_t) tmp << shift)  & mask);
+		numBits -= curNum;
+
+		// increment to next byte if need be
+		invBitIndex -= curNum;
+		if ( invBitIndex == 0 )
+		{
+			invBitIndex = 8;
+			bits->cur++;
+		}
+	}
+
+	bits->bitIndex = 8 - invBitIndex;
+}
+
+void	BitBufferReset( BitBuffer * bits )
+//void BitBufferInit( BitBuffer * bits, uint8_t * buffer, uint32_t byteSize )
+{
+	bits->cur		= bits->end - bits->byteSize;
+    bits->bitIndex	= 0;
+}
+
+#if PRAGMA_MARK
+#pragma mark -
+#endif

components/spotify/cspot/bell/external/alac/codec/ALACBitUtilities.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*=============================================================================
+    File:		ALACBitUtilities.h
+	
+	$NoKeywords: $
+=============================================================================*/
+
+#ifndef __ALACBITUTILITIES_H
+#define __ALACBITUTILITIES_H
+
+#include <stdint.h>
+
+#ifndef MIN
+#define MIN(x, y) 			( (x)<(y) ?(x) :(y) )
+#endif //MIN
+#ifndef MAX
+#define MAX(x, y) 			( (x)>(y) ?(x): (y) )
+#endif //MAX
+
+#ifndef nil
+#define nil NULL
+#endif
+
+#define RequireAction(condition, action)			if (!(condition)) { action }
+#define RequireActionSilent(condition, action)			if (!(condition)) { action }
+#define RequireNoErr(condition, action)			if ((condition)) { action }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum
+{
+    ALAC_noErr = 0
+};
+    
+
+typedef enum
+{
+    
+    ID_SCE = 0,						/* Single Channel Element   */
+    ID_CPE = 1,						/* Channel Pair Element     */
+    ID_CCE = 2,						/* Coupling Channel Element */
+    ID_LFE = 3,						/* LFE Channel Element      */
+    ID_DSE = 4,						/* not yet supported        */
+    ID_PCE = 5,
+    ID_FIL = 6,
+    ID_END = 7
+} ELEMENT_TYPE;
+
+// types
+typedef struct BitBuffer
+{
+	uint8_t *		cur;
+	uint8_t *		end;
+	uint32_t		bitIndex;
+	uint32_t		byteSize;
+	
+} BitBuffer;
+
+/*
+	BitBuffer routines
+	- these routines take a fixed size buffer and read/write to it
+	- bounds checking must be done by the client
+*/
+void	BitBufferInit( BitBuffer * bits, uint8_t * buffer, uint32_t byteSize );
+uint32_t	BitBufferRead( BitBuffer * bits, uint8_t numBits );   // note: cannot read more than 16 bits at a time
+uint8_t	BitBufferReadSmall( BitBuffer * bits, uint8_t numBits );
+uint8_t	BitBufferReadOne( BitBuffer * bits );
+uint32_t	BitBufferPeek( BitBuffer * bits, uint8_t numBits );   // note: cannot read more than 16 bits at a time
+uint32_t	BitBufferPeekOne( BitBuffer * bits );
+uint32_t	BitBufferUnpackBERSize( BitBuffer * bits );
+uint32_t	BitBufferGetPosition( BitBuffer * bits );
+void	BitBufferByteAlign( BitBuffer * bits, int32_t addZeros );
+void	BitBufferAdvance( BitBuffer * bits, uint32_t numBits );
+void	BitBufferRewind( BitBuffer * bits, uint32_t numBits );
+void	BitBufferWrite( BitBuffer * bits, uint32_t value, uint32_t numBits );
+void	BitBufferReset( BitBuffer * bits);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* __BITUTILITIES_H */

components/spotify/cspot/bell/external/alac/codec/ALACDecoder.cpp

@@ -0,0 +1,737 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		ALACDecoder.cpp
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "ALACDecoder.h"
+
+#include "dplib.h"
+#include "aglib.h"
+#include "matrixlib.h"
+
+#include "ALACBitUtilities.h"
+#include "EndianPortable.h"
+
+#if (__GNUC__) > 4 || defined (__APPLE__)
+#pragma GCC diagnostic ignored "-Wunused-const-variable"
+#endif
+#if !defined(__APPLE__) 
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+
+// constants/data
+const uint32_t kMaxBitDepth = 32;			// max allowed bit depth is 32
+
+
+// prototypes
+static void Zero16( int16_t * buffer, uint32_t numItems, uint32_t stride );
+static void Zero24( uint8_t * buffer, uint32_t numItems, uint32_t stride );
+static void Zero32( int32_t * buffer, uint32_t numItems, uint32_t stride );
+
+/*
+	Constructor
+*/
+ALACDecoder::ALACDecoder() :
+	mMixBufferU( nil ),
+	mMixBufferV( nil ),
+	mPredictor( nil ),
+	mShiftBuffer( nil )
+{
+	memset( &mConfig, 0, sizeof(mConfig) );
+}
+
+/*
+	Destructor
+*/
+ALACDecoder::~ALACDecoder()
+{
+	// delete the matrix mixing buffers
+	if ( mMixBufferU )
+    {
+		free(mMixBufferU);
+        mMixBufferU = NULL;
+    }
+	if ( mMixBufferV )
+    {
+		free(mMixBufferV);
+        mMixBufferV = NULL;
+    }
+	
+	// delete the dynamic predictor's "corrector" buffer
+	// - note: mShiftBuffer shares memory with this buffer
+	if ( mPredictor )
+    {
+		free(mPredictor);
+        mPredictor = NULL;
+    }
+}
+
+/*
+	Init()
+	- initialize the decoder with the given configuration
+*/
+int32_t ALACDecoder::Init( void * inMagicCookie, uint32_t inMagicCookieSize )
+{
+	int32_t		status = ALAC_noErr;
+    ALACSpecificConfig theConfig;
+    uint8_t * theActualCookie = (uint8_t *)inMagicCookie;
+    uint32_t theCookieBytesRemaining = inMagicCookieSize;
+
+    // For historical reasons the decoder needs to be resilient to magic cookies vended by older encoders.
+    // As specified in the ALACMagicCookieDescription.txt document, there may be additional data encapsulating 
+    // the ALACSpecificConfig. This would consist of format ('frma') and 'alac' atoms which precede the
+    // ALACSpecificConfig. 
+    // See ALACMagicCookieDescription.txt for additional documentation concerning the 'magic cookie'
+    
+    // skip format ('frma') atom if present
+    if (theActualCookie[4] == 'f' && theActualCookie[5] == 'r' && theActualCookie[6] == 'm' && theActualCookie[7] == 'a')
+    {
+        theActualCookie += 12;
+        theCookieBytesRemaining -= 12;
+    }
+    
+    // skip 'alac' atom header if present
+    if (theActualCookie[4] == 'a' && theActualCookie[5] == 'l' && theActualCookie[6] == 'a' && theActualCookie[7] == 'c')
+    {
+        theActualCookie += 12;
+        theCookieBytesRemaining -= 12;
+    }
+
+    // read the ALACSpecificConfig
+    if (theCookieBytesRemaining >= sizeof(ALACSpecificConfig))
+    {
+        theConfig.frameLength = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->frameLength);
+        theConfig.compatibleVersion = ((ALACSpecificConfig *)theActualCookie)->compatibleVersion;
+        theConfig.bitDepth = ((ALACSpecificConfig *)theActualCookie)->bitDepth;
+        theConfig.pb = ((ALACSpecificConfig *)theActualCookie)->pb;
+        theConfig.mb = ((ALACSpecificConfig *)theActualCookie)->mb;
+        theConfig.kb = ((ALACSpecificConfig *)theActualCookie)->kb;
+        theConfig.numChannels = ((ALACSpecificConfig *)theActualCookie)->numChannels;
+        theConfig.maxRun = Swap16BtoN(((ALACSpecificConfig *)theActualCookie)->maxRun);
+        theConfig.maxFrameBytes = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->maxFrameBytes);
+        theConfig.avgBitRate = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->avgBitRate);
+        theConfig.sampleRate = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->sampleRate);
+
+        mConfig = theConfig;
+        
+        RequireAction( mConfig.compatibleVersion <= kALACVersion, return kALAC_ParamError; );
+
+        // allocate mix buffers
+        mMixBufferU = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );
+        mMixBufferV = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );
+
+        // allocate dynamic predictor buffer
+        mPredictor = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );
+
+        // "shift off" buffer shares memory with predictor buffer
+        mShiftBuffer = (uint16_t *) mPredictor;
+        
+        RequireAction( (mMixBufferU != nil) && (mMixBufferV != nil) && (mPredictor != nil),
+                        status = kALAC_MemFullError; goto Exit; );
+     }
+    else
+    {
+        status = kALAC_ParamError;
+    }
+
+    // skip to Channel Layout Info
+    // theActualCookie += sizeof(ALACSpecificConfig);
+    
+    // Currently, the Channel Layout Info portion of the magic cookie (as defined in the 
+    // ALACMagicCookieDescription.txt document) is unused by the decoder. 
+    
+Exit:
+	return status;
+}
+
+/*
+	Decode()
+	- the decoded samples are interleaved into the output buffer in the order they arrive in
+	  the bitstream
+*/
+int32_t ALACDecoder::Decode( BitBuffer * bits, uint8_t * sampleBuffer, uint32_t numSamples, uint32_t numChannels, uint32_t * outNumSamples )
+{
+	BitBuffer			shiftBits;
+	uint32_t            bits1, bits2;
+	uint8_t				tag;
+	uint8_t				elementInstanceTag;
+	AGParamRec			agParams;
+	uint32_t				channelIndex;
+	int16_t				coefsU[32];		// max possible size is 32 although NUMCOEPAIRS is the current limit
+	int16_t				coefsV[32];
+	uint8_t				numU, numV;
+	uint8_t				mixBits;
+	int8_t				mixRes;
+	uint16_t			unusedHeader;
+	uint8_t				escapeFlag;
+	uint32_t			chanBits;
+	uint8_t				bytesShifted;
+	uint32_t			shift;
+	uint8_t				modeU, modeV;
+	uint32_t			denShiftU, denShiftV;
+	uint16_t			pbFactorU, pbFactorV;
+	uint16_t			pb;
+	int16_t *			samples;
+	int16_t *			out16;
+	uint8_t *			out20;
+	uint8_t *			out24;
+	int32_t *			out32;
+	uint8_t				headerByte;
+	uint8_t				partialFrame;
+	uint32_t			extraBits;
+	int32_t				val;
+	uint32_t			i, j;
+	int32_t             status;
+	
+	RequireAction( (bits != nil) && (sampleBuffer != nil) && (outNumSamples != nil), return kALAC_ParamError; );
+	RequireAction( numChannels > 0, return kALAC_ParamError; );
+
+	mActiveElements = 0;
+	channelIndex	= 0;
+	
+	samples = (int16_t *) sampleBuffer;
+
+	status = ALAC_noErr;
+	*outNumSamples = numSamples;
+
+	while ( status == ALAC_noErr )
+	{
+		// bail if we ran off the end of the buffer
+    	RequireAction( bits->cur < bits->end, status = kALAC_ParamError; goto Exit; );
+
+		// copy global decode params for this element
+		pb = mConfig.pb;
+
+		// read element tag
+		tag = BitBufferReadSmall( bits, 3 );
+		switch ( tag )
+		{
+			case ID_SCE:
+			case ID_LFE:
+			{
+				// mono/LFE channel
+				elementInstanceTag = BitBufferReadSmall( bits, 4 );
+				mActiveElements |= (1u << elementInstanceTag);
+
+				// read the 12 unused header bits
+				unusedHeader = (uint16_t) BitBufferRead( bits, 12 );
+				RequireAction( unusedHeader == 0, status = kALAC_ParamError; goto Exit; );
+
+				// read the 1-bit "partial frame" flag, 2-bit "shift-off" flag & 1-bit "escape" flag
+				headerByte = (uint8_t) BitBufferRead( bits, 4 );
+				
+				partialFrame = headerByte >> 3;
+				
+				bytesShifted = (headerByte >> 1) & 0x3u;
+				RequireAction( bytesShifted != 3, status = kALAC_ParamError; goto Exit; );
+
+				shift = bytesShifted * 8;
+
+				escapeFlag = headerByte & 0x1;
+
+				chanBits = mConfig.bitDepth - (bytesShifted * 8);
+				
+				// check for partial frame to override requested numSamples
+				if ( partialFrame != 0 )
+				{
+					numSamples  = BitBufferRead( bits, 16 ) << 16;
+					numSamples |= BitBufferRead( bits, 16 );
+				}
+
+				if ( escapeFlag == 0 )
+				{
+					// compressed frame, read rest of parameters
+					mixBits	= (uint8_t) BitBufferRead( bits, 8 );
+					mixRes	= (int8_t) BitBufferRead( bits, 8 );
+					//Assert( (mixBits == 0) && (mixRes == 0) );		// no mixing for mono
+
+					headerByte	= (uint8_t) BitBufferRead( bits, 8 );
+					modeU		= headerByte >> 4;
+					denShiftU	= headerByte & 0xfu;
+					
+					headerByte	= (uint8_t) BitBufferRead( bits, 8 );
+					pbFactorU	= headerByte >> 5;
+					numU		= headerByte & 0x1fu;
+
+					for ( i = 0; i < numU; i++ )
+						coefsU[i] = (int16_t) BitBufferRead( bits, 16 );
+					
+					// if shift active, skip the the shift buffer but remember where it starts
+					if ( bytesShifted != 0 )
+					{
+						shiftBits = *bits;
+						BitBufferAdvance( bits, (bytesShifted * 8) * numSamples ); 
+					}
+
+					// decompress
+					set_ag_params( &agParams, mConfig.mb, (pb * pbFactorU) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
+					status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits1 );
+					RequireNoErr( status, goto Exit; );
+
+					if ( modeU == 0 )
+					{
+						unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
+					}
+					else
+					{
+						// the special "numActive == 31" mode can be done in-place
+						unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
+						unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
+					}
+				}
+				else
+				{
+					//Assert( bytesShifted == 0 );
+
+					// uncompressed frame, copy data into the mix buffer to use common output code
+					shift = 32 - chanBits;
+					if ( chanBits <= 16 )
+					{
+						for ( i = 0; i < numSamples; i++ )
+						{
+							val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
+							val = (val << shift) >> shift;
+							mMixBufferU[i] = val;
+						}
+					}
+					else
+					{
+						// BitBufferRead() can't read more than 16 bits at a time so break up the reads
+						extraBits = chanBits - 16;
+						for ( i = 0; i < numSamples; i++ )
+						{
+							val = (int32_t) BitBufferRead( bits, 16 );
+							val = (val << 16) >> shift;
+							mMixBufferU[i] = val | BitBufferRead( bits, (uint8_t) extraBits );
+						}
+					}
+
+					mixBits = mixRes = 0;
+					bits1 = chanBits * numSamples;
+					bytesShifted = 0;
+				}
+
+				// now read the shifted values into the shift buffer
+				if ( bytesShifted != 0 )
+				{
+					shift = bytesShifted * 8;
+					//Assert( shift <= 16 );
+
+					for ( i = 0; i < numSamples; i++ )
+						mShiftBuffer[i] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
+				}
+
+				// convert 32-bit integers into output buffer
+				switch ( mConfig.bitDepth )
+				{
+					case 16:
+						out16 = &((int16_t *)sampleBuffer)[channelIndex];
+						for ( i = 0, j = 0; i < numSamples; i++, j += numChannels )
+							out16[j] = (int16_t) mMixBufferU[i];
+						break;
+					case 20:
+						out20 = (uint8_t *)sampleBuffer + (channelIndex * 3);
+						copyPredictorTo20( mMixBufferU, out20, numChannels, numSamples );
+						break;
+					case 24:
+						out24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
+						if ( bytesShifted != 0 )
+							copyPredictorTo24Shift( mMixBufferU, mShiftBuffer, out24, numChannels, numSamples, bytesShifted );
+						else
+							copyPredictorTo24( mMixBufferU, out24, numChannels, numSamples );							
+						break;
+					case 32:
+						out32 = &((int32_t *)sampleBuffer)[channelIndex];
+						if ( bytesShifted != 0 )
+							copyPredictorTo32Shift( mMixBufferU, mShiftBuffer, out32, numChannels, numSamples, bytesShifted );
+						else
+							copyPredictorTo32( mMixBufferU, out32, numChannels, numSamples);
+						break;
+				}
+
+				channelIndex += 1;
+				*outNumSamples = numSamples;
+				break;
+			}
+
+			case ID_CPE:
+			{
+				// if decoding this pair would take us over the max channels limit, bail
+				if ( (channelIndex + 2) > numChannels )
+					goto NoMoreChannels;
+
+				// stereo channel pair
+				elementInstanceTag = BitBufferReadSmall( bits, 4 );
+				mActiveElements |= (1u << elementInstanceTag);
+
+				// read the 12 unused header bits
+				unusedHeader = (uint16_t) BitBufferRead( bits, 12 );
+				RequireAction( unusedHeader == 0, status = kALAC_ParamError; goto Exit; );
+
+				// read the 1-bit "partial frame" flag, 2-bit "shift-off" flag & 1-bit "escape" flag
+				headerByte = (uint8_t) BitBufferRead( bits, 4 );
+				
+				partialFrame = headerByte >> 3;
+				
+				bytesShifted = (headerByte >> 1) & 0x3u;
+				RequireAction( bytesShifted != 3, status = kALAC_ParamError; goto Exit; );
+
+				shift = bytesShifted * 8;
+
+				escapeFlag = headerByte & 0x1;
+
+				chanBits = mConfig.bitDepth - (bytesShifted * 8) + 1;
+				
+				// check for partial frame length to override requested numSamples
+				if ( partialFrame != 0 )
+				{
+					numSamples  = BitBufferRead( bits, 16 ) << 16;
+					numSamples |= BitBufferRead( bits, 16 );
+				}
+
+				if ( escapeFlag == 0 )
+				{
+					// compressed frame, read rest of parameters
+					mixBits		= (uint8_t) BitBufferRead( bits, 8 );
+					mixRes		= (int8_t) BitBufferRead( bits, 8 );
+
+					headerByte	= (uint8_t) BitBufferRead( bits, 8 );
+					modeU		= headerByte >> 4;
+					denShiftU	= headerByte & 0xfu;
+					
+					headerByte	= (uint8_t) BitBufferRead( bits, 8 );
+					pbFactorU	= headerByte >> 5;
+					numU		= headerByte & 0x1fu;
+					for ( i = 0; i < numU; i++ )
+						coefsU[i] = (int16_t) BitBufferRead( bits, 16 );
+
+					headerByte	= (uint8_t) BitBufferRead( bits, 8 );
+					modeV		= headerByte >> 4;
+					denShiftV	= headerByte & 0xfu;
+					
+					headerByte	= (uint8_t) BitBufferRead( bits, 8 );
+					pbFactorV	= headerByte >> 5;
+					numV		= headerByte & 0x1fu;
+					for ( i = 0; i < numV; i++ )
+						coefsV[i] = (int16_t) BitBufferRead( bits, 16 );
+
+					// if shift active, skip the interleaved shifted values but remember where they start
+					if ( bytesShifted != 0 )
+					{
+						shiftBits = *bits;
+						BitBufferAdvance( bits, (bytesShifted * 8) * 2 * numSamples );
+					}
+
+					// decompress and run predictor for "left" channel
+					set_ag_params( &agParams, mConfig.mb, (pb * pbFactorU) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
+					status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits1 );
+					RequireNoErr( status, goto Exit; );
+
+					if ( modeU == 0 )
+					{
+						unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
+					}
+					else
+					{
+						// the special "numActive == 31" mode can be done in-place
+						unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
+						unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
+					}
+
+					// decompress and run predictor for "right" channel
+					set_ag_params( &agParams, mConfig.mb, (pb * pbFactorV) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
+					status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits2 );
+					RequireNoErr( status, goto Exit; );
+
+					if ( modeV == 0 )
+					{
+						unpc_block( mPredictor, mMixBufferV, numSamples, &coefsV[0], numV, chanBits, denShiftV );
+					}
+					else
+					{
+						// the special "numActive == 31" mode can be done in-place
+						unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
+						unpc_block( mPredictor, mMixBufferV, numSamples, &coefsV[0], numV, chanBits, denShiftV );
+					}
+				}
+				else
+				{
+					//Assert( bytesShifted == 0 );
+
+					// uncompressed frame, copy data into the mix buffers to use common output code
+					chanBits = mConfig.bitDepth;
+					shift = 32 - chanBits;
+					if ( chanBits <= 16 )
+					{
+						for ( i = 0; i < numSamples; i++ )
+						{
+							val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
+							val = (val << shift) >> shift;
+							mMixBufferU[i] = val;
+
+							val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
+							val = (val << shift) >> shift;
+							mMixBufferV[i] = val;
+						}
+					}
+					else
+					{
+						// BitBufferRead() can't read more than 16 bits at a time so break up the reads
+						extraBits = chanBits - 16;
+						for ( i = 0; i < numSamples; i++ )
+						{
+							val = (int32_t) BitBufferRead( bits, 16 );
+							val = (val << 16) >> shift;
+							mMixBufferU[i] = val | BitBufferRead( bits, (uint8_t)extraBits );
+
+							val = (int32_t) BitBufferRead( bits, 16 );
+							val = (val << 16) >> shift;
+							mMixBufferV[i] = val | BitBufferRead( bits, (uint8_t)extraBits );
+						}
+					}
+
+					bits1 = chanBits * numSamples;
+					bits2 = chanBits * numSamples;
+					mixBits = mixRes = 0;
+					bytesShifted = 0;
+				}
+
+				// now read the shifted values into the shift buffer
+				if ( bytesShifted != 0 )
+				{
+					shift = bytesShifted * 8;
+					//Assert( shift <= 16 );
+
+					for ( i = 0; i < (numSamples * 2); i += 2 )
+					{
+						mShiftBuffer[i + 0] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
+						mShiftBuffer[i + 1] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
+					}
+				}
+
+				// un-mix the data and convert to output format
+				// - note that mixRes = 0 means just interleave so we use that path for uncompressed frames
+				switch ( mConfig.bitDepth )
+				{
+					case 16:
+						out16 = &((int16_t *)sampleBuffer)[channelIndex];
+						unmix16( mMixBufferU, mMixBufferV, out16, numChannels, numSamples, mixBits, mixRes );
+						break;
+					case 20:
+						out20 = (uint8_t *)sampleBuffer + (channelIndex * 3);
+						unmix20( mMixBufferU, mMixBufferV, out20, numChannels, numSamples, mixBits, mixRes );
+						break;
+					case 24:
+						out24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
+						unmix24( mMixBufferU, mMixBufferV, out24, numChannels, numSamples,
+									mixBits, mixRes, mShiftBuffer, bytesShifted );
+						break;
+					case 32:
+						out32 = &((int32_t *)sampleBuffer)[channelIndex];
+						unmix32( mMixBufferU, mMixBufferV, out32, numChannels, numSamples,
+									mixBits, mixRes, mShiftBuffer, bytesShifted );
+						break;
+				}
+
+				channelIndex += 2;
+				*outNumSamples = numSamples;
+				break;
+			}
+
+			case ID_CCE:
+			case ID_PCE:
+			{
+				// unsupported element, bail
+				//AssertNoErr( tag );
+				status = kALAC_ParamError;
+				break;
+			}
+
+			case ID_DSE:
+			{
+				// data stream element -- parse but ignore
+				status = this->DataStreamElement( bits );
+				break;
+			}
+			
+			case ID_FIL:
+			{
+				// fill element -- parse but ignore
+				status = this->FillElement( bits );
+				break;
+			}
+
+			case ID_END:
+			{
+				// frame end, all done so byte align the frame and check for overruns
+				BitBufferByteAlign( bits, false );
+				//Assert( bits->cur == bits->end );
+				goto Exit;
+			}
+		}
+
+#if ! DEBUG
+		// if we've decoded all of our channels, bail (but not in debug b/c we want to know if we're seeing bad bits)
+		// - this also protects us if the config does not match the bitstream or crap data bits follow the audio bits
+		if ( channelIndex >= numChannels )
+			break;
+#endif
+	}
+
+NoMoreChannels:
+
+	// if we get here and haven't decoded all of the requested channels, fill the remaining channels with zeros
+	for ( ; channelIndex < numChannels; channelIndex++ )
+	{
+		switch ( mConfig.bitDepth )
+		{
+			case 16:
+			{
+				int16_t *	fill16 = &((int16_t *)sampleBuffer)[channelIndex];
+				Zero16( fill16, numSamples, numChannels );
+				break;
+			}
+			case 24:
+			{
+				uint8_t *	fill24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
+				Zero24( fill24, numSamples, numChannels );
+				break;
+			}
+			case 32:
+			{
+				int32_t *	fill32 = &((int32_t *)sampleBuffer)[channelIndex];
+				Zero32( fill32, numSamples, numChannels );
+				break;
+			}
+		}
+	}
+
+Exit:
+	return status;
+}
+
+#if PRAGMA_MARK
+#pragma mark -
+#endif
+
+/*
+	FillElement()
+	- they're just filler so we don't need 'em
+*/
+int32_t ALACDecoder::FillElement( BitBuffer * bits )
+{
+	int16_t		count;
+	
+	// 4-bit count or (4-bit + 8-bit count) if 4-bit count == 15
+	// - plus this weird -1 thing I still don't fully understand
+	count = BitBufferReadSmall( bits, 4 );
+	if ( count == 15 )
+		count += (int16_t) BitBufferReadSmall( bits, 8 ) - 1;
+
+	BitBufferAdvance( bits, count * 8 );
+
+	RequireAction( bits->cur <= bits->end, return kALAC_ParamError; );
+
+	return ALAC_noErr;	
+}
+
+/*
+	DataStreamElement()
+	- we don't care about data stream elements so just skip them
+*/
+int32_t ALACDecoder::DataStreamElement( BitBuffer * bits )
+{
+	uint8_t		element_instance_tag;
+	int32_t		data_byte_align_flag;
+	uint16_t		count;
+	
+	// the tag associates this data stream element with a given audio element
+	element_instance_tag = BitBufferReadSmall( bits, 4 );
+	
+	data_byte_align_flag = BitBufferReadOne( bits );
+
+	// 8-bit count or (8-bit + 8-bit count) if 8-bit count == 255
+	count = BitBufferReadSmall( bits, 8 );
+	if ( count == 255 )
+		count += BitBufferReadSmall( bits, 8 );
+
+	// the align flag means the bitstream should be byte-aligned before reading the following data bytes
+	if ( data_byte_align_flag )
+		BitBufferByteAlign( bits, false );
+
+	// skip the data bytes
+	BitBufferAdvance( bits, count * 8 );
+
+	RequireAction( bits->cur <= bits->end, return kALAC_ParamError; );
+
+	return ALAC_noErr;
+}
+
+/*
+	ZeroN()
+	- helper routines to clear out output channel buffers when decoding fewer channels than requested
+*/
+static void Zero16( int16_t * buffer, uint32_t numItems, uint32_t stride )
+{
+	if ( stride == 1 )
+	{
+		memset( buffer, 0, numItems * sizeof(int16_t) );
+	}
+	else
+	{
+		for ( uint32_t index = 0; index < (numItems * stride); index += stride )
+			buffer[index] = 0;
+	}
+}
+
+static void Zero24( uint8_t * buffer, uint32_t numItems, uint32_t stride )
+{
+	if ( stride == 1 )
+	{
+		memset( buffer, 0, numItems * 3 );
+	}
+	else
+	{
+		for ( uint32_t index = 0; index < (numItems * stride * 3); index += (stride * 3) )
+		{
+			buffer[index + 0] = 0;
+			buffer[index + 1] = 0;
+			buffer[index + 2] = 0;
+		}
+	}
+}
+
+static void Zero32( int32_t * buffer, uint32_t numItems, uint32_t stride )
+{
+	if ( stride == 1 )
+	{
+		memset( buffer, 0, numItems * sizeof(int32_t) );
+	}
+	else
+	{
+		for ( uint32_t index = 0; index < (numItems * stride); index += stride )
+			buffer[index] = 0;
+	}
+}

components/spotify/cspot/bell/external/alac/codec/ALACDecoder.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		ALACDecoder.h
+*/
+
+#ifndef _ALACDECODER_H
+#define _ALACDECODER_H
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#include <stdint.h>
+
+#include "ALACAudioTypes.h"
+
+struct BitBuffer;
+
+class ALACDecoder
+{
+	public:
+		ALACDecoder();
+		~ALACDecoder();
+
+		int32_t	Init( void * inMagicCookie, uint32_t inMagicCookieSize );
+		int32_t	Decode( struct BitBuffer * bits, uint8_t * sampleBuffer, uint32_t numSamples, uint32_t numChannels, uint32_t * outNumSamples );
+
+	public:
+		// decoding parameters (public for use in the analyzer)
+		ALACSpecificConfig		mConfig;
+
+	protected:
+		int32_t	FillElement( struct BitBuffer * bits );
+		int32_t	DataStreamElement( struct BitBuffer * bits );
+
+		uint16_t					mActiveElements;
+
+		// decoding buffers
+		int32_t *				mMixBufferU;
+		int32_t *				mMixBufferV;
+		int32_t *				mPredictor;
+		uint16_t *				mShiftBuffer;	// note: this points to mPredictor's memory but different
+												//		 variable for clarity and type difference
+};
+
+#endif	/* _ALACDECODER_H */

components/spotify/cspot/bell/external/alac/codec/ALACEncoder.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		ALACEncoder.h
+*/
+
+#pragma once
+
+#include <stdint.h>
+
+#include "ALACAudioTypes.h"
+
+
+struct BitBuffer;
+
+class ALACEncoder
+{
+	public:
+		ALACEncoder();
+		virtual ~ALACEncoder();
+
+		virtual int32_t	Encode(AudioFormatDescription theInputFormat, AudioFormatDescription theOutputFormat,
+                                   unsigned char * theReadBuffer, unsigned char * theWriteBuffer, int32_t * ioNumBytes);
+		virtual int32_t	Finish( );
+
+		void				SetFastMode( bool fast ) { mFastMode = fast; };
+
+		// this must be called *before* InitializeEncoder()
+		void				SetFrameSize( uint32_t frameSize ) { mFrameSize = frameSize; };
+
+		void				GetConfig( ALACSpecificConfig & config );
+        uint32_t            GetMagicCookieSize(uint32_t inNumChannels);
+        void				GetMagicCookie( void * config, uint32_t * ioSize ); 
+
+        virtual int32_t	InitializeEncoder(AudioFormatDescription theOutputFormat);
+
+    protected:
+		virtual void		GetSourceFormat( const AudioFormatDescription * source, AudioFormatDescription * output );
+		
+		int32_t			EncodeStereo( struct BitBuffer * bitstream, void * input, uint32_t stride, uint32_t channelIndex, uint32_t numSamples );
+		int32_t			EncodeStereoFast( struct BitBuffer * bitstream, void * input, uint32_t stride, uint32_t channelIndex, uint32_t numSamples );
+		int32_t			EncodeStereoEscape( struct BitBuffer * bitstream, void * input, uint32_t stride, uint32_t numSamples );
+		int32_t			EncodeMono( struct BitBuffer * bitstream, void * input, uint32_t stride, uint32_t channelIndex, uint32_t numSamples );
+
+
+		// ALAC encoder parameters
+		int16_t					mBitDepth;
+		bool					mFastMode;
+
+		// encoding state
+		int16_t					mLastMixRes[kALACMaxChannels];
+
+		// encoding buffers
+		int32_t *				mMixBufferU;
+		int32_t *				mMixBufferV;
+		int32_t *				mPredictorU;
+		int32_t *				mPredictorV;
+		uint16_t *				mShiftBufferUV;
+		
+		uint8_t *					mWorkBuffer;
+
+		// per-channel coefficients buffers
+		int16_t					mCoefsU[kALACMaxChannels][kALACMaxSearches][kALACMaxCoefs];
+		int16_t					mCoefsV[kALACMaxChannels][kALACMaxSearches][kALACMaxCoefs];
+
+		// encoding statistics
+		uint32_t					mTotalBytesGenerated;
+		uint32_t					mAvgBitRate;
+		uint32_t					mMaxFrameBytes;
+        uint32_t                  mFrameSize;
+        uint32_t                  mMaxOutputBytes;
+        uint32_t                  mNumChannels;
+        uint32_t                  mOutputSampleRate;		
+};

components/spotify/cspot/bell/external/alac/codec/APPLE_LICENSE.txt

@@ -0,0 +1,335 @@
+APPLE PUBLIC SOURCE LICENSE
+Version 2.0 -  August 6, 2003
+
+Please read this License carefully before downloading this software.  By
+downloading or using this software, you are agreeing to be bound by the terms
+of this License.  If you do not or cannot agree to the terms of this License,
+please do not download or use the software.
+
+Apple Note:  In January 2007, Apple changed its corporate name from "Apple
+Computer, Inc." to "Apple Inc."  This change has been reflected below and
+copyright years updated, but no other changes have been made to the APSL 2.0.
+
+1.	General; Definitions.  This License applies to any program or other
+work which Apple Inc. ("Apple") makes publicly available and which contains a
+notice placed by Apple identifying such program or work as "Original Code" and
+stating that it is subject to the terms of this Apple Public Source License
+version 2.0 ("License").  As used in this License:
+
+1.1	 "Applicable Patent Rights" mean:  (a) in the case where Apple is the
+grantor of rights, (i) claims of patents that are now or hereafter acquired,
+owned by or assigned to Apple and (ii) that cover subject matter contained in
+the Original Code, but only to the extent necessary to use, reproduce and/or
+distribute the Original Code without infringement; and (b) in the case where
+You are the grantor of rights, (i) claims of patents that are now or hereafter
+acquired, owned by or assigned to You and (ii) that cover subject matter in
+Your Modifications, taken alone or in combination with Original Code.
+
+1.2	"Contributor" means any person or entity that creates or contributes to
+the creation of Modifications.
+
+1.3	 "Covered Code" means the Original Code, Modifications, the combination
+of Original Code and any Modifications, and/or any respective portions thereof.
+
+1.4	"Externally Deploy" means: (a) to sublicense, distribute or otherwise
+make Covered Code available, directly or indirectly, to anyone other than You;
+and/or (b) to use Covered Code, alone or as part of a Larger Work, in any way
+to provide a service, including but not limited to delivery of content, through
+electronic communication with a client other than You.
+
+1.5	"Larger Work" means a work which combines Covered Code or portions
+thereof with code not governed by the terms of this License.
+
+1.6	"Modifications" mean any addition to, deletion from, and/or change to,
+the substance and/or structure of the Original Code, any previous
+Modifications, the combination of Original Code and any previous Modifications,
+and/or any respective portions thereof.  When code is released as a series of
+files, a Modification is:  (a) any addition to or deletion from the contents of
+a file containing Covered Code; and/or (b) any new file or other representation
+of computer program statements that contains any part of Covered Code. 
+
+1.7	"Original Code" means (a) the Source Code of a program or other work as
+originally made available by Apple under this License, including the Source
+Code of any updates or upgrades to such programs or works made available by
+Apple under this License, and that has been expressly identified by Apple as
+such in the header file(s) of such work; and (b) the object code compiled from
+such Source Code and originally made available by Apple under this License
+
+1.8	"Source Code" means the human readable form of a program or other work
+that is suitable for making modifications to it, including all modules it
+contains, plus any associated interface definition files, scripts used to
+control compilation and installation of an executable (object code).
+
+1.9	"You" or "Your" means an individual or a legal entity exercising rights
+under this License.  For legal entities, "You" or "Your" includes any entity
+which controls, is controlled by, or is under common control with, You, where
+"control" means (a) the power, direct or indirect, to cause the direction or
+management of such entity, whether by contract or otherwise, or (b) ownership
+of fifty percent (50%) or more of the outstanding shares or beneficial
+ownership of such entity.
+
+2.	Permitted Uses; Conditions & Restrictions.   Subject to the terms and
+conditions of this License, Apple hereby grants You, effective on the date You
+accept this License and download the Original Code, a world-wide, royalty-free,
+non-exclusive license, to the extent of Apple's Applicable Patent Rights and
+copyrights covering the Original Code, to do the following:
+
+2.1	Unmodified Code.  You may use, reproduce, display, perform, internally
+distribute within Your organization, and Externally Deploy verbatim, unmodified
+copies of the Original Code, for commercial or non-commercial purposes,
+provided that in each instance:
+
+(a)	You must retain and reproduce in all copies of Original Code the
+copyright and other proprietary notices and disclaimers of Apple as they appear
+in the Original Code, and keep intact all notices in the Original Code that
+refer to this License; and
+
+(b) 	You must include a copy of this License with every copy of Source Code
+of Covered Code and documentation You distribute or Externally Deploy, and You
+may not offer or impose any terms on such Source Code that alter or restrict
+this License or the recipients' rights hereunder, except as permitted under
+Section 6.
+
+2.2	Modified Code.  You may modify Covered Code and use, reproduce,
+display, perform, internally distribute within Your organization, and
+Externally Deploy Your Modifications and Covered Code, for commercial or
+non-commercial purposes, provided that in each instance You also meet all of
+these conditions:
+
+(a)	You must satisfy all the conditions of Section 2.1 with respect to the
+Source Code of the Covered Code; 
+
+(b)	You must duplicate, to the extent it does not already exist, the notice
+in Exhibit A in each file of the Source Code of all Your Modifications, and
+cause the modified files to carry prominent notices stating that You changed
+the files and the date of any change; and
+
+(c)	If You Externally Deploy Your Modifications, You must make Source Code
+of all Your Externally Deployed Modifications either available to those to whom
+You have Externally Deployed Your Modifications, or publicly available.  Source
+Code of Your Externally Deployed Modifications must be released under the terms
+set forth in this License, including the license grants set forth in Section 3
+below, for as long as you Externally Deploy the Covered Code or twelve (12)
+months from the date of initial External Deployment, whichever is longer. You
+should preferably distribute the Source Code of Your Externally Deployed
+Modifications electronically (e.g. download from a web site).
+
+2.3	Distribution of Executable Versions.  In addition, if You Externally
+Deploy Covered Code (Original Code and/or Modifications) in object code,
+executable form only, You must include a prominent notice, in the code itself
+as well as in related documentation, stating that Source Code of the Covered
+Code is available under the terms of this License with information on how and
+where to obtain such Source Code.  
+
+2.4	Third Party Rights.  You expressly acknowledge and agree that although
+Apple and each Contributor grants the licenses to their respective portions of
+the Covered Code set forth herein, no assurances are provided by Apple or any
+Contributor that the Covered Code does not infringe the patent or other
+intellectual property rights of any other entity. Apple and each Contributor
+disclaim any liability to You for claims brought by any other entity based on
+infringement of intellectual property rights or otherwise. As a condition to
+exercising the rights and licenses granted hereunder, You hereby assume sole
+responsibility to secure any other intellectual property rights needed, if any.
+For example, if a third party patent license is required to allow You to
+distribute the Covered Code, it is Your responsibility to acquire that license
+before distributing the Covered Code.
+
+3.	Your Grants.  In consideration of, and as a condition to, the licenses
+granted to You under this License, You hereby grant to any person or entity
+receiving or distributing Covered Code under this License a non-exclusive,
+royalty-free, perpetual, irrevocable license, under Your Applicable Patent
+Rights and other intellectual property rights (other than patent) owned or
+controlled by You, to use, reproduce, display, perform, modify, sublicense,
+distribute and Externally Deploy Your Modifications of the same scope and
+extent as Apple's licenses under Sections 2.1 and 2.2 above.  
+
+4.	Larger Works.  You may create a Larger Work by combining Covered Code
+with other code not governed by the terms of this License and distribute the
+Larger Work as a single product.  In each such instance, You must make sure the
+requirements of this License are fulfilled for the Covered Code or any portion
+thereof. 
+
+5.	Limitations on Patent License.   Except as expressly stated in Section
+2, no other patent rights, express or implied, are granted by Apple herein.
+Modifications and/or Larger Works may require additional patent licenses from
+Apple which Apple may grant in its sole discretion.  
+
+6.	Additional Terms.  You may choose to offer, and to charge a fee for,
+warranty, support, indemnity or liability obligations and/or other rights
+consistent with the scope of the license granted herein ("Additional Terms") to
+one or more recipients of Covered Code. However, You may do so only on Your own
+behalf and as Your sole responsibility, and not on behalf of Apple or any
+Contributor. You must obtain the recipient's agreement that any such Additional
+Terms are offered by You alone, and You hereby agree to indemnify, defend and
+hold Apple and every Contributor harmless for any liability incurred by or
+claims asserted against Apple or such Contributor by reason of any such
+Additional Terms. 
+
+7.	Versions of the License.  Apple may publish revised and/or new versions
+of this License from time to time.  Each version will be given a distinguishing
+version number.  Once Original Code has been published under a particular
+version of this License, You may continue to use it under the terms of that
+version. You may also choose to use such Original Code under the terms of any
+subsequent version of this License published by Apple.  No one other than Apple
+has the right to modify the terms applicable to Covered Code created under this
+License.  
+
+8.	NO WARRANTY OR SUPPORT.  The Covered Code may contain in whole or in
+part pre-release, untested, or not fully tested works.  The Covered Code may
+contain errors that could cause failures or loss of data, and may be incomplete
+or contain inaccuracies.  You expressly acknowledge and agree that use of the
+Covered Code, or any portion thereof, is at Your sole and entire risk.  THE
+COVERED CODE IS PROVIDED "AS IS" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF
+ANY KIND AND APPLE AND APPLE'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS "APPLE"
+FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM
+ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF
+SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF
+QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  APPLE AND EACH
+CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE
+COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR
+REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR
+ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED.  NO ORAL OR
+WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE, AN APPLE AUTHORIZED
+REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY.  You acknowledge
+that the Covered Code is not intended for use in the operation of nuclear
+facilities, aircraft navigation, communication systems, or air traffic control
+machines in which case the failure of the Covered Code could lead to death,
+personal injury, or severe physical or environmental damage.
+
+9.	LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO
+EVENT SHALL APPLE OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL,
+INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR
+YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER
+UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS
+LIABILITY OR OTHERWISE, EVEN IF APPLE OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL
+PURPOSE OF ANY REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF
+LIABILITY OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT
+APPLY TO YOU. In no event shall Apple's total liability to You for all damages
+(other than as may be required by applicable law) under this License exceed the
+amount of fifty dollars ($50.00).
+
+10.	Trademarks.  This License does not grant any rights to use the
+trademarks or trade names  "Apple", "Mac", "Mac OS", "QuickTime", "QuickTime
+Streaming Server" or any other trademarks, service marks, logos or trade names
+belonging to Apple (collectively "Apple Marks") or to any trademark, service
+mark, logo or trade name belonging to any Contributor.  You agree not to use
+any Apple Marks in or as part of the name of products derived from the Original
+Code or to endorse or promote products derived from the Original Code other
+than as expressly permitted by and in strict compliance at all times with
+Apple's third party trademark usage guidelines which are posted at
+http://www.apple.com/legal/guidelinesfor3rdparties.html.  
+
+11.	Ownership. Subject to the licenses granted under this License, each
+Contributor retains all rights, title and interest in and to any Modifications
+made by such Contributor.  Apple retains all rights, title and interest in and
+to the Original Code and any Modifications made by or on behalf of Apple
+("Apple Modifications"), and such Apple Modifications will not be automatically
+subject to this License.  Apple may, at its sole discretion, choose to license
+such Apple Modifications under this License, or on different terms from those
+contained in this License or may choose not to license them at all.  
+
+12.	Termination.  
+
+12.1	Termination.  This License and the rights granted hereunder will
+terminate:
+
+(a)	automatically without notice from Apple if You fail to comply with any
+term(s) of this License and fail to cure such breach within 30 days of becoming
+aware of such breach;
+(b)	immediately in the event of the circumstances described in Section
+13.5(b); or
+(c)	automatically without notice from Apple if You, at any time during the
+term of this License, commence an action for patent infringement against Apple;
+provided that Apple did not first commence an action for patent infringement
+against You in that instance.
+
+12.2	Effect of Termination.  Upon termination, You agree to immediately stop
+any further use, reproduction, modification, sublicensing and distribution of
+the Covered Code.  All sublicenses to the Covered Code which have been properly
+granted prior to termination shall survive any termination of this License.
+Provisions which, by their nature, should remain in effect beyond the
+termination of this License shall survive, including but not limited to
+Sections 3, 5, 8, 9, 10, 11, 12.2 and 13.  No party will be liable to any other
+for compensation, indemnity or damages of any sort solely as a result of
+terminating this License in accordance with its terms, and termination of this
+License will be without prejudice to any other right or remedy of any party.
+
+13. 	Miscellaneous.
+
+13.1	Government End Users.   The Covered Code is a "commercial item" as
+defined in FAR 2.101.  Government software and technical data rights in the
+Covered Code include only those rights customarily provided to the public as
+defined in this License. This customary commercial license in technical data
+and software is provided in accordance with FAR 12.211 (Technical Data) and
+12.212 (Computer Software) and, for Department of Defense purchases, DFAR
+252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in
+Commercial Computer Software or Computer Software Documentation).  Accordingly,
+all U.S. Government End Users acquire Covered Code with only those rights set
+forth herein.
+
+13.2	Relationship of Parties.  This License will not be construed as
+creating an agency, partnership, joint venture or any other form of legal
+association between or among You, Apple or any Contributor, and You will not
+represent to the contrary, whether expressly, by implication, appearance or
+otherwise.
+
+13.3	Independent Development.   Nothing in this License will impair Apple's
+right to acquire, license, develop, have others develop for it, market and/or
+distribute technology or products that perform the same or similar functions
+as, or otherwise compete with, Modifications, Larger Works, technology or
+products that You may develop, produce, market or distribute.
+
+13.4	Waiver; Construction.  Failure by Apple or any Contributor to enforce
+any provision of this License will not be deemed a waiver of future enforcement
+of that or any other provision.  Any law or regulation which provides that the
+language of a contract shall be construed against the drafter will not apply to
+this License.
+
+13.5	Severability.  (a) If for any reason a court of competent jurisdiction
+finds any provision of this License, or portion thereof, to be unenforceable,
+that provision of the License will be enforced to the maximum extent
+permissible so as to effect the economic benefits and intent of the parties,
+and the remainder of this License will continue in full force and effect.  (b)
+Notwithstanding the foregoing, if applicable law prohibits or restricts You
+from fully and/or specifically complying with Sections 2 and/or 3 or prevents
+the enforceability of either of those Sections, this License will immediately
+terminate and You must immediately discontinue any use of the Covered Code and
+destroy all copies of it that are in your possession or control.
+
+13.6	Dispute Resolution.  Any litigation or other dispute resolution between
+You and Apple relating to this License shall take place in the Northern
+District of California, and You and Apple hereby consent to the personal
+jurisdiction of, and venue in, the state and federal courts within that
+District with respect to this License. The application of the United Nations
+Convention on Contracts for the International Sale of Goods is expressly
+excluded.
+
+13.7	Entire Agreement; Governing Law.  This License constitutes the entire
+agreement between the parties with respect to the subject matter hereof.  This
+License shall be governed by the laws of the United States and the State of
+California, except that body of California law concerning conflicts of law. 
+
+Where You are located in the province of Quebec, Canada, the following clause
+applies:  The parties hereby confirm that they have requested that this License
+and all related documents be drafted in English. Les parties ont exigé que le
+présent contrat et tous les documents connexes soient rédigés en anglais. 
+
+EXHIBIT A. 
+
+"Portions Copyright (c) 1999-2007 Apple Inc.  All Rights Reserved.
+
+This file contains Original Code and/or Modifications of Original Code as
+defined in and that are subject to the Apple Public Source License Version 2.0
+(the 'License').  You may not use this file except in compliance with the
+License.  Please obtain a copy of the License at
+http://www.opensource.apple.com/apsl/ and read it before using this file.
+
+The Original Code and all software distributed under the License are
+distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
+OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
+LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.  Please see the License for the
+specific language governing rights and limitations under the License." 
+

components/spotify/cspot/bell/external/alac/codec/EndianPortable.c

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+//
+//  EndianPortable.c
+//
+//  Copyright 2011 Apple Inc. All rights reserved.
+//
+
+#include <stdio.h>
+#include "EndianPortable.h"
+
+#define BSWAP16(x) (((x << 8) | ((x >> 8) & 0x00ff)))
+#define BSWAP32(x) (((x << 24) | ((x << 8) & 0x00ff0000) | ((x >> 8) & 0x0000ff00) | ((x >> 24) & 0x000000ff)))
+#define BSWAP64(x) ((((int64_t)x << 56) | (((int64_t)x << 40) & 0x00ff000000000000LL) | \
+                    (((int64_t)x << 24) & 0x0000ff0000000000LL) | (((int64_t)x << 8) & 0x000000ff00000000LL) | \
+                    (((int64_t)x >> 8) & 0x00000000ff000000LL) | (((int64_t)x >> 24) & 0x0000000000ff0000LL) | \
+                    (((int64_t)x >> 40) & 0x000000000000ff00LL) | (((int64_t)x >> 56) & 0x00000000000000ffLL)))
+
+#if defined(__i386__)
+#define TARGET_RT_LITTLE_ENDIAN 1
+#elif defined(__x86_64__)
+#define TARGET_RT_LITTLE_ENDIAN 1
+#elif defined (TARGET_OS_WIN32)
+#define TARGET_RT_LITTLE_ENDIAN 1
+#elif defined (__arm__) || defined(__aarch64__)
+#define TARGET_RT_LITTLE_ENDIAN 1
+#endif
+
+uint16_t Swap16NtoB(uint16_t inUInt16)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+    return BSWAP16(inUInt16);
+#else
+    return inUInt16;
+#endif
+}
+
+uint16_t Swap16BtoN(uint16_t inUInt16)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+    return BSWAP16(inUInt16);
+#else
+    return inUInt16;
+#endif
+}
+
+uint32_t Swap32NtoB(uint32_t inUInt32)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+    return BSWAP32(inUInt32);
+#else
+    return inUInt32;
+#endif
+}
+
+uint32_t Swap32BtoN(uint32_t inUInt32)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+    return BSWAP32(inUInt32);
+#else
+    return inUInt32;
+#endif
+}
+
+uint64_t Swap64BtoN(uint64_t inUInt64)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+    return BSWAP64(inUInt64);
+#else
+    return inUInt64;
+#endif
+}
+
+uint64_t Swap64NtoB(uint64_t inUInt64)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+    return BSWAP64(inUInt64);
+#else
+    return inUInt64;
+#endif
+}
+
+float SwapFloat32BtoN(float in)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+	union {
+		float f;
+		int32_t i;
+	} x;
+	x.f = in;	
+	x.i = BSWAP32(x.i);
+	return x.f;
+#else
+	return in;
+#endif
+}
+
+float SwapFloat32NtoB(float in)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+	union {
+		float f;
+		int32_t i;
+	} x;
+	x.f = in;	
+	x.i = BSWAP32(x.i);
+	return x.f;
+#else
+	return in;
+#endif
+}
+
+double SwapFloat64BtoN(double in)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+	union {
+		double f;
+		int64_t i;
+	} x;
+	x.f = in;	
+	x.i = BSWAP64(x.i);
+	return x.f;
+#else
+	return in;
+#endif
+}
+
+double SwapFloat64NtoB(double in)
+{
+#if TARGET_RT_LITTLE_ENDIAN
+	union {
+		double f;
+		int64_t i;
+	} x;
+	x.f = in;	
+	x.i = BSWAP64(x.i);
+	return x.f;
+#else
+	return in;
+#endif
+}
+
+void Swap16(uint16_t * inUInt16)
+{
+	*inUInt16 = BSWAP16(*inUInt16);
+}
+
+void Swap24(uint8_t * inUInt24)
+{
+	uint8_t tempVal = inUInt24[0];
+	inUInt24[0] = inUInt24[2];
+	inUInt24[2] = tempVal;
+}
+
+void Swap32(uint32_t * inUInt32)
+{
+	*inUInt32 = BSWAP32(*inUInt32);
+}
+

components/spotify/cspot/bell/external/alac/codec/EndianPortable.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+//
+//  EndianPortable.h
+//
+//  Copyright 2011 Apple Inc. All rights reserved.
+//
+
+#ifndef _EndianPortable_h
+#define _EndianPortable_h
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint16_t Swap16NtoB(uint16_t inUInt16);
+uint16_t Swap16BtoN(uint16_t inUInt16);
+
+uint32_t Swap32NtoB(uint32_t inUInt32);
+uint32_t Swap32BtoN(uint32_t inUInt32);
+
+uint64_t Swap64BtoN(uint64_t inUInt64);
+uint64_t Swap64NtoB(uint64_t inUInt64);
+
+float SwapFloat32BtoN(float in);
+float SwapFloat32NtoB(float in);
+
+double SwapFloat64BtoN(double in);
+double SwapFloat64NtoB(double in);
+
+void Swap16(uint16_t * inUInt16);
+void Swap24(uint8_t * inUInt24);
+void Swap32(uint32_t * inUInt32);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/spotify/cspot/bell/external/alac/codec/ag_dec.c

@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		ag_dec.c
+	
+	Contains:   Adaptive Golomb decode routines.
+
+	Copyright:	(c) 2001-2011 Apple, Inc.
+*/
+
+#include "aglib.h"
+#include "ALACBitUtilities.h"
+#include "ALACAudioTypes.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if __GNUC__ && TARGET_OS_MAC
+	#if __POWERPC__
+		#include <ppc_intrinsics.h>
+	#else
+		#include <libkern/OSByteOrder.h>
+	#endif
+#endif
+
+#define CODE_TO_LONG_MAXBITS	32
+#define N_MAX_MEAN_CLAMP		0xffff
+#define N_MEAN_CLAMP_VAL		0xffff
+#define REPORT_VAL  40
+
+#if __GNUC__
+#define ALWAYS_INLINE		__attribute__((always_inline))
+#else
+#define ALWAYS_INLINE
+#endif
+
+/*	And on the subject of the CodeWarrior x86 compiler and inlining, I reworked a lot of this
+	to help the compiler out.   In many cases this required manual inlining or a macro.  Sorry
+	if it is ugly but the performance gains are well worth it.
+	- WSK 5/19/04
+*/
+
+void set_standard_ag_params(AGParamRecPtr params, uint32_t fullwidth, uint32_t sectorwidth)
+{
+	/* Use
+		fullwidth = sectorwidth = numOfSamples, for analog 1-dimensional type-short data,
+		but use
+		fullwidth = full image width, sectorwidth = sector (patch) width
+		for such as image (2-dim.) data.
+	*/
+	set_ag_params( params, MB0, PB0, KB0, fullwidth, sectorwidth, MAX_RUN_DEFAULT );
+}
+
+void set_ag_params(AGParamRecPtr params, uint32_t m, uint32_t p, uint32_t k, uint32_t f, uint32_t s, uint32_t maxrun)
+{
+	params->mb = params->mb0 = m;
+	params->pb = p;
+	params->kb = k;
+	params->wb = (1u<<params->kb)-1;
+	params->qb = QB-params->pb; 
+	params->fw = f;
+	params->sw = s;
+	params->maxrun = maxrun;
+}
+
+#if PRAGMA_MARK
+#pragma mark -
+#endif
+
+
+// note: implementing this with some kind of "count leading zeros" assembly is a big performance win
+static inline int32_t lead( int32_t m )
+{
+	long j;
+	unsigned long c = (1ul << 31);
+
+	for(j=0; j < 32; j++)
+	{
+		if((c & m) != 0)
+			break;
+		c >>= 1;
+	}
+	return (j);
+}
+
+#define arithmin(a, b) ((a) < (b) ? (a) : (b))
+
+static inline int32_t ALWAYS_INLINE lg3a( int32_t x)
+{
+    int32_t result;
+
+    x += 3;
+    result = lead(x);
+
+    return 31 - result;
+}
+
+static inline uint32_t ALWAYS_INLINE read32bit( uint8_t * buffer )
+{
+	// embedded CPUs typically can't read unaligned 32-bit words so just read the bytes
+	uint32_t		value;
+	
+	value = ((uint32_t)buffer[0] << 24) | ((uint32_t)buffer[1] << 16) |
+			 ((uint32_t)buffer[2] << 8) | (uint32_t)buffer[3];
+	return value;
+
+}
+
+#if PRAGMA_MARK
+#pragma mark -
+#endif
+
+#define get_next_fromlong(inlong, suff)		((inlong) >> (32 - (suff)))
+
+
+static inline uint32_t ALWAYS_INLINE
+getstreambits( uint8_t *in, int32_t bitoffset, int32_t numbits )
+{
+	uint32_t	load1, load2;
+	uint32_t	byteoffset = bitoffset / 8;
+	uint32_t	result;
+	
+	//Assert( numbits <= 32 );
+
+	load1 = read32bit( in + byteoffset );
+
+	if ( (numbits + (bitoffset & 0x7)) > 32)
+	{
+		int32_t load2shift;
+
+		result = load1 << (bitoffset & 0x7);
+		load2 = (uint32_t) in[byteoffset+4];
+		load2shift = (8-(numbits + (bitoffset & 0x7)-32));
+		load2 >>= load2shift;
+		result >>= (32-numbits);
+		result |= load2;		
+	}
+	else
+	{
+		result = load1 >> (32-numbits-(bitoffset & 7));
+	}
+
+	// a shift of >= "the number of bits in the type of the value being shifted" results in undefined
+	// behavior so don't try to shift by 32
+	if ( numbits != (sizeof(result) * 8) )
+		result &= ~(0xfffffffful << numbits);
+	
+	return result;
+}
+
+
+static inline int32_t dyn_get(unsigned char *in, uint32_t *bitPos, uint32_t m, uint32_t k)
+{
+    uint32_t	tempbits = *bitPos;
+    uint32_t		result;
+    uint32_t		pre = 0, v;
+    uint32_t		streamlong;
+
+	streamlong = read32bit( in + (tempbits >> 3) );
+    streamlong <<= (tempbits & 7);
+
+    /* find the number of bits in the prefix */ 
+    {
+        uint32_t	notI = ~streamlong;
+    	pre = lead( notI);
+    }
+
+    if(pre >= MAX_PREFIX_16)
+    {
+        pre = MAX_PREFIX_16;
+        tempbits += pre;
+        streamlong <<= pre;
+        result = get_next_fromlong(streamlong,MAX_DATATYPE_BITS_16);
+        tempbits += MAX_DATATYPE_BITS_16;
+
+    }
+    else
+    {
+        // all of the bits must fit within the long we have loaded
+        //Assert(pre+1+k <= 32);
+
+        tempbits += pre;
+        tempbits += 1;
+        streamlong <<= pre+1;
+        v = get_next_fromlong(streamlong, k);
+        tempbits += k;
+    
+        result = pre*m + v-1;
+
+        if(v<2) {
+            result -= (v-1);
+            tempbits -= 1;
+        }
+    }
+
+    *bitPos = tempbits;
+    return result;
+}
+
+
+static inline int32_t dyn_get_32bit( uint8_t * in, uint32_t * bitPos, int32_t m, int32_t k, int32_t maxbits )
+{
+	uint32_t	tempbits = *bitPos;
+	uint32_t		v;
+	uint32_t		streamlong;
+	uint32_t		result;
+	
+	streamlong = read32bit( in + (tempbits >> 3) );
+	streamlong <<= (tempbits & 7);
+
+	/* find the number of bits in the prefix */ 
+	{
+		uint32_t notI = ~streamlong;
+		result = lead( notI);
+	}
+	
+	if(result >= MAX_PREFIX_32)
+	{
+		result = getstreambits(in, tempbits+MAX_PREFIX_32, maxbits);
+		tempbits += MAX_PREFIX_32 + maxbits;
+	}
+	else
+	{		
+		/* all of the bits must fit within the long we have loaded*/
+		//Assert(k<=14);
+		//Assert(result<MAX_PREFIX_32);
+		//Assert(result+1+k <= 32);
+		
+		tempbits += result;
+		tempbits += 1;
+		
+		if (k != 1)
+		{
+			streamlong <<= result+1;
+			v = get_next_fromlong(streamlong, k);
+			tempbits += k;
+			tempbits -= 1;
+			result = result*m;
+			
+			if(v>=2)
+			{
+				result += (v-1);
+				tempbits += 1;
+			}
+		}
+	}
+
+	*bitPos = tempbits;
+
+	return result;
+}
+
+int32_t dyn_decomp( AGParamRecPtr params, BitBuffer * bitstream, int32_t * pc, int32_t numSamples, int32_t maxSize, uint32_t * outNumBits )
+{
+    uint8_t 		*in;
+    int32_t			*outPtr = pc;
+    uint32_t 	bitPos, startPos, maxPos;
+    uint32_t		j, m, k, n, c, mz;
+    int32_t			del, zmode;
+    uint32_t 	mb;
+    uint32_t	pb_local = params->pb;
+    uint32_t	kb_local = params->kb;
+    uint32_t	wb_local = params->wb;
+    int32_t				status;
+
+	RequireAction( (bitstream != nil) && (pc != nil) && (outNumBits != nil), return kALAC_ParamError; );
+	*outNumBits = 0;
+
+	in = bitstream->cur;
+	startPos = bitstream->bitIndex;
+	maxPos = bitstream->byteSize * 8;
+	bitPos = startPos;
+
+    mb = params->mb0;
+    zmode = 0;
+
+    c = 0;
+	status = ALAC_noErr;
+
+    while (c < numSamples)
+    {
+		// bail if we've run off the end of the buffer
+    	RequireAction( bitPos < maxPos, status = kALAC_ParamError; goto Exit; );
+
+        m = (mb)>>QBSHIFT;
+        k = lg3a(m);
+
+        k = arithmin(k, kb_local);
+        m = (1<<k)-1;
+        
+		n = dyn_get_32bit( in, &bitPos, m, k, maxSize );
+
+        // least significant bit is sign bit
+        {
+        	uint32_t	ndecode = n + zmode;
+            int32_t		multiplier = (- (ndecode&1));
+
+            multiplier |= 1;
+            del = ((ndecode+1) >> 1) * (multiplier);
+        }
+
+        *outPtr++ = del;
+
+        c++;
+
+        mb = pb_local*(n+zmode) + mb - ((pb_local*mb)>>QBSHIFT);
+
+		// update mean tracking
+		if (n > N_MAX_MEAN_CLAMP)
+			mb = N_MEAN_CLAMP_VAL;
+
+        zmode = 0;
+
+        if (((mb << MMULSHIFT) < QB) && (c < numSamples))
+        {
+            zmode = 1;
+            k = lead(mb) - BITOFF+((mb+MOFF)>>MDENSHIFT);
+            mz = ((1<<k)-1) & wb_local;
+
+            n = dyn_get(in, &bitPos, mz, k);
+
+            RequireAction(c+n <= numSamples, status = kALAC_ParamError; goto Exit; );
+
+            for(j=0; j < n; j++)
+            {
+                *outPtr++ = 0;
+                ++c;                    
+            }
+
+            if(n >= 65535)
+            	zmode = 0;
+
+            mb = 0;
+        }
+    }
+
+Exit:
+	*outNumBits = (bitPos - startPos);
+	BitBufferAdvance( bitstream, *outNumBits );
+	RequireAction( bitstream->cur <= bitstream->end, status = kALAC_ParamError; );
+
+    return status;
+}

components/spotify/cspot/bell/external/alac/codec/ag_enc.c

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		ag_enc.c
+	
+	Contains:   Adaptive Golomb encode routines.
+
+	Copyright:	(c) 2001-2011 Apple, Inc.
+*/
+
+#include "aglib.h"
+#include "ALACBitUtilities.h"
+#include "EndianPortable.h"
+#include "ALACAudioTypes.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if __GNUC__ && TARGET_OS_MAC
+	#if __POWERPC__
+		#include <ppc_intrinsics.h>
+	#else
+		#include <libkern/OSByteOrder.h>
+	#endif
+#endif
+
+#define CODE_TO_LONG_MAXBITS	32
+#define N_MAX_MEAN_CLAMP		0xffff
+#define N_MEAN_CLAMP_VAL		0xffff
+#define REPORT_VAL  40
+
+#if __GNUC__
+#define ALWAYS_INLINE		__attribute__((always_inline))
+#else
+#define ALWAYS_INLINE
+#endif
+
+
+/*	And on the subject of the CodeWarrior x86 compiler and inlining, I reworked a lot of this
+	to help the compiler out.   In many cases this required manual inlining or a macro.  Sorry
+	if it is ugly but the performance gains are well worth it.
+	- WSK 5/19/04
+*/
+
+// note: implementing this with some kind of "count leading zeros" assembly is a big performance win
+static inline int32_t lead( int32_t m )
+{
+	long j;
+	unsigned long c = (1ul << 31);
+
+	for(j=0; j < 32; j++)
+	{
+		if((c & m) != 0)
+			break;
+		c >>= 1;
+	}
+	return (j);
+}
+
+#define arithmin(a, b) ((a) < (b) ? (a) : (b))
+
+static inline int32_t ALWAYS_INLINE lg3a( int32_t x)
+{
+    int32_t result;
+
+    x += 3;
+    result = lead(x);
+
+    return 31 - result;
+}
+
+static inline int32_t ALWAYS_INLINE abs_func( int32_t a )
+{
+	// note: the CW PPC intrinsic __abs() turns into these instructions so no need to try and use it
+	int32_t isneg  = a >> 31;
+	int32_t xorval = a ^ isneg;
+	int32_t result = xorval-isneg;
+	
+	return result;	
+}
+
+static inline uint32_t ALWAYS_INLINE read32bit( uint8_t * buffer )
+{
+	// embedded CPUs typically can't read unaligned 32-bit words so just read the bytes
+	uint32_t		value;
+	
+	value = ((uint32_t)buffer[0] << 24) | ((uint32_t)buffer[1] << 16) |
+			 ((uint32_t)buffer[2] << 8) | (uint32_t)buffer[3];
+	return value;
+}
+
+#if PRAGMA_MARK
+#pragma mark -
+#endif
+
+static inline int32_t dyn_code(int32_t m, int32_t k, int32_t n, uint32_t *outNumBits)
+{
+	uint32_t 	div, mod, de;
+	uint32_t	numBits;
+	uint32_t	value;
+
+	//Assert( n >= 0 );
+
+	div = n/m;
+
+	if(div >= MAX_PREFIX_16)
+	{
+		numBits = MAX_PREFIX_16 + MAX_DATATYPE_BITS_16;
+		value = (((1<<MAX_PREFIX_16)-1)<<MAX_DATATYPE_BITS_16) + n;
+	}
+	else
+	{
+		mod = n%m;
+		de = (mod == 0);
+		numBits = div + k + 1 - de;
+		value = (((1<<div)-1)<<(numBits-div)) + mod + 1 - de;
+
+		// if coding this way is bigger than doing escape, then do escape
+		if (numBits > MAX_PREFIX_16 + MAX_DATATYPE_BITS_16)
+		{
+		    numBits = MAX_PREFIX_16 + MAX_DATATYPE_BITS_16;
+		    value = (((1<<MAX_PREFIX_16)-1)<<MAX_DATATYPE_BITS_16) + n;            
+		}
+	}
+	
+	*outNumBits = numBits;
+
+	return (int32_t) value;
+}
+
+
+static inline int32_t dyn_code_32bit(int32_t maxbits, uint32_t m, uint32_t k, uint32_t n, uint32_t *outNumBits, uint32_t *outValue, uint32_t *overflow, uint32_t *overflowbits)
+{
+	uint32_t 	div, mod, de;
+	uint32_t	numBits;
+	uint32_t	value;
+	int32_t			didOverflow = 0;
+
+	div = n/m;
+
+	if (div < MAX_PREFIX_32)
+	{
+		mod = n - (m * div);
+
+		de = (mod == 0);
+		numBits = div + k + 1 - de;
+		value = (((1<<div)-1)<<(numBits-div)) + mod + 1 - de;		
+		if (numBits > 25)
+			goto codeasescape;
+	}
+	else
+	{
+codeasescape:
+		numBits = MAX_PREFIX_32;
+		value = (((1<<MAX_PREFIX_32)-1));
+		*overflow = n;
+		*overflowbits = maxbits;
+		didOverflow = 1;
+	}
+	
+	*outNumBits = numBits;
+	*outValue = value;
+
+	return didOverflow;
+}
+
+
+static inline void ALWAYS_INLINE dyn_jam_noDeref(unsigned char *out, uint32_t bitPos, uint32_t numBits, uint32_t value)
+{
+	uint32_t	*i = (uint32_t *)(out + (bitPos >> 3));
+	uint32_t	mask;
+	uint32_t	curr;
+	uint32_t	shift;
+
+	//Assert( numBits <= 32 );
+
+	curr = *i;
+	curr = Swap32NtoB( curr );
+
+	shift = 32 - (bitPos & 7) - numBits;
+
+	mask = ~0u >> (32 - numBits);		// mask must be created in two steps to avoid compiler sequencing ambiguity
+	mask <<= shift;
+
+	value  = (value << shift) & mask;
+	value |= curr & ~mask;
+	
+	*i = Swap32BtoN( value );
+}
+
+
+static inline void ALWAYS_INLINE dyn_jam_noDeref_large(unsigned char *out, uint32_t bitPos, uint32_t numBits, uint32_t value)
+{
+	uint32_t *	i = (uint32_t *)(out + (bitPos>>3));
+	uint32_t	w;
+	uint32_t	curr;
+	uint32_t	mask;
+	int32_t			shiftvalue = (32 - (bitPos&7) - numBits);
+	
+	//Assert(numBits <= 32);
+
+	curr = *i;
+	curr = Swap32NtoB( curr );
+
+	if (shiftvalue < 0)
+	{
+		uint8_t 	tailbyte;
+		uint8_t 	*tailptr;
+
+		w = value >> -shiftvalue;
+		mask = ~0u >> -shiftvalue;
+		w |= (curr & ~mask);
+
+		tailptr = ((uint8_t *)i) + 4;
+		tailbyte = (value << ((8+shiftvalue))) & 0xff;
+		*tailptr = (uint8_t)tailbyte;
+	}
+	else
+	{
+		mask = ~0u >> (32 - numBits);
+		mask <<= shiftvalue;			// mask must be created in two steps to avoid compiler sequencing ambiguity
+
+		w  = (value << shiftvalue) & mask;
+		w |= curr & ~mask;
+	}
+	
+	*i = Swap32BtoN( w );
+}
+
+
+int32_t dyn_comp( AGParamRecPtr params, int32_t * pc, BitBuffer * bitstream, int32_t numSamples, int32_t bitSize, uint32_t * outNumBits )
+{
+    unsigned char *		out;
+    uint32_t		bitPos, startPos;
+    uint32_t			m, k, n, c, mz, nz;
+    uint32_t		numBits;
+    uint32_t			value;
+    int32_t				del, zmode;
+	uint32_t		overflow, overflowbits;
+    int32_t					status;
+
+    // shadow the variables in params so there's not the dereferencing overhead
+    uint32_t		mb, pb, kb, wb;
+    int32_t					rowPos = 0;
+    int32_t					rowSize = params->sw;
+    int32_t					rowJump = (params->fw) - rowSize;
+    int32_t *			inPtr = pc;
+
+	*outNumBits = 0;
+	RequireAction( (bitSize >= 1) && (bitSize <= 32), return kALAC_ParamError; );
+
+	out = bitstream->cur;
+	startPos = bitstream->bitIndex;
+    bitPos = startPos;
+
+    mb = params->mb = params->mb0;
+    pb = params->pb;
+    kb = params->kb;
+    wb = params->wb;
+    zmode = 0;
+
+    c=0;
+	status = ALAC_noErr;
+
+    while (c < numSamples)
+    {
+        m  = mb >> QBSHIFT;
+        k = lg3a(m);
+        if ( k > kb)
+        {
+        	k = kb;
+        }
+        m = (1<<k)-1;
+
+        del = *inPtr++;
+        rowPos++;
+
+        n = (abs_func(del) << 1) - ((del >> 31) & 1) - zmode;
+		//Assert( 32-lead(n) <= bitSize );
+
+		if ( dyn_code_32bit(bitSize, m, k, n, &numBits, &value, &overflow, &overflowbits) )
+		{
+			dyn_jam_noDeref(out, bitPos, numBits, value);
+			bitPos += numBits;			
+			dyn_jam_noDeref_large(out, bitPos, overflowbits, overflow);			
+			bitPos += overflowbits;
+		}
+		else
+		{
+			dyn_jam_noDeref(out, bitPos, numBits, value);
+			bitPos += numBits;
+		}
+      
+        c++;
+        if ( rowPos >= rowSize)
+        {
+        	rowPos = 0;
+        	inPtr += rowJump;
+        }
+
+        mb = pb * (n + zmode) + mb - ((pb *mb)>>QBSHIFT);
+
+		// update mean tracking if it's overflowed
+		if (n > N_MAX_MEAN_CLAMP)
+			mb = N_MEAN_CLAMP_VAL;
+
+        zmode = 0;
+
+        RequireAction(c <= numSamples, status = kALAC_ParamError; goto Exit; );
+
+        if (((mb << MMULSHIFT) < QB) && (c < numSamples))
+        {
+            zmode = 1;
+            nz = 0;
+
+            while(c<numSamples && *inPtr == 0)
+            {
+            	/* Take care of wrap-around globals. */
+                ++inPtr;
+                ++nz;
+                ++c;
+                if ( ++rowPos >= rowSize)
+                {
+                	rowPos = 0;
+                	inPtr += rowJump;
+                }
+
+                if(nz >= 65535)
+                {
+                	zmode = 0;
+                	break;
+                }
+            }
+
+            k = lead(mb) - BITOFF+((mb+MOFF)>>MDENSHIFT);
+            mz = ((1<<k)-1) & wb;
+
+            value = dyn_code(mz, k, nz, &numBits);
+            dyn_jam_noDeref(out, bitPos, numBits, value);
+            bitPos += numBits;
+
+            mb = 0;
+        }
+    }
+
+    *outNumBits = (bitPos - startPos);
+	BitBufferAdvance( bitstream, *outNumBits );
+
+Exit:
+	return status;
+}

components/spotify/cspot/bell/external/alac/codec/aglib.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		aglib.h
+	
+	Copyright:	(C) 2001-2011 Apple, Inc.
+*/
+
+#ifndef AGLIB_H
+#define AGLIB_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define QBSHIFT 9
+#define QB (1<<QBSHIFT)
+#define PB0 40
+#define MB0 10
+#define KB0 14
+#define MAX_RUN_DEFAULT 255
+
+#define MMULSHIFT 2
+#define MDENSHIFT (QBSHIFT - MMULSHIFT - 1)
+#define MOFF ((1<<(MDENSHIFT-2)))
+
+#define BITOFF 24
+
+/* Max. prefix of 1's. */
+#define MAX_PREFIX_16			9
+#define MAX_PREFIX_TOLONG_16	15
+#define MAX_PREFIX_32			9
+
+/* Max. bits in 16-bit data type */
+#define MAX_DATATYPE_BITS_16	16
+
+typedef struct AGParamRec
+{
+    uint32_t mb, mb0, pb, kb, wb, qb;
+    uint32_t fw, sw;
+
+    uint32_t maxrun;
+
+    // fw = 1, sw = 1;
+
+} AGParamRec, *AGParamRecPtr;
+
+struct BitBuffer;
+
+void	set_standard_ag_params(AGParamRecPtr params, uint32_t fullwidth, uint32_t sectorwidth);
+void	set_ag_params(AGParamRecPtr params, uint32_t m, uint32_t p, uint32_t k, uint32_t f, uint32_t s, uint32_t maxrun);
+
+int32_t		dyn_comp(AGParamRecPtr params, int32_t * pc, struct BitBuffer * bitstream, int32_t numSamples, int32_t bitSize, uint32_t * outNumBits);
+int32_t		dyn_decomp(AGParamRecPtr params, struct BitBuffer * bitstream, int32_t * pc, int32_t numSamples, int32_t maxSize, uint32_t * outNumBits);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //#ifndef AGLIB_H

components/spotify/cspot/bell/external/alac/codec/alac.vcxproj

@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="ag_dec.c" />
+    <ClCompile Include="ag_enc.c" />
+    <ClCompile Include="ALACBitUtilities.c" />
+    <ClCompile Include="ALACDecoder.cpp" />
+    <ClCompile Include="ALACEncoder.cpp" />
+    <ClCompile Include="dp_dec.c" />
+    <ClCompile Include="dp_enc.c" />
+    <ClCompile Include="EndianPortable.c" />
+    <ClCompile Include="matrix_dec.c" />
+    <ClCompile Include="matrix_enc.c" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{73ae36f4-6af9-46b0-a682-4321d57ef8e7}</ProjectGuid>
+    <RootNamespace>alac</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <IntDir>build\$(Configuration)\$(Platform)</IntDir>	
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <OutDir>..\targets\win32\x86</OutDir>	
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <OutDir>..\targets\win32\$(Platform)</OutDir>	
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>false</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <Link>
+      <SubSystem>
+      </SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

components/spotify/cspot/bell/external/alac/codec/build.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+list="x86_64-linux-gnu-gcc i686-linux-gnu-gcc arm-linux-gnueabi-gcc aarch64-linux-gnu-gcc sparc64-linux-gnu-gcc mips-linux-gnu-gcc powerpc-linux-gnu-gcc"
+declare -A alias=( [i686-linux-gnu-gcc]=x86-linux-gnu-gcc )
+declare -a compilers
+
+IFS= read -ra candidates <<< "$list"
+
+# first select platforms/compilers
+for cc in ${candidates[@]}
+do
+	# check compiler first
+	if ! command -v $cc &> /dev/null; then
+		continue
+	fi
+	
+	if [[ $# == 0 ]]; then
+		compilers+=($cc)
+		continue
+	fi
+
+	for arg in $@
+	do
+		if [[ ${alias[$cc]:-$cc} =~ $arg ]]; then 
+			compilers+=($cc)
+		fi
+	done
+done
+
+for cc in ${compilers[@]}
+do
+	IFS=- read -r platform host dummy <<< ${alias[$cc]:-$cc}
+	
+	make clean && make CC=$cc
+	mkdir -p ../targets/$host/$platform
+	cp libalac.a $_
+done
+
+mkdir -p ../targets/include
+cp ALACAudioTypes.h $_
+cp ALACEncoder.h $_
+cp ALACDecoder.h $_

components/spotify/cspot/bell/external/alac/codec/dp_dec.c

@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		dp_dec.c
+
+	Contains:	Dynamic Predictor decode routines
+
+	Copyright:	(c) 2001-2011 Apple, Inc.
+*/
+
+
+#include "dplib.h"
+#include <string.h>
+
+#if __GNUC__
+#define ALWAYS_INLINE		__attribute__((always_inline))
+#else
+#define ALWAYS_INLINE
+#endif
+
+#if TARGET_CPU_PPC && (__MWERKS__ >= 0x3200)
+// align loops to a 16 byte boundary to make the G5 happy
+#pragma function_align 16
+#define LOOP_ALIGN			asm { align 16 }
+#else
+#define LOOP_ALIGN
+#endif
+
+static inline int32_t ALWAYS_INLINE sign_of_int( int32_t i )
+{
+    int32_t negishift;
+	
+    negishift = ((uint32_t)-i) >> 31;
+    return negishift | (i >> 31);
+}
+
+void unpc_block( int32_t * pc1, int32_t * out, int32_t num, int16_t * coefs, int32_t numactive, uint32_t chanbits, uint32_t denshift )
+{
+	register int16_t	a0, a1, a2, a3;
+	register int32_t	b0, b1, b2, b3;
+	int32_t					j, k, lim;
+	int32_t				sum1, sg, sgn, top, dd;
+	int32_t *			pout;
+	int32_t				del, del0;
+	uint32_t			chanshift = 32 - chanbits;
+	int32_t				denhalf = 1<<(denshift-1);
+
+	out[0] = pc1[0];
+	if ( numactive == 0 )
+	{
+		// just copy if numactive == 0 (but don't bother if in/out pointers the same)
+		if ( (num > 1)  && (pc1 != out) )
+			memcpy( &out[1], &pc1[1], (num - 1) * sizeof(int32_t) );
+		return;
+	}
+	if ( numactive == 31 )
+	{
+		// short-circuit if numactive == 31
+		int32_t		prev;
+		
+		/*	this code is written such that the in/out buffers can be the same
+			to conserve buffer space on embedded devices like the iPod
+			
+			(original code)
+			for ( j = 1; j < num; j++ )
+				del = pc1[j] + out[j-1];
+				out[j] = (del << chanshift) >> chanshift;
+		*/
+		prev = out[0];
+		for ( j = 1; j < num; j++ )
+		{
+			del = pc1[j] + prev;
+			prev = (del << chanshift) >> chanshift;
+			out[j] = prev;
+		}
+		return;
+	}
+
+	for ( j = 1; j <= numactive; j++ )
+	{
+		del = pc1[j] + out[j-1];
+		out[j] = (del << chanshift) >> chanshift;
+	}
+
+	lim = numactive + 1;
+
+	if ( numactive == 4 )
+	{
+		// optimization for numactive == 4
+		register int16_t	a0, a1, a2, a3;
+		register int32_t	b0, b1, b2, b3;
+
+		a0 = coefs[0];
+		a1 = coefs[1];
+		a2 = coefs[2];
+		a3 = coefs[3];
+
+		for ( j = lim; j < num; j++ )
+		{
+			LOOP_ALIGN
+
+			top = out[j - lim];
+			pout = out + j - 1;
+
+			b0 = top - pout[0];
+			b1 = top - pout[-1];
+			b2 = top - pout[-2];
+			b3 = top - pout[-3];
+
+			sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3) >> denshift;
+
+			del = pc1[j];
+			del0 = del;
+			sg = sign_of_int(del);
+			del += top + sum1;
+
+			out[j] = (del << chanshift) >> chanshift;
+
+			if ( sg > 0 )
+			{
+				sgn = sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= (4 - 3) * ((sgn * b3) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= (4 - 2) * ((sgn * b2) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= (4 - 1) * ((sgn * b1) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+
+				a0 -= sign_of_int( b0 );
+			}
+			else if ( sg < 0 )
+			{
+				// note: to avoid unnecessary negations, we flip the value of "sgn"
+				sgn = -sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= (4 - 3) * ((sgn * b3) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= (4 - 2) * ((sgn * b2) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= (4 - 1) * ((sgn * b1) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+
+				a0 += sign_of_int( b0 );
+			}
+		}
+
+		coefs[0] = a0;
+		coefs[1] = a1;
+		coefs[2] = a2;
+		coefs[3] = a3;
+	}
+	else if ( numactive == 8 )
+	{
+		register int16_t	a4, a5, a6, a7;
+		register int32_t	b4, b5, b6, b7;
+
+		// optimization for numactive == 8
+		a0 = coefs[0];
+		a1 = coefs[1];
+		a2 = coefs[2];
+		a3 = coefs[3];
+		a4 = coefs[4];
+		a5 = coefs[5];
+		a6 = coefs[6];
+		a7 = coefs[7];
+
+		for ( j = lim; j < num; j++ )
+		{
+			LOOP_ALIGN
+
+			top = out[j - lim];
+			pout = out + j - 1;
+
+			b0 = top - (*pout--);
+			b1 = top - (*pout--);
+			b2 = top - (*pout--);
+			b3 = top - (*pout--);
+			b4 = top - (*pout--);
+			b5 = top - (*pout--);
+			b6 = top - (*pout--);
+			b7 = top - (*pout);
+			pout += 8;
+
+			sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3
+					- a4 * b4 - a5 * b5 - a6 * b6 - a7 * b7) >> denshift;
+
+			del = pc1[j];
+			del0 = del;
+			sg = sign_of_int(del);
+			del += top + sum1;
+
+			out[j] = (del << chanshift) >> chanshift;
+
+			if ( sg > 0 )
+			{
+				sgn = sign_of_int( b7 );
+				a7 -= sgn;
+				del0 -= 1 * ((sgn * b7) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b6 );
+				a6 -= sgn;
+				del0 -= 2 * ((sgn * b6) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b5 );
+				a5 -= sgn;
+				del0 -= 3 * ((sgn * b5) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+
+				sgn = sign_of_int( b4 );
+				a4 -= sgn;
+				del0 -= 4 * ((sgn * b4) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= 5 * ((sgn * b3) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= 6 * ((sgn * b2) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= 7 * ((sgn * b1) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+
+				a0 -= sign_of_int( b0 );
+			}
+			else if ( sg < 0 )
+			{
+				// note: to avoid unnecessary negations, we flip the value of "sgn"
+				sgn = -sign_of_int( b7 );
+				a7 -= sgn;
+				del0 -= 1 * ((sgn * b7) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b6 );
+				a6 -= sgn;
+				del0 -= 2 * ((sgn * b6) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b5 );
+				a5 -= sgn;
+				del0 -= 3 * ((sgn * b5) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+
+				sgn = -sign_of_int( b4 );
+				a4 -= sgn;
+				del0 -= 4 * ((sgn * b4) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= 5 * ((sgn * b3) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= 6 * ((sgn * b2) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= 7 * ((sgn * b1) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+
+				a0 += sign_of_int( b0 );
+			}
+		}
+
+		coefs[0] = a0;
+		coefs[1] = a1;
+		coefs[2] = a2;
+		coefs[3] = a3;
+		coefs[4] = a4;
+		coefs[5] = a5;
+		coefs[6] = a6;
+		coefs[7] = a7;
+	}
+	else
+	{
+		// general case
+		for ( j = lim; j < num; j++ )
+		{
+			LOOP_ALIGN
+
+			sum1 = 0;
+			pout = out + j - 1;
+			top = out[j-lim];
+
+			for ( k = 0; k < numactive; k++ )
+				sum1 += coefs[k] * (pout[-k] - top);
+
+			del = pc1[j];
+			del0 = del;
+			sg = sign_of_int( del );
+			del += top + ((sum1 + denhalf) >> denshift);
+			out[j] = (del << chanshift) >> chanshift;
+
+			if ( sg > 0 )
+			{
+				for ( k = (numactive - 1); k >= 0; k-- )
+				{
+					dd = top - pout[-k];
+					sgn = sign_of_int( dd );
+					coefs[k] -= sgn;
+					del0 -= (numactive - k) * ((sgn * dd) >> denshift);
+					if ( del0 <= 0 )
+						break;
+				}
+			}
+			else if ( sg < 0 )
+			{
+				for ( k = (numactive - 1); k >= 0; k-- )
+				{
+					dd = top - pout[-k];
+					sgn = sign_of_int( dd );
+					coefs[k] += sgn;
+					del0 -= (numactive - k) * ((-sgn * dd) >> denshift);
+					if ( del0 >= 0 )
+						break;
+				}
+			}
+		}
+	}
+}

components/spotify/cspot/bell/external/alac/codec/dp_enc.c

@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		dp_enc.c
+
+	Contains:	Dynamic Predictor encode routines
+
+	Copyright:	(c) 2001-2011 Apple, Inc.
+*/
+
+#include "dplib.h"
+#include <string.h>
+
+#if __GNUC__
+#define ALWAYS_INLINE		__attribute__((always_inline))
+#else
+#define ALWAYS_INLINE
+#endif
+
+#if TARGET_CPU_PPC && (__MWERKS__ >= 0x3200)
+// align loops to a 16 byte boundary to make the G5 happy
+#pragma function_align 16
+#define LOOP_ALIGN			asm { align 16 }
+#else
+#define LOOP_ALIGN
+#endif
+
+void init_coefs( int16_t * coefs, uint32_t denshift, int32_t numPairs )
+{
+	int32_t		k;
+	int32_t		den = 1 << denshift;
+
+	coefs[0] = (AINIT * den) >> 4;
+	coefs[1] = (BINIT * den) >> 4;
+	coefs[2] = (CINIT * den) >> 4;
+	for ( k = 3; k < numPairs; k++ )
+		coefs[k]  = 0;
+}
+
+void copy_coefs( int16_t * srcCoefs, int16_t * dstCoefs, int32_t numPairs )
+{
+	int32_t k;
+
+	for ( k = 0; k < numPairs; k++ )
+		dstCoefs[k] = srcCoefs[k];
+}
+
+static inline int32_t ALWAYS_INLINE sign_of_int( int32_t i )
+{
+    int32_t negishift;
+	
+    negishift = ((uint32_t)-i) >> 31;
+    return negishift | (i >> 31);
+}
+
+void pc_block( int32_t * in, int32_t * pc1, int32_t num, int16_t * coefs, int32_t numactive, uint32_t chanbits, uint32_t denshift )
+{
+	register int16_t	a0, a1, a2, a3;
+	register int32_t	b0, b1, b2, b3;
+	int32_t					j, k, lim;
+	int32_t *			pin;
+	int32_t				sum1, dd;
+	int32_t				sg, sgn;
+	int32_t				top;
+	int32_t				del, del0;
+	uint32_t			chanshift = 32 - chanbits;
+	int32_t				denhalf = 1 << (denshift - 1);
+
+	pc1[0] = in[0];
+	if ( numactive == 0 )
+	{
+		// just copy if numactive == 0 (but don't bother if in/out pointers the same)
+		if ( (num > 1) && (in != pc1) )
+			memcpy( &pc1[1], &in[1], (num - 1) * sizeof(int32_t) );
+		return;
+	}
+	if ( numactive == 31 )
+	{
+		// short-circuit if numactive == 31
+		for( j = 1; j < num; j++ )
+		{
+			del = in[j] - in[j-1];
+			pc1[j] = (del << chanshift) >> chanshift;
+		}
+		return;
+	}
+	
+	for ( j = 1; j <= numactive; j++ )
+	{
+		del = in[j] - in[j-1];
+		pc1[j] = (del << chanshift) >> chanshift;
+	}
+
+	lim = numactive + 1;
+
+	if ( numactive == 4 )
+	{
+		// optimization for numactive == 4
+		a0 = coefs[0];
+		a1 = coefs[1];
+		a2 = coefs[2];
+		a3 = coefs[3];
+
+		for ( j = lim; j < num; j++ )
+		{
+			LOOP_ALIGN
+
+			top = in[j - lim];
+			pin = in + j - 1;
+
+			b0 = top - pin[0];
+			b1 = top - pin[-1];
+			b2 = top - pin[-2];
+			b3 = top - pin[-3];
+
+			sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3) >> denshift;
+
+			del = in[j] - top - sum1;
+			del = (del << chanshift) >> chanshift;
+			pc1[j] = del;	     
+			del0 = del;
+
+			sg = sign_of_int(del);
+			if ( sg > 0 )
+			{
+				sgn = sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= (4 - 3) * ((sgn * b3) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= (4 - 2) * ((sgn * b2) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= (4 - 1) * ((sgn * b1) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+
+				a0 -= sign_of_int( b0 );
+			}
+			else if ( sg < 0 )
+			{
+				// note: to avoid unnecessary negations, we flip the value of "sgn"
+				sgn = -sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= (4 - 3) * ((sgn * b3) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= (4 - 2) * ((sgn * b2) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= (4 - 1) * ((sgn * b1) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+
+				a0 += sign_of_int( b0 );
+			}
+		}
+
+		coefs[0] = a0;
+		coefs[1] = a1;
+		coefs[2] = a2;
+		coefs[3] = a3;
+	}
+	else if ( numactive == 8 )
+	{
+		// optimization for numactive == 8
+		register int16_t	a4, a5, a6, a7;
+		register int32_t	b4, b5, b6, b7;
+
+		a0 = coefs[0];
+		a1 = coefs[1];
+		a2 = coefs[2];
+		a3 = coefs[3];
+		a4 = coefs[4];
+		a5 = coefs[5];
+		a6 = coefs[6];
+		a7 = coefs[7];
+
+		for ( j = lim; j < num; j++ )
+		{
+			LOOP_ALIGN
+
+			top = in[j - lim];
+			pin = in + j - 1;
+
+			b0 = top - (*pin--);
+			b1 = top - (*pin--);
+			b2 = top - (*pin--);
+			b3 = top - (*pin--);
+			b4 = top - (*pin--);
+			b5 = top - (*pin--);
+			b6 = top - (*pin--);
+			b7 = top - (*pin);
+			pin += 8;
+
+			sum1 = (denhalf - a0 * b0 - a1 * b1 - a2 * b2 - a3 * b3
+					- a4 * b4 - a5 * b5 - a6 * b6 - a7 * b7) >> denshift;
+
+			del = in[j] - top - sum1;
+			del = (del << chanshift) >> chanshift;
+			pc1[j] = del;	     
+			del0 = del;
+
+			sg = sign_of_int(del);
+			if ( sg > 0 )
+			{
+				sgn = sign_of_int( b7 );
+				a7 -= sgn;
+				del0 -= 1 * ((sgn * b7) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b6 );
+				a6 -= sgn;
+				del0 -= 2 * ((sgn * b6) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b5 );
+				a5 -= sgn;
+				del0 -= 3 * ((sgn * b5) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+
+				sgn = sign_of_int( b4 );
+				a4 -= sgn;
+				del0 -= 4 * ((sgn * b4) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= 5 * ((sgn * b3) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= 6 * ((sgn * b2) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+				
+				sgn = sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= 7 * ((sgn * b1) >> denshift);
+				if ( del0 <= 0 )
+					continue;
+
+				a0 -= sign_of_int( b0 );
+			}
+			else if ( sg < 0 )
+			{
+				// note: to avoid unnecessary negations, we flip the value of "sgn"
+				sgn = -sign_of_int( b7 );
+				a7 -= sgn;
+				del0 -= 1 * ((sgn * b7) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b6 );
+				a6 -= sgn;
+				del0 -= 2 * ((sgn * b6) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b5 );
+				a5 -= sgn;
+				del0 -= 3 * ((sgn * b5) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+
+				sgn = -sign_of_int( b4 );
+				a4 -= sgn;
+				del0 -= 4 * ((sgn * b4) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b3 );
+				a3 -= sgn;
+				del0 -= 5 * ((sgn * b3) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b2 );
+				a2 -= sgn;
+				del0 -= 6 * ((sgn * b2) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+				
+				sgn = -sign_of_int( b1 );
+				a1 -= sgn;
+				del0 -= 7 * ((sgn * b1) >> denshift);
+				if ( del0 >= 0 )
+					continue;
+
+				a0 += sign_of_int( b0 );
+			}
+		}
+
+		coefs[0] = a0;
+		coefs[1] = a1;
+		coefs[2] = a2;
+		coefs[3] = a3;
+		coefs[4] = a4;
+		coefs[5] = a5;
+		coefs[6] = a6;
+		coefs[7] = a7;
+	}
+	else
+	{
+//pc_block_general:
+		// general case
+		for ( j = lim; j < num; j++ )
+		{
+			LOOP_ALIGN
+
+			top = in[j - lim];
+			pin = in + j - 1;
+
+			sum1 = 0;
+			for ( k = 0; k < numactive; k++ )
+				sum1 -= coefs[k] * (top - pin[-k]);
+		
+			del = in[j] - top - ((sum1 + denhalf) >> denshift);
+			del = (del << chanshift) >> chanshift;
+			pc1[j] = del;
+			del0 = del;
+
+			sg = sign_of_int( del );
+			if ( sg > 0 )
+			{
+				for ( k = (numactive - 1); k >= 0; k-- )
+				{
+					dd = top - pin[-k];
+					sgn = sign_of_int( dd );
+					coefs[k] -= sgn;
+					del0 -= (numactive - k) * ((sgn * dd) >> denshift);
+					if ( del0 <= 0 )
+						break;
+				}
+			}
+			else if ( sg < 0 )
+			{
+				for ( k = (numactive - 1); k >= 0; k-- )
+				{
+					dd = top - pin[-k];
+					sgn = sign_of_int( dd );
+					coefs[k] += sgn;
+					del0 -= (numactive - k) * ((-sgn * dd) >> denshift);
+					if ( del0 >= 0 )
+						break;
+				}
+			}
+		}
+	}
+}

components/spotify/cspot/bell/external/alac/codec/dplib.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		dplib.h
+	
+	Contains:	Dynamic Predictor routines
+
+	Copyright:	Copyright (C) 2001-2011 Apple, Inc.
+*/
+
+#ifndef __DPLIB_H__
+#define __DPLIB_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// defines
+
+#define DENSHIFT_MAX  15
+#define DENSHIFT_DEFAULT 9
+#define AINIT 38
+#define BINIT (-29)
+#define CINIT (-2)
+#define NUMCOEPAIRS 16
+
+// prototypes
+
+void init_coefs( int16_t * coefs, uint32_t denshift, int32_t numPairs );
+void copy_coefs( int16_t * srcCoefs, int16_t * dstCoefs, int32_t numPairs );
+
+// NOTE: these routines read at least "numactive" samples so the i/o buffers must be at least that big
+
+void pc_block( int32_t * in, int32_t * pc, int32_t num, int16_t * coefs, int32_t numactive, uint32_t chanbits, uint32_t denshift );
+void unpc_block( int32_t * pc, int32_t * out, int32_t num, int16_t * coefs, int32_t numactive, uint32_t chanbits, uint32_t denshift );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* __DPLIB_H__ */

components/spotify/cspot/bell/external/alac/codec/matrix_dec.c

@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		matrix_dec.c
+	
+	Contains:	ALAC mixing/matrixing decode routines.
+
+	Copyright:	(c) 2004-2011 Apple, Inc.
+*/
+
+#include "matrixlib.h"
+#include "ALACAudioTypes.h"
+
+// up to 24-bit "offset" macros for the individual bytes of a 20/24-bit word
+#if TARGET_RT_BIG_ENDIAN
+	#define LBYTE	2
+	#define MBYTE	1
+	#define HBYTE	0
+#else
+	#define LBYTE	0
+	#define MBYTE	1
+	#define HBYTE	2
+#endif
+
+/*
+    There is no plain middle-side option; instead there are various mixing
+    modes including middle-side, each lossless, as embodied in the mix()
+    and unmix() functions.  These functions exploit a generalized middle-side
+    transformation:
+    
+    u := [(rL + (m-r)R)/m];
+    v := L - R;
+    
+    where [ ] denotes integer floor.  The (lossless) inverse is
+    
+    L = u + v - [rV/m];
+    R = L - v;
+*/
+
+// 16-bit routines
+
+void unmix16( int32_t * u, int32_t * v, int16_t * out, uint32_t stride, int32_t numSamples, int32_t mixbits, int32_t mixres )
+{
+	int16_t *	op = out;
+	int32_t 		j;
+
+	if ( mixres != 0 )
+	{
+		/* matrixed stereo */
+		for ( j = 0; j < numSamples; j++ )
+		{
+			int32_t		l, r;
+
+			l = u[j] + v[j] - ((mixres * v[j]) >> mixbits);
+			r = l - v[j];
+
+			op[0] = (int16_t) l;
+			op[1] = (int16_t) r;
+			op += stride;
+		} 
+	}
+	else
+	{
+		/* Conventional separated stereo. */
+		for ( j = 0; j < numSamples; j++ )
+		{
+			op[0] = (int16_t) u[j];
+			op[1] = (int16_t) v[j];
+			op += stride;
+		}
+	}
+}
+
+// 20-bit routines
+// - the 20 bits of data are left-justified in 3 bytes of storage but right-aligned for input/output predictor buffers
+
+void unmix20( int32_t * u, int32_t * v, uint8_t * out, uint32_t stride, int32_t numSamples, int32_t mixbits, int32_t mixres )
+{
+	uint8_t *	op = out;
+	int32_t 		j;
+
+	if ( mixres != 0 )
+	{
+		/* matrixed stereo */
+		for ( j = 0; j < numSamples; j++ )
+		{
+			int32_t		l, r;
+
+			l = u[j] + v[j] - ((mixres * v[j]) >> mixbits);
+			r = l - v[j];
+
+			l <<= 4;
+			r <<= 4;
+
+			op[HBYTE] = (uint8_t)((l >> 16) & 0xffu);
+			op[MBYTE] = (uint8_t)((l >>  8) & 0xffu);
+			op[LBYTE] = (uint8_t)((l >>  0) & 0xffu);
+			op += 3;
+
+			op[HBYTE] = (uint8_t)((r >> 16) & 0xffu);
+			op[MBYTE] = (uint8_t)((r >>  8) & 0xffu);
+			op[LBYTE] = (uint8_t)((r >>  0) & 0xffu);
+
+			op += (stride - 1) * 3;
+		}
+	}
+	else 
+	{
+		/* Conventional separated stereo. */
+		for ( j = 0; j < numSamples; j++ )
+		{
+			int32_t		val;
+
+			val = u[j] << 4;
+			op[HBYTE] = (uint8_t)((val >> 16) & 0xffu);
+			op[MBYTE] = (uint8_t)((val >>  8) & 0xffu);
+			op[LBYTE] = (uint8_t)((val >>  0) & 0xffu);
+			op += 3;
+
+			val = v[j] << 4;
+			op[HBYTE] = (uint8_t)((val >> 16) & 0xffu);
+			op[MBYTE] = (uint8_t)((val >>  8) & 0xffu);
+			op[LBYTE] = (uint8_t)((val >>  0) & 0xffu);
+
+			op += (stride - 1) * 3;
+		}
+	}
+}
+
+// 24-bit routines
+// - the 24 bits of data are right-justified in the input/output predictor buffers
+
+void unmix24( int32_t * u, int32_t * v, uint8_t * out, uint32_t stride, int32_t numSamples,
+				int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted )
+{
+	uint8_t *	op = out;
+	int32_t			shift = bytesShifted * 8;
+	int32_t		l, r;
+	int32_t 		j, k;
+
+	if ( mixres != 0 )
+	{
+		/* matrixed stereo */
+		if ( bytesShifted != 0 )
+		{
+			for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+			{
+				l = u[j] + v[j] - ((mixres * v[j]) >> mixbits);
+				r = l - v[j];
+
+				l = (l << shift) | (uint32_t) shiftUV[k + 0];
+				r = (r << shift) | (uint32_t) shiftUV[k + 1];
+
+				op[HBYTE] = (uint8_t)((l >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((l >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((l >>  0) & 0xffu);
+				op += 3;
+
+				op[HBYTE] = (uint8_t)((r >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((r >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((r >>  0) & 0xffu);
+
+				op += (stride - 1) * 3;
+			}
+		}
+		else
+		{
+			for ( j = 0; j < numSamples; j++ )
+			{
+				l = u[j] + v[j] - ((mixres * v[j]) >> mixbits);
+				r = l - v[j];
+
+				op[HBYTE] = (uint8_t)((l >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((l >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((l >>  0) & 0xffu);
+				op += 3;
+
+				op[HBYTE] = (uint8_t)((r >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((r >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((r >>  0) & 0xffu);
+
+				op += (stride - 1) * 3;
+			}
+		}
+	}
+	else 
+	{
+		/* Conventional separated stereo. */
+		if ( bytesShifted != 0 )
+		{
+			for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+			{
+				l = u[j];
+				r = v[j];
+
+				l = (l << shift) | (uint32_t) shiftUV[k + 0];
+				r = (r << shift) | (uint32_t) shiftUV[k + 1];
+
+				op[HBYTE] = (uint8_t)((l >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((l >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((l >>  0) & 0xffu);
+				op += 3;
+
+				op[HBYTE] = (uint8_t)((r >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((r >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((r >>  0) & 0xffu);
+
+				op += (stride - 1) * 3;
+			}
+		}
+		else
+		{
+			for ( j = 0; j < numSamples; j++ )
+			{
+				int32_t		val;
+
+				val = u[j];
+				op[HBYTE] = (uint8_t)((val >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((val >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((val >>  0) & 0xffu);
+				op += 3;
+
+				val = v[j];
+				op[HBYTE] = (uint8_t)((val >> 16) & 0xffu);
+				op[MBYTE] = (uint8_t)((val >>  8) & 0xffu);
+				op[LBYTE] = (uint8_t)((val >>  0) & 0xffu);
+
+				op += (stride - 1) * 3;
+			}
+		}
+	}
+}
+
+// 32-bit routines
+// - note that these really expect the internal data width to be < 32 but the arrays are 32-bit
+// - otherwise, the calculations might overflow into the 33rd bit and be lost
+// - therefore, these routines deal with the specified "unused lower" bytes in the "shift" buffers
+
+void unmix32( int32_t * u, int32_t * v, int32_t * out, uint32_t stride, int32_t numSamples,
+				int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted )
+{
+	int32_t *	op = out;
+	int32_t			shift = bytesShifted * 8;
+	int32_t		l, r;
+	int32_t 		j, k;
+
+	if ( mixres != 0 )
+	{
+		//Assert( bytesShifted != 0 );
+
+		/* matrixed stereo with shift */
+		for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+		{
+			int32_t		lt, rt;
+
+			lt = u[j];
+			rt = v[j];
+			
+			l = lt + rt - ((mixres * rt) >> mixbits);
+			r = l - rt;
+
+			op[0] = (l << shift) | (uint32_t) shiftUV[k + 0];
+			op[1] = (r << shift) | (uint32_t) shiftUV[k + 1];
+			op += stride;
+		} 
+	}
+	else
+	{
+		if ( bytesShifted == 0 )
+		{
+			/* interleaving w/o shift */
+			for ( j = 0; j < numSamples; j++ )
+			{
+				op[0] = u[j];
+				op[1] = v[j];
+				op += stride;
+			}
+		}
+		else
+		{
+			/* interleaving with shift */
+			for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+			{
+				op[0] = (u[j] << shift) | (uint32_t) shiftUV[k + 0];
+				op[1] = (v[j] << shift) | (uint32_t) shiftUV[k + 1];
+				op += stride;
+			}
+		}
+	}
+}
+
+// 20/24-bit <-> 32-bit helper routines (not really matrixing but convenient to put here)
+
+void copyPredictorTo24( int32_t * in, uint8_t * out, uint32_t stride, int32_t numSamples )
+{
+	uint8_t *	op = out;
+	int32_t			j;
+
+	for ( j = 0; j < numSamples; j++ )
+	{
+		int32_t		val = in[j];
+
+		op[HBYTE] = (uint8_t)((val >> 16) & 0xffu);
+		op[MBYTE] = (uint8_t)((val >>  8) & 0xffu);
+		op[LBYTE] = (uint8_t)((val >>  0) & 0xffu);
+		op += (stride * 3);
+	}
+}
+
+void copyPredictorTo24Shift( int32_t * in, uint16_t * shift, uint8_t * out, uint32_t stride, int32_t numSamples, int32_t bytesShifted )
+{
+	uint8_t *	op = out;
+	int32_t			shiftVal = bytesShifted * 8;
+	int32_t			j;
+
+	//Assert( bytesShifted != 0 );
+
+	for ( j = 0; j < numSamples; j++ )
+	{
+		int32_t		val = in[j];
+
+		val = (val << shiftVal) | (uint32_t) shift[j];
+
+		op[HBYTE] = (uint8_t)((val >> 16) & 0xffu);
+		op[MBYTE] = (uint8_t)((val >>  8) & 0xffu);
+		op[LBYTE] = (uint8_t)((val >>  0) & 0xffu);
+		op += (stride * 3);
+	}
+}
+
+void copyPredictorTo20( int32_t * in, uint8_t * out, uint32_t stride, int32_t numSamples )
+{
+	uint8_t *	op = out;
+	int32_t			j;
+
+	// 32-bit predictor values are right-aligned but 20-bit output values should be left-aligned
+	// in the 24-bit output buffer
+	for ( j = 0; j < numSamples; j++ )
+	{
+		int32_t		val = in[j];
+
+		op[HBYTE] = (uint8_t)((val >> 12) & 0xffu);
+		op[MBYTE] = (uint8_t)((val >>  4) & 0xffu);
+		op[LBYTE] = (uint8_t)((val <<  4) & 0xffu);
+		op += (stride * 3);
+	}
+}
+
+void copyPredictorTo32( int32_t * in, int32_t * out, uint32_t stride, int32_t numSamples )
+{
+	int32_t			i, j;
+
+	// this is only a subroutine to abstract the "iPod can only output 16-bit data" problem
+	for ( i = 0, j = 0; i < numSamples; i++, j += stride )
+		out[j] = in[i];
+}
+
+void copyPredictorTo32Shift( int32_t * in, uint16_t * shift, int32_t * out, uint32_t stride, int32_t numSamples, int32_t bytesShifted )
+{
+	int32_t *		op = out;
+	uint32_t		shiftVal = bytesShifted * 8;
+	int32_t				j;
+
+	//Assert( bytesShifted != 0 );
+
+	// this is only a subroutine to abstract the "iPod can only output 16-bit data" problem
+	for ( j = 0; j < numSamples; j++ )
+	{
+		op[0] = (in[j] << shiftVal) | (uint32_t) shift[j];
+		op += stride;
+	}
+}

components/spotify/cspot/bell/external/alac/codec/matrix_enc.c

@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		matrix_enc.c
+	
+	Contains:	ALAC mixing/matrixing encode routines.
+
+	Copyright:	(c) 2004-2011 Apple, Inc.
+*/
+
+#include "matrixlib.h"
+#include "ALACAudioTypes.h"
+
+// up to 24-bit "offset" macros for the individual bytes of a 20/24-bit word
+#if TARGET_RT_BIG_ENDIAN
+	#define LBYTE	2
+	#define MBYTE	1
+	#define HBYTE	0
+#else
+	#define LBYTE	0
+	#define MBYTE	1
+	#define HBYTE	2
+#endif
+
+/*
+    There is no plain middle-side option; instead there are various mixing
+    modes including middle-side, each lossless, as embodied in the mix()
+    and unmix() functions.  These functions exploit a generalized middle-side
+    transformation:
+    
+    u := [(rL + (m-r)R)/m];
+    v := L - R;
+    
+    where [ ] denotes integer floor.  The (lossless) inverse is
+    
+    L = u + v - [rV/m];
+    R = L - v;
+*/
+
+// 16-bit routines
+
+void mix16( int16_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres )
+{
+	int16_t	*	ip = in;
+	int32_t			j;
+
+	if ( mixres != 0 )
+	{
+		int32_t		mod = 1 << mixbits;
+		int32_t		m2;
+
+		/* matrixed stereo */
+		m2 = mod - mixres;
+		for ( j = 0; j < numSamples; j++ )
+		{
+			int32_t		l, r;
+
+			l = (int32_t) ip[0];
+			r = (int32_t) ip[1];
+			ip += stride;
+			u[j] = (mixres * l + m2 * r) >> mixbits;
+			v[j] = l - r;
+		}
+	}
+	else
+	{
+		/* Conventional separated stereo. */
+		for ( j = 0; j < numSamples; j++ )
+		{
+			u[j] = (int32_t) ip[0];
+			v[j] = (int32_t) ip[1];
+			ip += stride;
+		}
+	}
+}
+
+// 20-bit routines
+// - the 20 bits of data are left-justified in 3 bytes of storage but right-aligned for input/output predictor buffers
+
+void mix20( uint8_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres )
+{
+	int32_t		l, r;
+	uint8_t *	ip = in;
+	int32_t			j;
+
+	if ( mixres != 0 )
+	{
+		/* matrixed stereo */
+		int32_t		mod = 1 << mixbits;
+		int32_t		m2 = mod - mixres;
+
+		for ( j = 0; j < numSamples; j++ )
+		{
+			l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+			l = (l << 8) >> 12;
+			ip += 3;
+
+			r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+			r = (r << 8) >> 12;
+			ip += (stride - 1) * 3;
+
+			u[j] = (mixres * l + m2 * r) >> mixbits;
+			v[j] = l - r;
+		} 
+	}
+	else
+	{
+		/* Conventional separated stereo. */
+		for ( j = 0; j < numSamples; j++ )
+		{
+			l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+			u[j] = (l << 8) >> 12;
+			ip += 3;
+
+			r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+			v[j] = (r << 8) >> 12;
+			ip += (stride - 1) * 3;
+		}
+	}
+}
+
+// 24-bit routines
+// - the 24 bits of data are right-justified in the input/output predictor buffers
+
+void mix24( uint8_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples,
+			int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted )
+{	
+	int32_t		l, r;
+	uint8_t *	ip = in;
+	int32_t			shift = bytesShifted * 8;
+	uint32_t	mask  = (1ul << shift) - 1;
+	int32_t			j, k;
+
+	if ( mixres != 0 )
+	{
+		/* matrixed stereo */
+		int32_t		mod = 1 << mixbits;
+		int32_t		m2 = mod - mixres;
+
+		if ( bytesShifted != 0 )
+		{
+			for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+			{
+				l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				l = (l << 8) >> 8;
+				ip += 3;
+
+				r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				r = (r << 8) >> 8;
+				ip += (stride - 1) * 3;
+
+				shiftUV[k + 0] = (uint16_t)(l & mask);
+				shiftUV[k + 1] = (uint16_t)(r & mask);
+				
+				l >>= shift;
+				r >>= shift;
+
+				u[j] = (mixres * l + m2 * r) >> mixbits;
+				v[j] = l - r;
+			}
+		}
+		else
+		{
+			for ( j = 0; j < numSamples; j++ )
+			{
+				l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				l = (l << 8) >> 8;
+				ip += 3;
+
+				r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				r = (r << 8) >> 8;
+				ip += (stride - 1) * 3;
+
+				u[j] = (mixres * l + m2 * r) >> mixbits;
+				v[j] = l - r;
+			}
+		}
+	}
+	else
+	{
+		/* Conventional separated stereo. */
+		if ( bytesShifted != 0 )
+		{
+			for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+			{
+				l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				l = (l << 8) >> 8;
+				ip += 3;
+
+				r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				r = (r << 8) >> 8;
+				ip += (stride - 1) * 3;
+
+				shiftUV[k + 0] = (uint16_t)(l & mask);
+				shiftUV[k + 1] = (uint16_t)(r & mask);
+				
+				l >>= shift;
+				r >>= shift;
+
+				u[j] = l;
+				v[j] = r;
+			}
+		}
+		else
+		{
+			for ( j = 0; j < numSamples; j++ )
+			{
+				l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				u[j] = (l << 8) >> 8;
+				ip += 3;
+
+				r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+				v[j] = (r << 8) >> 8;
+				ip += (stride - 1) * 3;
+			}
+		}
+	}
+}
+
+// 32-bit routines
+// - note that these really expect the internal data width to be < 32 but the arrays are 32-bit
+// - otherwise, the calculations might overflow into the 33rd bit and be lost
+// - therefore, these routines deal with the specified "unused lower" bytes in the "shift" buffers
+
+void mix32( int32_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples,
+			int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted )
+{
+	int32_t	*	ip = in;
+	int32_t			shift = bytesShifted * 8;
+	uint32_t	mask  = (1ul << shift) - 1;
+	int32_t		l, r;
+	int32_t			j, k;
+
+	if ( mixres != 0 )
+	{
+		int32_t		mod = 1 << mixbits;
+		int32_t		m2;
+
+		//Assert( bytesShifted != 0 );
+
+		/* matrixed stereo with shift */
+		m2 = mod - mixres;
+		for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+		{
+			l = ip[0];
+			r = ip[1];
+			ip += stride;
+
+			shiftUV[k + 0] = (uint16_t)(l & mask);
+			shiftUV[k + 1] = (uint16_t)(r & mask);
+			
+			l >>= shift;
+			r >>= shift;
+
+			u[j] = (mixres * l + m2 * r) >> mixbits;
+			v[j] = l - r;
+		}
+	}
+	else
+	{
+		if ( bytesShifted == 0 )
+		{
+			/* de-interleaving w/o shift */
+			for ( j = 0; j < numSamples; j++ )
+			{
+				u[j] = ip[0];
+				v[j] = ip[1];
+				ip += stride;
+			}
+		}
+		else
+		{
+			/* de-interleaving with shift */
+			for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
+			{
+				l = ip[0];
+				r = ip[1];
+				ip += stride;
+
+				shiftUV[k + 0] = (uint16_t)(l & mask);
+				shiftUV[k + 1] = (uint16_t)(r & mask);
+				
+				l >>= shift;
+				r >>= shift;
+
+				u[j] = l;
+				v[j] = r;
+			}
+		}
+	}
+}
+
+// 20/24-bit <-> 32-bit helper routines (not really matrixing but convenient to put here)
+
+void copy20ToPredictor( uint8_t * in, uint32_t stride, int32_t * out, int32_t numSamples )
+{
+	uint8_t *	ip = in;
+	int32_t			j;
+
+	for ( j = 0; j < numSamples; j++ )
+	{
+		int32_t			val;
+
+		// 20-bit values are left-aligned in the 24-bit input buffer but right-aligned in the 32-bit output buffer
+		val = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+		out[j] = (val << 8) >> 12;
+		ip += stride * 3;
+	}
+}
+
+void copy24ToPredictor( uint8_t * in, uint32_t stride, int32_t * out, int32_t numSamples )
+{
+	uint8_t *	ip = in;
+	int32_t			j;
+
+	for ( j = 0; j < numSamples; j++ )
+	{
+		int32_t			val;
+
+		val = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
+		out[j] = (val << 8) >> 8;
+		ip += stride * 3;
+	}
+}

components/spotify/cspot/bell/external/alac/codec/matrixlib.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+/*
+	File:		matrixlib.h
+	
+	Contains:	ALAC mixing/matrixing routines to/from 32-bit predictor buffers.
+
+	Copyright:	Copyright (C) 2004 to 2011 Apple, Inc.
+*/
+
+#ifndef __MATRIXLIB_H
+#define __MATRIXLIB_H
+
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// 16-bit routines
+void	mix16( int16_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres );
+void	unmix16( int32_t * u, int32_t * v, int16_t * out, uint32_t stride, int32_t numSamples, int32_t mixbits, int32_t mixres );
+
+// 20-bit routines
+void	mix20( uint8_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres );
+void	unmix20( int32_t * u, int32_t * v, uint8_t * out, uint32_t stride, int32_t numSamples, int32_t mixbits, int32_t mixres );
+
+// 24-bit routines
+// - 24-bit data sometimes compresses better by shifting off the bottom byte so these routines deal with
+//	 the specified "unused lower bytes" in the combined "shift" buffer
+void	mix24( uint8_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples,
+				int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted );
+void	unmix24( int32_t * u, int32_t * v, uint8_t * out, uint32_t stride, int32_t numSamples,
+				 int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted );
+
+// 32-bit routines
+// - note that these really expect the internal data width to be < 32-bit but the arrays are 32-bit
+// - otherwise, the calculations might overflow into the 33rd bit and be lost
+// - therefore, these routines deal with the specified "unused lower" bytes in the combined "shift" buffer
+void	mix32( int32_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples,
+				int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted );
+void	unmix32( int32_t * u, int32_t * v, int32_t * out, uint32_t stride, int32_t numSamples,
+				 int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted );
+
+// 20/24/32-bit <-> 32-bit helper routines (not really matrixing but convenient to put here)
+void	copy20ToPredictor( uint8_t * in, uint32_t stride, int32_t * out, int32_t numSamples );
+void	copy24ToPredictor( uint8_t * in, uint32_t stride, int32_t * out, int32_t numSamples );
+
+void	copyPredictorTo24( int32_t * in, uint8_t * out, uint32_t stride, int32_t numSamples );
+void	copyPredictorTo24Shift( int32_t * in, uint16_t * shift, uint8_t * out, uint32_t stride, int32_t numSamples, int32_t bytesShifted );
+void	copyPredictorTo20( int32_t * in, uint8_t * out, uint32_t stride, int32_t numSamples );
+
+void	copyPredictorTo32( int32_t * in, int32_t * out, uint32_t stride, int32_t numSamples );
+void	copyPredictorTo32Shift( int32_t * in, uint16_t * shift, int32_t * out, uint32_t stride, int32_t numSamples, int32_t bytesShifted );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* __MATRIXLIB_H */