react-native-queue-player 1.0.0

package/android/src/main/cpp/stretch_jni.cpp

@@ -0,0 +1,171 @@
+// JNI bridge for Signalsmith Stretch — the Android "music" pitch-correction
+// time-stretch engine. Wraps a per-instance SignalsmithStretch<float>,
+// converting between Media3's interleaved float PCM and Signalsmith's planar
+// per-channel buffers. One native instance per AudioProcessor (per crossfade
+// leg). Pure DSP — no Android framework deps beyond JNI + __android_log.
+//
+// Stretch ratio is set per process() call by the input/output frame counts
+// (Signalsmith has no ratio setter): outputFrames/inputFrames == time-stretch.
+
+#include <jni.h>
+#include <android/log.h>
+#include <vector>
+#include <cstring>
+#include "signalsmith-stretch.h"
+
+#define LOG_TAG "RNQP-Stretch"
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+namespace {
+
+struct StretchHandle {
+  signalsmith::stretch::SignalsmithStretch<float> stretch;
+  int channels = 2;
+  // Planar scratch — inputs[ch] / outputs[ch] pointers handed to process().
+  std::vector<std::vector<float>> planarIn;
+  std::vector<std::vector<float>> planarOut;
+  std::vector<float *> inPtrs;
+  std::vector<float *> outPtrs;
+
+  void ensureCapacity(int inFrames, int outFrames) {
+    for (int c = 0; c < channels; ++c) {
+      if ((int)planarIn[c].size() < inFrames) planarIn[c].resize(inFrames);
+      if ((int)planarOut[c].size() < outFrames) planarOut[c].resize(outFrames);
+      inPtrs[c] = planarIn[c].data();
+      outPtrs[c] = planarOut[c].data();
+    }
+  }
+};
+
+inline StretchHandle *fromHandle(jlong h) {
+  return reinterpret_cast<StretchHandle *>(h);
+}
+
+}  // namespace
+
+extern "C" {
+
+// Returns an opaque handle, or 0 on failure (invalid channels / allocation
+// error). The Kotlin binding turns a 0 handle into a thrown error.
+JNIEXPORT jlong JNICALL
+Java_com_margelo_nitro_queueplayer_SignalsmithStretchNative_nativeCreate(
+    JNIEnv *, jclass, jint channels, jfloat sampleRate, jboolean splitComputation) {
+  if (channels <= 0) {
+    LOGE("nativeCreate: invalid channels=%d", channels);
+    return 0;
+  }
+  try {
+    auto *h = new StretchHandle();
+    h->channels = channels;
+    h->planarIn.assign(channels, {});
+    h->planarOut.assign(channels, {});
+    h->inPtrs.assign(channels, nullptr);
+    h->outPtrs.assign(channels, nullptr);
+    // presetDefault = the music-grade quality preset; splitComputation spreads
+    // the FFT work across calls to avoid per-callback CPU spikes.
+    h->stretch.presetDefault(channels, sampleRate, splitComputation == JNI_TRUE);
+    h->stretch.reset();
+    return reinterpret_cast<jlong>(h);
+  } catch (const std::exception &e) {
+    LOGE("nativeCreate: %s", e.what());
+    return 0;
+  }
+}
+
+// True if `buf`'s direct capacity holds at least `frames * ch` floats from its
+// start. GetDirectBufferAddress points at offset 0, so callers must hand
+// buffers whose interleaved data begins at position 0.
+inline bool hasCapacity(JNIEnv *env, jobject buf, int frames, int ch) {
+  const jlong needBytes = static_cast<jlong>(frames) * ch * sizeof(float);
+  return env->GetDirectBufferCapacity(buf) >= needBytes;
+}
+
+// Process `inFrames` interleaved float frames from `inBuf` and write exactly
+// `outFrames` interleaved float frames to `outBuf`. Both are direct
+// ByteBuffers (native byte order) whose data starts at offset 0. Returns
+// frames written (== outFrames), or 0 on any validation failure.
+JNIEXPORT jint JNICALL
+Java_com_margelo_nitro_queueplayer_SignalsmithStretchNative_nativeProcess(
+    JNIEnv *env, jclass, jlong handle, jobject inBuf, jint inFrames,
+    jobject outBuf, jint outFrames) {
+  auto *h = fromHandle(handle);
+  if (h == nullptr || inFrames < 0 || outFrames <= 0) return 0;
+  auto *in = static_cast<float *>(env->GetDirectBufferAddress(inBuf));
+  auto *out = static_cast<float *>(env->GetDirectBufferAddress(outBuf));
+  if (in == nullptr || out == nullptr) {
+    LOGE("nativeProcess: null direct buffer address");
+    return 0;
+  }
+  const int ch = h->channels;
+  if (!hasCapacity(env, inBuf, inFrames, ch) ||
+      !hasCapacity(env, outBuf, outFrames, ch)) {
+    LOGE("nativeProcess: buffer too small for %d ch (in=%d out=%d frames)", ch,
+         inFrames, outFrames);
+    return 0;
+  }
+  try {
+    h->ensureCapacity(inFrames, outFrames);
+    // De-interleave input -> planar.
+    for (int i = 0; i < inFrames; ++i) {
+      for (int c = 0; c < ch; ++c) h->planarIn[c][i] = in[i * ch + c];
+    }
+    h->stretch.process(h->inPtrs.data(), inFrames, h->outPtrs.data(), outFrames);
+    // Re-interleave planar -> output.
+    for (int i = 0; i < outFrames; ++i) {
+      for (int c = 0; c < ch; ++c) out[i * ch + c] = h->planarOut[c][i];
+    }
+    return outFrames;
+  } catch (const std::exception &e) {
+    LOGE("nativeProcess: %s", e.what());
+    return 0;
+  }
+}
+
+// Drain the stretcher's internal tail (output latency) at end-of-stream into
+// `outBuf`; returns frames written. Mirrors process() interleaving.
+JNIEXPORT jint JNICALL
+Java_com_margelo_nitro_queueplayer_SignalsmithStretchNative_nativeFlush(
+    JNIEnv *env, jclass, jlong handle, jobject outBuf, jint outFrames) {
+  auto *h = fromHandle(handle);
+  if (h == nullptr || outFrames <= 0) return 0;
+  auto *out = static_cast<float *>(env->GetDirectBufferAddress(outBuf));
+  if (out == nullptr) return 0;
+  const int ch = h->channels;
+  if (!hasCapacity(env, outBuf, outFrames, ch)) {
+    LOGE("nativeFlush: buffer too small for %d ch (out=%d frames)", ch, outFrames);
+    return 0;
+  }
+  try {
+    h->ensureCapacity(0, outFrames);
+    h->stretch.flush(h->outPtrs.data(), outFrames);
+    for (int i = 0; i < outFrames; ++i) {
+      for (int c = 0; c < ch; ++c) out[i * ch + c] = h->planarOut[c][i];
+    }
+    return outFrames;
+  } catch (const std::exception &e) {
+    LOGE("nativeFlush: %s", e.what());
+    return 0;
+  }
+}
+
+JNIEXPORT jint JNICALL
+Java_com_margelo_nitro_queueplayer_SignalsmithStretchNative_nativeOutputLatency(
+    JNIEnv *, jclass, jlong handle) {
+  auto *h = fromHandle(handle);
+  return h == nullptr ? 0 : static_cast<jint>(h->stretch.outputLatency());
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_queueplayer_SignalsmithStretchNative_nativeReset(
+    JNIEnv *, jclass, jlong handle) {
+  auto *h = fromHandle(handle);
+  if (h != nullptr) h->stretch.reset();
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_queueplayer_SignalsmithStretchNative_nativeDestroy(
+    JNIEnv *, jclass, jlong handle) {
+  delete fromHandle(handle);
+}
+
+}  // extern "C"

package/android/src/main/cpp/third_party/alac/addons/alac_wrapper.cpp

@@ -0,0 +1,198 @@
+/*****************************************************************************
+ * audio_stream.c: audio file stream
+ *
+ * Copyright (C) 2005 Shiro Ninomiya <shiron@snino.com>
+ *				 2016 Philippe <philippe_44@outlook.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ALACEncoder.h"
+#include "ALACDecoder.h"
+#include "ALACBitUtilities.h"
+
+#include "alac_wrapper.h"
+
+#include <atomic>
+
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+
+typedef struct alac_codec_s {
+	AudioFormatDescription inputFormat, outputFormat;
+	ALACEncoder *encoder;
+	ALACDecoder *Decoder;
+	unsigned block_size, frames_per_packet;
+} alac_codec_t;
+
+/*----------------------------------------------------------------------------*/
+extern "C" struct alac_codec_s *alac_create_decoder(int magic_cookie_size, unsigned char *magic_cookie,
+											unsigned char *sample_size, unsigned *sample_rate,
+											unsigned char *channels, unsigned int *block_size) {
+	struct alac_codec_s *codec = (struct alac_codec_s*) malloc(sizeof(struct alac_codec_s));
+
+	codec->Decoder = new ALACDecoder;
+	codec->Decoder->Init(magic_cookie, magic_cookie_size);
+
+	*channels = codec->Decoder->mConfig.numChannels;
+	*sample_rate = codec->Decoder->mConfig.sampleRate;
+	*sample_size = codec->Decoder->mConfig.bitDepth;
+
+	codec->frames_per_packet = codec->Decoder->mConfig.frameLength;
+	*block_size = codec->block_size = codec->frames_per_packet * (*channels) * (*sample_size) / 8;
+
+	return codec;
+}
+
+/*----------------------------------------------------------------------------*/
+extern "C" void alac_delete_decoder(struct alac_codec_s *codec) {
+	delete (ALACDecoder*) codec->Decoder;
+	free(codec);
+}
+
+/*----------------------------------------------------------------------------*/
+
+extern "C" bool alac_to_pcm(struct alac_codec_s *codec, unsigned char* input,
+							unsigned char *output, char channels, unsigned *out_frames) {
+	BitBuffer input_buffer;
+
+	BitBufferInit(&input_buffer, input, codec->block_size);
+	return codec->Decoder->Decode(&input_buffer, output, codec->frames_per_packet, channels, out_frames) == ALAC_noErr;
+
+}
+
+/*----------------------------------------------------------------------------*/
+// assumes stereo and little endian
+extern "C" bool pcm_to_alac_raw(uint8_t *sample, int frames, uint8_t **out, int *size, int bsize) {
+	uint8_t *p;
+	uint32_t *in = (uint32_t*) sample;
+	int count;
+
+	frames = min(frames, bsize);
+
+	*out = (uint8_t*) malloc(bsize * 4 + 16);
+	p = *out;
+
+	*p++ = (1 << 5);
+	*p++ = 0;
+	*p++ = (1 << 4) | (1 << 1) | ((bsize & 0x80000000) >> 31); // b31
+	*p++ = ((bsize & 0x7f800000) << 1) >> 24;	// b30--b23
+	*p++ = ((bsize & 0x007f8000) << 1) >> 16;	// b22--b15
+	*p++ = ((bsize & 0x00007f80) << 1) >> 8;	// b14--b7
+	*p =   ((bsize & 0x0000007f) << 1);       	// b6--b0
+	*p++ |= (*in &  0x00008000) >> 15;			// LB1 b7
+
+	count = frames - 1;
+
+	while (count--) {
+		// LB1 b6--b0 + LB0 b7
+		*p++ = ((*in & 0x00007f80) >> 7);
+		// LB0 b6--b0 + RB1 b7
+		*p++ = ((*in & 0x0000007f) << 1) | ((*in & 0x80000000) >> 31);
+		// RB1 b6--b0 + RB0 b7
+		*p++ = ((*in & 0x7f800000) >> 23);
+		// RB0 b6--b0 + next LB1 b7
+		*p++ = ((*in & 0x007f0000) >> 15) | ((*(in + 1) & 0x00008000) >> 15);
+
+		in++;
+	}
+
+	// last sample
+	// LB1 b6--b0 + LB0 b7
+	*p++ = ((*in & 0x00007f80) >> 7);
+	// LB0 b6--b0 + RB1 b7
+	*p++ = ((*in & 0x0000007f) << 1) | ((*in & 0x80000000) >> 31);
+	// RB1 b6--b0 + RB0 b7
+	*p++ = ((*in & 0x7f800000) >> 23);
+	// RB0 b6--b0 + next LB1 b7
+	*p++ = ((*in & 0x007f0000) >> 15);
+
+	// when readable size is less than bsize, fill 0 at the bottom
+	count = (bsize - frames) * 4;
+	while (count--)	*p++ = 0;
+
+	// frame footer ??
+	*(p-1) |= 1;
+	*p = (7 >> 1) << 6;
+
+	*size = p - *out + 1;
+
+	return true;
+}
+
+/*----------------------------------------------------------------------------*/
+// assumes stereo and little endian
+extern "C" bool pcm_to_alac(struct alac_codec_s *codec, uint8_t *in, int frames, uint8_t **out, int *size) {
+	/* for the forgetful, ALACEncode::Encode wants the number of actual bytes in input but it has
+	 *a internal bug where it might use more. So we allocate twice the maximum size. In addition, 
+	 * the buffer needs to be zero'd */
+	*size = frames * codec->inputFormat.mBytesPerFrame;
+	*out = (uint8_t*) calloc(2 * codec->outputFormat.mFramesPerPacket * codec->inputFormat.mBytesPerFrame + kALACMaxEscapeHeaderBytes, 1);
+	return !codec->encoder->Encode(codec->inputFormat, codec->outputFormat, in, *out, size);
+}
+
+#define kTestFormatFlag_16BitSourceData 1
+
+/*----------------------------------------------------------------------------*/
+extern "C" struct alac_codec_s *alac_create_encoder(int max_frames, int sample_rate, int sample_size, int channels) {
+	alac_codec_t *codec;
+
+	if ((codec = (alac_codec_t*) malloc(sizeof(alac_codec_t))) == NULL) return NULL;
+
+	if ((codec->encoder = new ALACEncoder) == NULL) {
+		free(codec);
+		return NULL;
+	}
+
+	// input format is pretty much dictated
+	codec->inputFormat.mFormatID = kALACFormatLinearPCM;
+	codec->inputFormat.mSampleRate = sample_rate;
+	codec->inputFormat.mBitsPerChannel = sample_size;
+	codec->inputFormat.mFramesPerPacket = 1;
+	codec->inputFormat.mChannelsPerFrame = channels;
+	codec->inputFormat.mBytesPerFrame = codec->inputFormat.mChannelsPerFrame * codec->inputFormat.mFramesPerPacket * (codec->inputFormat.mBitsPerChannel / 8);
+	codec->inputFormat.mBytesPerPacket = codec->inputFormat.mBytesPerFrame * codec->inputFormat.mFramesPerPacket;
+	codec->inputFormat.mFormatFlags = kALACFormatFlagsNativeEndian | kALACFormatFlagIsSignedInteger; // expect signed native-endian data
+	codec->inputFormat.mReserved = 0;
+
+	// and so is the output format
+	codec->outputFormat.mFormatID = kALACFormatAppleLossless;
+	codec->outputFormat.mSampleRate = codec->inputFormat.mSampleRate;
+	codec->outputFormat.mFormatFlags = kTestFormatFlag_16BitSourceData;
+	codec->outputFormat.mFramesPerPacket = max_frames;
+	codec->outputFormat.mChannelsPerFrame = codec->inputFormat.mChannelsPerFrame;
+	codec->outputFormat.mBytesPerPacket = 0; // we're VBR
+	codec->outputFormat.mBytesPerFrame = 0; // same
+	codec->outputFormat.mBitsPerChannel = 0; // each bit doesn't really go with 1 sample
+	codec->outputFormat.mReserved = 0;
+
+	codec->encoder->SetFrameSize(codec->outputFormat.mFramesPerPacket);
+	codec->encoder->SetFastMode(true);
+	codec->encoder->InitializeEncoder(codec->outputFormat);
+
+	return codec;
+}
+
+/*----------------------------------------------------------------------------*/
+extern "C" void alac_delete_encoder(struct alac_codec_s *codec) {
+	delete codec->encoder;
+	free(codec);
+}
+
+
+

package/android/src/main/cpp/third_party/alac/addons/alac_wrapper.h

@@ -0,0 +1,46 @@
+/*****************************************************************************
+ * audio_stream.h: audio file stream, header file
+ *
+ * Copyright (C) 2016 Philippe <philippe44@outlook.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+#ifndef __ALAC_WRAPPER_H_
+#define __ALAC_WRAPPER_H_
+
+struct alac_codec_s;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ALAC_MAX_FRAMES	4096
+
+struct alac_codec_s *alac_create_decoder(int magic_cookie_size, uint8_t *magic_cookie,
+								uint8_t *sample_size, unsigned *sample_rate,
+								uint8_t *channels, unsigned int *block_size);
+void alac_delete_decoder(struct alac_codec_s *codec);
+bool alac_to_pcm(struct alac_codec_s *codec, uint8_t* input,
+				 uint8_t *output, char channels, unsigned *out_frames);
+
+bool pcm_to_alac(struct alac_codec_s *codec, uint8_t *in, int frames, uint8_t **out, int *size);
+bool pcm_to_alac_raw(uint8_t *in, int frames, uint8_t **out, int *size, int bsize);
+struct alac_codec_s *alac_create_encoder(int max_frames, int sample_rate, int sample_size, int channels);
+void alac_delete_encoder(struct alac_codec_s *codec);
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/android/src/main/cpp/third_party/alac/codec/ALACAudioTypes.h

@@ -0,0 +1,197 @@
+/*
+ * 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
+    
+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'
+};
+
+#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 */