diff options
Diffstat (limited to 'apps/metadata.c')
| -rw-r--r-- | apps/metadata.c | 723 |
1 files changed, 427 insertions, 296 deletions
diff --git a/apps/metadata.c b/apps/metadata.c index 1b2dde3a24..ff0cb76cbe 100644 --- a/apps/metadata.c +++ b/apps/metadata.c @@ -22,6 +22,7 @@ #include <ctype.h> #include <inttypes.h> +#include "errno.h" #include "metadata.h" #include "mp3_playback.h" #include "logf.h" @@ -40,6 +41,37 @@ enum tagtype { TAGTYPE_APE = 1, TAGTYPE_VORBIS }; #define TAG_NAME_LENGTH 32 #define TAG_VALUE_LENGTH 128 +#define MP4_ID(a, b, c, d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d)) + +#define MP4_3gp6 MP4_ID('3', 'g', 'p', '6') +#define MP4_alac MP4_ID('a', 'l', 'a', 'c') +#define MP4_calb MP4_ID(0xa9, 'a', 'l', 'b') +#define MP4_cART MP4_ID(0xa9, 'A', 'R', 'T') +#define MP4_cnam MP4_ID(0xa9, 'n', 'a', 'm') +#define MP4_cwrt MP4_ID(0xa9, 'w', 'r', 't') +#define MP4_ftyp MP4_ID('f', 't', 'y', 'p') +#define MP4_gnre MP4_ID('g', 'n', 'r', 'e') +#define MP4_hdlr MP4_ID('h', 'd', 'l', 'r') +#define MP4_ilst MP4_ID('i', 'l', 's', 't') +#define MP4_M4A MP4_ID('M', '4', 'A', ' ') +#define MP4_mdat MP4_ID('m', 'd', 'a', 't') +#define MP4_mdia MP4_ID('m', 'd', 'i', 'a') +#define MP4_mdir MP4_ID('m', 'd', 'i', 'r') +#define MP4_meta MP4_ID('m', 'e', 't', 'a') +#define MP4_minf MP4_ID('m', 'i', 'n', 'f') +#define MP4_moov MP4_ID('m', 'o', 'o', 'v') +#define MP4_mp4a MP4_ID('m', 'p', '4', 'a') +#define MP4_mp42 MP4_ID('m', 'p', '4', '2') +#define MP4_qt MP4_ID('q', 't', ' ', ' ') +#define MP4_soun MP4_ID('s', 'o', 'u', 'n') +#define MP4_stbl MP4_ID('s', 't', 'b', 'l') +#define MP4_stsd MP4_ID('s', 't', 's', 'd') +#define MP4_stts MP4_ID('s', 't', 't', 's') +#define MP4_trak MP4_ID('t', 'r', 'a', 'k') +#define MP4_trkn MP4_ID('t', 'r', 'k', 'n') +#define MP4_udta MP4_ID('u', 'd', 't', 'a') +#define MP4_extra MP4_ID('-', '-', '-', '-') + struct apetag_header { char id[8]; @@ -190,28 +222,31 @@ 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 -*/ +/* Read an unsigned 16-bit integer from a big-endian file. */ #ifdef ROCKBOX_BIG_ENDIAN -#define read_uint32be(fd,buf) read((fd),(buf),4) +#define read_uint16be(fd, buf) read((fd), (buf), 2) #else -int read_uint32be(int fd, unsigned int* buf) { - char tmp; - char* p=(char*)buf; - size_t n; +int read_uint16be(int fd, unsigned short* buf) +{ + size_t n; + + n = read(fd, (char*) buf, 2); + *buf = betoh16(*buf); + return n; +} +#endif - n=read(fd,p,4); - if (n==4) { - tmp=p[0]; - p[0]=p[3]; - p[3]=tmp; - tmp=p[2]; - p[2]=p[1]; - p[1]=tmp; - } +/* Read an unsigned 32-bit integer from a big-endian file. */ +#ifdef ROCKBOX_BIG_ENDIAN +#define read_uint32be(fd,buf) read((fd), (buf), 4) +#else +int read_uint32be(int fd, unsigned int* buf) +{ + size_t n; - return(n); + n = read(fd, (char*) buf, 4); + *buf = betoh32(*buf); + return n; } #endif @@ -921,292 +956,388 @@ static bool get_wave_metadata(int fd, struct mp3entry* id3) return true; } -static bool get_m4a_metadata(int fd, struct mp3entry* id3) +/* Read the tag data from an MP4 file, storing up to buffer_size bytes in + * buffer. + */ +unsigned long read_mp4_tag(int fd, unsigned int size_left, char* buffer, + unsigned int buffer_left) { - 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 (n < 4) - return false; - - if (memcmp(&chunk_id,"ftyp",4)==0) { - /* Check for M4A type */ - n=read(fd,&chunk_id,4); - if ((memcmp(&chunk_id,"M4A ",4)!=0) && - (memcmp(&chunk_id,"mp42",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; + unsigned int bytes_read = 0; + + if (buffer_left == 0) + { + lseek(fd, size_left, SEEK_CUR); /* Skip everything */ + } + else + { + /* Skip the data tag header - maybe we should parse it properly? */ + lseek(fd, 16, SEEK_CUR); + size_left -= 16; + + if (size_left > buffer_left) + { + read(fd, buffer, buffer_left); + lseek(fd, size_left - buffer_left, SEEK_CUR); + bytes_read = buffer_left; + } + else + { + read(fd, buffer, size_left); + bytes_read = size_left; + } + } + + return bytes_read; +} + +/* Read a string tag from an MP4 file */ +unsigned int read_mp4_tag_string(int fd, int size_left, char** buffer, + unsigned int* buffer_left, char** dest) +{ + unsigned int bytes_read = read_mp4_tag(fd, size_left, *buffer, + *buffer_left - 1); + unsigned int length = 0; + + if (bytes_read) + { + (*buffer)[bytes_read] = 0; + *dest = *buffer; + length = strlen(*buffer) + 1; + *buffer_left -= length; + *buffer += length; + } + else + { + *dest = NULL; + } + + return length; +} + +static unsigned int read_mp4_atom(int fd, unsigned int* size, + unsigned int* type, unsigned int size_left) +{ + read_uint32be(fd, size); + read_uint32be(fd, type); + + if (*size == 1) + { + /* FAT32 doesn't support files this big, so something seems to + * be wrong. (64-bit sizes should only be used when required.) + */ + errno = EFBIG; + *type = 0; + return 0; + } + + if (*size > 0) + { + if (*size > size_left) + { + size_left = 0; } - 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 + { + size_left -= *size; + } + + *size -= 8; + } + else + { + *size = size_left; + size_left = 0; + } + + return size_left; +} + +static bool read_mp4_tags(int fd, struct mp3entry* id3, + unsigned int size_left) +{ + unsigned int size; + unsigned int type; + unsigned int buffer_left = sizeof(id3->id3v2buf) + sizeof(id3->id3v1buf); + char* buffer = id3->id3v2buf; + bool cwrt = false; + + do + { + size_left = read_mp4_atom(fd, &size, &type, size_left); + + /* DEBUGF("Tag atom: '%c%c%c%c' (%d bytes left)\n", type >> 24 & 0xff, + type >> 16 & 0xff, type >> 8 & 0xff, type & 0xff, size); */ + + switch (type) + { + case MP4_cnam: + read_mp4_tag_string(fd, size, &buffer, &buffer_left, + &id3->title); + break; + + case MP4_cART: + read_mp4_tag_string(fd, size, &buffer, &buffer_left, + &id3->artist); + break; + + case MP4_calb: + read_mp4_tag_string(fd, size, &buffer, &buffer_left, + &id3->album); + break; + + case MP4_cwrt: + read_mp4_tag_string(fd, size, &buffer, &buffer_left, + &id3->composer); + cwrt = false; + break; + + case MP4_gnre: + { + unsigned short genre; + + read_mp4_tag(fd, size, (char*) &genre, sizeof(genre)); + id3->genre = betoh16(genre); + } + break; + + case MP4_trkn: + { + unsigned short n[2]; + + read_mp4_tag(fd, size, (char*) &n, sizeof(n)); + id3->tracknum = betoh16(n[1]); + } + break; + + case MP4_extra: + { + char tag_name[TAG_NAME_LENGTH]; + unsigned int sub_size; + + /* "mean" atom */ + read_uint32be(fd, &sub_size); + size -= sub_size; + lseek(fd, sub_size - 4, SEEK_CUR); + /* "name" atom */ + read_uint32be(fd, &sub_size); + size -= sub_size; + lseek(fd, 8, SEEK_CUR); + sub_size -= 12; + + if (sub_size > sizeof(tag_name) - 1) + { + read(fd, tag_name, sizeof(tag_name) - 1); + lseek(fd, sub_size - sizeof(tag_name) - 1, SEEK_CUR); + tag_name[sizeof(tag_name) - 1] = 0; + } + else + { + read(fd, tag_name, sub_size); + tag_name[sub_size] = 0; + } + + if ((strcasecmp(tag_name, "composer") == 0) && !cwrt) + { + read_mp4_tag_string(fd, size, &buffer, &buffer_left, + &id3->composer); + } + else + { + char* any; + unsigned int length = read_mp4_tag_string(fd, size, + &buffer, &buffer_left, &any); + + if (length > 0) + { + /* Re-use the read buffer as the dest buffer... */ + buffer -= length; + buffer_left += length; + + parse_replaygain(tag_name, buffer, id3, buffer, + buffer_left); } - } 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 - skipping possible edts */ - n=read_uint32be(fd,&sub_chunk_len); - n=read(fd,&sub_chunk_id,4); - if (memcmp(&sub_chunk_id,"edts",4)==0) { - lseek(fd, sub_chunk_len - 8, SEEK_CUR); /* FIXME not 8 */ - size_remaining-=sub_chunk_len; - 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; - - if (memcmp(&buf[i],"alac",4)==0) { - id3->codectype=AFMT_ALAC; - } else if (memcmp(&buf[i],"mp4a",4)==0) { - id3->codectype=AFMT_AAC; - } else { - logf("Not an ALAC or AAC 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; + break; + + default: + lseek(fd, size, SEEK_CUR); + break; } - } - } 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; } - } + while ((size_left > 0) && (errno == 0)); - 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; +} - return true; -} +static bool read_mp4_container(int fd, struct mp3entry* id3, + unsigned int size_left) +{ + unsigned int size; + unsigned int type; + unsigned int handler = 0; + bool rc = true; + + do + { + size_left = read_mp4_atom(fd, &size, &type, size_left); + + /* DEBUGF("Atom: '%c%c%c%c' (0x%08x, %d bytes left)\n", + (type >> 24) & 0xff, (type >> 16) & 0xff, (type >> 8) & 0xff, + type & 0xff, type, size); */ + + switch (type) + { + case MP4_ftyp: + { + unsigned int id; + + read_uint32be(fd, &id); + size -= 4; + + if ((id != MP4_M4A) && (id != MP4_mp42) && (id != MP4_qt) + && (id != MP4_3gp6)) + { + DEBUGF("Unknown MP4 file type: '%c%c%c%c'\n", + id >> 24 & 0xff, id >> 16 & 0xff, id >> 8 & 0xff, + id & 0xff); + return false; + } + } + break; + + case MP4_meta: + lseek(fd, 4, SEEK_CUR); /* Skip version */ + size -= 4; + /* Fall through */ + + case MP4_moov: + case MP4_udta: + case MP4_mdia: + case MP4_stbl: + case MP4_trak: + rc = read_mp4_container(fd, id3, size); + size = 0; + break; + + case MP4_ilst: + if (handler == MP4_mdir) + { + rc = read_mp4_tags(fd, id3, size); + size = 0; + } + break; + + case MP4_minf: + if (handler == MP4_soun) + { + rc = read_mp4_container(fd, id3, size); + size = 0; + } + break; + + case MP4_stsd: + lseek(fd, 8, SEEK_CUR); + size -= 8; + rc = read_mp4_container(fd, id3, size); + size = 0; + break; + + case MP4_hdlr: + lseek(fd, 8, SEEK_CUR); + read_uint32be(fd, &handler); + size -= 12; + /* DEBUGF(" Handler '%c%c%c%c'\n", handler >> 24 & 0xff, + handler >> 16 & 0xff, handler >> 8 & 0xff,handler & 0xff); */ + break; + + case MP4_stts: + { + unsigned int entries; + unsigned int i; + + lseek(fd, 4, SEEK_CUR); + read_uint32be(fd, &entries); + id3->samples = 0; + + for (i = 0; i < entries; i++) + { + unsigned int n; + unsigned int l; + + read_uint32be(fd, &n); + read_uint32be(fd, &l); + id3->samples += n * l; + } + + size = 0; + } + break; + + case MP4_mp4a: + case MP4_alac: + { + unsigned int frequency; + + id3->codectype = (type == MP4_mp4a) ? AFMT_AAC : AFMT_ALAC; + lseek(fd, 22, SEEK_CUR); + read_uint32be(fd, &frequency); + size -= 26; + id3->frequency = frequency; + /* There're some child atoms here, but we don't need them */ + } + break; + + case MP4_mdat: + id3->filesize = size; + break; + + default: + break; + } + + lseek(fd, size, SEEK_CUR); + } + while (rc && (size_left > 0) && (errno == 0) && (id3->filesize == 0)); + /* Break on non-zero filesize, since Rockbox currently doesn't support + * metadata after the mdat atom (which sets the filesize field). + */ + + return rc; +} + +static bool get_mp4_metadata(int fd, struct mp3entry* id3) +{ + id3->codectype = AFMT_UNKNOWN; + id3->genre = 255; + id3->filesize = 0; + errno = 0; + + if (read_mp4_container(fd, id3, filesize(fd)) && (errno == 0) + && (id3->samples > 0) && (id3->frequency > 0) + && (id3->filesize > 0)) + { + if (id3->codectype == AFMT_UNKNOWN) + { + logf("Not an ALAC or AAC file"); + return false; + } + + id3->length = (id3->samples / id3->frequency) * 1000; + id3->bitrate = ((int64_t) id3->filesize * 8) / id3->length; + DEBUGF("MP4 bitrate %d, frequency %d Hz, length %d ms\n", + id3->bitrate, id3->frequency, id3->length); + } + else + { + logf("MP4 metadata error"); + DEBUGF("MP4 metadata error. errno %d, length %d, frequency %d, filesize %d\n", + errno, id3->length, id3->frequency, id3->filesize); + return false; + } + + return true; +} static bool get_musepack_metadata(int fd, struct mp3entry *id3) { @@ -1718,7 +1849,7 @@ bool get_metadata(struct track_info* track, int fd, const char* trackname, case AFMT_ALAC: case AFMT_AAC: - if (!get_m4a_metadata(fd, &(track->id3))) + if (!get_mp4_metadata(fd, &(track->id3))) { return false; } |