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_3gp6 FOURCC('3', 'g', 'p', '6')
37 #define MP4_aART FOURCC('a', 'A', 'R', 'T')
38 #define MP4_alac FOURCC('a', 'l', 'a', 'c')
39 #define MP4_calb FOURCC(0xa9, 'a', 'l', 'b')
40 #define MP4_cART FOURCC(0xa9, 'A', 'R', 'T')
41 #define MP4_cgrp FOURCC(0xa9, 'g', 'r', 'p')
42 #define MP4_cgen FOURCC(0xa9, 'g', 'e', 'n')
43 #define MP4_chpl FOURCC('c', 'h', 'p', 'l')
44 #define MP4_cnam FOURCC(0xa9, 'n', 'a', 'm')
45 #define MP4_cwrt FOURCC(0xa9, 'w', 'r', 't')
46 #define MP4_ccmt FOURCC(0xa9, 'c', 'm', 't')
47 #define MP4_cday FOURCC(0xa9, 'd', 'a', 'y')
48 #define MP4_disk FOURCC('d', 'i', 's', 'k')
49 #define MP4_esds FOURCC('e', 's', 'd', 's')
50 #define MP4_ftyp FOURCC('f', 't', 'y', 'p')
51 #define MP4_gnre FOURCC('g', 'n', 'r', 'e')
52 #define MP4_hdlr FOURCC('h', 'd', 'l', 'r')
53 #define MP4_ilst FOURCC('i', 'l', 's', 't')
54 #define MP4_M4A FOURCC('M', '4', 'A', ' ')
55 #define MP4_M4B FOURCC('M', '4', 'B', ' ')
56 #define MP4_mdat FOURCC('m', 'd', 'a', 't')
57 #define MP4_mdia FOURCC('m', 'd', 'i', 'a')
58 #define MP4_mdir FOURCC('m', 'd', 'i', 'r')
59 #define MP4_meta FOURCC('m', 'e', 't', 'a')
60 #define MP4_minf FOURCC('m', 'i', 'n', 'f')
61 #define MP4_moov FOURCC('m', 'o', 'o', 'v')
62 #define MP4_mp4a FOURCC('m', 'p', '4', 'a')
63 #define MP4_mp42 FOURCC('m', 'p', '4', '2')
64 #define MP4_qt FOURCC('q', 't', ' ', ' ')
65 #define MP4_soun FOURCC('s', 'o', 'u', 'n')
66 #define MP4_stbl FOURCC('s', 't', 'b', 'l')
67 #define MP4_stsd FOURCC('s', 't', 's', 'd')
68 #define MP4_stts FOURCC('s', 't', 't', 's')
69 #define MP4_trak FOURCC('t', 'r', 'a', 'k')
70 #define MP4_trkn FOURCC('t', 'r', 'k', 'n')
71 #define MP4_udta FOURCC('u', 'd', 't', 'a')
72 #define MP4_extra FOURCC('-', '-', '-', '-')
74 /* Read the tag data from an MP4 file, storing up to buffer_size bytes in
77 static unsigned long read_mp4_tag(int fd
, unsigned int size_left
, char* buffer
,
78 unsigned int buffer_left
)
80 unsigned int bytes_read
= 0;
84 lseek(fd
, size_left
, SEEK_CUR
); /* Skip everything */
88 /* Skip the data tag header - maybe we should parse it properly? */
89 lseek(fd
, 16, SEEK_CUR
);
92 if (size_left
> buffer_left
)
94 read(fd
, buffer
, buffer_left
);
95 lseek(fd
, size_left
- buffer_left
, SEEK_CUR
);
96 bytes_read
= buffer_left
;
100 read(fd
, buffer
, size_left
);
101 bytes_read
= size_left
;
108 /* Read a string tag from an MP4 file */
109 static unsigned int read_mp4_tag_string(int fd
, int size_left
, char** buffer
,
110 unsigned int* buffer_left
, char** dest
)
112 unsigned int bytes_read
= read_mp4_tag(fd
, size_left
, *buffer
,
113 *buffer_left
> 0 ? *buffer_left
- 1 : 0);
114 unsigned int length
= 0;
118 (*buffer
)[bytes_read
] = 0;
120 length
= strlen(*buffer
) + 1;
121 *buffer_left
-= length
;
132 static unsigned int read_mp4_atom(int fd
, uint32_t* size
,
133 uint32_t* type
, uint32_t size_left
)
135 read_uint32be(fd
, size
);
136 read_uint32be(fd
, type
);
140 /* FAT32 doesn't support files this big, so something seems to
141 * be wrong. (64-bit sizes should only be used when required.)
150 if (*size
> size_left
)
170 static unsigned int read_mp4_length(int fd
, uint32_t* size
)
172 unsigned int length
= 0;
181 length
= (length
<< 7) | (c
& 0x7F);
183 while ((c
& 0x80) && (bytes
< 4) && (*size
> 0));
188 static bool read_mp4_esds(int fd
, struct mp3entry
* id3
, uint32_t* size
)
190 unsigned char buf
[8];
193 lseek(fd
, 4, SEEK_CUR
); /* Version and flags. */
194 read(fd
, buf
, 1); /* Verify ES_DescrTag. */
200 if (read_mp4_length(fd
, size
) < 20)
205 lseek(fd
, 3, SEEK_CUR
);
210 lseek(fd
, 2, SEEK_CUR
);
214 read(fd
, buf
, 1); /* Verify DecoderConfigDescrTab. */
222 if (read_mp4_length(fd
, size
) < 13)
227 lseek(fd
, 13, SEEK_CUR
); /* Skip audio type, bit rates, etc. */
231 if (*buf
!= 5) /* Verify DecSpecificInfoTag. */
237 static const int sample_rates
[] =
239 96000, 88200, 64000, 48000, 44100, 32000,
240 24000, 22050, 16000, 12000, 11025, 8000
247 /* Read the (leading part of the) decoder config. */
248 length
= read_mp4_length(fd
, size
);
249 length
= MIN(length
, *size
);
250 length
= MIN(length
, sizeof(buf
));
251 memset(buf
, 0, sizeof(buf
));
252 read(fd
, buf
, length
);
255 /* Maybe time to write a simple read_bits function... */
257 /* Decoder config format:
258 * Object type - 5 bits
259 * Frequency index - 4 bits
260 * Channel configuration - 4 bits
262 bits
= get_long_be(buf
);
263 type
= bits
>> 27; /* Object type - 5 bits */
264 index
= (bits
>> 23) & 0xf; /* Frequency index - 4 bits */
266 if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
268 id3
->frequency
= sample_rates
[index
];
273 DEBUGF("MP4: SBR\n");
274 unsigned int old_index
= index
;
277 index
= (bits
>> 15) & 0xf; /* Frequency index - 4 bits */
281 /* 17 bits read so far... */
282 bits
= get_long_be(&buf
[2]);
283 id3
->frequency
= (bits
>> 7) & 0x00ffffff;
285 else if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
287 id3
->frequency
= sample_rates
[index
];
290 if (old_index
== index
)
292 /* Downsampled SBR */
296 /* Skip 13 bits from above, plus 3 bits, then read 11 bits */
297 else if ((length
>= 4) && (((bits
>> 5) & 0x7ff) == 0x2b7))
299 /* extensionAudioObjectType */
300 DEBUGF("MP4: extensionAudioType\n");
301 type
= bits
& 0x1f; /* Object type - 5 bits*/
302 bits
= get_long_be(&buf
[4]);
310 unsigned int old_index
= index
;
312 /* 1 bit read so far */
313 index
= (bits
>> 27) & 0xf; /* Frequency index - 4 bits */
317 /* 5 bits read so far */
318 id3
->frequency
= (bits
>> 3) & 0x00ffffff;
320 else if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
322 id3
->frequency
= sample_rates
[index
];
325 if (old_index
== index
)
327 /* Downsampled SBR */
334 if (!sbr
&& (id3
->frequency
<= 24000) && (length
<= 2))
336 /* Double the frequency for low-frequency files without a "long"
337 * DecSpecificConfig header. The file may or may not contain SBR,
338 * but here we guess it does if the header is short. This can
339 * fail on some files, but it's the best we can do, short of
340 * decoding (parts of) the file.
349 static bool read_mp4_tags(int fd
, struct mp3entry
* id3
,
354 unsigned int buffer_left
= sizeof(id3
->id3v2buf
) + sizeof(id3
->id3v1buf
);
355 char* buffer
= id3
->id3v2buf
;
360 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
362 /* DEBUGF("Tag atom: '%c%c%c%c' (%d bytes left)\n", type >> 24 & 0xff,
363 type >> 16 & 0xff, type >> 8 & 0xff, type & 0xff, size); */
368 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
373 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
378 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
383 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
388 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
393 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
399 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
404 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
407 /* Try to parse it as a year, for the benefit of the database.
411 id3
->year
= atoi(id3
->year_string
);
412 if (id3
->year
< 1900)
424 unsigned short genre
;
426 read_mp4_tag(fd
, size
, (char*) &genre
, sizeof(genre
));
427 id3
->genre_string
= id3_get_num_genre(betoh16(genre
) - 1);
432 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
440 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
441 id3
->discnum
= betoh16(n
[1]);
449 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
450 id3
->tracknum
= betoh16(n
[1]);
456 char tag_name
[TAG_NAME_LENGTH
];
460 read_uint32be(fd
, &sub_size
);
462 lseek(fd
, sub_size
- 4, SEEK_CUR
);
464 read_uint32be(fd
, &sub_size
);
466 lseek(fd
, 8, SEEK_CUR
);
469 if (sub_size
> sizeof(tag_name
) - 1)
471 read(fd
, tag_name
, sizeof(tag_name
) - 1);
472 lseek(fd
, sub_size
- (sizeof(tag_name
) - 1), SEEK_CUR
);
473 tag_name
[sizeof(tag_name
) - 1] = 0;
477 read(fd
, tag_name
, sub_size
);
478 tag_name
[sub_size
] = 0;
481 if ((strcasecmp(tag_name
, "composer") == 0) && !cwrt
)
483 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
486 else if (strcasecmp(tag_name
, "iTunSMPB") == 0)
488 char value
[TAG_VALUE_LENGTH
];
489 char* value_p
= value
;
491 unsigned int length
= sizeof(value
);
493 read_mp4_tag_string(fd
, size
, &value_p
, &length
, &any
);
494 id3
->lead_trim
= get_itunes_int32(value
, 1);
495 id3
->tail_trim
= get_itunes_int32(value
, 2);
496 DEBUGF("AAC: lead_trim %d, tail_trim %d\n",
497 id3
->lead_trim
, id3
->tail_trim
);
499 else if (strcasecmp(tag_name
, "musicbrainz track id") == 0)
501 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
504 else if ((strcasecmp(tag_name
, "album artist") == 0))
506 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
512 unsigned int length
= read_mp4_tag_string(fd
, size
,
513 &buffer
, &buffer_left
, &any
);
517 /* Re-use the read buffer as the dest buffer... */
519 buffer_left
+= length
;
521 if (parse_replaygain(tag_name
, buffer
, id3
,
522 buffer
, buffer_left
) > 0)
524 /* Data used, keep it. */
526 buffer_left
-= length
;
534 lseek(fd
, size
, SEEK_CUR
);
538 while ((size_left
> 0) && (errno
== 0));
543 static bool read_mp4_container(int fd
, struct mp3entry
* id3
,
548 uint32_t handler
= 0;
553 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
555 /* DEBUGF("Atom: '%c%c%c%c' (0x%08x, %d bytes left)\n",
556 (type >> 24) & 0xff, (type >> 16) & 0xff, (type >> 8) & 0xff,
557 type & 0xff, type, size); */
565 read_uint32be(fd
, &id
);
568 if ((id
!= MP4_M4A
) && (id
!= MP4_M4B
) && (id
!= MP4_mp42
)
569 && (id
!= MP4_qt
) && (id
!= MP4_3gp6
))
571 DEBUGF("Unknown MP4 file type: '%c%c%c%c'\n",
572 (int)(id
>> 24 & 0xff), (int)(id
>> 16 & 0xff),
573 (int)(id
>> 8 & 0xff), (int)(id
& 0xff));
580 lseek(fd
, 4, SEEK_CUR
); /* Skip version */
589 rc
= read_mp4_container(fd
, id3
, size
);
594 if (handler
== MP4_mdir
)
596 rc
= read_mp4_tags(fd
, id3
, size
);
602 if (handler
== MP4_soun
)
604 rc
= read_mp4_container(fd
, id3
, size
);
610 lseek(fd
, 8, SEEK_CUR
);
612 rc
= read_mp4_container(fd
, id3
, size
);
617 lseek(fd
, 8, SEEK_CUR
);
618 read_uint32be(fd
, &handler
);
620 /* DEBUGF(" Handler '%c%c%c%c'\n", handler >> 24 & 0xff,
621 handler >> 16 & 0xff, handler >> 8 & 0xff,handler & 0xff); */
629 lseek(fd
, 4, SEEK_CUR
);
630 read_uint32be(fd
, &entries
);
633 for (i
= 0; i
< entries
; i
++)
638 read_uint32be(fd
, &n
);
639 read_uint32be(fd
, &l
);
640 id3
->samples
+= n
* l
;
652 id3
->codectype
= (type
== MP4_mp4a
) ? AFMT_MP4_AAC
: AFMT_MP4_ALAC
;
653 lseek(fd
, 22, SEEK_CUR
);
654 read_uint32be(fd
, &frequency
);
656 id3
->frequency
= frequency
;
658 if (type
== MP4_mp4a
)
663 /* Get frequency from the decoder info tag, if possible. */
664 lseek(fd
, 2, SEEK_CUR
);
665 /* The esds atom is a part of the mp4a atom, so ignore
666 * the returned size (it's already accounted for).
668 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
671 if (subtype
== MP4_esds
)
673 read_mp4_esds(fd
, id3
, &size
);
680 id3
->filesize
= size
;
685 /* ADDME: add support for real chapters. Right now it's only
686 * used for Nero's gapless hack */
690 lseek(fd
, 8, SEEK_CUR
);
691 read_uint8(fd
, &chapters
);
694 /* the first chapter will be used as the lead_trim */
696 read_uint64be(fd
, ×tamp
);
697 id3
->lead_trim
= (timestamp
* id3
->frequency
) / 10000000;
707 lseek(fd
, size
, SEEK_CUR
);
709 while (rc
&& (size_left
> 0) && (errno
== 0) && (id3
->filesize
== 0));
710 /* Break on non-zero filesize, since Rockbox currently doesn't support
711 * metadata after the mdat atom (which sets the filesize field).
717 bool get_mp4_metadata(int fd
, struct mp3entry
* id3
)
719 id3
->codectype
= AFMT_UNKNOWN
;
723 if (read_mp4_container(fd
, id3
, filesize(fd
)) && (errno
== 0)
724 && (id3
->samples
> 0) && (id3
->frequency
> 0)
725 && (id3
->filesize
> 0))
727 if (id3
->codectype
== AFMT_UNKNOWN
)
729 logf("Not an ALAC or AAC file");
733 id3
->length
= ((int64_t) id3
->samples
* 1000) / id3
->frequency
;
735 if (id3
->length
<= 0)
737 logf("mp4 length invalid!");
741 id3
->bitrate
= ((int64_t) id3
->filesize
* 8) / id3
->length
;
742 DEBUGF("MP4 bitrate %d, frequency %ld Hz, length %ld ms\n",
743 id3
->bitrate
, id3
->frequency
, id3
->length
);
747 logf("MP4 metadata error");
748 DEBUGF("MP4 metadata error. errno %d, frequency %ld, filesize %ld\n",
749 errno
, id3
->frequency
, id3
->filesize
);