Merge pull request 'Preliminary ALAC support' (#416) from ayumi/tangara-fw:alac into main

Reviewed-on: https://codeberg.org/cool-tech-zone/tangara-fw/pulls/416

19 files changed, 1805 insertions, 7 deletions

diff --git a/lib/alac/CMakeLists.txt b/lib/alac/CMakeLists.txt
new file mode 100644
index 00000000..9c99ad88
--- /dev/null
+++ b/lib/alac/CMakeLists.txt
@@ -0,0 +1,4 @@
+idf_component_register(
+  SRCS alac.c
+  INCLUDE_DIRS .
+)
diff --git a/lib/alac/LICENCE b/lib/alac/LICENCE
new file mode 100644
index 00000000..0e58101c
--- /dev/null
+++ b/lib/alac/LICENCE
@@ -0,0 +1,7 @@
+Copyright (c) 2004 David Hammerton.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/lib/alac/README b/lib/alac/README
new file mode 100644
index 00000000..c6026a6b
--- /dev/null
+++ b/lib/alac/README
@@ -0,0 +1,43 @@
+INSTALLATION:
+-------------
+
+Simply compile by running 'make'
+
+USAGE:
+------
+
+Then run the program, it will give you usage instructions.
+
+It's really quite trivial to use.
+
+For example, to decode input.m4a to output.wav:
+./alac -f output.wav input.m4a
+
+Or, as another example, say if you wanted to stream play
+http://www.mplayerhq.hu/MPlayer/samples/A-codecs/lossless/luckynight.m4a
+and you're system uses the ALSA sound system:
+wget -O - http://www.mplayerhq.hu/MPlayer/samples/A-codecs/lossless/luckynight.m4a | ./alac - | aplay
+
+By default the output file is in WAV format. To output as raw PCM, provide the
+-r option on the command line.
+
+MORE INFORMATION:
+-----------------
+
+Please visit http://crazney.net/programs/itunes/alac.html for more information.
+
+HELP NEEDED:
+------------
+I need help to allow myself to continue hacking on various Apple Audio things, please visit
+http://crazney.net/programs/itunes/help.html
+
+AUTHOR:
+-------
+
+David Hammerton
+
+CONTRIBUTORS:
+-------------
+
+Serafina Brocious
+
diff --git a/lib/alac/alac.c b/lib/alac/alac.c
new file mode 100644
index 00000000..a1b22943
--- /dev/null
+++ b/lib/alac/alac.c
@@ -0,0 +1,976 @@
+/*
+ * ALAC (Apple Lossless Audio Codec) decoder
+ * Copyright (c) 2005 David Hammerton
+ * All rights reserved.
+ *
+ * This is the actual decoder.
+ *
+ * http://crazney.net/programs/itunes/alac.html
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+	#include "stdint_win.h"
+#else
+	#include <stdint.h>
+#endif
+
+#include "decomp.h"
+#include "esp_log.h"
+
+static const char *TAG = "alac_decoder";
+
+struct {signed int x:24;} se_struct_24;
+#define SignExtend24(val) (se_struct_24.x = val)
+
+void alac_set_info(alac_file *alac, char *inputbuffer)
+{
+	char *ptr = inputbuffer;
+	alac->setinfo_max_samples_per_frame = __builtin_bswap32(*(uint32_t*)ptr); /* buffer size / 2 ? */
+	ptr += 4;
+	alac->setinfo_7a = *(uint8_t*)ptr;
+	ptr += 1;
+	alac->setinfo_sample_size = *(uint8_t*)ptr;
+	ptr += 1;
+	alac->setinfo_rice_historymult = *(uint8_t*)ptr;
+	ptr += 1;
+	alac->setinfo_rice_initialhistory = *(uint8_t*)ptr;
+	ptr += 1;
+	alac->setinfo_rice_kmodifier = *(uint8_t*)ptr;
+	ptr += 1;
+	alac->setinfo_7f = *(uint8_t*)ptr;
+	ptr += 1;
+	alac->setinfo_80 = __builtin_bswap16(*(uint16_t*)ptr);
+	ptr += 2;
+	alac->setinfo_82 = __builtin_bswap32(*(uint32_t*)ptr);
+	ptr += 4;
+	alac->setinfo_86 = __builtin_bswap32(*(uint32_t*)ptr);
+	ptr += 4;
+	alac->setinfo_8a_rate = __builtin_bswap32(*(uint32_t*)ptr);
+	ptr += 4;
+
+	//allocate_buffers(alac);
+
+}
+
+/* stream reading */
+
+/* supports reading 1 to 16 bits, in big endian format */
+static uint32_t readbits_16(alac_file *alac, int bits)
+{
+	uint32_t result;
+	int new_accumulator;
+
+	result = (alac->input_buffer[0] << 16) |
+			 (alac->input_buffer[1] << 8) |
+			 (alac->input_buffer[2]);
+
+	/* shift left by the number of bits we've already read,
+	 * so that the top 'n' bits of the 24 bits we read will
+	 * be the return bits */
+	result = result << alac->input_buffer_bitaccumulator;
+
+	result = result & 0x00ffffff;
+
+	/* and then only want the top 'n' bits from that, where
+	 * n is 'bits' */
+	result = result >> (24 - bits);
+
+	new_accumulator = (alac->input_buffer_bitaccumulator + bits);
+
+	/* increase the buffer pointer if we've read over n bytes. */
+	alac->input_buffer += (new_accumulator >> 3);
+
+	/* and the remainder goes back into the bit accumulator */
+	alac->input_buffer_bitaccumulator = (new_accumulator & 7);
+
+	return result;
+}
+
+/* supports reading 1 to 32 bits, in big endian format */
+static uint32_t readbits(alac_file *alac, int bits)
+{
+	int32_t result = 0;
+
+	if (bits > 16)
+	{
+		bits -= 16;
+		result = readbits_16(alac, 16) << bits;
+	}
+
+	result |= readbits_16(alac, bits);
+
+	return result;
+}
+
+/* reads a single bit */
+static int readbit(alac_file *alac)
+{
+	int result;
+	int new_accumulator;
+
+	result = alac->input_buffer[0];
+
+	result = result << alac->input_buffer_bitaccumulator;
+
+	result = result >> 7 & 1;
+
+	new_accumulator = (alac->input_buffer_bitaccumulator + 1);
+
+	alac->input_buffer += (new_accumulator / 8);
+
+	alac->input_buffer_bitaccumulator = (new_accumulator % 8);
+
+	return result;
+}
+
+static void unreadbits(alac_file *alac, int bits)
+{
+	int new_accumulator = (alac->input_buffer_bitaccumulator - bits);
+
+	alac->input_buffer += (new_accumulator >> 3);
+
+	alac->input_buffer_bitaccumulator = (new_accumulator & 7);
+	if (alac->input_buffer_bitaccumulator < 0)
+		alac->input_buffer_bitaccumulator *= -1;
+}
+
+static int count_leading_zeros(int input)
+{
+	if(input == 0)
+		return 32;
+	return __builtin_clz(input);
+}
+
+#define RICE_THRESHOLD 8 // maximum number of bits for a rice prefix.
+
+int32_t entropy_decode_value(alac_file* alac,
+							 int readSampleSize,
+							 int k,
+							 int rice_kmodifier_mask)
+{
+	int32_t x = 0; // decoded value
+
+	// read x, number of 1s before 0 represent the rice value.
+	while (x <= RICE_THRESHOLD && readbit(alac))
+	{
+		x++;
+	}
+
+	if (x > RICE_THRESHOLD)
+	{
+		// read the number from the bit stream (raw value)
+		int32_t value;
+
+		value = readbits(alac, readSampleSize);
+
+		// mask value
+		value &= (((uint32_t)0xffffffff) >> (32 - readSampleSize));
+
+		x = value;
+	}
+	else
+	{
+		if (k != 1)
+		{
+			int extraBits = readbits(alac, k);
+
+			// x = x * (2^k - 1)
+			x *= (((1 << k) - 1) & rice_kmodifier_mask);
+
+			if (extraBits > 1)
+				x += extraBits - 1;
+			else
+				unreadbits(alac, 1);
+		}
+	}
+
+	return x;
+}
+
+void entropy_rice_decode(alac_file* alac,
+						 int32_t* outputBuffer,
+						 int outputSize,
+						 int readSampleSize,
+						 int rice_initialhistory,
+						 int rice_kmodifier,
+						 int rice_historymult,
+						 int rice_kmodifier_mask)
+{
+	int outputCount;
+	int history = rice_initialhistory;
+	int signModifier = 0;
+
+	for (outputCount = 0; outputCount < outputSize; outputCount++)
+	{
+		int32_t decodedValue;
+		int32_t finalValue;
+		int32_t k;
+
+		k = 31 - rice_kmodifier - count_leading_zeros((history >> 9) + 3);
+
+		if (k < 0) k += rice_kmodifier;
+		else k = rice_kmodifier;
+
+		// note: don't use rice_kmodifier_mask here (set mask to 0xFFFFFFFF)
+		decodedValue = entropy_decode_value(alac, readSampleSize, k, 0xFFFFFFFF);
+
+		decodedValue += signModifier;
+		finalValue = (decodedValue + 1) / 2; // inc by 1 and shift out sign bit
+		if (decodedValue & 1) // the sign is stored in the low bit
+			finalValue *= -1;
+
+		outputBuffer[outputCount] = finalValue;
+
+		signModifier = 0;
+
+		// update history
+		history += (decodedValue * rice_historymult)
+				- ((history * rice_historymult) >> 9);
+
+		if (decodedValue > 0xFFFF)
+			history = 0xFFFF;
+
+		// special case, for compressed blocks of 0
+		if ((history < 128) && (outputCount + 1 < outputSize))
+		{
+			int32_t		blockSize;
+
+			signModifier = 1;
+
+			k = count_leading_zeros(history) + ((history + 16) / 64) - 24;
+
+			// note: blockSize is always 16bit
+			blockSize = entropy_decode_value(alac, 16, k, rice_kmodifier_mask);
+
+			// got blockSize 0s
+			if (blockSize > 0)
+			{
+				memset(&outputBuffer[outputCount + 1], 0, blockSize * sizeof(*outputBuffer));
+				outputCount += blockSize;
+			}
+
+			if (blockSize > 0xFFFF)
+				signModifier = 0;
+
+			history = 0;
+		}
+	}
+}
+
+#define SIGN_EXTENDED32(val, bits) ((val << (32 - bits)) >> (32 - bits))
+
+#define SIGN_ONLY(v) \
+	((v < 0) ? (-1) : \
+		((v > 0) ? (1) : \
+			(0)))
+
+static void predictor_decompress_fir_adapt(int32_t *error_buffer,
+										   int32_t *buffer_out,
+										   int output_size,
+										   int readsamplesize,
+										   int16_t *predictor_coef_table,
+										   int predictor_coef_num,
+										   int predictor_quantitization)
+{
+	int i;
+
+	/* first sample always copies */
+	*buffer_out = *error_buffer;
+
+	if (!predictor_coef_num)
+	{
+		if (output_size <= 1) return;
+		memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4);
+		return;
+	}
+
+	if (predictor_coef_num == 0x1f) /* 11111 - max value of predictor_coef_num */
+	{ /* second-best case scenario for fir decompression,
+	   * error describes a small difference from the previous sample only
+	   */
+		if (output_size <= 1) return;
+		for (i = 0; i < output_size - 1; i++)
+		{
+			int32_t prev_value;
+			int32_t error_value;
+
+			prev_value = buffer_out[i];
+			error_value = error_buffer[i+1];
+			buffer_out[i+1] = SIGN_EXTENDED32((prev_value + error_value), readsamplesize);
+		}
+		return;
+	}
+
+	/* read warm-up samples */
+	if (predictor_coef_num > 0)
+	{
+		int i;
+		for (i = 0; i < predictor_coef_num; i++)
+		{
+			int32_t val;
+
+			val = buffer_out[i] + error_buffer[i+1];
+
+			val = SIGN_EXTENDED32(val, readsamplesize);
+
+			buffer_out[i+1] = val;
+		}
+	}
+
+#if 0
+	/* 4 and 8 are very common cases (the only ones i've seen). these
+	 * should be unrolled and optimised
+	 */
+	if (predictor_coef_num == 4)
+	{
+		/* FIXME: optimised general case */
+		return;
+	}
+
+	if (predictor_coef_table == 8)
+	{
+		/* FIXME: optimised general case */
+		return;
+	}
+#endif
+
+	/* general case */
+	if (predictor_coef_num > 0)
+	{
+		for (i = predictor_coef_num + 1;
+			 i < output_size;
+			 i++)
+		{
+			int j;
+			int sum = 0;
+			int outval;
+			int error_val = error_buffer[i];
+
+			for (j = 0; j < predictor_coef_num; j++)
+			{
+				sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) *
+					   predictor_coef_table[j];
+			}
+
+			outval = (1 << (predictor_quantitization-1)) + sum;
+			outval = outval >> predictor_quantitization;
+			outval = outval + buffer_out[0] + error_val;
+			outval = SIGN_EXTENDED32(outval, readsamplesize);
+
+			buffer_out[predictor_coef_num+1] = outval;
+
+			if (error_val > 0)
+			{
+				int predictor_num = predictor_coef_num - 1;
+
+				while (predictor_num >= 0 && error_val > 0)
+				{
+					int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
+					int sign = SIGN_ONLY(val);
+
+					predictor_coef_table[predictor_num] -= sign;
+
+					val *= sign; /* absolute value */
+
+					error_val -= ((val >> predictor_quantitization) *
+								  (predictor_coef_num - predictor_num));
+
+					predictor_num--;
+				}
+			}
+			else if (error_val < 0)
+			{
+				int predictor_num = predictor_coef_num - 1;
+
+				while (predictor_num >= 0 && error_val < 0)
+				{
+					int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
+					int sign = - SIGN_ONLY(val);
+
+					predictor_coef_table[predictor_num] -= sign;
+
+					val *= sign; /* neg value */
+
+					error_val -= ((val >> predictor_quantitization) *
+								  (predictor_coef_num - predictor_num));
+
+					predictor_num--;
+				}
+			}
+
+			buffer_out++;
+		}
+	}
+}
+
+void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b,
+					int16_t *buffer_out,
+					int numchannels, int numsamples,
+					uint8_t interlacing_shift,
+					uint8_t interlacing_leftweight)
+{
+	int i;
+	if (numsamples <= 0) return;
+
+	/* weighted interlacing */
+	if (interlacing_leftweight)
+	{
+		for (i = 0; i < numsamples; i++)
+		{
+			int32_t difference, midright;
+			int16_t left;
+			int16_t right;
+
+			midright = buffer_a[i];
+			difference = buffer_b[i];
+
+			right = midright - ((difference * interlacing_leftweight) >> interlacing_shift);
+			left = right + difference;
+
+			buffer_out[i*numchannels] = left;
+			buffer_out[i*numchannels + 1] = right;
+		}
+
+		return;
+	}
+
+	/* otherwise basic interlacing took place */
+	for (i = 0; i < numsamples; i++)
+	{
+		int16_t left, right;
+
+		left = buffer_a[i];
+		right = buffer_b[i];
+
+		buffer_out[i*numchannels] = left;
+		buffer_out[i*numchannels + 1] = right;
+	}
+}
+
+void deinterlace_24(int32_t *buffer_a, int32_t *buffer_b,
+					int uncompressed_bytes,
+					int32_t *uncompressed_bytes_buffer_a, int32_t *uncompressed_bytes_buffer_b,
+					void *buffer_out,
+					int numchannels, int numsamples,
+					uint8_t interlacing_shift,
+					uint8_t interlacing_leftweight)
+{
+	int i;
+	if (numsamples <= 0) return;
+
+	/* weighted interlacing */
+	if (interlacing_leftweight)
+	{
+		for (i = 0; i < numsamples; i++)
+		{
+			int32_t difference, midright;
+			int32_t left;
+			int32_t right;
+
+			midright = buffer_a[i];
+			difference = buffer_b[i];
+
+			right = midright - ((difference * interlacing_leftweight) >> interlacing_shift);
+			left = right + difference;
+
+			if (uncompressed_bytes)
+			{
+				uint32_t mask = ~(0xFFFFFFFF << (uncompressed_bytes * 8));
+				left <<= (uncompressed_bytes * 8);
+				right <<= (uncompressed_bytes * 8);
+
+				left |= uncompressed_bytes_buffer_a[i] & mask;
+				right |= uncompressed_bytes_buffer_b[i] & mask;
+			}
+
+			((uint8_t*)buffer_out)[i * numchannels * 3] = (left) & 0xFF;
+			((uint8_t*)buffer_out)[i * numchannels * 3 + 1] = (left >> 8) & 0xFF;
+			((uint8_t*)buffer_out)[i * numchannels * 3 + 2] = (left >> 16) & 0xFF;
+
+			((uint8_t*)buffer_out)[i * numchannels * 3 + 3] = (right) & 0xFF;
+			((uint8_t*)buffer_out)[i * numchannels * 3 + 4] = (right >> 8) & 0xFF;
+			((uint8_t*)buffer_out)[i * numchannels * 3 + 5] = (right >> 16) & 0xFF;
+		}
+
+		return;
+	}
+
+	/* otherwise basic interlacing took place */
+	for (i = 0; i < numsamples; i++)
+	{
+		int32_t left, right;
+
+		left = buffer_a[i];
+		right = buffer_b[i];
+
+		if (uncompressed_bytes)
+		{
+			uint32_t mask = ~(0xFFFFFFFF << (uncompressed_bytes * 8));
+			left <<= (uncompressed_bytes * 8);
+			right <<= (uncompressed_bytes * 8);
+
+			left |= uncompressed_bytes_buffer_a[i] & mask;
+			right |= uncompressed_bytes_buffer_b[i] & mask;
+		}
+
+		((uint8_t*)buffer_out)[i * numchannels * 3] = (left) & 0xFF;
+		((uint8_t*)buffer_out)[i * numchannels * 3 + 1] = (left >> 8) & 0xFF;
+		((uint8_t*)buffer_out)[i * numchannels * 3 + 2] = (left >> 16) & 0xFF;
+
+		((uint8_t*)buffer_out)[i * numchannels * 3 + 3] = (right) & 0xFF;
+		((uint8_t*)buffer_out)[i * numchannels * 3 + 4] = (right >> 8) & 0xFF;
+		((uint8_t*)buffer_out)[i * numchannels * 3 + 5] = (right >> 16) & 0xFF;
+
+	}
+
+}
+
+int decode_frame(alac_file *alac,
+				  unsigned char *inbuffer,
+				  void *outbuffer, int *outputsize)
+{
+	int channels;
+	int32_t outputsamples = alac->setinfo_max_samples_per_frame;
+
+	/* setup the stream */
+	alac->input_buffer = inbuffer;
+	alac->input_buffer_bitaccumulator = 0;
+
+	channels = readbits(alac, 3);
+
+	*outputsize = outputsamples * alac->bytespersample;
+
+	switch(channels)
+	{
+	case 0: /* 1 channel */
+	{
+		int hassize;
+		int isnotcompressed;
+		int readsamplesize;
+
+		int uncompressed_bytes;
+		int ricemodifier;
+
+		/* 2^result = something to do with output waiting.
+		 * perhaps matters if we read > 1 frame in a pass?
+		 */
+		readbits(alac, 4);
+
+		readbits(alac, 12); /* unknown, skip 12 bits */
+
+		hassize = readbits(alac, 1); /* the output sample size is stored soon */
+
+		uncompressed_bytes = readbits(alac, 2); /* number of bytes in the (compressed) stream that are not compressed */
+
+		isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */
+
+		if (hassize)
+		{
+			/* now read the number of samples,
+			 * as a 32bit integer */
+			outputsamples = readbits(alac, 32);
+			*outputsize = outputsamples * alac->bytespersample;
+		}
+
+		readsamplesize = alac->setinfo_sample_size - (uncompressed_bytes * 8);
+
+		if (!isnotcompressed)
+		{ /* so it is compressed */
+			int16_t predictor_coef_table[32];
+			int predictor_coef_num;
+			int prediction_type;
+			int prediction_quantitization;
+			int i;
+
+			/* skip 16 bits, not sure what they are. seem to be used in
+			 * two channel case */
+			readbits(alac, 8);
+			readbits(alac, 8);
+
+			prediction_type = readbits(alac, 4);
+			prediction_quantitization = readbits(alac, 4);
+
+			ricemodifier = readbits(alac, 3);
+			predictor_coef_num = readbits(alac, 5);
+
+			/* read the predictor table */
+			for (i = 0; i < predictor_coef_num; i++)
+			{
+				predictor_coef_table[i] = (int16_t)readbits(alac, 16);
+			}
+
+			if (uncompressed_bytes)
+			{
+				int i;
+				for (i = 0; i < outputsamples; i++)
+				{
+					alac->uncompressed_bytes_buffer_a[i] = readbits(alac, uncompressed_bytes * 8);
+				}
+			}
+
+			entropy_rice_decode(alac,
+								alac->predicterror_buffer_a,
+								outputsamples,
+								readsamplesize,
+								alac->setinfo_rice_initialhistory,
+								alac->setinfo_rice_kmodifier,
+								ricemodifier * alac->setinfo_rice_historymult / 4,
+								(1 << alac->setinfo_rice_kmodifier) - 1);
+
+			if (prediction_type == 0)
+			{ /* adaptive fir */
+				predictor_decompress_fir_adapt(alac->predicterror_buffer_a,
+											   alac->outputsamples_buffer_a,
+											   outputsamples,
+											   readsamplesize,
+											   predictor_coef_table,
+											   predictor_coef_num,
+											   prediction_quantitization);
+			}
+			else
+			{
+				ESP_LOGE(TAG, "FIXME: unhandled predicition type: %i", prediction_type);
+				/* i think the only other prediction type (or perhaps this is just a
+				 * boolean?) runs adaptive fir twice.. like:
+				 * predictor_decompress_fir_adapt(predictor_error, tempout, ...)
+				 * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)
+				 * little strange..
+				 */
+				return 0;
+			}
+
+		}
+		else
+		{ /* not compressed, easy case */
+			if (alac->setinfo_sample_size <= 16)
+			{
+				int i;
+				for (i = 0; i < outputsamples; i++)
+				{
+					int32_t audiobits = readbits(alac, alac->setinfo_sample_size);
+
+					audiobits = SIGN_EXTENDED32(audiobits, alac->setinfo_sample_size);
+
+					alac->outputsamples_buffer_a[i] = audiobits;
+				}
+			}
+			else
+			{
+				int i;
+				for (i = 0; i < outputsamples; i++)
+				{
+					int32_t audiobits;
+
+					audiobits = readbits(alac, 16);
+					/* special case of sign extension..
+					 * as we'll be ORing the low 16bits into this */
+					audiobits = audiobits << (alac->setinfo_sample_size - 16);
+					audiobits |= readbits(alac, alac->setinfo_sample_size - 16);
+					audiobits = SignExtend24(audiobits);
+
+					alac->outputsamples_buffer_a[i] = audiobits;
+				}
+			}
+			uncompressed_bytes = 0; // always 0 for uncompressed
+		}
+
+		switch(alac->setinfo_sample_size)
+		{
+		case 16:
+		{
+			int i;
+			for (i = 0; i < outputsamples; i++)
+			{
+				int16_t sample = alac->outputsamples_buffer_a[i];
+				((int16_t*)outbuffer)[i * alac->numchannels] = sample;
+			}
+			break;
+		}
+		case 24:
+		{
+			int i;
+			for (i = 0; i < outputsamples; i++)
+			{
+				int32_t sample = alac->outputsamples_buffer_a[i];
+
+				if (uncompressed_bytes)
+				{
+					uint32_t mask;
+					sample = sample << (uncompressed_bytes * 8);
+					mask = ~(0xFFFFFFFF << (uncompressed_bytes * 8));
+					sample |= alac->uncompressed_bytes_buffer_a[i] & mask;
+				}
+
+				((uint8_t*)outbuffer)[i * alac->numchannels * 3] = (sample) & 0xFF;
+				((uint8_t*)outbuffer)[i * alac->numchannels * 3 + 1] = (sample >> 8) & 0xFF;
+				((uint8_t*)outbuffer)[i * alac->numchannels * 3 + 2] = (sample >> 16) & 0xFF;
+			}
+			break;
+		}
+		case 20:
+		case 32:
+			ESP_LOGE(TAG, "FIXME: unimplemented sample size %i", alac->setinfo_sample_size);
+			return 0;
+		default:
+			break;
+		}
+		break;
+	}
+	case 1: /* 2 channels */
+	{
+		int hassize;
+		int isnotcompressed;
+		int readsamplesize;
+
+		int uncompressed_bytes;
+
+		uint8_t interlacing_shift;
+		uint8_t interlacing_leftweight;
+
+		/* 2^result = something to do with output waiting.
+		 * perhaps matters if we read > 1 frame in a pass?
+		 */
+		readbits(alac, 4);
+
+		readbits(alac, 12); /* unknown, skip 12 bits */
+
+		hassize = readbits(alac, 1); /* the output sample size is stored soon */
+
+		uncompressed_bytes = readbits(alac, 2); /* the number of bytes in the (compressed) stream that are not compressed */
+
+		isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */
+
+		if (hassize)
+		{
+			/* now read the number of samples,
+			 * as a 32bit integer */
+			outputsamples = readbits(alac, 32);
+			*outputsize = outputsamples * alac->bytespersample;
+		}
+
+		readsamplesize = alac->setinfo_sample_size - (uncompressed_bytes * 8) + 1;
+
+		if (!isnotcompressed)
+		{ /* compressed */
+			int16_t predictor_coef_table_a[32];
+			int predictor_coef_num_a;
+			int prediction_type_a;
+			int prediction_quantitization_a;
+			int ricemodifier_a;
+
+			int16_t predictor_coef_table_b[32];
+			int predictor_coef_num_b;
+			int prediction_type_b;
+			int prediction_quantitization_b;
+			int ricemodifier_b;
+
+			int i;
+
+			interlacing_shift = readbits(alac, 8);
+			interlacing_leftweight = readbits(alac, 8);
+
+			/******** channel 1 ***********/
+			prediction_type_a = readbits(alac, 4);
+			prediction_quantitization_a = readbits(alac, 4);
+
+			ricemodifier_a = readbits(alac, 3);
+			predictor_coef_num_a = readbits(alac, 5);
+
+			/* read the predictor table */
+			for (i = 0; i < predictor_coef_num_a; i++)
+			{
+				predictor_coef_table_a[i] = (int16_t)readbits(alac, 16);
+			}
+
+			/******** channel 2 *********/
+			prediction_type_b = readbits(alac, 4);
+			prediction_quantitization_b = readbits(alac, 4);
+
+			ricemodifier_b = readbits(alac, 3);
+			predictor_coef_num_b = readbits(alac, 5);
+
+			/* read the predictor table */
+			for (i = 0; i < predictor_coef_num_b; i++)
+			{
+				predictor_coef_table_b[i] = (int16_t)readbits(alac, 16);
+			}
+
+			/*********************/
+			if (uncompressed_bytes)
+			{ /* see mono case */
+				int i;
+				for (i = 0; i < outputsamples; i++)
+				{
+					alac->uncompressed_bytes_buffer_a[i] = readbits(alac, uncompressed_bytes * 8);
+					alac->uncompressed_bytes_buffer_b[i] = readbits(alac, uncompressed_bytes * 8);
+				}
+			}
+
+			/* channel 1 */
+			entropy_rice_decode(alac,
+								alac->predicterror_buffer_a,
+								outputsamples,
+								readsamplesize,
+								alac->setinfo_rice_initialhistory,
+								alac->setinfo_rice_kmodifier,
+								ricemodifier_a * alac->setinfo_rice_historymult / 4,
+								(1 << alac->setinfo_rice_kmodifier) - 1);
+
+			if (prediction_type_a == 0)
+			{ /* adaptive fir */
+				predictor_decompress_fir_adapt(alac->predicterror_buffer_a,
+											   alac->outputsamples_buffer_a,
+											   outputsamples,
+											   readsamplesize,
+											   predictor_coef_table_a,
+											   predictor_coef_num_a,
+											   prediction_quantitization_a);
+			}
+			else
+			{ /* see mono case */
+				ESP_LOGE(TAG, "FIXME: unhandled predicition type: %i", prediction_type_a);
+				return 0;
+			}
+
+			/* channel 2 */
+			entropy_rice_decode(alac,
+								alac->predicterror_buffer_b,
+								outputsamples,
+								readsamplesize,
+								alac->setinfo_rice_initialhistory,
+								alac->setinfo_rice_kmodifier,
+								ricemodifier_b * alac->setinfo_rice_historymult / 4,
+								(1 << alac->setinfo_rice_kmodifier) - 1);
+
+			if (prediction_type_b == 0)
+			{ /* adaptive fir */
+				predictor_decompress_fir_adapt(alac->predicterror_buffer_b,
+											   alac->outputsamples_buffer_b,
+											   outputsamples,
+											   readsamplesize,
+											   predictor_coef_table_b,
+											   predictor_coef_num_b,
+											   prediction_quantitization_b);
+			}
+			else
+			{
+				ESP_LOGE(TAG, "FIXME: unhandled predicition type: %i", prediction_type_b);
+				return 0;
+			}
+		}
+		else
+		{ /* not compressed, easy case */
+			if (alac->setinfo_sample_size <= 16)
+			{
+				int i;
+				for (i = 0; i < outputsamples; i++)
+				{
+					int32_t audiobits_a, audiobits_b;
+
+					audiobits_a = readbits(alac, alac->setinfo_sample_size);
+					audiobits_b = readbits(alac, alac->setinfo_sample_size);
+
+					audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size);
+					audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size);
+
+					alac->outputsamples_buffer_a[i] = audiobits_a;
+					alac->outputsamples_buffer_b[i] = audiobits_b;
+				}
+			}
+			else
+			{
+				int i;
+				for (i = 0; i < outputsamples; i++)
+				{
+					int32_t audiobits_a, audiobits_b;
+
+					audiobits_a = readbits(alac, 16);
+					audiobits_a = audiobits_a << (alac->setinfo_sample_size - 16);
+					audiobits_a |= readbits(alac, alac->setinfo_sample_size - 16);
+					audiobits_a = SignExtend24(audiobits_a);
+
+					audiobits_b = readbits(alac, 16);
+					audiobits_b = audiobits_b << (alac->setinfo_sample_size - 16);
+					audiobits_b |= readbits(alac, alac->setinfo_sample_size - 16);
+					audiobits_b = SignExtend24(audiobits_b);
+
+					alac->outputsamples_buffer_a[i] = audiobits_a;
+					alac->outputsamples_buffer_b[i] = audiobits_b;
+				}
+			}
+			uncompressed_bytes = 0; // always 0 for uncompressed
+			interlacing_shift = 0;
+			interlacing_leftweight = 0;
+		}
+
+		switch(alac->setinfo_sample_size)
+		{
+		case 16:
+		{
+			deinterlace_16(alac->outputsamples_buffer_a,
+						   alac->outputsamples_buffer_b,
+						   (int16_t*)outbuffer,
+						   alac->numchannels,
+						   outputsamples,
+						   interlacing_shift,
+						   interlacing_leftweight);
+			break;
+		}
+		case 24:
+		{
+			deinterlace_24(alac->outputsamples_buffer_a,
+						   alac->outputsamples_buffer_b,
+						   uncompressed_bytes,
+						   alac->uncompressed_bytes_buffer_a,
+						   alac->uncompressed_bytes_buffer_b,
+						   (int16_t*)outbuffer,
+						   alac->numchannels,
+						   outputsamples,
+						   interlacing_shift,
+						   interlacing_leftweight);
+			break;
+		}
+		case 20:
+		case 32:
+			ESP_LOGE(TAG, "FIXME: unimplemented sample size %i", alac->setinfo_sample_size);
+			return 0;
+		default:
+			break;
+		}
+
+		break;
+	}
+	}
+	return 1;
+}
+
+void create_alac(alac_file *alac, int samplesize, int numchannels)
+{
+	alac->samplesize = samplesize;
+	alac->numchannels = numchannels;
+	alac->bytespersample = (samplesize / 8) * numchannels;
+}
diff --git a/lib/alac/decomp.h b/lib/alac/decomp.h
new file mode 100644
index 00000000..50e26b24
--- /dev/null
+++ b/lib/alac/decomp.h
@@ -0,0 +1,35 @@
+#ifndef __ALAC__DECOMP_H
+#define __ALAC__DECOMP_H
+
+typedef struct alac_file {
+	unsigned char *input_buffer;
+	int input_buffer_bitaccumulator; /* used so we can do arbitary bit reads */
+	int samplesize;
+	int numchannels;
+	int bytespersample;
+	/* buffers */
+	int32_t *predicterror_buffer_a;
+	int32_t *predicterror_buffer_b;
+	int32_t *outputsamples_buffer_a;
+	int32_t *outputsamples_buffer_b;
+	int32_t *uncompressed_bytes_buffer_a;
+	int32_t *uncompressed_bytes_buffer_b;
+	/* stuff from setinfo */
+	uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */    /* max samples per frame? */
+	uint8_t setinfo_7a; /* 0x00 */
+	uint8_t setinfo_sample_size; /* 0x10 */
+	uint8_t setinfo_rice_historymult; /* 0x28 */
+	uint8_t setinfo_rice_initialhistory; /* 0x0a */
+	uint8_t setinfo_rice_kmodifier; /* 0x0e */
+	uint8_t setinfo_7f; /* 0x02 */
+	uint16_t setinfo_80; /* 0x00ff */
+	uint32_t setinfo_82; /* 0x000020e7 */ /* max sample size?? */
+	uint32_t setinfo_86; /* 0x00069fe4 */ /* bit rate (avarge)?? */
+	uint32_t setinfo_8a_rate; /* 0x0000ac44 */
+	/* end setinfo stuff */
+} alac_file;
+void create_alac(alac_file *alac, int samplesize, int numchannels);
+int decode_frame(alac_file *alac, unsigned char *inbuffer, void *outbuffer, int *outputsize);
+void alac_set_info(alac_file *alac, char *inputbuffer);
+
+#endif /* __ALAC__DECOMP_H */
diff --git a/lib/libtags/m4a.c b/lib/libtags/m4a.c
index ec254c3f..c1b62328 100644
--- a/lib/libtags/m4a.c
+++ b/lib/libtags/m4a.c
@@ -59,9 +59,16 @@ tagm4a(Tagctx *ctx)
 				sz -= 8;
 				skip = beuint(d) - 8;
 
-				if(memcmp(&d[4], "mp4a", 4) == 0){ /* audio */
+				if(memcmp(&d[4], "mp4a", 4) == 0 || memcmp(&d[4], "alac", 4) == 0){ /* audio */
 					n = 6+2 + 2+4+2 + 2+2 + 2+2 + 4; /* read a bunch at once */
 					/* reserved+id, ver+rev+vendor, channels+bps, ?+?, sample rate */
+					switch(d[4]) {
+					case 'a':
+						ctx->format = Falac;
+						break;
+					case 'm':
+						ctx->format = Fm4a;
+					}
 					if(ctx->read(ctx, d, n) != n)
 						return -1;
 					skip -= n;
@@ -85,6 +92,8 @@ tagm4a(Tagctx *ctx)
 			type = Talbum;
 		else if(memcmp(d, "\251ART", 4) == 0)
 			type = Tartist;
+		else if(memcmp(d, "aART", 4) == 0)
+			type = Talbumartist;
 		else if(memcmp(d, "\251gen", 4) == 0 || memcmp(d, "gnre", 4) == 0)
 			type = Tgenre;
 		else if(memcmp(d, "\251day", 4) == 0)
diff --git a/lib/libtags/tags.c b/lib/libtags/tags.c
index b1442e69..64812a95 100644
--- a/lib/libtags/tags.c
+++ b/lib/libtags/tags.c
@@ -28,7 +28,7 @@ static const Getter g[] =
 	{tagid3v1, Fmp3},
 	{tagvorbis, Fogg},
 	{tagflac, Fflac},
-	{tagm4a, Fm4a},
+	{tagm4a, Funknown},
 	{tagopus, Fopus},
 	{tagwav, Fwav},
 	// {tagit, Fit},
diff --git a/lib/libtags/tags.h b/lib/libtags/tags.h
index 0b54936a..9b5c95af 100644
--- a/lib/libtags/tags.h
+++ b/lib/libtags/tags.h
@@ -38,6 +38,7 @@ enum
 	Fopus,
 	Fwav,
 	Fwavpack,
+	Falac,
 	Fit,
 	Fxm,
 	Fs3m,
diff --git a/lua/licenses.lua b/lua/licenses.lua
index 7a66c063..dae7ea15 100644
--- a/lua/licenses.lua
+++ b/lua/licenses.lua
@@ -178,6 +178,9 @@ return function(self)
     button:onClicked(show_fn)
   end
 
+  library("ALAC decoder", "MIT", function()
+    MIT("Copyright (c) 2005 David Hammerton")
+  end)
   library("Ark Pixel font", "OFL", function()
     ofl("Copyright (C) 2021 TakWolf")
   end)
diff --git a/src/codecs/CMakeLists.txt b/src/codecs/CMakeLists.txt
index 1b79b863..55b8dcbc 100644
--- a/src/codecs/CMakeLists.txt
+++ b/src/codecs/CMakeLists.txt
@@ -3,10 +3,10 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 idf_component_register(
-  SRCS "dr_flac.cpp" "codec.cpp" "mad.cpp" "opus.cpp" "vorbis.cpp"
+  SRCS "alac.cpp" "dr_flac.cpp" "codec.cpp" "mad.cpp" "opus.cpp" "vorbis.cpp"
        "source_buffer.cpp" "sample.cpp" "wav.cpp" "native.cpp" "wavpack.cpp"
   INCLUDE_DIRS "include"
   REQUIRES "result" "libmad" "drflac" "tremor" "opusfile" "memory" "util"
-       "komihash" "wavpack")
+       "komihash" "wavpack" "alac")
 
 target_compile_options("${COMPONENT_LIB}" PRIVATE ${EXTRA_WARNINGS})
diff --git a/src/codecs/alac.cpp b/src/codecs/alac.cpp
new file mode 100644
index 00000000..f99d3a53
--- /dev/null
+++ b/src/codecs/alac.cpp
@@ -0,0 +1,616 @@
+/*
+ * Copyright 2025 ayumi <ayumi@noreply.codeberg.org>
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#include "alac.hpp"
+
+#include <cstring>
+#include <algorithm>
+
+#include "esp_heap_caps.h"
+#include "codec.hpp"
+#include "esp_log.h"
+#include "result.hpp"
+#include "sample.hpp"
+#include "types.hpp"
+
+namespace codecs {
+
+[[maybe_unused]] static constexpr const char kTag[] = "alac";
+
+static inline constexpr auto loadBe16(std::byte data[2]) -> uint16_t {
+  return __builtin_bswap16(*reinterpret_cast<uint16_t*>(data));
+}
+
+static inline constexpr auto loadBe32(std::byte data[4]) -> uint32_t {
+  return __builtin_bswap32(*reinterpret_cast<uint32_t*>(data));
+}
+
+static inline constexpr auto loadBe64(std::byte data[8]) -> uint64_t {
+  return __builtin_bswap64(*reinterpret_cast<uint64_t*>(data));
+}
+
+static inline constexpr auto str4(const char str[4]) -> uint32_t {
+  return static_cast<uint32_t>(str[0]) << 24
+      | static_cast<uint32_t>(str[1]) << 16
+      | static_cast<uint32_t>(str[2]) << 8
+      | static_cast<uint32_t>(str[3]);
+}
+
+static inline constexpr auto loadLe16(std::byte* data) -> int16_t {
+  return *reinterpret_cast<int16_t*>(data);
+}
+
+auto AlacDecoder::readBoxHeader()
+    -> cpp::result<std::tuple<std::uint64_t, std::array<std::byte, 4>>, ICodec::Error> {
+  std::byte buf[4];
+  input_->Read(buf);
+  std::uint64_t size = loadBe32(buf);
+  switch (size) {
+  case 0:
+    return cpp::fail(Error::kUnsupportedFormat);
+  case 1:
+    std::byte buf[8];
+    input_->Read(buf);
+    size = loadBe64(buf);
+  }
+  std::array<std::byte, 4> type;
+  input_->Read(type);
+  return std::make_tuple(size, type);
+}
+
+auto AlacDecoder::readFullBoxHeader()
+    -> std::tuple<std::uint8_t, std::uint32_t> {
+  std::byte buf1[1];
+  input_->Read(buf1);
+  const std::uint8_t version = static_cast<uint8_t>(buf1[0]);
+  std::byte buf4[4] = {};
+  input_->Read({
+      static_cast<std::byte*>(buf4+1),
+      static_cast<std::span<std::byte>::size_type>(3)
+  });
+  std::uint32_t flags = loadBe32(buf4);
+  return std::make_tuple(version, flags);
+}
+
+auto AlacDecoder::readFtyp(uint64_t size)
+    -> cpp::result<void, ICodec::Error> {
+  std::array<std::byte, 4> brand;
+  input_->Read(brand);
+  if (loadBe32(brand.data()) != str4("M4A "))
+    return cpp::fail(Error::kUnsupportedFormat);
+  input_->SeekTo(
+      size - 12 - (size > std::numeric_limits<uint32_t>::max() ? 8 : 0),
+      IStream::SeekFrom::kCurrentPosition
+  );
+  return {};
+}
+
+void AlacDecoder::readFree(uint64_t size) {
+  input_->SeekTo(
+      size - 8 - (size > std::numeric_limits<uint32_t>::max() ? 8 : 0),
+      IStream::SeekFrom::kCurrentPosition
+  );
+}
+
+auto AlacDecoder::readStsd() -> cpp::result<void, ICodec::Error> {
+  uint8_t version;
+  uint32_t flags;
+  std::tie(version, flags) = readFullBoxHeader();
+  if (version != 0 || flags != 0)
+    return cpp::fail(Error::kMalformedData);
+  std::byte buf4[4];
+  input_->Read(buf4);
+  if (std::uint32_t entryCount = loadBe32(buf4); entryCount != 1)
+    return cpp::fail(Error::kMalformedData);
+  uint64_t size2;
+  std::array<std::byte, 4> type;
+  if (auto v = readBoxHeader(); v.has_value())
+    std::tie(size2, type) = v.value();
+  else
+    return cpp::fail(v.error());
+  if (loadBe32(type.data()) != str4("alac"))
+    return cpp::fail(Error::kUnsupportedFormat);
+  input_->SeekTo(6, IStream::SeekFrom::kCurrentPosition);
+  std::byte buf2[2];
+  input_->Read(buf2);
+  index_ = loadBe16(buf2);
+  input_->SeekTo(8, IStream::SeekFrom::kCurrentPosition);
+  input_->Read(buf2);
+  if (channels_ = loadBe16(buf2); channels_ > 2)
+    return cpp::fail(Error::kUnsupportedFormat);
+  input_->Read(buf2);
+  bitdepth_ = loadBe16(buf2);
+  input_->SeekTo(4, IStream::SeekFrom::kCurrentPosition);
+  input_->Read(buf4);
+  sampleRate_ = loadBe32(buf4) >> 16;
+  input_->Read(buf4);
+  uint32_t alacInfoSize = loadBe32(buf4) - 12;
+  input_->Read(buf4);
+  if (loadBe32(buf4) != str4("alac"))
+    return cpp::fail(Error::kUnsupportedFormat);
+  input_->Read(buf4);
+  if (uint32_t alacInfoVersion = loadBe32(buf4); alacInfoVersion != 0)
+    return cpp::fail(Error::kUnsupportedFormat);
+  std::vector<std::byte> cookie(alacInfoSize);
+  input_->Read(cookie);
+  create_alac(&alac_, bitdepth_, channels_);
+  alac_set_info(&alac_, reinterpret_cast<char*>(cookie.data()));
+  alac_.predicterror_buffer_a = static_cast<int32_t*>(
+      heap_caps_malloc(
+          alac_.setinfo_max_samples_per_frame * 4,
+          MALLOC_CAP_CACHE_ALIGNED | MALLOC_CAP_32BIT
+  ));
+  alac_.predicterror_buffer_b = static_cast<int32_t*>(
+      heap_caps_malloc(
+          alac_.setinfo_max_samples_per_frame * 4,
+          MALLOC_CAP_CACHE_ALIGNED | MALLOC_CAP_32BIT
+  ));
+  alac_.outputsamples_buffer_a = static_cast<int32_t*>(
+      heap_caps_malloc(
+          alac_.setinfo_max_samples_per_frame * 4,
+          MALLOC_CAP_CACHE_ALIGNED | MALLOC_CAP_32BIT
+  ));
+  alac_.outputsamples_buffer_b = static_cast<int32_t*>(
+      heap_caps_malloc(
+          alac_.setinfo_max_samples_per_frame * 4,
+          MALLOC_CAP_CACHE_ALIGNED | MALLOC_CAP_32BIT
+  ));
+  alac_.uncompressed_bytes_buffer_a = static_cast<int32_t*>(
+      heap_caps_malloc(
+          alac_.setinfo_max_samples_per_frame * 4,
+          MALLOC_CAP_CACHE_ALIGNED | MALLOC_CAP_32BIT
+  ));
+  alac_.uncompressed_bytes_buffer_b = static_cast<int32_t*>(
+      heap_caps_malloc(
+          alac_.setinfo_max_samples_per_frame * 4,
+          MALLOC_CAP_CACHE_ALIGNED | MALLOC_CAP_32BIT
+  ));
+  return {};
+}
+
+auto AlacDecoder::readStts() -> cpp::result<void, ICodec::Error> {
+  uint8_t version;
+  uint32_t flags;
+  std::tie(version, flags) = readFullBoxHeader();
+  if (version != 0 || flags != 0)
+    return cpp::fail(Error::kMalformedData);
+  std::byte buf[4];
+  input_->Read(buf);
+  uint32_t entryCount = loadBe32(buf);
+  stts_.resize(entryCount);
+  for (size_t i = 0; i < entryCount; i++) {
+    input_->Read(buf);
+    uint32_t count = loadBe32(buf);
+    input_->Read(buf);
+    uint32_t delta = loadBe32(buf);
+    stts_[i] = std::make_tuple(count, delta);
+  }
+  hasStts_ = true;
+  return {};
+}
+
+auto AlacDecoder::readStsc() -> cpp::result<void, ICodec::Error> {
+  uint8_t version;
+  uint32_t flags;
+  std::tie(version, flags) = readFullBoxHeader();
+  if (version != 0 || flags != 0)
+    return cpp::fail(Error::kMalformedData);
+  std::byte buf[4];
+  input_->Read(buf);
+  uint32_t entryCount = loadBe32(buf);
+  stsc_.resize(entryCount);
+  for (size_t i = 0; i < entryCount; i++) {
+    input_->Read(buf);
+    uint32_t firstChunk = loadBe32(buf) - 1;
+    input_->Read(buf);
+    uint32_t samples = loadBe32(buf);
+    input_->Read(buf);
+    if (uint32_t index = loadBe32(buf); index != index_)
+      return cpp::fail(Error::kMalformedData);
+    stsc_[i] = std::make_tuple(firstChunk, samples);
+  }
+  hasStsc_ = true;
+  return {};
+}
+
+auto AlacDecoder::readStsz() -> cpp::result<void, ICodec::Error> {
+  uint8_t version;
+  uint32_t flags;
+  std::tie(version, flags) = readFullBoxHeader();
+  if (version != 0 || flags != 0)
+    return cpp::fail(Error::kMalformedData);
+  std::byte buf[4];
+  input_->Read(buf);
+  uint32_t sampleSize = loadBe32(buf);
+  input_->Read(buf);
+  uint32_t sampleCount = loadBe32(buf);
+  if(sampleSize != 0) {
+    stsz_ = sampleSize;
+    return {};
+  }
+  stsz_ = std::vector<uint32_t>(sampleCount);
+  for (size_t i = 0; i < sampleCount; i++) {
+    input_->Read(buf);
+    std::get<1>(stsz_)[i] = loadBe32(buf);
+  }
+  hasStsz_ = true;
+  return {};
+}
+
+auto AlacDecoder::readStco() -> cpp::result<void, ICodec::Error> {
+  uint8_t version;
+  uint32_t flags;
+  std::tie(version, flags) = readFullBoxHeader();
+  if (version != 0 || flags != 0)
+    return cpp::fail(Error::kMalformedData);
+  std::byte buf[4];
+  input_->Read(buf);
+  uint32_t entryCount = loadBe32(buf);
+  stco_ = std::vector<uint64_t>(entryCount);
+  for (size_t i = 0; i < entryCount; i++) {
+    input_->Read(buf);
+    stco_[i] = loadBe32(buf);
+  }
+  hasStco_ = true;
+  return {};
+}
+
+auto AlacDecoder::readCo64() -> cpp::result<void, ICodec::Error> {
+  uint8_t version;
+  uint32_t flags;
+  std::tie(version, flags) = readFullBoxHeader();
+  if (version != 0 || flags != 0)
+    return cpp::fail(Error::kMalformedData);
+  std::byte buf4[4];
+  input_->Read(buf4);
+  uint32_t entryCount = loadBe64(buf4);
+  stco_ = std::vector<uint64_t>(entryCount);
+  for (size_t i = 0; i < entryCount; i++) {
+    std::byte buf8[8];
+    input_->Read(buf8);
+    stco_[i] = loadBe64(buf8);
+  }
+  hasStco_ = true;
+  return {};
+}
+
+auto AlacDecoder::readBox() -> cpp::result<uint64_t, ICodec::Error> {
+  uint64_t size;
+  std::array<std::byte, 4> type;
+  if (auto v = readBoxHeader(); v.has_value())
+    std::tie(size, type) = v.value();
+  else
+    return cpp::fail(v.error());
+  switch (loadBe32(type.data())) {
+  case str4("ftyp"):
+    if(auto v = readFtyp(size); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  case str4("moov"):
+  case str4("trak"):
+  case str4("mdia"):
+  case str4("minf"):
+  case str4("stbl"):
+    if(auto v = readContainer(size); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  case str4("stsd"):
+    if(auto v = readStsd(); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  case str4("stts"):
+    if(auto v = readStts(); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  case str4("stsc"):
+    if(auto v = readStsc(); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  case str4("stsz"):
+    if(auto v = readStsz(); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  case str4("stco"):
+    if(auto v = readStco(); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  case str4("co64"):
+    if(auto v = readCo64(); v.has_error())
+      return cpp::fail(v.error());
+    break;
+  default:
+    readFree(size);
+  }
+  return size;
+}
+
+auto AlacDecoder::readContainer(uint64_t size)
+    -> cpp::result<uint64_t, ICodec::Error> {
+  size -= 8 + (size > std::numeric_limits<uint32_t>::max() ? 8 : 0);
+  while (size != 0) {
+    if (auto v = readBox(); v.has_value())
+      size -= v.value();
+    else
+      return cpp::fail(v.error());
+  }
+  return {};
+}
+
+auto AlacDecoder::getFrameDuration(uint32_t frame)
+    -> cpp::result<uint32_t, ICodec::Error> {
+  uint32_t base = 0;
+  for (size_t i = 0; i < stts_.size(); i++) {
+    uint32_t count, delta;
+    std::tie(count, delta) = stts_[i];
+    base += count;
+    if (frame < base) {
+      return delta;
+    }
+  }
+  return cpp::fail(Error::kInternalError);
+}
+
+auto AlacDecoder::getFrameSize(uint32_t frame) -> uint32_t {
+  switch(stsz_.index()) {
+  case 0:
+    return std::get<0>(stsz_);
+  case 1:
+    return std::get<1>(stsz_)[frame];
+  default:
+    return 0;
+  }
+}
+
+auto AlacDecoder::getTotalSamples() -> uint64_t {
+  uint64_t total = 0;
+  for (size_t i = 0; i < stts_.size(); i++) {
+    uint32_t count, delta;
+    std::tie(count, delta) = stts_[i];
+    total += count * delta;
+  }
+  return total;
+}
+
+auto AlacDecoder::getTotalFrames() -> uint32_t {
+  uint32_t total = 0;
+  for (size_t i = 0; i < stts_.size(); i++)
+    total += std::get<0>(stts_[i]);
+  return total;
+}
+
+auto AlacDecoder::getTotalFrameSize() -> uint64_t {
+  if (stsz_.index() == 0)
+    return static_cast<uint64_t>(std::get<0>(stsz_)) * getTotalFrames();
+  uint64_t total = 0;
+  for (size_t i = 0; i < std::get<1>(stsz_).size(); i++)
+    total += std::get<1>(stsz_)[i];
+  return total;
+}
+
+auto AlacDecoder::frameToOffset(uint32_t frame)
+    -> cpp::result<std::tuple<uint64_t, uint32_t>, ICodec::Error> {
+  uint32_t chunk, frames, skip, targetFrame = frame;
+  std::tie(chunk, frames) = stsc_[0];
+  skip = frames;
+  if (chunk != 0)
+    return cpp::fail(Error::kMalformedData);
+  if (frame < frames) {
+    uint64_t offset = 0;
+    for(size_t i = 0; i < targetFrame; i++)
+      offset += getFrameSize(i);
+    return std::make_tuple(stco_[0] + offset, 0);
+  }
+  for (size_t i = 1; i < stsc_.size(); i++) {
+    frame -= frames;
+    uint32_t newChunk, newFrames;
+    std::tie(newChunk, newFrames) = stsc_[i];
+    for (size_t i = chunk, j = 1; newChunk - i > 1; i++, j++) {
+      if (frame < frames) {
+        uint64_t offset = 0;
+        for (size_t i = skip; i < targetFrame; i++)
+          offset += getFrameSize(i);
+        return std::make_tuple(stco_[i + j] + offset, i + j);
+      }
+      skip += frames;
+      frame -= frames;
+    }
+    if (frame < newFrames) {
+      uint64_t offset = 0;
+      for (size_t i = skip; i < targetFrame; i++)
+        offset += getFrameSize(i);
+      return std::make_tuple(stco_[newChunk] + offset, newChunk);
+    }
+    skip += newFrames;
+    chunk = newChunk;
+    frames = newFrames;
+  }
+  return cpp::fail(Error::kInternalError);
+}
+
+auto AlacDecoder::getChunkMixMaxFrames(uint32_t chunk)
+    -> cpp::result<std::tuple<uint32_t, uint32_t>, ICodec::Error> {
+  uint32_t from, frames, max, min = 0;
+  std::tie(from, frames) = stsc_[0];
+  if (from != 0)
+    return cpp::fail(Error::kMalformedData);
+  max = frames;
+  if(chunk == 0)
+    return std::make_tuple(min, max);
+  min = max;
+  for (size_t i = 1; i < stsc_.size(); i++) {
+    uint32_t newFrom, newFrames;
+    std::tie(newFrom, newFrames) = stsc_[i];
+    while (newFrom - from > 1) {
+      max += frames;
+      if(chunk == ++from)
+        return std::make_tuple(min, max);
+      min = max;
+    }
+    frames = newFrames;
+    max += frames;
+    if (chunk == newFrom)
+      return std::make_tuple(min, max);
+    min = max;
+    from++;
+  }
+  return cpp::fail(Error::kInternalError);
+}
+
+auto AlacDecoder::sampleToFrame(uint64_t sample)
+    -> cpp::result<std::tuple<uint32_t, uint32_t>, ICodec::Error> {
+  uint64_t accumulator = 0;
+  uint32_t frame = 0;
+  for (size_t i = 0; i < stts_.size(); i++) {
+    uint32_t count, delta;
+    std::tie(count, delta) = stts_[i];
+    for (size_t i = 0; i < count; i++, frame++) {
+      if (sample >= accumulator && sample < accumulator + delta)
+        return std::make_tuple(frame, sample - accumulator);
+      accumulator += delta;
+    }
+  }
+  return cpp::fail(Error::kInternalError);
+}
+
+AlacDecoder::AlacDecoder() : input_() {
+  alac_.predicterror_buffer_a = nullptr;
+  alac_.predicterror_buffer_b = nullptr;
+  alac_.outputsamples_buffer_a = nullptr;
+  alac_.outputsamples_buffer_b = nullptr;
+  alac_.uncompressed_bytes_buffer_a = nullptr;
+  alac_.uncompressed_bytes_buffer_b = nullptr;
+}
+
+AlacDecoder::~AlacDecoder() {
+  if (alac_.predicterror_buffer_a != nullptr)
+    heap_caps_free(alac_.predicterror_buffer_a);
+  if (alac_.predicterror_buffer_b != nullptr)
+    heap_caps_free(alac_.predicterror_buffer_b);
+  if (alac_.outputsamples_buffer_a != nullptr)
+    heap_caps_free(alac_.outputsamples_buffer_a);
+  if (alac_.outputsamples_buffer_b != nullptr)
+    heap_caps_free(alac_.outputsamples_buffer_b);
+  if (alac_.uncompressed_bytes_buffer_a != nullptr)
+    heap_caps_free(alac_.uncompressed_bytes_buffer_a);
+  if (alac_.uncompressed_bytes_buffer_b != nullptr)
+    heap_caps_free(alac_.uncompressed_bytes_buffer_b);
+}
+
+auto AlacDecoder::OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
+    -> cpp::result<OutputFormat, ICodec::Error> {
+  input_ = input;
+  while (!hasStts_ || !hasStsc_ || !hasStsz_ || !hasStco_)
+    if (auto v = readBox(); v.has_error())
+      return cpp::fail(v.error());
+  uint32_t diff;
+  if (
+      auto v = sampleToFrame(static_cast<uint64_t>(offset) * sampleRate_);
+      v.has_error()
+  )
+    return cpp::fail(v.error());
+  else
+    std::tie(frame_, diff) = v.value();
+  uint64_t off;
+  if (auto v = frameToOffset(frame_); v.has_error())
+    return cpp::fail(v.error());
+  else
+    std::tie(off, chunk_) = v.value();
+  input_->SeekTo(off, IStream::SeekFrom::kStartOfStream);
+  in_.resize(getFrameSize(frame_));
+  if(auto v = getFrameDuration(frame_); v.has_error())
+    return cpp::fail(v.error());
+  else
+    out_.resize((bitdepth_ / 8) * channels_ * v.value());
+  const auto size = input->Size();
+  input_->SetPreambleFinished();
+  if (auto v = UnpackFrame(diff); v.has_error())
+    return cpp::fail(v.error());
+  return OutputFormat{
+    .num_channels = channels_,
+    .sample_rate_hz = sampleRate_,
+    .total_samples = getTotalSamples() * channels_,
+    .bitrate_kbps = size
+          ? std::optional(
+              ((double)size.value() * 8.0)
+              / ((double)getTotalFrameSize() / channels_ / sampleRate_) / 1000
+            )
+          : std::nullopt,
+  };
+}
+
+auto AlacDecoder::UnpackFrame(uint32_t offset)
+    -> cpp::result<void, ICodec::Error> {
+  uint32_t min, max;
+  if (auto v = getChunkMixMaxFrames(chunk_); v.has_error())
+    return cpp::fail(v.error());
+  else
+    std::tie(min, max) = v.value();
+  uint32_t duration;
+  if (auto v = getFrameDuration(frame_); v.has_error())
+    return cpp::fail(v.error());
+  else
+    duration = v.value();
+  const uint32_t size = getFrameSize(frame_);
+  if (in_.size() < size)
+    in_.resize(size);
+  int outputSize = (bitdepth_ / 8) * channels_ * duration;
+  if (out_.size() < outputSize)
+    out_.resize(outputSize);
+  input_->Read({in_.data(), size});
+  if (decode_frame(
+      &alac_,
+      reinterpret_cast<unsigned char*>(in_.data()),
+      out_.data(),
+      &outputSize) == 0)
+    return cpp::fail(Error::kInternalError);
+  outOff_ = offset * (bitdepth_ / 8) * channels_;
+  outSize_ = outputSize - outOff_;
+  if (++frame_ >= max) {
+    if (chunk_++; chunk_ < stco_.size())
+      input_->SeekTo(stco_[chunk_], IStream::SeekFrom::kStartOfStream);
+    else
+      outSize_ = 0;
+  }
+  return {};
+}
+
+auto AlacDecoder::DecodeTo(std::span<sample::Sample> output)
+    -> cpp::result<OutputInfo, Error> {
+  if (outSize_ == 0)
+    if (auto v = UnpackFrame(0); v.has_error())
+      return cpp::fail(v.error());
+  if (outSize_ == 0)
+    return OutputInfo{
+        .samples_written = 0,
+        .is_stream_finished = true,
+    };
+  const auto sampleSize = (bitdepth_ / 8);
+  const auto size = std::min(outSize_ / sampleSize, output.size());
+  switch (bitdepth_) {
+  case 16:
+    for (size_t i = 0; i < size; i++, outOff_ += 2)
+      output[i] = loadLe16(out_.data()+outOff_);
+    break;
+  case 24:
+    for (size_t i = 0; i < size; i++, outOff_ += 3)
+      output[i] = sample::shiftWithDither(
+          static_cast<uint32_t>(out_[outOff_])
+              | static_cast<uint32_t>(out_[outOff_+1]) << 8
+              | static_cast<uint32_t>(out_[outOff_+2]) << 16,
+          8
+      );
+    break;
+  default:
+    return cpp::fail(Error::kInternalError);
+  }
+  outSize_ -= size * sampleSize;
+  return OutputInfo{
+      .samples_written = size,
+      .is_stream_finished = false,
+  };
+}
+
+}  // namespace codecs
diff --git a/src/codecs/codec.cpp b/src/codecs/codec.cpp
index 4ddb16ad..071c9778 100644
--- a/src/codecs/codec.cpp
+++ b/src/codecs/codec.cpp
@@ -9,6 +9,7 @@
 #include <memory>
 #include <optional>
 
+#include "alac.hpp"
 #include "dr_flac.hpp"
 #include "mad.hpp"
 #include "native.hpp"
@@ -36,6 +37,8 @@ auto StreamTypeToString(StreamType t) -> std::string {
       return "Native";
     case StreamType::kWavPack:
       return "WavPack";
+    case StreamType::kAlac:
+      return "ALAC";
     default:
       return "";
   }
@@ -57,6 +60,8 @@ auto CreateCodecForType(StreamType type) -> std::optional<ICodec*> {
       return new NativeDecoder();
     case StreamType::kWavPack:
       return new WavPackDecoder();
+    case StreamType::kAlac:
+      return new AlacDecoder();
     default:
       return {};
   }
diff --git a/src/codecs/include/alac.hpp b/src/codecs/include/alac.hpp
new file mode 100644
index 00000000..a0dcd1f2
--- /dev/null
+++ b/src/codecs/include/alac.hpp
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2025 ayumi <ayumi@noreply.codeberg.org>
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+
+extern "C" {
+  #include "decomp.h"
+}
+#include "sample.hpp"
+
+#include "codec.hpp"
+
+namespace codecs {
+
+class AlacDecoder : public ICodec {
+ public:
+  AlacDecoder();
+  ~AlacDecoder();
+
+  auto OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
+      -> cpp::result<OutputFormat, Error> override;
+  auto DecodeTo(std::span<sample::Sample> destination)
+      -> cpp::result<OutputInfo, Error> override;
+
+  AlacDecoder(const AlacDecoder&) = delete;
+  AlacDecoder& operator=(const AlacDecoder&) = delete;
+
+ private:
+  auto readBoxHeader()
+      -> cpp::result<std::tuple<uint64_t, std::array<std::byte, 4>>, ICodec::Error>;
+  auto readFullBoxHeader() -> std::tuple<uint8_t, uint32_t>;
+  auto readFtyp(uint64_t size) -> cpp::result<void, ICodec::Error>;
+  void readFree(uint64_t size);
+  auto readStsd() -> cpp::result<void, ICodec::Error>;
+  auto readStts() -> cpp::result<void, ICodec::Error>;
+  auto readStsc() -> cpp::result<void, ICodec::Error>;
+  auto readStsz() -> cpp::result<void, ICodec::Error>;
+  auto readStco() -> cpp::result<void, ICodec::Error>;
+  auto readCo64() -> cpp::result<void, ICodec::Error>;
+  auto readBox() -> cpp::result<uint64_t, ICodec::Error>;
+  auto readContainer(uint64_t size) -> cpp::result<uint64_t, ICodec::Error>;
+  auto getFrameDuration(uint32_t frame) -> cpp::result<uint32_t, ICodec::Error>;
+  auto getFrameSize(uint32_t frame) -> uint32_t;
+  auto getTotalSamples() -> uint64_t;
+  auto getTotalFrames() -> uint32_t;
+  auto getTotalFrameSize() -> uint64_t;
+  auto frameToOffset(uint32_t frame)
+      -> cpp::result<std::tuple<uint64_t, uint32_t>, ICodec::Error>;
+  auto getChunkMixMaxFrames(uint32_t chunk)
+      -> cpp::result<std::tuple<uint32_t, uint32_t>, ICodec::Error>;
+  auto sampleToFrame(uint64_t sample)
+      -> cpp::result<std::tuple<uint32_t, uint32_t>, ICodec::Error>;
+  auto UnpackFrame(uint32_t offset) -> cpp::result<void, ICodec::Error>;
+
+  std::shared_ptr<IStream> input_;
+  alac_file alac_;
+  uint8_t bitdepth_;
+  uint8_t channels_;
+  uint16_t sampleRate_;
+  uint16_t index_;
+
+  std::vector<std::tuple<uint32_t, uint32_t>> stts_;
+  std::vector<std::tuple<uint32_t, uint32_t>> stsc_;
+  std::variant<uint32_t, std::vector<uint32_t>> stsz_;
+  std::vector<uint64_t> stco_;
+
+  bool hasStts_ = false;
+  bool hasStsc_ = false;
+  bool hasStsz_ = false;
+  bool hasStco_ = false;
+
+  uint32_t chunk_;
+  uint32_t frame_;
+  std::vector<std::byte> in_;
+  std::vector<std::byte> out_;
+  size_t outSize_;
+  size_t outOff_;
+};
+
+}  // namespace codecs
diff --git a/src/codecs/include/types.hpp b/src/codecs/include/types.hpp
index 493a177a..60a49300 100644
--- a/src/codecs/include/types.hpp
+++ b/src/codecs/include/types.hpp
@@ -18,6 +18,7 @@ enum class StreamType {
   kWav,
   kNative,
   kWavPack,
+  kAlac,
 };
 
 auto StreamTypeToString(StreamType t) -> std::string;
diff --git a/src/tangara/audio/fatfs_stream_factory.cpp b/src/tangara/audio/fatfs_stream_factory.cpp
index 9089735c..2385eb69 100644
--- a/src/tangara/audio/fatfs_stream_factory.cpp
+++ b/src/tangara/audio/fatfs_stream_factory.cpp
@@ -90,6 +90,8 @@ auto FatfsStreamFactory::ContainerToStreamType(database::Container enc)
       return codecs::StreamType::kOpus;
     case database::Container::kWavPack:
       return codecs::StreamType::kWavPack;
+    case database::Container::kAlac:
+      return codecs::StreamType::kAlac;
     case database::Container::kUnsupported:
     default:
       return {};
diff --git a/src/tangara/database/tag_parser.cpp b/src/tangara/database/tag_parser.cpp
index 0be6cb35..1b7b4b82 100644
--- a/src/tangara/database/tag_parser.cpp
+++ b/src/tangara/database/tag_parser.cpp
@@ -416,6 +416,9 @@ auto GenericTagParser::ReadAndParseTags(std::string_view p)
     case Fwavpack:
       out->encoding(Container::kWavPack);
       break;
+    case Falac:
+      out->encoding(Container::kAlac);
+      break;
     default:
       out->encoding(Container::kUnsupported);
   }
diff --git a/src/tangara/database/tag_parser.hpp b/src/tangara/database/tag_parser.hpp
index eb0f4c7c..fc86c10a 100644
--- a/src/tangara/database/tag_parser.hpp
+++ b/src/tangara/database/tag_parser.hpp
@@ -62,9 +62,9 @@ class GenericTagParser : public ITagParser {
   // Supported file extensions for parsing tags, derived from the list of
   // supported audio formats here:
   // https://cooltech.zone/tangara/docs/music-library/
-  static constexpr std::string supported_exts[] = {"flac", "mp3",  "ogg",
-                                                   "ogx",  "opus", "wav",
-                                                   "wv"};
+  static constexpr std::string supported_exts[] = {"flac", "m4a", "mp3",
+                                                   "ogg", "ogx",  "opus",
+                                                   "wav", "wv"};
 };
 
 }  // namespace database
diff --git a/src/tangara/database/track.hpp b/src/tangara/database/track.hpp
index d6039451..e215abb1 100644
--- a/src/tangara/database/track.hpp
+++ b/src/tangara/database/track.hpp
@@ -46,6 +46,7 @@ enum class Container {
   kFlac = 4,
   kOpus = 5,
   kWavPack = 6,
+  kAlac = 7,
 };
 
 enum class MediaType {
diff --git a/tools/cmake/common.cmake b/tools/cmake/common.cmake
index d5206708..f03da34a 100644
--- a/tools/cmake/common.cmake
+++ b/tools/cmake/common.cmake
@@ -15,6 +15,7 @@ set(CMAKE_CXX_EXTENSIONS ON)
 set(COMPONENTS "")
 
 # External dependencies
+list(APPEND EXTRA_COMPONENT_DIRS "$ENV{PROJ_PATH}/lib/alac")
 list(APPEND EXTRA_COMPONENT_DIRS "$ENV{PROJ_PATH}/lib/bt")
 list(APPEND EXTRA_COMPONENT_DIRS "$ENV{PROJ_PATH}/lib/catch2")
 list(APPEND EXTRA_COMPONENT_DIRS "$ENV{PROJ_PATH}/lib/cbor")