1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2005 Magnus Holmgren
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
30 #include "metadata_common.h"
31 #include "metadata_parsers.h"
34 #include "replaygain.h"
36 #define MP4_ID(a, b, c, d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
38 #define MP4_3gp6 MP4_ID('3', 'g', 'p', '6')
39 #define MP4_aART MP4_ID('a', 'A', 'R', 'T')
40 #define MP4_alac MP4_ID('a', 'l', 'a', 'c')
41 #define MP4_calb MP4_ID(0xa9, 'a', 'l', 'b')
42 #define MP4_cART MP4_ID(0xa9, 'A', 'R', 'T')
43 #define MP4_cgrp MP4_ID(0xa9, 'g', 'r', 'p')
44 #define MP4_cgen MP4_ID(0xa9, 'g', 'e', 'n')
45 #define MP4_chpl MP4_ID('c', 'h', 'p', 'l')
46 #define MP4_cnam MP4_ID(0xa9, 'n', 'a', 'm')
47 #define MP4_cwrt MP4_ID(0xa9, 'w', 'r', 't')
48 #define MP4_ccmt MP4_ID(0xa9, 'c', 'm', 't')
49 #define MP4_cday MP4_ID(0xa9, 'd', 'a', 'y')
50 #define MP4_disk MP4_ID('d', 'i', 's', 'k')
51 #define MP4_esds MP4_ID('e', 's', 'd', 's')
52 #define MP4_ftyp MP4_ID('f', 't', 'y', 'p')
53 #define MP4_gnre MP4_ID('g', 'n', 'r', 'e')
54 #define MP4_hdlr MP4_ID('h', 'd', 'l', 'r')
55 #define MP4_ilst MP4_ID('i', 'l', 's', 't')
56 #define MP4_M4A MP4_ID('M', '4', 'A', ' ')
57 #define MP4_M4B MP4_ID('M', '4', 'B', ' ')
58 #define MP4_mdat MP4_ID('m', 'd', 'a', 't')
59 #define MP4_mdia MP4_ID('m', 'd', 'i', 'a')
60 #define MP4_mdir MP4_ID('m', 'd', 'i', 'r')
61 #define MP4_meta MP4_ID('m', 'e', 't', 'a')
62 #define MP4_minf MP4_ID('m', 'i', 'n', 'f')
63 #define MP4_moov MP4_ID('m', 'o', 'o', 'v')
64 #define MP4_mp4a MP4_ID('m', 'p', '4', 'a')
65 #define MP4_mp42 MP4_ID('m', 'p', '4', '2')
66 #define MP4_qt MP4_ID('q', 't', ' ', ' ')
67 #define MP4_soun MP4_ID('s', 'o', 'u', 'n')
68 #define MP4_stbl MP4_ID('s', 't', 'b', 'l')
69 #define MP4_stsd MP4_ID('s', 't', 's', 'd')
70 #define MP4_stts MP4_ID('s', 't', 't', 's')
71 #define MP4_trak MP4_ID('t', 'r', 'a', 'k')
72 #define MP4_trkn MP4_ID('t', 'r', 'k', 'n')
73 #define MP4_udta MP4_ID('u', 'd', 't', 'a')
74 #define MP4_extra MP4_ID('-', '-', '-', '-')
76 /* Read the tag data from an MP4 file, storing up to buffer_size bytes in
79 static unsigned long read_mp4_tag(int fd
, unsigned int size_left
, char* buffer
,
80 unsigned int buffer_left
)
82 unsigned int bytes_read
= 0;
86 lseek(fd
, size_left
, SEEK_CUR
); /* Skip everything */
90 /* Skip the data tag header - maybe we should parse it properly? */
91 lseek(fd
, 16, SEEK_CUR
);
94 if (size_left
> buffer_left
)
96 read(fd
, buffer
, buffer_left
);
97 lseek(fd
, size_left
- buffer_left
, SEEK_CUR
);
98 bytes_read
= buffer_left
;
102 read(fd
, buffer
, size_left
);
103 bytes_read
= size_left
;
110 /* Read a string tag from an MP4 file */
111 static unsigned int read_mp4_tag_string(int fd
, int size_left
, char** buffer
,
112 unsigned int* buffer_left
, char** dest
)
114 unsigned int bytes_read
= read_mp4_tag(fd
, size_left
, *buffer
,
115 *buffer_left
> 0 ? *buffer_left
- 1 : 0);
116 unsigned int length
= 0;
120 (*buffer
)[bytes_read
] = 0;
122 length
= strlen(*buffer
) + 1;
123 *buffer_left
-= length
;
134 static unsigned int read_mp4_atom(int fd
, uint32_t* size
,
135 uint32_t* type
, uint32_t size_left
)
137 read_uint32be(fd
, size
);
138 read_uint32be(fd
, type
);
142 /* FAT32 doesn't support files this big, so something seems to
143 * be wrong. (64-bit sizes should only be used when required.)
152 if (*size
> size_left
)
172 static unsigned int read_mp4_length(int fd
, uint32_t* size
)
174 unsigned int length
= 0;
183 length
= (length
<< 7) | (c
& 0x7F);
185 while ((c
& 0x80) && (bytes
< 4) && (*size
> 0));
190 static bool read_mp4_esds(int fd
, struct mp3entry
* id3
, uint32_t* size
)
192 unsigned char buf
[8];
195 lseek(fd
, 4, SEEK_CUR
); /* Version and flags. */
196 read(fd
, buf
, 1); /* Verify ES_DescrTag. */
202 if (read_mp4_length(fd
, size
) < 20)
207 lseek(fd
, 3, SEEK_CUR
);
212 lseek(fd
, 2, SEEK_CUR
);
216 read(fd
, buf
, 1); /* Verify DecoderConfigDescrTab. */
224 if (read_mp4_length(fd
, size
) < 13)
229 lseek(fd
, 13, SEEK_CUR
); /* Skip audio type, bit rates, etc. */
233 if (*buf
!= 5) /* Verify DecSpecificInfoTag. */
239 static const int sample_rates
[] =
241 96000, 88200, 64000, 48000, 44100, 32000,
242 24000, 22050, 16000, 12000, 11025, 8000
249 /* Read the (leading part of the) decoder config. */
250 length
= read_mp4_length(fd
, size
);
251 length
= MIN(length
, *size
);
252 length
= MIN(length
, sizeof(buf
));
253 memset(buf
, 0, sizeof(buf
));
254 read(fd
, buf
, length
);
257 /* Maybe time to write a simple read_bits function... */
259 /* Decoder config format:
260 * Object type - 5 bits
261 * Frequency index - 4 bits
262 * Channel configuration - 4 bits
264 bits
= get_long_be(buf
);
265 type
= bits
>> 27; /* Object type - 5 bits */
266 index
= (bits
>> 23) & 0xf; /* Frequency index - 4 bits */
268 if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
270 id3
->frequency
= sample_rates
[index
];
275 DEBUGF("MP4: SBR\n");
276 unsigned int old_index
= index
;
279 index
= (bits
>> 15) & 0xf; /* Frequency index - 4 bits */
283 /* 17 bits read so far... */
284 bits
= get_long_be(&buf
[2]);
285 id3
->frequency
= (bits
>> 7) & 0x00ffffff;
287 else if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
289 id3
->frequency
= sample_rates
[index
];
292 if (old_index
== index
)
294 /* Downsampled SBR */
298 /* Skip 13 bits from above, plus 3 bits, then read 11 bits */
299 else if ((length
>= 4) && (((bits
>> 5) & 0x7ff) == 0x2b7))
301 /* extensionAudioObjectType */
302 DEBUGF("MP4: extensionAudioType\n");
303 type
= bits
& 0x1f; /* Object type - 5 bits*/
304 bits
= get_long_be(&buf
[4]);
312 unsigned int old_index
= index
;
314 /* 1 bit read so far */
315 index
= (bits
>> 27) & 0xf; /* Frequency index - 4 bits */
319 /* 5 bits read so far */
320 id3
->frequency
= (bits
>> 3) & 0x00ffffff;
322 else if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
324 id3
->frequency
= sample_rates
[index
];
327 if (old_index
== index
)
329 /* Downsampled SBR */
336 if (!sbr
&& (id3
->frequency
<= 24000) && (length
<= 2))
338 /* Double the frequency for low-frequency files without a "long"
339 * DecSpecificConfig header. The file may or may not contain SBR,
340 * but here we guess it does if the header is short. This can
341 * fail on some files, but it's the best we can do, short of
342 * decoding (parts of) the file.
351 static bool read_mp4_tags(int fd
, struct mp3entry
* id3
,
356 unsigned int buffer_left
= sizeof(id3
->id3v2buf
) + sizeof(id3
->id3v1buf
);
357 char* buffer
= id3
->id3v2buf
;
362 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
364 /* DEBUGF("Tag atom: '%c%c%c%c' (%d bytes left)\n", type >> 24 & 0xff,
365 type >> 16 & 0xff, type >> 8 & 0xff, type & 0xff, size); */
370 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
375 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
380 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
385 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
390 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
395 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
401 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
406 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
409 /* Try to parse it as a year, for the benefit of the database.
413 id3
->year
= atoi(id3
->year_string
);
414 if (id3
->year
< 1900)
426 unsigned short genre
;
428 read_mp4_tag(fd
, size
, (char*) &genre
, sizeof(genre
));
429 id3
->genre_string
= id3_get_num_genre(betoh16(genre
) - 1);
434 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
442 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
443 id3
->discnum
= betoh16(n
[1]);
451 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
452 id3
->tracknum
= betoh16(n
[1]);
458 char tag_name
[TAG_NAME_LENGTH
];
462 read_uint32be(fd
, &sub_size
);
464 lseek(fd
, sub_size
- 4, SEEK_CUR
);
466 read_uint32be(fd
, &sub_size
);
468 lseek(fd
, 8, SEEK_CUR
);
471 if (sub_size
> sizeof(tag_name
) - 1)
473 read(fd
, tag_name
, sizeof(tag_name
) - 1);
474 lseek(fd
, sub_size
- (sizeof(tag_name
) - 1), SEEK_CUR
);
475 tag_name
[sizeof(tag_name
) - 1] = 0;
479 read(fd
, tag_name
, sub_size
);
480 tag_name
[sub_size
] = 0;
483 if ((strcasecmp(tag_name
, "composer") == 0) && !cwrt
)
485 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
488 else if (strcasecmp(tag_name
, "iTunSMPB") == 0)
490 char value
[TAG_VALUE_LENGTH
];
491 char* value_p
= value
;
493 unsigned int length
= sizeof(value
);
495 read_mp4_tag_string(fd
, size
, &value_p
, &length
, &any
);
496 id3
->lead_trim
= get_itunes_int32(value
, 1);
497 id3
->tail_trim
= get_itunes_int32(value
, 2);
498 DEBUGF("AAC: lead_trim %d, tail_trim %d\n",
499 id3
->lead_trim
, id3
->tail_trim
);
501 else if (strcasecmp(tag_name
, "musicbrainz track id") == 0)
503 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
506 else if ((strcasecmp(tag_name
, "album artist") == 0))
508 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
514 unsigned int length
= read_mp4_tag_string(fd
, size
,
515 &buffer
, &buffer_left
, &any
);
519 /* Re-use the read buffer as the dest buffer... */
521 buffer_left
+= length
;
523 if (parse_replaygain(tag_name
, buffer
, id3
,
524 buffer
, buffer_left
) > 0)
526 /* Data used, keep it. */
528 buffer_left
-= length
;
536 lseek(fd
, size
, SEEK_CUR
);
540 while ((size_left
> 0) && (errno
== 0));
545 static bool read_mp4_container(int fd
, struct mp3entry
* id3
,
550 uint32_t handler
= 0;
555 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
557 /* DEBUGF("Atom: '%c%c%c%c' (0x%08x, %d bytes left)\n",
558 (type >> 24) & 0xff, (type >> 16) & 0xff, (type >> 8) & 0xff,
559 type & 0xff, type, size); */
567 read_uint32be(fd
, &id
);
570 if ((id
!= MP4_M4A
) && (id
!= MP4_M4B
) && (id
!= MP4_mp42
)
571 && (id
!= MP4_qt
) && (id
!= MP4_3gp6
))
573 DEBUGF("Unknown MP4 file type: '%c%c%c%c'\n",
574 (int)(id
>> 24 & 0xff), (int)(id
>> 16 & 0xff),
575 (int)(id
>> 8 & 0xff), (int)(id
& 0xff));
582 lseek(fd
, 4, SEEK_CUR
); /* Skip version */
591 rc
= read_mp4_container(fd
, id3
, size
);
596 if (handler
== MP4_mdir
)
598 rc
= read_mp4_tags(fd
, id3
, size
);
604 if (handler
== MP4_soun
)
606 rc
= read_mp4_container(fd
, id3
, size
);
612 lseek(fd
, 8, SEEK_CUR
);
614 rc
= read_mp4_container(fd
, id3
, size
);
619 lseek(fd
, 8, SEEK_CUR
);
620 read_uint32be(fd
, &handler
);
622 /* DEBUGF(" Handler '%c%c%c%c'\n", handler >> 24 & 0xff,
623 handler >> 16 & 0xff, handler >> 8 & 0xff,handler & 0xff); */
631 lseek(fd
, 4, SEEK_CUR
);
632 read_uint32be(fd
, &entries
);
635 for (i
= 0; i
< entries
; i
++)
640 read_uint32be(fd
, &n
);
641 read_uint32be(fd
, &l
);
642 id3
->samples
+= n
* l
;
654 id3
->codectype
= (type
== MP4_mp4a
) ? AFMT_MP4_AAC
: AFMT_MP4_ALAC
;
655 lseek(fd
, 22, SEEK_CUR
);
656 read_uint32be(fd
, &frequency
);
658 id3
->frequency
= frequency
;
660 if (type
== MP4_mp4a
)
665 /* Get frequency from the decoder info tag, if possible. */
666 lseek(fd
, 2, SEEK_CUR
);
667 /* The esds atom is a part of the mp4a atom, so ignore
668 * the returned size (it's already accounted for).
670 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
673 if (subtype
== MP4_esds
)
675 read_mp4_esds(fd
, id3
, &size
);
682 id3
->filesize
= size
;
687 /* ADDME: add support for real chapters. Right now it's only
688 * used for Nero's gapless hack */
692 lseek(fd
, 8, SEEK_CUR
);
693 read_uint8(fd
, &chapters
);
696 /* the first chapter will be used as the lead_trim */
698 read_uint64be(fd
, ×tamp
);
699 id3
->lead_trim
= (timestamp
* id3
->frequency
) / 10000000;
709 lseek(fd
, size
, SEEK_CUR
);
711 while (rc
&& (size_left
> 0) && (errno
== 0) && (id3
->filesize
== 0));
712 /* Break on non-zero filesize, since Rockbox currently doesn't support
713 * metadata after the mdat atom (which sets the filesize field).
719 bool get_mp4_metadata(int fd
, struct mp3entry
* id3
)
721 id3
->codectype
= AFMT_UNKNOWN
;
725 if (read_mp4_container(fd
, id3
, filesize(fd
)) && (errno
== 0)
726 && (id3
->samples
> 0) && (id3
->frequency
> 0)
727 && (id3
->filesize
> 0))
729 if (id3
->codectype
== AFMT_UNKNOWN
)
731 logf("Not an ALAC or AAC file");
735 id3
->length
= ((int64_t) id3
->samples
* 1000) / id3
->frequency
;
737 if (id3
->length
<= 0)
739 logf("mp4 length invalid!");
743 id3
->bitrate
= ((int64_t) id3
->filesize
* 8) / id3
->length
;
744 DEBUGF("MP4 bitrate %d, frequency %ld Hz, length %ld ms\n",
745 id3
->bitrate
, id3
->frequency
, id3
->length
);
749 logf("MP4 metadata error");
750 DEBUGF("MP4 metadata error. errno %d, frequency %ld, filesize %ld\n",
751 errno
, id3
->frequency
, id3
->filesize
);