forked from len0rd/rockbox
First version of ALAC (Apple Lossless) decoder
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@7547 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Dave Chapman
parent
8026f0fe05
commit
139c1cb824
7 changed files with 744 additions and 3 deletions
|
|
@ -54,6 +54,7 @@ codecs/dumb/src/core/*
|
|||
codecs/dumb/src/helpers/*
|
||||
codecs/dumb/src/it/*
|
||||
codecs/libmusepack/*
|
||||
codecs/libalac/*
|
||||
codecs/lib/*.[ch]
|
||||
codecs/lib/Makefile
|
||||
codecs/lib/SOURCES
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ ifdef APPEXTRA
|
|||
endif
|
||||
|
||||
ifdef SOFTWARECODECS
|
||||
CODECLIBS = -lmad -la52 -lFLAC -lTremor -lwavpack -lmusepack
|
||||
CODECLIBS = -lmad -la52 -lFLAC -lTremor -lwavpack -lmusepack -lalac
|
||||
endif
|
||||
|
||||
# we "borrow" the plugin LDS file
|
||||
|
|
@ -39,7 +39,7 @@ DIRS = .
|
|||
|
||||
CODECDEPS = $(LINKCODEC) $(BUILDDIR)/libcodec.a
|
||||
|
||||
.PHONY: libmad liba52 libFLAC libTremor libwavpack dumb libmusepack
|
||||
.PHONY: libmad liba52 libFLAC libTremor libwavpack dumb libmusepack libalac
|
||||
|
||||
OUTPUT = $(SOFTWARECODECS)
|
||||
|
||||
|
|
@ -60,6 +60,7 @@ $(OBJDIR)/vorbis.elf: $(OBJDIR)/vorbis.o $(CODECDEPS) $(BUILDDIR)/libTremor.a
|
|||
$(OBJDIR)/mpc.elf: $(OBJDIR)/mpc.o $(CODECDEPS) $(BUILDDIR)/libmusepack.a
|
||||
$(OBJDIR)/wav.elf: $(OBJDIR)/wav.o $(CODECDEPS)
|
||||
$(OBJDIR)/wavpack.elf: $(OBJDIR)/wavpack.o $(CODECDEPS) $(BUILDDIR)/libwavpack.a
|
||||
$(OBJDIR)/alac.elf: $(OBJDIR)/alac.o $(CODECDEPS) $(BUILDDIR)/libalac.a
|
||||
|
||||
$(OBJDIR)/%.elf: $(OBJDIR)/%.o $(CODECDEPS)
|
||||
$(ELFIT)
|
||||
|
|
@ -152,14 +153,20 @@ libmusepack:
|
|||
@mkdir -p $(OBJDIR)/libmusepack
|
||||
@$(MAKE) -C libmusepack OBJDIR=$(OBJDIR)/libmusepack OUTPUT=$(BUILDDIR)/libmusepack.a
|
||||
|
||||
libalac:
|
||||
@echo "MAKE in libalac"
|
||||
@mkdir -p $(OBJDIR)/libalac
|
||||
@$(MAKE) -C libalac OBJDIR=$(OBJDIR)/libalac OUTPUT=$(BUILDDIR)/libalac.a
|
||||
|
||||
clean:
|
||||
@echo "cleaning codecs"
|
||||
$(SILENT)rm -fr $(OBJDIR)/libmad $(BUILDDIR)/libmad.a $(OBJDIR)/liba52 $(OBJDIR)/libFLAC $(OBJDIR)/Tremor $(OBJDIR)/libwavpack $(OBJDIR)/dumb $(BUILDDIR)/libdumb.a $(BUILDDIR)/libdumbd.a $(OBJDIR)/libmusepack $(BUILDDIR)/libmusepack.a
|
||||
$(SILENT)rm -fr $(OBJDIR)/libmad $(BUILDDIR)/libmad.a $(OBJDIR)/liba52 $(OBJDIR)/libFLAC $(OBJDIR)/Tremor $(OBJDIR)/libwavpack $(OBJDIR)/dumb $(BUILDDIR)/libdumb.a $(BUILDDIR)/libdumbd.a $(OBJDIR)/libmusepack $(BUILDDIR)/libmusepack.a $(OBJDIR)/libalac $(BUILDDIR)/libalac.a
|
||||
@$(MAKE) -C libmad clean OBJDIR=$(OBJDIR)/libmad
|
||||
@$(MAKE) -C liba52 clean OBJDIR=$(OBJDIR)/liba52
|
||||
@$(MAKE) -C libFLAC clean OBJDIR=$(OBJDIR)/libFLAC
|
||||
@$(MAKE) -C Tremor clean OBJDIR=$(OBJDIR)/Tremor
|
||||
@$(MAKE) -C libwavpack clean OBJDIR=$(OBJDIR)/libwavpack
|
||||
@$(MAKE) -C libmusepack clean OBJDIR=$(OBJDIR)/libmusepack
|
||||
@$(MAKE) -C libalac clean OBJDIR=$(OBJDIR)/libalac
|
||||
@$(MAKE) -C dumb clean OBJDIR=$(OBJDIR)/dumb
|
||||
@$(MAKE) -C lib clean OBJDIR=$(OBJDIR)/lib
|
||||
|
|
|
|||
|
|
@ -6,4 +6,5 @@ wav.c
|
|||
a52.c
|
||||
mpc.c
|
||||
wavpack.c
|
||||
alac.c
|
||||
#endif
|
||||
|
|
|
|||
388
apps/codecs/alac.c
Normal file
388
apps/codecs/alac.c
Normal file
|
|
@ -0,0 +1,388 @@
|
|||
/***************************************************************************
|
||||
* __________ __ ___.
|
||||
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
||||
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
||||
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
||||
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
||||
* \/ \/ \/ \/ \/
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2005 Dave Chapman
|
||||
*
|
||||
* All files in this archive are subject to the GNU General Public License.
|
||||
* See the file COPYING in the source tree root for full license agreement.
|
||||
*
|
||||
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
||||
* KIND, either express or implied.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#include "codec.h"
|
||||
|
||||
#include <codecs/libalac/demux.h>
|
||||
#include <codecs/libalac/decomp.h>
|
||||
#include <codecs/libalac/stream.h>
|
||||
|
||||
#include "playback.h"
|
||||
#include "dsp.h"
|
||||
#include "lib/codeclib.h"
|
||||
|
||||
#ifndef SIMULATOR
|
||||
extern char iramcopy[];
|
||||
extern char iramstart[];
|
||||
extern char iramend[];
|
||||
#endif
|
||||
|
||||
#define destBufferSize (1024*16)
|
||||
|
||||
char inputBuffer[1024*32]; /* Input buffer */
|
||||
size_t mdat_offset;
|
||||
struct codec_api* rb;
|
||||
struct codec_api* ci;
|
||||
|
||||
/* Implementation of the stream.h functions used by libalac */
|
||||
|
||||
#define _Swap32(v) do { \
|
||||
v = (((v) & 0x000000FF) << 0x18) | \
|
||||
(((v) & 0x0000FF00) << 0x08) | \
|
||||
(((v) & 0x00FF0000) >> 0x08) | \
|
||||
(((v) & 0xFF000000) >> 0x18); } while(0)
|
||||
|
||||
#define _Swap16(v) do { \
|
||||
v = (((v) & 0x00FF) << 0x08) | \
|
||||
(((v) & 0xFF00) >> 0x08); } while (0)
|
||||
|
||||
/* A normal read without any byte-swapping */
|
||||
void stream_read(stream_t *stream, size_t size, void *buf)
|
||||
{
|
||||
ci->read_filebuf(buf,size);
|
||||
if (ci->curpos >= ci->filesize) { stream->eof=1; }
|
||||
}
|
||||
|
||||
int32_t stream_read_int32(stream_t *stream)
|
||||
{
|
||||
int32_t v;
|
||||
stream_read(stream, 4, &v);
|
||||
#ifdef ROCKBOX_LITTLE_ENDIAN
|
||||
_Swap32(v);
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
|
||||
uint32_t stream_read_uint32(stream_t *stream)
|
||||
{
|
||||
uint32_t v;
|
||||
stream_read(stream, 4, &v);
|
||||
#ifdef ROCKBOX_LITTLE_ENDIAN
|
||||
_Swap32(v);
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
|
||||
int16_t stream_read_int16(stream_t *stream)
|
||||
{
|
||||
int16_t v;
|
||||
stream_read(stream, 2, &v);
|
||||
#ifdef ROCKBOX_LITTLE_ENDIAN
|
||||
_Swap16(v);
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
|
||||
uint16_t stream_read_uint16(stream_t *stream)
|
||||
{
|
||||
uint16_t v;
|
||||
stream_read(stream, 2, &v);
|
||||
#ifdef ROCKBOX_LITTLE_ENDIAN
|
||||
_Swap16(v);
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
|
||||
int8_t stream_read_int8(stream_t *stream)
|
||||
{
|
||||
int8_t v;
|
||||
stream_read(stream, 1, &v);
|
||||
return v;
|
||||
}
|
||||
|
||||
uint8_t stream_read_uint8(stream_t *stream)
|
||||
{
|
||||
uint8_t v;
|
||||
stream_read(stream, 1, &v);
|
||||
return v;
|
||||
}
|
||||
|
||||
void stream_skip(stream_t *stream, size_t skip)
|
||||
{
|
||||
(void)stream;
|
||||
ci->advance_buffer(skip);
|
||||
}
|
||||
|
||||
int stream_eof(stream_t *stream)
|
||||
{
|
||||
return stream->eof;
|
||||
}
|
||||
|
||||
void stream_create(stream_t *stream)
|
||||
{
|
||||
stream->eof=0;
|
||||
}
|
||||
|
||||
/* This function was part of the original alac decoder implementation */
|
||||
|
||||
static int get_sample_info(demux_res_t *demux_res, uint32_t samplenum,
|
||||
uint32_t *sample_duration,
|
||||
uint32_t *sample_byte_size)
|
||||
{
|
||||
unsigned int duration_index_accum = 0;
|
||||
unsigned int duration_cur_index = 0;
|
||||
|
||||
if (samplenum >= demux_res->num_sample_byte_sizes) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!demux_res->num_time_to_samples) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
while ((demux_res->time_to_sample[duration_cur_index].sample_count
|
||||
+ duration_index_accum) <= samplenum) {
|
||||
duration_index_accum +=
|
||||
demux_res->time_to_sample[duration_cur_index].sample_count;
|
||||
|
||||
duration_cur_index++;
|
||||
if (duration_cur_index >= demux_res->num_time_to_samples) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
*sample_duration =
|
||||
demux_res->time_to_sample[duration_cur_index].sample_duration;
|
||||
*sample_byte_size = demux_res->sample_byte_size[samplenum];
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Seek to sample_loc (or close to it). Return 1 on success (and
|
||||
modify samplesdone and currentblock), 0 if failed
|
||||
|
||||
Seeking uses the following two arrays:
|
||||
|
||||
1) the sample_byte_size array contains the length in bytes of
|
||||
each block ("sample" in Applespeak).
|
||||
|
||||
2) the time_to_sample array contains the duration (in samples) of
|
||||
each block of data.
|
||||
|
||||
So we just find the block number we are going to seek to (using
|
||||
time_to_sample) and then find the offset in the file (using
|
||||
sample_byte_size).
|
||||
|
||||
Each ALAC block seems to be independent of all the others.
|
||||
*/
|
||||
|
||||
static unsigned int alac_seek (demux_res_t* demux_res,
|
||||
unsigned int sample_loc,
|
||||
size_t* samplesdone, int* currentblock)
|
||||
{
|
||||
int flag;
|
||||
unsigned int i,j;
|
||||
unsigned int newblock;
|
||||
unsigned int newsample;
|
||||
unsigned int newpos;
|
||||
|
||||
/* First check we have the appropriate metadata - we should always
|
||||
have it. */
|
||||
if ((demux_res->num_time_to_samples==0) ||
|
||||
(demux_res->num_sample_byte_sizes==0)) { return 0; }
|
||||
|
||||
/* Find the destination block from time_to_sample array */
|
||||
i=0;
|
||||
newblock=0;
|
||||
newsample=0;
|
||||
flag=0;
|
||||
|
||||
while ((i<demux_res->num_time_to_samples) && (flag==0) &&
|
||||
(newsample < sample_loc)) {
|
||||
j=(sample_loc-newsample) /
|
||||
demux_res->time_to_sample[i].sample_duration;
|
||||
|
||||
if (j <= demux_res->time_to_sample[i].sample_count) {
|
||||
newblock+=j;
|
||||
newsample+=j*demux_res->time_to_sample[i].sample_duration;
|
||||
flag=1;
|
||||
} else {
|
||||
newsample+=(demux_res->time_to_sample[i].sample_duration
|
||||
* demux_res->time_to_sample[i].sample_count);
|
||||
newblock+=demux_res->time_to_sample[i].sample_count;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
/* We know the new block, now calculate the file position */
|
||||
newpos=mdat_offset;
|
||||
for (i=0;i<newblock;i++) {
|
||||
newpos+=demux_res->sample_byte_size[i];
|
||||
}
|
||||
|
||||
/* We know the new file position, so let's try to seek to it */
|
||||
if (ci->seek_buffer(newpos)) {
|
||||
*samplesdone=newsample;
|
||||
*currentblock=newblock;
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* this is the codec entry point */
|
||||
enum codec_status codec_start(struct codec_api* api)
|
||||
{
|
||||
size_t n;
|
||||
demux_res_t demux_res;
|
||||
static stream_t input_stream;
|
||||
uint32_t samplesdone;
|
||||
uint32_t elapsedtime;
|
||||
uint32_t sample_duration;
|
||||
uint32_t sample_byte_size;
|
||||
int outputBytes;
|
||||
unsigned int i;
|
||||
unsigned char* buffer;
|
||||
alac_file alac;
|
||||
int16_t* pDestBuffer;
|
||||
|
||||
/* Generic codec initialisation */
|
||||
TEST_CODEC_API(api);
|
||||
|
||||
rb = api;
|
||||
ci = (struct codec_api*)api;
|
||||
|
||||
#ifndef SIMULATOR
|
||||
rb->memcpy(iramstart, iramcopy, iramend-iramstart);
|
||||
#endif
|
||||
|
||||
ci->configure(CODEC_SET_FILEBUF_LIMIT, (int *)(1024*1024*10));
|
||||
ci->configure(CODEC_SET_FILEBUF_WATERMARK, (int *)(1024*512));
|
||||
ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128));
|
||||
|
||||
ci->configure(DSP_DITHER, (bool *)false);
|
||||
ci->configure(DSP_SET_STEREO_MODE, (int *)STEREO_INTERLEAVED);
|
||||
ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(16));
|
||||
|
||||
next_track:
|
||||
|
||||
if (codec_init(api)) {
|
||||
LOGF("ALAC: Error initialising codec\n");
|
||||
return CODEC_ERROR;
|
||||
}
|
||||
|
||||
while (!rb->taginfo_ready)
|
||||
rb->yield();
|
||||
|
||||
if (rb->id3->frequency != NATIVE_FREQUENCY) {
|
||||
rb->configure(DSP_SET_FREQUENCY, (long *)(rb->id3->frequency));
|
||||
rb->configure(CODEC_DSP_ENABLE, (bool *)true);
|
||||
} else {
|
||||
rb->configure(CODEC_DSP_ENABLE, (bool *)false);
|
||||
}
|
||||
|
||||
stream_create(&input_stream);
|
||||
|
||||
/* if qtmovie_read returns successfully, the stream is up to
|
||||
* the movie data, which can be used directly by the decoder */
|
||||
if (!qtmovie_read(&input_stream, &demux_res)) {
|
||||
LOGF("ALAC: Error initialising file\n");
|
||||
return CODEC_ERROR;
|
||||
}
|
||||
|
||||
/* Keep track of start of stream in file - used for seeking */
|
||||
mdat_offset=ci->curpos;
|
||||
|
||||
/* initialise the sound converter */
|
||||
create_alac(demux_res.sample_size, demux_res.num_channels,&alac);
|
||||
alac_set_info(&alac, demux_res.codecdata);
|
||||
|
||||
i=0;
|
||||
samplesdone=0;
|
||||
/* The main decoding loop */
|
||||
while (i < demux_res.num_sample_byte_sizes) {
|
||||
rb->yield();
|
||||
if (ci->stop_codec || ci->reload_codec) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* Deal with any pending seek requests */
|
||||
if (ci->seek_time) {
|
||||
if (alac_seek(&demux_res,
|
||||
(ci->seek_time/10) * (ci->id3->frequency/100),
|
||||
&samplesdone, &i)) {
|
||||
elapsedtime=(samplesdone*10)/(ci->id3->frequency/100);
|
||||
ci->set_elapsed(elapsedtime);
|
||||
}
|
||||
ci->seek_time = 0;
|
||||
}
|
||||
|
||||
/* Lookup the length (in samples and bytes) of block i */
|
||||
if (!get_sample_info(&demux_res, i, &sample_duration,
|
||||
&sample_byte_size)) {
|
||||
LOGF("ALAC: Error in get_sample_info\n");
|
||||
return CODEC_ERROR;
|
||||
}
|
||||
|
||||
/* Request the required number of bytes from the input buffer */
|
||||
|
||||
buffer=ci->request_buffer(&n,sample_byte_size);
|
||||
if (n!=sample_byte_size) {
|
||||
/* The decode_frame function requires the whole frame, so if we
|
||||
can't get it contiguously from the buffer, then we need to
|
||||
copy it via a read - i.e. we are at the buffer wraparound
|
||||
point */
|
||||
|
||||
/* Check we estimated the maximum buffer size correctly */
|
||||
if (sample_byte_size > sizeof(inputBuffer)) {
|
||||
LOGF("ALAC: Input buffer < %d bytes\n",sample_byte_size);
|
||||
return CODEC_ERROR;
|
||||
}
|
||||
|
||||
n=ci->read_filebuf(inputBuffer,sample_byte_size);
|
||||
if (n!=sample_byte_size) {
|
||||
LOGF("ALAC: Error reading data\n");
|
||||
return CODEC_ERROR;
|
||||
}
|
||||
buffer=inputBuffer;
|
||||
}
|
||||
|
||||
/* Decode one block - returned samples will be host-endian */
|
||||
outputBytes = destBufferSize;
|
||||
rb->yield();
|
||||
pDestBuffer=decode_frame(&alac, buffer, &outputBytes);
|
||||
|
||||
/* Advance codec buffer - unless we did a read */
|
||||
if ((char*)buffer!=(char*)inputBuffer) {
|
||||
ci->advance_buffer(n);
|
||||
}
|
||||
|
||||
/* Output the audio */
|
||||
rb->yield();
|
||||
while(!ci->pcmbuf_insert((char*)pDestBuffer,outputBytes))
|
||||
rb->yield();
|
||||
|
||||
/* Update the elapsed-time indicator */
|
||||
samplesdone+=sample_duration;
|
||||
elapsedtime=(samplesdone*10)/(ci->id3->frequency/100);
|
||||
ci->set_elapsed(elapsedtime);
|
||||
|
||||
/* Keep track of current position - for resuming */
|
||||
ci->set_offset(elapsedtime);
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
LOGF("ALAC: Decoded %d samples\n",samplesdone);
|
||||
|
||||
if (ci->request_next_track())
|
||||
goto next_track;
|
||||
|
||||
return CODEC_OK;
|
||||
}
|
||||
338
apps/metadata.c
338
apps/metadata.c
|
|
@ -75,6 +75,7 @@ static const struct format_list formats[] =
|
|||
{ AFMT_A52, "a52" },
|
||||
{ AFMT_A52, "ac3" },
|
||||
{ AFMT_WAVPACK, "wv" },
|
||||
{ AFMT_ALAC, "m4a" },
|
||||
};
|
||||
|
||||
static const unsigned short a52_bitrates[] =
|
||||
|
|
@ -180,6 +181,30 @@ static void convert_endian(void *data, const char *format)
|
|||
}
|
||||
}
|
||||
|
||||
/* read_uint32be() - read an unsigned integer from a big-endian
|
||||
(e.g. Quicktime) file. This is used by the .m4a parser
|
||||
*/
|
||||
#ifdef ROCKBOX_BIG_ENDIAN
|
||||
#define read_uint32be(fd,buf) read((fd),(buf),4)
|
||||
#else
|
||||
int read_uint32be(int fd, unsigned int* buf) {
|
||||
char tmp;
|
||||
char* p=(char*)buf;
|
||||
size_t n;
|
||||
|
||||
n=read(fd,tmp,4);
|
||||
if (n==4) {
|
||||
tmp=p[0];
|
||||
p[0]=p[3];
|
||||
p[1]=p[2];
|
||||
p[2]=p[1];
|
||||
p[3]=tmp;
|
||||
}
|
||||
|
||||
return(n);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Read an unaligned 32-bit little endian long from buffer. */
|
||||
static unsigned long get_long(void* buf)
|
||||
{
|
||||
|
|
@ -264,6 +289,37 @@ static void convert_utf8(char* utf8)
|
|||
*dest = 0;
|
||||
}
|
||||
|
||||
|
||||
/* Read a string tag from an M4A file */
|
||||
void read_m4a_tag_string(int fd, int len,char** bufptr,size_t* bytes_remaining, char** dest)
|
||||
{
|
||||
int data_length;
|
||||
|
||||
if (bytes_remaining==0) {
|
||||
lseek(fd,len,SEEK_CUR); /* Skip everything */
|
||||
} else {
|
||||
/* Skip the data tag header - maybe we should parse it properly? */
|
||||
lseek(fd,16,SEEK_CUR);
|
||||
len-=16;
|
||||
|
||||
*dest=*bufptr;
|
||||
if ((size_t)len+1 > *bytes_remaining) {
|
||||
read(fd,*bufptr,*bytes_remaining-1);
|
||||
lseek(fd,len-(*bytes_remaining-1),SEEK_CUR);
|
||||
*bufptr+=(*bytes_remaining-1);
|
||||
} else {
|
||||
read(fd,*bufptr,len);
|
||||
*bufptr+=len;
|
||||
}
|
||||
**bufptr=(char)0;
|
||||
|
||||
convert_utf8(*dest);
|
||||
data_length = strlen(*dest)+1;
|
||||
*bufptr=(*dest)+data_length;
|
||||
*bytes_remaining-=data_length;
|
||||
}
|
||||
}
|
||||
|
||||
/* Parse the tag (the name-value pair) and fill id3 and buffer accordingly.
|
||||
* String values to keep are written to buf. Returns number of bytes written
|
||||
* to buf (including end nil).
|
||||
|
|
@ -887,6 +943,280 @@ static bool get_wave_metadata(int fd, struct mp3entry* id3)
|
|||
}
|
||||
|
||||
|
||||
|
||||
static bool get_alac_metadata(int fd, struct mp3entry* id3)
|
||||
{
|
||||
unsigned char* buf;
|
||||
unsigned long totalsamples;
|
||||
int i,j,k;
|
||||
size_t n;
|
||||
size_t bytes_remaining;
|
||||
char* id3buf;
|
||||
unsigned int compressedsize;
|
||||
unsigned int sample_count;
|
||||
unsigned int sample_duration;
|
||||
int numentries;
|
||||
int entry_size;
|
||||
int size_remaining;
|
||||
int chunk_len;
|
||||
unsigned char chunk_id[4];
|
||||
int sub_chunk_len;
|
||||
unsigned char sub_chunk_id[4];
|
||||
|
||||
/* A simple parser to read vital metadata from an ALAC file.
|
||||
This parser also works for AAC files - they are both stored in
|
||||
a Quicktime M4A container. */
|
||||
|
||||
/* Use the trackname part of the id3 structure as a temporary buffer */
|
||||
buf=id3->path;
|
||||
|
||||
lseek(fd, 0, SEEK_SET);
|
||||
|
||||
totalsamples=0;
|
||||
compressedsize=0;
|
||||
/* read the chunks - we stop when we find the mdat chunk and set compressedsize */
|
||||
while (compressedsize==0) {
|
||||
n=read_uint32be(fd,&chunk_len);
|
||||
|
||||
// This means it was a 64-bit file, so we have problems.
|
||||
if (chunk_len == 1) {
|
||||
logf("need 64bit support\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
n=read(fd,&chunk_id,4);
|
||||
if (memcmp(&chunk_id,"ftyp",4)==0) {
|
||||
/* Check for M4A type */
|
||||
n=read(fd,&chunk_id,4);
|
||||
if (memcmp(&chunk_id,"M4A ",4)!=0) {
|
||||
logf("Not an M4A file, aborting\n");
|
||||
return false;
|
||||
}
|
||||
/* Skip rest of chunk */
|
||||
lseek(fd, chunk_len - 8 - 4, SEEK_CUR); /* FIXME not 8 */
|
||||
} else if (memcmp(&chunk_id,"moov",4)==0) {
|
||||
size_remaining=chunk_len - 8; /* FIXME not 8 */
|
||||
|
||||
while (size_remaining > 0) {
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
if ((sub_chunk_len < 1) || (sub_chunk_len > size_remaining)) {
|
||||
logf("Strange sub_chunk_len value inside moov: %d (remaining: %d)\n",sub_chunk_len,size_remaining);
|
||||
return false;
|
||||
}
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
size_remaining-=8;
|
||||
|
||||
if (memcmp(&sub_chunk_id,"mvhd",4)==0) {
|
||||
/* We don't need anything from here - skip */
|
||||
lseek(fd, sub_chunk_len - 8, SEEK_CUR); /* FIXME not 8 */
|
||||
size_remaining-=(sub_chunk_len-8);
|
||||
} else if (memcmp(&sub_chunk_id,"udta",4)==0) {
|
||||
/* The udta chunk contains the metadata - track, artist, album etc.
|
||||
The format appears to be:
|
||||
udta
|
||||
meta
|
||||
hdlr
|
||||
ilst
|
||||
.nam
|
||||
[rest of tags]
|
||||
free
|
||||
|
||||
NOTE: This code was written by examination of some .m4a files
|
||||
produced by iTunes v4.9 - it may not therefore be 100%
|
||||
compliant with all streams. But it should fail gracefully.
|
||||
*/
|
||||
j=(sub_chunk_len-8);
|
||||
size_remaining-=j;
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
j-=8;
|
||||
if (memcmp(&sub_chunk_id,"meta",4)==0) {
|
||||
lseek(fd, 4, SEEK_CUR);
|
||||
j-=4;
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
j-=8;
|
||||
if (memcmp(&sub_chunk_id,"hdlr",4)==0) {
|
||||
lseek(fd, sub_chunk_len - 8, SEEK_CUR);
|
||||
j-=(sub_chunk_len - 8);
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
j-=8;
|
||||
if (memcmp(&sub_chunk_id,"ilst",4)==0) {
|
||||
/* Here are the actual tags. We use the id3v2 300-byte buffer
|
||||
to store the string data */
|
||||
bytes_remaining=sizeof(id3->id3v2buf);
|
||||
id3->genre=255; /* Not every track is the Blues */
|
||||
id3buf=id3->id3v2buf;
|
||||
k=sub_chunk_len-8;
|
||||
j-=k;
|
||||
while (k > 0) {
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
k-=8;
|
||||
if (memcmp(sub_chunk_id,"\251nam",4)==0) {
|
||||
read_m4a_tag_string(fd,sub_chunk_len-8,&id3buf,&bytes_remaining,&id3->title);
|
||||
} else if (memcmp(sub_chunk_id,"\251ART",4)==0) {
|
||||
read_m4a_tag_string(fd,sub_chunk_len-8,&id3buf,&bytes_remaining,&id3->artist);
|
||||
} else if (memcmp(sub_chunk_id,"\251alb",4)==0) {
|
||||
read_m4a_tag_string(fd,sub_chunk_len-8,&id3buf,&bytes_remaining,&id3->album);
|
||||
} else if (memcmp(sub_chunk_id,"\251gen",4)==0) {
|
||||
read_m4a_tag_string(fd,sub_chunk_len-8,&id3buf,&bytes_remaining,&id3->genre_string);
|
||||
} else if (memcmp(sub_chunk_id,"\251day",4)==0) {
|
||||
read_m4a_tag_string(fd,sub_chunk_len-8,&id3buf,&bytes_remaining,&id3->year_string);
|
||||
} else if (memcmp(sub_chunk_id,"trkn",4)==0) {
|
||||
if (sub_chunk_len==0x20) {
|
||||
read(fd,buf,sub_chunk_len-8);
|
||||
id3->tracknum=buf[19];
|
||||
} else {
|
||||
lseek(fd, sub_chunk_len-8,SEEK_CUR);
|
||||
}
|
||||
} else {
|
||||
lseek(fd, sub_chunk_len-8,SEEK_CUR);
|
||||
}
|
||||
k-=(sub_chunk_len-8);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Skip any remaining data in udta chunk */
|
||||
lseek(fd, j, SEEK_CUR);
|
||||
} else if (memcmp(&sub_chunk_id,"trak",4)==0) {
|
||||
/* Format of trak chunk:
|
||||
tkhd
|
||||
mdia
|
||||
mdhd
|
||||
hdlr
|
||||
minf
|
||||
smhd
|
||||
dinf
|
||||
stbl
|
||||
stsd - Samplerate, Samplesize, Numchannels
|
||||
stts - time_to_sample array - RLE'd table containing duration of each block
|
||||
stsz - sample_byte_size array - ?Size in bytes of each compressed block
|
||||
stsc - Seek table related?
|
||||
stco - Seek table related?
|
||||
*/
|
||||
|
||||
/* Skip tkhd - not needed */
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
if (memcmp(&sub_chunk_id,"tkhd",4)!=0) {
|
||||
logf("Expecting tkhd\n");
|
||||
return false;
|
||||
}
|
||||
lseek(fd, sub_chunk_len - 8, SEEK_CUR); /* FIXME not 8 */
|
||||
size_remaining-=sub_chunk_len;
|
||||
|
||||
/* Process mdia */
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
if (memcmp(&sub_chunk_id,"mdia",4)!=0) {
|
||||
logf("Expecting mdia\n");
|
||||
return false;
|
||||
}
|
||||
size_remaining-=sub_chunk_len;
|
||||
j=sub_chunk_len-8;
|
||||
|
||||
while (j > 0) {
|
||||
n=read_uint32be(fd,&sub_chunk_len);
|
||||
n=read(fd,&sub_chunk_id,4);
|
||||
j-=4;
|
||||
if (memcmp(&sub_chunk_id,"minf",4)==0) {
|
||||
j=sub_chunk_len-8;
|
||||
} else if (memcmp(&sub_chunk_id,"stbl",4)==0) {
|
||||
j=sub_chunk_len-8;
|
||||
} else if (memcmp(&sub_chunk_id,"stsd",4)==0) {
|
||||
n=read(fd,buf,sub_chunk_len-8);
|
||||
j-=sub_chunk_len;
|
||||
i=0;
|
||||
/* Skip version and flags */
|
||||
i+=4;
|
||||
|
||||
numentries=(buf[i]<<24)|(buf[i+1]<<16)|(buf[i+2]<<8)|buf[i+3];
|
||||
i+=4;
|
||||
if (numentries!=1) {
|
||||
logf("ERROR: Expecting only one entry in stsd\n");
|
||||
}
|
||||
|
||||
entry_size=(buf[i]<<24)|(buf[i+1]<<16)|(buf[i+2]<<8)|buf[i+3];
|
||||
i+=4;
|
||||
|
||||
/* Check the codec type - 'alac' for ALAC, 'mp4a' for AAC */
|
||||
if (memcmp(&buf[i],"alac",4)!=0) {
|
||||
logf("Not an ALAC file\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
//numchannels=(buf[i+20]<<8)|buf[i+21]; /* Not used - assume Stereo */
|
||||
//samplesize=(buf[i+22]<<8)|buf[i+23]; /* Not used - assume 16-bit */
|
||||
|
||||
/* Samplerate is 32-bit fixed point, but this works for < 65536 Hz */
|
||||
id3->frequency=(buf[i+28]<<8)|buf[i+29];
|
||||
} else if (memcmp(&sub_chunk_id,"stts",4)==0) {
|
||||
j-=sub_chunk_len;
|
||||
i=8;
|
||||
n=read(fd,buf,8);
|
||||
i+=8;
|
||||
numentries=(buf[4]<<24)|(buf[5]<<16)|(buf[6]<<8)|buf[7];
|
||||
for (k=0;k<numentries;k++) {
|
||||
n=read_uint32be(fd,&sample_count);
|
||||
n=read_uint32be(fd,&sample_duration);
|
||||
totalsamples+=sample_count*sample_duration;
|
||||
i+=8;
|
||||
}
|
||||
if (i > 0) lseek(fd, sub_chunk_len - i, SEEK_CUR);
|
||||
} else if (memcmp(&sub_chunk_id,"stsz",4)==0) {
|
||||
j-=sub_chunk_len;
|
||||
i=8;
|
||||
n=read(fd,buf,8);
|
||||
i+=8;
|
||||
numentries=(buf[4]<<24)|(buf[5]<<16)|(buf[6]<<8)|buf[7];
|
||||
for (k=0;k<numentries;k++) {
|
||||
n=read_uint32be(fd,&sample_count);
|
||||
n=read_uint32be(fd,&sample_duration);
|
||||
totalsamples+=sample_count*sample_duration;
|
||||
i+=8;
|
||||
}
|
||||
if (i > 0) lseek(fd, sub_chunk_len - i, SEEK_CUR);
|
||||
} else {
|
||||
lseek(fd, sub_chunk_len - 8, SEEK_CUR); /* FIXME not 8 */
|
||||
j-=sub_chunk_len;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
logf("Unexpected sub_chunk_id inside moov: %c%c%c%c\n",
|
||||
sub_chunk_id[0],sub_chunk_id[1],sub_chunk_id[2],sub_chunk_id[3]);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else if (memcmp(&chunk_id,"mdat",4)==0) {
|
||||
/* once we hit mdat we stop reading and return.
|
||||
* this is on the assumption that there is no furhter interesting
|
||||
* stuff in the stream. if there is stuff will fail (:()).
|
||||
* But we need the read pointer to be at the mdat stuff
|
||||
* for the decoder. And we don't want to rely on fseek/ftell,
|
||||
* as they may not always be avilable */
|
||||
lseek(fd, chunk_len - 8, SEEK_CUR); /* FIXME not 8 */
|
||||
compressedsize=chunk_len-8;
|
||||
} else if (memcmp(&chunk_id,"free",4)==0) {
|
||||
/* these following atoms can be skipped !!!! */
|
||||
lseek(fd, chunk_len - 8, SEEK_CUR); /* FIXME not 8 */
|
||||
} else {
|
||||
logf("(top) unknown chunk id: %c%c%c%c\n", chunk_id[0],chunk_id[1],chunk_id[2],chunk_id[3]);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
id3->vbr=true; /* All ALAC files are VBR */
|
||||
id3->filesize=filesize(fd);
|
||||
id3->samples=totalsamples;
|
||||
id3->length=(10*totalsamples)/(id3->frequency/100);
|
||||
id3->bitrate=(compressedsize*8)/id3->length;;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Simple file type probing by looking at the filename extension. */
|
||||
unsigned int probe_file_format(const char *filename)
|
||||
{
|
||||
|
|
@ -1064,6 +1394,14 @@ bool get_metadata(struct track_info* track, int fd, const char* trackname,
|
|||
track->id3.length = (totalsamples / track->id3.frequency) * 1000;
|
||||
break;
|
||||
|
||||
case AFMT_ALAC:
|
||||
if (!get_alac_metadata(fd, &(track->id3)))
|
||||
{
|
||||
// return false;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
/* If we don't know how to read the metadata, just store the filename */
|
||||
default:
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -74,6 +74,7 @@ static volatile bool paused;
|
|||
#define CODEC_A52 "/.rockbox/codecs/a52.codec"
|
||||
#define CODEC_MPC "/.rockbox/codecs/mpc.codec"
|
||||
#define CODEC_WAVPACK "/.rockbox/codecs/wavpack.codec"
|
||||
#define CODEC_ALAC "/.rockbox/codecs/alac.codec"
|
||||
|
||||
#define AUDIO_FILL_CYCLE (1024*256)
|
||||
#define AUDIO_DEFAULT_WATERMARK (1024*512)
|
||||
|
|
@ -881,6 +882,10 @@ bool loadcodec(const char *trackname, bool start_play)
|
|||
logf("Codec: WAVPACK");
|
||||
codec_path = CODEC_WAVPACK;
|
||||
break;
|
||||
case AFMT_ALAC:
|
||||
logf("Codec: ALAC");
|
||||
codec_path = CODEC_ALAC;
|
||||
break;
|
||||
default:
|
||||
logf("Codec: Unsupported");
|
||||
snprintf(msgbuf, sizeof(msgbuf)-1, "No codec for: %s", trackname);
|
||||
|
|
|
|||
|
|
@ -82,6 +82,7 @@ const struct filetype filetypes[] = {
|
|||
{ "a52", TREE_ATTR_MPA, Icon_Audio, VOICE_EXT_MPA },
|
||||
{ "mpc", TREE_ATTR_MPA, Icon_Audio, VOICE_EXT_MPA },
|
||||
{ "wv", TREE_ATTR_MPA, Icon_Audio, VOICE_EXT_MPA },
|
||||
{ "m4a", TREE_ATTR_MPA, Icon_Audio, VOICE_EXT_MPA },
|
||||
#endif
|
||||
{ "m3u", TREE_ATTR_M3U, Icon_Playlist, LANG_PLAYLIST },
|
||||
{ "cfg", TREE_ATTR_CFG, Icon_Config, VOICE_EXT_CFG },
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue