add libsndfile

Classes/libsndfile/Android.mk

+LOCAL_PATH	:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_C_INCLUDES	:= $(LOCAL_PATH)/include		\
+					$(LOCAL_PATH)/src				\
+					$(LOCAL_PATH)/libFLAC/include	\
+					$(LOCAL_PATH)/libvorbis			\
+
+LOCAL_MODULE		:= sndfile
+LOCAL_CFLAGS		:= -DHAVE_CONFIG_H -w -DHOST_TRIPLET=\"$(LLVM_TRIPLE)\"
+LOCAL_CFLAGS		+= -DFLAC__HAS_OGG -DFLAC__INTEGER_ONLY_LIBRARY
+
+#LOCAL_ALLOW_UNDEFINED_SYMBOLS := true
+
+FLAC_SRC := \
+	libFLAC/bitmath.c \
+	libFLAC/bitreader.c \
+	libFLAC/bitwriter.c \
+	libFLAC/cpu.c \
+	libFLAC/crc.c \
+	libFLAC/fixed.c \
+	libFLAC/fixed_intrin_sse2.c \
+	libFLAC/fixed_intrin_ssse3.c \
+	libFLAC/float.c \
+	libFLAC/format.c \
+	libFLAC/lpc.c \
+	libFLAC/lpc_intrin_sse.c \
+	libFLAC/lpc_intrin_sse2.c \
+	libFLAC/lpc_intrin_sse41.c \
+	libFLAC/lpc_intrin_avx2.c \
+	libFLAC/md5.c \
+	libFLAC/memory.c \
+	libFLAC/metadata_iterators.c \
+	libFLAC/metadata_object.c \
+	libFLAC/ogg_decoder_aspect.c \
+	libFLAC/ogg_encoder_aspect.c \
+	libFLAC/ogg_helper.c \
+	libFLAC/ogg_mapping.c \
+	libFLAC/stream_decoder.c \
+	libFLAC/stream_encoder.c \
+	libFLAC/stream_encoder_intrin_sse2.c \
+	libFLAC/stream_encoder_intrin_ssse3.c \
+	libFLAC/stream_encoder_intrin_avx2.c \
+	libFLAC/stream_encoder_framing.c \
+	libFLAC/window.c \
+
+OGG_SRC := \
+	libogg/bitwise.c \
+	libogg/framing.c \
+
+VORBIS_SRC := \
+	libvorbis/analysis.c \
+	libvorbis/bitrate.c \
+	libvorbis/block.c \
+	libvorbis/codebook.c \
+	libvorbis/envelope.c \
+	libvorbis/floor0.c \
+	libvorbis/floor1.c \
+	libvorbis/info.c \
+	libvorbis/lookup.c \
+	libvorbis/lpc.c \
+	libvorbis/lsp.c \
+	libvorbis/mapping0.c \
+	libvorbis/mdct.c \
+	libvorbis/psy.c \
+	libvorbis/registry.c \
+	libvorbis/res0.c \
+	libvorbis/sharedbook.c \
+	libvorbis/smallft.c \
+	libvorbis/synthesis.c \
+	libvorbis/vorbisenc.c \
+	libvorbis/vorbisfile.c \
+	libvorbis/window.c \
+
+SNDFILE_SRC		:= \
+	src/sndfile.c \
+	src/aiff.c \
+	src/au.c \
+	src/avr.c \
+	src/caf.c \
+	src/dwd.c \
+	src/flac.c \
+	src/g72x.c \
+	src/htk.c \
+	src/ircam.c \
+	src/macos.c \
+	src/mat4.c \
+	src/mat5.c \
+	src/nist.c \
+	src/paf.c \
+	src/pvf.c \
+	src/raw.c \
+	src/rx2.c \
+	src/sd2.c \
+	src/sds.c \
+	src/svx.c \
+	src/txw.c \
+	src/voc.c \
+	src/wve.c \
+	src/w64.c \
+	src/wavlike.c \
+	src/wav.c \
+	src/xi.c \
+	src/mpc2k.c \
+	src/rf64.c \
+	src/ogg_vorbis.c \
+	src/ogg_speex.c \
+	src/ogg_pcm.c \
+	src/ogg_opus.c \
+	src/common.c \
+	src/file_io.c \
+	src/command.c \
+	src/pcm.c \
+	src/ulaw.c \
+	src/alaw.c \
+	src/float32.c \
+	src/double64.c \
+	src/ima_adpcm.c \
+	src/ms_adpcm.c \
+	src/gsm610.c \
+	src/dwvw.c \
+	src/vox_adpcm.c \
+	src/interleave.c \
+	src/strings.c \
+	src/dither.c \
+	src/cart.c \
+	src/broadcast.c \
+	src/audio_detect.c \
+	src/ima_oki_adpcm.c \
+	src/alac.c \
+	src/chunk.c \
+	src/ogg.c \
+	src/chanmap.c \
+	src/windows.c \
+	src/id3.c \
+	\
+	src/GSM610/add.c \
+	src/GSM610/code.c \
+	src/GSM610/decode.c \
+	src/GSM610/gsm_create.c \
+	src/GSM610/gsm_decode.c \
+	src/GSM610/gsm_destroy.c \
+	src/GSM610/gsm_encode.c \
+	src/GSM610/gsm_option.c \
+	src/GSM610/long_term.c \
+	src/GSM610/lpc.c \
+	src/GSM610/preprocess.c \
+	src/GSM610/rpe.c \
+	src/GSM610/short_term.c \
+	src/GSM610/table.c \
+	\
+	src/G72x/g721.c \
+	src/G72x/g723_16.c \
+	src/G72x/g723_24.c \
+	src/G72x/g723_40.c \
+	src/G72x/g72x.c \
+	\
+	src/ALAC/ALACBitUtilities.c \
+	src/ALAC/ag_dec.c \
+	src/ALAC/ag_enc.c \
+	src/ALAC/dp_dec.c \
+	src/ALAC/dp_enc.c \
+	src/ALAC/matrix_dec.c \
+	src/ALAC/matrix_enc.c \
+	src/ALAC/alac_decoder.c \
+	src/ALAC/alac_encoder.c \
+
+LOCAL_SRC_FILES		:= \
+	$(FLAC_SRC) \
+	$(OGG_SRC) \
+	$(VORBIS_SRC) \
+	$(SNDFILE_SRC) \
+
+include $(BUILD_STATIC_LIBRARY)

Classes/libsndfile/src/ALAC/ALACAudioTypes.h

+/*
+ * 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
+
+/* Force these Mac OS specific things to zero. */
+#define PRAGMA_STRUCT_ALIGN 0
+#define PRAGMA_STRUCT_PACKPUSH 0
+#define PRAGMA_STRUCT_PACK 0
+#define PRAGMA_ONCE 0
+#define PRAGMA_MARK 0
+
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#include "sfendian.h"
+
+#if CPU_IS_BIG_ENDIAN == 1
+#define TARGET_RT_BIG_ENDIAN 1
+#else
+#define TARGET_RT_BIG_ENDIAN 0
+#endif
+
+#define kChannelAtomSize 12
+
+enum
+{
+	kALAC_UnimplementedError	= -4,
+	kALAC_FileNotFoundError		= -43,
+	kALAC_ParamError			= -50,
+	kALAC_MemFullError			= -108,
+	fALAC_FrameLengthError		= -666,
+
+	/* Add for libsndfile */
+	kALAC_BadBitWidth			= -0x100000,
+	kALAC_IncompatibleVersion	= -0x100001,
+	kALAC_BadSpecificConfigSize	= -0x100002,
+	kALAC_ZeroChannelCount		= -0x100003,
+	kALAC_NumSamplesTooBig		= -0x100004,
+	kALAC_UnsupportedElement	= -0x100005,
+} ;
+
+enum
+{
+	kALACFormatAppleLossless = MAKE_MARKER ('a', 'l', 'a', 'c'),
+	kALACFormatLinearPCM = MAKE_MARKER ('l', 'p', 'c', 'm')
+} ;
+
+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		= MAKE_MARKER ('a', 'l', 'a', 'c'),
+	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 = MAKE_MARKER ('c', 'h', 'a', 'n')
+} ;
+
+#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 */

Classes/libsndfile/src/ALAC/ALACBitUtilities.c

+/*
+ * 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"
+
+#define PRAGMA_MARK 0
+
+// 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 != NULL, 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

Classes/libsndfile/src/ALAC/ALACBitUtilities.h

+/*
+ * 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
+
+#define RequireAction(condition, action)		if (! (condition)) { action }
+#define RequireActionSilent(condition, action)	if (! (condition)) { action }
+#define RequireNoErr(condition, action)			if (condition) { action }
+
+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) ;
+
+#endif	/* __BITUTILITIES_H */

Classes/libsndfile/src/ALAC/ALACDecoder.h

+/*
+ * 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
+
+#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 */

Classes/libsndfile/src/ALAC/ALACEncoder.h

+/*
+ * 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 ;
+} ;

Classes/libsndfile/src/ALAC/EndianPortable.h

+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+** Copyright (C) 2013-2014 Erik de Castro Lopo <erikd@mega-nerd.com>
+ *
+ * @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 <sfendian.h>
+
+#define Swap16NtoB(x)	H2BE_16 (x)
+#define Swap16BtoN(x)	BE2H_16 (x)
+
+#define Swap32NtoB(x)	H2BE_32 (x)
+#define Swap32BtoN(x)	BE2H_32 (x)
+
+#endif

Classes/libsndfile/src/ALAC/ag_dec.c

+/*
+ * 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 <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "aglib.h"
+#include "ALACBitUtilities.h"
+#include "ALACAudioTypes.h"
+
+#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 != NULL) && (pc != NULL) && (outNumBits != NULL), 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 < (uint32_t) 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 = - (int) (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 < (uint32_t) 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 <= (uint32_t) 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 ;
+}

Classes/libsndfile/src/ALAC/ag_enc.c

+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2014 Erik de Castro Lopo <erikd@mega-nerd.com>
+ *
+ * @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>
+
+#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 ;
+}
+
+#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 	divx, mod, de ;
+	uint32_t	numBits ;
+	uint32_t	value ;
+
+	// Assert (n >= 0) ;
+
+	divx = n / m ;
+
+	if (divx >= 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 = divx + k + 1 - de ;
+		value = (((1 << divx) - 1) << (numBits - divx)) + 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 	divx, mod, de ;
+	uint32_t	numBits ;
+	uint32_t	value ;
+	int32_t			didOverflow = 0 ;
+
+	divx = n / m ;
+
+	if (divx < MAX_PREFIX_32)
+	{
+		mod = n - (m * divx) ;
+
+		de = (mod == 0) ;
+		numBits = divx + k + 1 - de ;
+		value = (((1 << divx) - 1) << (numBits - divx)) + 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	mask ;
+	uint32_t	curr ;
+	uint32_t	shift ;
+
+	//Assert (numBits <= 32) ;
+
+	curr = psf_get_be32 (out, bitPos >> 3) ;
+
+	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 ;
+
+	psf_put_be32 (out, bitPos >> 3, value) ;
+}
+
+
+static inline void ALWAYS_INLINE dyn_jam_noDeref_large (unsigned char *out, uint32_t bitPos, uint32_t numBits, uint32_t value)
+{
+	uint32_t	w ;
+	uint32_t	curr ;
+	uint32_t	mask ;
+	int32_t		shiftvalue = (32 - (bitPos & 7) - numBits) ;
+
+	//Assert (numBits <= 32) ;
+
+	curr = psf_get_be32 (out, bitPos >> 3) ;
+
+	if (shiftvalue < 0)
+	{
+		uint8_t 	tailbyte ;
+		uint8_t 	*tailptr ;
+
+		w = value >> -shiftvalue ;
+		mask = ~0u >> -shiftvalue ;
+		w |= (curr & ~mask) ;
+
+		tailptr = out + (bitPos >> 3) + 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 ;
+	}
+
+	psf_put_be32 (out, bitPos >> 3, 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 < (uint32_t) 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 <= (uint32_t) numSamples, status = kALAC_ParamError ; goto Exit ;) ;
+
+		if (((mb << MMULSHIFT) < QB) && (c < (uint32_t) numSamples))
+		{
+			zmode = 1 ;
+			nz = 0 ;
+
+			while (c < (uint32_t) 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 ;
+}

Classes/libsndfile/src/ALAC/aglib.h

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

Classes/libsndfile/src/ALAC/alac_codec.h

+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2014 Erik de Castro Lopo <erikd@mega-nerd.com>
+ *
+ * @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:		alac_codec.h
+*/
+
+#ifndef ALAC_CODEC_H
+#define ALAC_CODEC_H
+
+#include <stdint.h>
+
+#include "ALACAudioTypes.h"
+
+#define		ALAC_FRAME_LENGTH	4096
+
+struct BitBuffer ;
+
+typedef struct alac_decoder_s
+{
+	// decoding parameters (public for use in the analyzer)
+	ALACSpecificConfig		mConfig ;
+
+	uint16_t				mActiveElements ;
+
+	// decoding buffers
+	int32_t				mMixBufferU [ALAC_FRAME_LENGTH] ;
+	int32_t				mMixBufferV [ALAC_FRAME_LENGTH] ;
+	union
+	{
+		int32_t			mPredictor [ALAC_FRAME_LENGTH] ;
+		uint16_t		mShiftBuffer [ALAC_FRAME_LENGTH] ;
+	} ;
+	uint32_t			mNumChannels ;
+} ALAC_DECODER ;
+
+typedef struct alac_encoder_s
+{
+	// ALAC encoder parameters
+	int16_t			mBitDepth ;
+
+	// encoding state
+	int16_t			mLastMixRes [kALACMaxChannels] ;
+
+	int32_t			mFastMode ;
+
+	// encoding buffers
+	int32_t			mMixBufferU [ALAC_FRAME_LENGTH] ;
+	int32_t			mMixBufferV [ALAC_FRAME_LENGTH] ;
+	int32_t			mPredictorU [ALAC_FRAME_LENGTH] ;
+	int32_t			mPredictorV [ALAC_FRAME_LENGTH] ;
+	uint16_t		mShiftBufferUV [2 * ALAC_FRAME_LENGTH] ;
+	uint8_t			mWorkBuffer [4 * ALAC_FRAME_LENGTH] ;
+
+	// 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 ;
+} ALAC_ENCODER ;
+
+
+int32_t	alac_decoder_init (ALAC_DECODER *p, void * inMagicCookie, uint32_t inMagicCookieSize) ;
+int32_t alac_encoder_init (ALAC_ENCODER *p, uint32_t samplerate, uint32_t channels, uint32_t format_flags, uint32_t frameSize) ;
+
+int32_t	alac_decode (ALAC_DECODER *, struct BitBuffer * bits, int32_t * sampleBuffer,
+					uint32_t numSamples, uint32_t * outNumSamples) ;
+
+int32_t	alac_encode (ALAC_ENCODER *p, uint32_t numSamples,
+					const int32_t * theReadBuffer, unsigned char * theWriteBuffer,
+					uint32_t * ioNumBytes) ;
+
+void alac_set_fastmode (ALAC_ENCODER * p, int32_t fast) ;
+
+uint32_t alac_get_magic_cookie_size (uint32_t inNumChannels) ;
+void	alac_get_magic_cookie (ALAC_ENCODER *p, void * config, uint32_t * ioSize) ;
+void	alac_get_source_format (ALAC_ENCODER *p, const AudioFormatDescription * source, AudioFormatDescription * output) ;
+
+#endif

Classes/libsndfile/src/ALAC/alac_decoder.h

+/*
+ * 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:		alac_decoder.h
+*/
+
+#ifndef ALAC_DECODER_H
+#define ALAC_DECODER_H
+
+#include <stdint.h>
+
+#include "ALACAudioTypes.h"
+
+typedef enum
+{
+	false = 0,
+	ALAC_TRUE = 1
+} bool ;
+
+struct BitBuffer ;
+
+typedef struct alac_decoder
+{
+		// decoding parameters (public for use in the analyzer)
+		ALACSpecificConfig		mConfig ;
+
+		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
+} alac_decoder ;
+
+alac_decoder * alac_decoder_new (void) ;
+void alac_decoder_delete (alac_decoder *) ;
+
+int32_t	alac_init (alac_decoder *p, void * inMagicCookie, uint32_t inMagicCookieSize) ;
+int32_t	alac_decode (alac_decoder *, struct BitBuffer * bits, uint8_t * sampleBuffer, uint32_t numSamples, uint32_t numChannels, uint32_t * outNumSamples) ;
+
+#endif	/* ALAC_DECODER_H */

Classes/libsndfile/src/ALAC/dplib.h

+/*
+ * 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 (const 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 (const 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__ */

Classes/libsndfile/src/ALAC/matrixlib.h

+/*
+ * Copyright (c) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2014 Erik de Castro Lopo <erikd@mega-nerd.com>
+ *
+ * @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 (const int32_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres) ;
+void	unmix16 (const int32_t * u, int32_t * v, int32_t * out, uint32_t stride, int32_t numSamples, int32_t mixbits, int32_t mixres) ;
+
+// 20-bit routines
+void	mix20 (const int32_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres) ;
+void	unmix20 (const int32_t * u, int32_t * v, int32_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 (const 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	unmix24 (const 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) ;
+
+// 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 (const 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 (const 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 (const int32_t * in, uint32_t stride, int32_t * out, int32_t numSamples) ;
+void	copy24ToPredictor (const int32_t * in, uint32_t stride, int32_t * out, int32_t numSamples) ;
+
+void	copyPredictorTo24 (const int32_t * in, int32_t * out, uint32_t stride, int32_t numSamples) ;
+void	copyPredictorTo24Shift (const int32_t * in, uint16_t * shift, int32_t * out, uint32_t stride, int32_t numSamples, int32_t bytesShifted) ;
+void	copyPredictorTo20 (const int32_t * in, int32_t * out, uint32_t stride, int32_t numSamples) ;
+
+void	copyPredictorTo32 (const int32_t * in, int32_t * out, uint32_t stride, int32_t numSamples) ;
+void	copyPredictorTo32Shift (const int32_t * in, uint16_t * shift, int32_t * out, uint32_t stride, int32_t numSamples, int32_t bytesShifted) ;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* __MATRIXLIB_H */

Classes/libsndfile/src/ALAC/shift.h

+/*
+** Copyright (C) 2014 Erik de Castro Lopo <erikd@mega-nerd.com>
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation; either version 2.1 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#if __GNUC__
+#define ALWAYS_INLINE		__attribute__ ((always_inline))
+#else
+#define ALWAYS_INLINE
+#endif
+
+
+static inline int32_t ALWAYS_INLINE
+arith_shift_left (int32_t x, int shift)
+{	return (int32_t) (((uint32_t) x) << shift) ;
+} /* arith_shift_left */

Classes/libsndfile/src/G72x/g72x.h

+/*
+** Copyright (C) 1999-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation; either version 2.1 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+/*
+** This file is not the same as the original file from Sun Microsystems. Nearly
+** all the original definitions and function prototypes that were in the file
+** of this name have been moved to g72x_priv.h.
+*/
+
+#ifndef G72X_HEADER_FILE
+#define	G72X_HEADER_FILE
+
+/*
+** Number of samples per block to process.
+** Must be a common multiple of possible bits per sample : 2, 3, 4, 5 and 8.
+*/
+#define	G72x_BLOCK_SIZE		(3 * 5 * 8)
+
+/*
+**	Identifiers for the differing kinds of G72x ADPCM codecs.
+**	The identifiers also define the number of encoded bits per sample.
+*/
+
+enum
+{	G723_16_BITS_PER_SAMPLE = 2,
+	G723_24_BITS_PER_SAMPLE = 3,
+	G723_40_BITS_PER_SAMPLE = 5,
+
+	G721_32_BITS_PER_SAMPLE = 4,
+	G721_40_BITS_PER_SAMPLE = 5,
+
+	G723_16_SAMPLES_PER_BLOCK = G72x_BLOCK_SIZE,
+	G723_24_SAMPLES_PER_BLOCK = G723_24_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G723_24_BITS_PER_SAMPLE),
+	G723_40_SAMPLES_PER_BLOCK = G723_40_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G723_40_BITS_PER_SAMPLE),
+
+	G721_32_SAMPLES_PER_BLOCK = G72x_BLOCK_SIZE,
+	G721_40_SAMPLES_PER_BLOCK = G721_40_BITS_PER_SAMPLE * (G72x_BLOCK_SIZE / G721_40_BITS_PER_SAMPLE),
+
+	G723_16_BYTES_PER_BLOCK = (G723_16_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8,
+	G723_24_BYTES_PER_BLOCK = (G723_24_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8,
+	G723_40_BYTES_PER_BLOCK = (G723_40_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8,
+
+	G721_32_BYTES_PER_BLOCK = (G721_32_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8,
+	G721_40_BYTES_PER_BLOCK = (G721_40_BITS_PER_SAMPLE * G72x_BLOCK_SIZE) / 8
+} ;
+
+/* Forward declaration of of g72x_state. */
+
+struct g72x_state ;
+
+/* External function definitions. */
+
+struct g72x_state * g72x_reader_init (int codec, int *blocksize, int *samplesperblock) ;
+struct g72x_state * g72x_writer_init (int codec, int *blocksize, int *samplesperblock) ;
+/*
+**	Initialize the ADPCM state table for the given codec.
+**	Return 0 on success, 1 on fail.
+*/
+
+int g72x_decode_block (struct g72x_state *pstate, const unsigned char *block, short *samples) ;
+/*
+**	The caller fills data->block with data->bytes bytes before calling the
+**	function. The value data->bytes must be an integer multiple of
+**	data->blocksize and be <= data->max_bytes.
+**	When it returns, the caller can read out data->samples samples.
+*/
+
+int g72x_encode_block (struct g72x_state *pstate, short *samples, unsigned char *block) ;
+/*
+**	The caller fills state->samples some integer multiple data->samples_per_block
+**	(up to G72x_BLOCK_SIZE) samples before calling the function.
+**	When it returns, the caller can read out bytes encoded bytes.
+*/
+
+#endif /* !G72X_HEADER_FILE */
+