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_isom FOURCC('i', 's', 'o', 'm')
55 #define MP4_M4A FOURCC('M', '4', 'A', ' ')
56 #define MP4_m4a FOURCC('m', '4', 'a', ' ') /*technically its "M4A "*/
57 #define MP4_M4B FOURCC('M', '4', 'B', ' ') /*but files exist with lower case*/
58 #define MP4_mdat FOURCC('m', 'd', 'a', 't')
59 #define MP4_mdia FOURCC('m', 'd', 'i', 'a')
60 #define MP4_mdir FOURCC('m', 'd', 'i', 'r')
61 #define MP4_meta FOURCC('m', 'e', 't', 'a')
62 #define MP4_minf FOURCC('m', 'i', 'n', 'f')
63 #define MP4_moov FOURCC('m', 'o', 'o', 'v')
64 #define MP4_mp4a FOURCC('m', 'p', '4', 'a')
65 #define MP4_mp42 FOURCC('m', 'p', '4', '2')
66 #define MP4_qt FOURCC('q', 't', ' ', ' ')
67 #define MP4_soun FOURCC('s', 'o', 'u', 'n')
68 #define MP4_stbl FOURCC('s', 't', 'b', 'l')
69 #define MP4_stsd FOURCC('s', 't', 's', 'd')
70 #define MP4_stts FOURCC('s', 't', 't', 's')
71 #define MP4_trak FOURCC('t', 'r', 'a', 'k')
72 #define MP4_trkn FOURCC('t', 'r', 'k', 'n')
73 #define MP4_udta FOURCC('u', 'd', 't', 'a')
74 #define MP4_extra FOURCC('-', '-', '-', '-')
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 unsigned int old_index
= index
;
278 index
= (bits
>> 15) & 0xf; /* Frequency index - 4 bits */
282 /* 17 bits read so far... */
283 bits
= get_long_be(&buf
[2]);
284 id3
->frequency
= (bits
>> 7) & 0x00ffffff;
286 else if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
288 id3
->frequency
= sample_rates
[index
];
291 if (old_index
== index
)
293 /* Downsampled SBR */
297 /* Skip 13 bits from above, plus 3 bits, then read 11 bits */
298 else if ((length
>= 4) && (((bits
>> 5) & 0x7ff) == 0x2b7))
300 /* We found an extensionAudioObjectType */
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.
350 static bool read_mp4_tags(int fd
, struct mp3entry
* id3
,
355 unsigned int buffer_left
= sizeof(id3
->id3v2buf
) + sizeof(id3
->id3v1buf
);
356 char* buffer
= id3
->id3v2buf
;
361 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
363 /* DEBUGF("Tag atom: '%c%c%c%c' (%d bytes left)\n", type >> 24 & 0xff,
364 type >> 16 & 0xff, type >> 8 & 0xff, type & 0xff, size); */
369 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
374 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
379 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
384 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
389 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
394 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
400 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
405 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
408 /* Try to parse it as a year, for the benefit of the database.
412 id3
->year
= atoi(id3
->year_string
);
413 if (id3
->year
< 1900)
425 unsigned short genre
;
427 read_mp4_tag(fd
, size
, (char*) &genre
, sizeof(genre
));
428 id3
->genre_string
= id3_get_num_genre(betoh16(genre
) - 1);
433 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
441 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
442 id3
->discnum
= betoh16(n
[1]);
450 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
451 id3
->tracknum
= betoh16(n
[1]);
457 char tag_name
[TAG_NAME_LENGTH
];
461 read_uint32be(fd
, &sub_size
);
463 lseek(fd
, sub_size
- 4, SEEK_CUR
);
465 read_uint32be(fd
, &sub_size
);
467 lseek(fd
, 8, SEEK_CUR
);
470 if (sub_size
> sizeof(tag_name
) - 1)
472 read(fd
, tag_name
, sizeof(tag_name
) - 1);
473 lseek(fd
, sub_size
- (sizeof(tag_name
) - 1), SEEK_CUR
);
474 tag_name
[sizeof(tag_name
) - 1] = 0;
478 read(fd
, tag_name
, sub_size
);
479 tag_name
[sub_size
] = 0;
482 if ((strcasecmp(tag_name
, "composer") == 0) && !cwrt
)
484 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
487 else if (strcasecmp(tag_name
, "iTunSMPB") == 0)
489 char value
[TAG_VALUE_LENGTH
];
490 char* value_p
= value
;
492 unsigned int length
= sizeof(value
);
494 read_mp4_tag_string(fd
, size
, &value_p
, &length
, &any
);
495 id3
->lead_trim
= get_itunes_int32(value
, 1);
496 id3
->tail_trim
= get_itunes_int32(value
, 2);
497 DEBUGF("AAC: lead_trim %d, tail_trim %d\n",
498 id3
->lead_trim
, id3
->tail_trim
);
500 else if (strcasecmp(tag_name
, "musicbrainz track id") == 0)
502 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
505 else if ((strcasecmp(tag_name
, "album artist") == 0))
507 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
513 unsigned int length
= read_mp4_tag_string(fd
, size
,
514 &buffer
, &buffer_left
, &any
);
518 /* Re-use the read buffer as the dest buffer... */
520 buffer_left
+= length
;
522 if (parse_replaygain(tag_name
, buffer
, id3
,
523 buffer
, buffer_left
) > 0)
525 /* Data used, keep it. */
527 buffer_left
-= length
;
535 lseek(fd
, size
, SEEK_CUR
);
539 while ((size_left
> 0) && (errno
== 0));
544 static bool read_mp4_container(int fd
, struct mp3entry
* id3
,
549 uint32_t handler
= 0;
555 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
557 /* DEBUGF("Atom: '%c%c%c%c' (0x%08lx, %lu bytes left)\n",
558 (int) ((type >> 24) & 0xff), (int) ((type >> 16) & 0xff),
559 (int) ((type >> 8) & 0xff), (int) (type & 0xff),
568 read_uint32be(fd
, &id
);
571 if ((id
!= MP4_M4A
) && (id
!= MP4_M4B
) && (id
!= MP4_mp42
)
572 && (id
!= MP4_qt
) && (id
!= MP4_3gp6
) && (id
!= MP4_m4a
)
575 DEBUGF("Unknown MP4 file type: '%c%c%c%c'\n",
576 (int)(id
>> 24 & 0xff), (int)(id
>> 16 & 0xff),
577 (int)(id
>> 8 & 0xff), (int)(id
& 0xff));
584 lseek(fd
, 4, SEEK_CUR
); /* Skip version */
593 rc
= read_mp4_container(fd
, id3
, size
);
598 /* We need at least a size of 8 to read the next atom. */
599 if (handler
== MP4_mdir
&& size
>8)
601 rc
= read_mp4_tags(fd
, id3
, size
);
607 if (handler
== MP4_soun
)
609 rc
= read_mp4_container(fd
, id3
, size
);
615 lseek(fd
, 8, SEEK_CUR
);
617 rc
= read_mp4_container(fd
, id3
, size
);
622 lseek(fd
, 8, SEEK_CUR
);
623 read_uint32be(fd
, &handler
);
625 /* DEBUGF(" Handler '%c%c%c%c'\n", handler >> 24 & 0xff,
626 handler >> 16 & 0xff, handler >> 8 & 0xff,handler & 0xff); */
634 /* Reset to false. */
635 id3
->needs_upsampling_correction
= false;
637 lseek(fd
, 4, SEEK_CUR
);
638 read_uint32be(fd
, &entries
);
641 for (i
= 0; i
< entries
; i
++)
646 read_uint32be(fd
, &n
);
647 read_uint32be(fd
, &l
);
649 /* Some AAC file use HE profile. In this case the number
650 * of output samples is doubled to a maximum of 2048
651 * samples per frame. This means that files which already
652 * report a frame size of 2048 in their header will not
653 * need any further special handling. */
654 if (id3
->codectype
==AFMT_MP4_AAC_HE
&& l
<=1024)
656 id3
->samples
+= n
* l
* 2;
657 id3
->needs_upsampling_correction
= true;
661 id3
->samples
+= n
* l
;
674 /* Move to the next expected mp4 atom. */
675 lseek(fd
, 28, SEEK_CUR
);
676 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
679 if (subtype
== MP4_esds
)
681 /* Read esds metadata and return if AAC-HE/SBR is used. */
682 if (read_mp4_esds(fd
, id3
, &size
))
683 id3
->codectype
= AFMT_MP4_AAC_HE
;
685 id3
->codectype
= AFMT_MP4_AAC
;
696 /* Move to the next expected mp4 atom. */
697 lseek(fd
, 28, SEEK_CUR
);
698 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
701 /* We might need to parse for the alac metadata atom. */
702 while (!((subsize
==28) && (subtype
==MP4_alac
)) && (size
>0))
704 lseek(fd
, -7, SEEK_CUR
);
705 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
707 errno
= 0; /* will most likely be set while parsing */
710 if (subtype
== MP4_alac
)
712 lseek(fd
, 24, SEEK_CUR
);
713 read_uint32be(fd
, &frequency
);
715 id3
->frequency
= frequency
;
716 id3
->codectype
= AFMT_MP4_ALAC
;
722 /* Some AAC files appear to contain additional empty mdat chunks.
726 id3
->filesize
= size
;
727 if(id3
->samples
> 0) {
728 /* We've already seen the moov chunk. */
735 /* ADDME: add support for real chapters. Right now it's only
736 * used for Nero's gapless hack */
740 lseek(fd
, 8, SEEK_CUR
);
741 read_uint8(fd
, &chapters
);
744 /* the first chapter will be used as the lead_trim */
746 read_uint64be(fd
, ×tamp
);
747 id3
->lead_trim
= (timestamp
* id3
->frequency
) / 10000000;
757 /* Skip final seek. */
760 lseek(fd
, size
, SEEK_CUR
);
762 } while (rc
&& (size_left
> 0) && (errno
== 0) && !done
);
767 bool get_mp4_metadata(int fd
, struct mp3entry
* id3
)
769 id3
->codectype
= AFMT_UNKNOWN
;
773 if (read_mp4_container(fd
, id3
, filesize(fd
)) && (errno
== 0)
774 && (id3
->samples
> 0) && (id3
->frequency
> 0)
775 && (id3
->filesize
> 0))
777 if (id3
->codectype
== AFMT_UNKNOWN
)
779 logf("Not an ALAC or AAC file");
783 id3
->length
= ((int64_t) id3
->samples
* 1000) / id3
->frequency
;
785 id3
->vbr
= true; /* ALAC is native VBR, AAC very unlikely is CBR. */
787 if (id3
->length
<= 0)
789 logf("mp4 length invalid!");
793 id3
->bitrate
= ((int64_t) id3
->filesize
* 8) / id3
->length
;
794 DEBUGF("MP4 bitrate %d, frequency %ld Hz, length %ld ms\n",
795 id3
->bitrate
, id3
->frequency
, id3
->length
);
799 logf("MP4 metadata error");
800 DEBUGF("MP4 metadata error. errno %d, samples %ld, frequency %ld, "
801 "filesize %ld\n", errno
, id3
->samples
, id3
->frequency
,