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"
41 #define MP4_3gp6 FOURCC('3', 'g', 'p', '6')
42 #define MP4_aART FOURCC('a', 'A', 'R', 'T')
43 #define MP4_alac FOURCC('a', 'l', 'a', 'c')
44 #define MP4_calb FOURCC(0xa9, 'a', 'l', 'b')
45 #define MP4_cART FOURCC(0xa9, 'A', 'R', 'T')
46 #define MP4_cgrp FOURCC(0xa9, 'g', 'r', 'p')
47 #define MP4_cgen FOURCC(0xa9, 'g', 'e', 'n')
48 #define MP4_chpl FOURCC('c', 'h', 'p', 'l')
49 #define MP4_cnam FOURCC(0xa9, 'n', 'a', 'm')
50 #define MP4_cwrt FOURCC(0xa9, 'w', 'r', 't')
51 #define MP4_ccmt FOURCC(0xa9, 'c', 'm', 't')
52 #define MP4_cday FOURCC(0xa9, 'd', 'a', 'y')
53 #define MP4_covr FOURCC('c', 'o', 'v', 'r')
54 #define MP4_disk FOURCC('d', 'i', 's', 'k')
55 #define MP4_esds FOURCC('e', 's', 'd', 's')
56 #define MP4_ftyp FOURCC('f', 't', 'y', 'p')
57 #define MP4_gnre FOURCC('g', 'n', 'r', 'e')
58 #define MP4_hdlr FOURCC('h', 'd', 'l', 'r')
59 #define MP4_ilst FOURCC('i', 'l', 's', 't')
60 #define MP4_isom FOURCC('i', 's', 'o', 'm')
61 #define MP4_M4A FOURCC('M', '4', 'A', ' ')
62 #define MP4_m4a FOURCC('m', '4', 'a', ' ') /*technically its "M4A "*/
63 #define MP4_M4B FOURCC('M', '4', 'B', ' ') /*but files exist with lower case*/
64 #define MP4_mdat FOURCC('m', 'd', 'a', 't')
65 #define MP4_mdia FOURCC('m', 'd', 'i', 'a')
66 #define MP4_mdir FOURCC('m', 'd', 'i', 'r')
67 #define MP4_meta FOURCC('m', 'e', 't', 'a')
68 #define MP4_minf FOURCC('m', 'i', 'n', 'f')
69 #define MP4_moov FOURCC('m', 'o', 'o', 'v')
70 #define MP4_mp4a FOURCC('m', 'p', '4', 'a')
71 #define MP4_mp42 FOURCC('m', 'p', '4', '2')
72 #define MP4_qt FOURCC('q', 't', ' ', ' ')
73 #define MP4_soun FOURCC('s', 'o', 'u', 'n')
74 #define MP4_stbl FOURCC('s', 't', 'b', 'l')
75 #define MP4_stsd FOURCC('s', 't', 's', 'd')
76 #define MP4_stts FOURCC('s', 't', 't', 's')
77 #define MP4_trak FOURCC('t', 'r', 'a', 'k')
78 #define MP4_trkn FOURCC('t', 'r', 'k', 'n')
79 #define MP4_udta FOURCC('u', 'd', 't', 'a')
80 #define MP4_extra FOURCC('-', '-', '-', '-')
82 /* Read the tag data from an MP4 file, storing up to buffer_size bytes in
85 static unsigned long read_mp4_tag(int fd
, unsigned int size_left
, char* buffer
,
86 unsigned int buffer_left
)
88 unsigned int bytes_read
= 0;
92 lseek(fd
, size_left
, SEEK_CUR
); /* Skip everything */
96 /* Skip the data tag header - maybe we should parse it properly? */
97 lseek(fd
, 16, SEEK_CUR
);
100 if (size_left
> buffer_left
)
102 read(fd
, buffer
, buffer_left
);
103 lseek(fd
, size_left
- buffer_left
, SEEK_CUR
);
104 bytes_read
= buffer_left
;
108 read(fd
, buffer
, size_left
);
109 bytes_read
= size_left
;
116 /* Read a string tag from an MP4 file */
117 static unsigned int read_mp4_tag_string(int fd
, int size_left
, char** buffer
,
118 unsigned int* buffer_left
, char** dest
)
120 unsigned int bytes_read
= read_mp4_tag(fd
, size_left
, *buffer
,
121 *buffer_left
> 0 ? *buffer_left
- 1 : 0);
122 unsigned int length
= 0;
126 /* Do not overwrite already available metadata. Especially when reading
127 * tags with e.g. multiple genres / artists. This way only the first
128 * of multiple entries is used, all following are dropped. */
131 (*buffer
)[bytes_read
] = 0; /* zero-terminate for correct strlen().*/
132 length
= strlen(*buffer
) + 1;
133 length
= MIN(length
, ID3V2_MAX_ITEM_SIZE
); /* Limit item size. */
136 (*buffer
)[length
-1] = 0; /* zero-terminate buffer. */
137 *buffer_left
-= length
;
149 static unsigned int read_mp4_atom(int fd
, uint32_t* size
,
150 uint32_t* type
, uint32_t size_left
)
152 read_uint32be(fd
, size
);
153 read_uint32be(fd
, type
);
157 /* FAT32 doesn't support files this big, so something seems to
158 * be wrong. (64-bit sizes should only be used when required.)
167 if (*size
> size_left
)
187 static unsigned int read_mp4_length(int fd
, uint32_t* size
)
189 unsigned int length
= 0;
198 length
= (length
<< 7) | (c
& 0x7F);
200 while ((c
& 0x80) && (bytes
< 4) && (*size
> 0));
205 static bool read_mp4_esds(int fd
, struct mp3entry
* id3
, uint32_t* size
)
207 unsigned char buf
[8];
210 lseek(fd
, 4, SEEK_CUR
); /* Version and flags. */
211 read(fd
, buf
, 1); /* Verify ES_DescrTag. */
217 if (read_mp4_length(fd
, size
) < 20)
222 lseek(fd
, 3, SEEK_CUR
);
227 lseek(fd
, 2, SEEK_CUR
);
231 read(fd
, buf
, 1); /* Verify DecoderConfigDescrTab. */
239 if (read_mp4_length(fd
, size
) < 13)
244 lseek(fd
, 13, SEEK_CUR
); /* Skip audio type, bit rates, etc. */
248 if (*buf
!= 5) /* Verify DecSpecificInfoTag. */
254 static const int sample_rates
[] =
256 96000, 88200, 64000, 48000, 44100, 32000,
257 24000, 22050, 16000, 12000, 11025, 8000
264 /* Read the (leading part of the) decoder config. */
265 length
= read_mp4_length(fd
, size
);
266 length
= MIN(length
, *size
);
267 length
= MIN(length
, sizeof(buf
));
268 memset(buf
, 0, sizeof(buf
));
269 read(fd
, buf
, length
);
272 /* Maybe time to write a simple read_bits function... */
274 /* Decoder config format:
275 * Object type - 5 bits
276 * Frequency index - 4 bits
277 * Channel configuration - 4 bits
279 bits
= get_long_be(buf
);
280 type
= bits
>> 27; /* Object type - 5 bits */
281 index
= (bits
>> 23) & 0xf; /* Frequency index - 4 bits */
283 if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
285 id3
->frequency
= sample_rates
[index
];
290 unsigned int old_index
= index
;
293 index
= (bits
>> 15) & 0xf; /* Frequency index - 4 bits */
297 /* 17 bits read so far... */
298 bits
= get_long_be(&buf
[2]);
299 id3
->frequency
= (bits
>> 7) & 0x00ffffff;
301 else if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
303 id3
->frequency
= sample_rates
[index
];
306 if (old_index
== index
)
308 /* Downsampled SBR */
312 /* Skip 13 bits from above, plus 3 bits, then read 11 bits */
313 else if ((length
>= 4) && (((bits
>> 5) & 0x7ff) == 0x2b7))
315 /* We found an extensionAudioObjectType */
316 type
= bits
& 0x1f; /* Object type - 5 bits*/
317 bits
= get_long_be(&buf
[4]);
325 unsigned int old_index
= index
;
327 /* 1 bit read so far */
328 index
= (bits
>> 27) & 0xf; /* Frequency index - 4 bits */
332 /* 5 bits read so far */
333 id3
->frequency
= (bits
>> 3) & 0x00ffffff;
335 else if (index
< (sizeof(sample_rates
) / sizeof(*sample_rates
)))
337 id3
->frequency
= sample_rates
[index
];
340 if (old_index
== index
)
342 /* Downsampled SBR */
349 if (!sbr
&& (id3
->frequency
<= 24000) && (length
<= 2))
351 /* Double the frequency for low-frequency files without a "long"
352 * DecSpecificConfig header. The file may or may not contain SBR,
353 * but here we guess it does if the header is short. This can
354 * fail on some files, but it's the best we can do, short of
355 * decoding (parts of) the file.
365 static bool read_mp4_tags(int fd
, struct mp3entry
* id3
,
370 unsigned int buffer_left
= sizeof(id3
->id3v2buf
) + sizeof(id3
->id3v1buf
);
371 char* buffer
= id3
->id3v2buf
;
376 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
378 /* DEBUGF("Tag atom: '%c%c%c%c' (%d bytes left)\n", type >> 24 & 0xff,
379 type >> 16 & 0xff, type >> 8 & 0xff, type & 0xff, size); */
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
,
399 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
404 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
409 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
415 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
420 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
423 /* Try to parse it as a year, for the benefit of the database.
427 id3
->year
= atoi(id3
->year_string
);
428 if (id3
->year
< 1900)
440 unsigned short genre
;
442 read_mp4_tag(fd
, size
, (char*) &genre
, sizeof(genre
));
443 id3
->genre_string
= id3_get_num_genre(betoh16(genre
) - 1);
448 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
456 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
457 id3
->discnum
= betoh16(n
[1]);
465 read_mp4_tag(fd
, size
, (char*) &n
, sizeof(n
));
466 id3
->tracknum
= betoh16(n
[1]);
473 int pos
= lseek(fd
, 0, SEEK_CUR
) + 16;
475 read_mp4_tag(fd
, size
, buffer
, 8);
476 id3
->albumart
.type
= AA_TYPE_UNKNOWN
;
477 if (memcmp(buffer
, "\xff\xd8\xff\xe0", 4) == 0)
479 id3
->albumart
.type
= AA_TYPE_JPG
;
481 else if (memcmp(buffer
, "\x89\x50\x4e\x47\x0d\x0a\x1a\x0a", 8) == 0)
483 id3
->albumart
.type
= AA_TYPE_PNG
;
486 if (id3
->albumart
.type
!= AA_TYPE_UNKNOWN
)
488 id3
->albumart
.pos
= pos
;
489 id3
->albumart
.size
= size
- 16;
490 id3
->embed_albumart
= true;
498 char tag_name
[TAG_NAME_LENGTH
];
502 read_uint32be(fd
, &sub_size
);
504 lseek(fd
, sub_size
- 4, SEEK_CUR
);
506 read_uint32be(fd
, &sub_size
);
508 lseek(fd
, 8, SEEK_CUR
);
511 if (sub_size
> sizeof(tag_name
) - 1)
513 read(fd
, tag_name
, sizeof(tag_name
) - 1);
514 lseek(fd
, sub_size
- (sizeof(tag_name
) - 1), SEEK_CUR
);
515 tag_name
[sizeof(tag_name
) - 1] = 0;
519 read(fd
, tag_name
, sub_size
);
520 tag_name
[sub_size
] = 0;
523 if ((strcasecmp(tag_name
, "composer") == 0) && !cwrt
)
525 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
528 else if (strcasecmp(tag_name
, "iTunSMPB") == 0)
530 char value
[TAG_VALUE_LENGTH
];
531 char* value_p
= value
;
533 unsigned int length
= sizeof(value
);
535 read_mp4_tag_string(fd
, size
, &value_p
, &length
, &any
);
536 id3
->lead_trim
= get_itunes_int32(value
, 1);
537 id3
->tail_trim
= get_itunes_int32(value
, 2);
538 DEBUGF("AAC: lead_trim %d, tail_trim %d\n",
539 id3
->lead_trim
, id3
->tail_trim
);
541 else if (strcasecmp(tag_name
, "musicbrainz track id") == 0)
543 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
546 else if ((strcasecmp(tag_name
, "album artist") == 0))
548 read_mp4_tag_string(fd
, size
, &buffer
, &buffer_left
,
554 unsigned int length
= read_mp4_tag_string(fd
, size
,
555 &buffer
, &buffer_left
, &any
);
559 /* Re-use the read buffer as the dest buffer... */
561 buffer_left
+= length
;
563 parse_replaygain(tag_name
, buffer
, id3
);
570 lseek(fd
, size
, SEEK_CUR
);
574 while ((size_left
> 0) && (errno
== 0));
579 static bool read_mp4_container(int fd
, struct mp3entry
* id3
,
584 uint32_t handler
= 0;
590 size_left
= read_mp4_atom(fd
, &size
, &type
, size_left
);
592 /* DEBUGF("Atom: '%c%c%c%c' (0x%08lx, %lu bytes left)\n",
593 (int) ((type >> 24) & 0xff), (int) ((type >> 16) & 0xff),
594 (int) ((type >> 8) & 0xff), (int) (type & 0xff),
603 read_uint32be(fd
, &id
);
606 if ((id
!= MP4_M4A
) && (id
!= MP4_M4B
) && (id
!= MP4_mp42
)
607 && (id
!= MP4_qt
) && (id
!= MP4_3gp6
) && (id
!= MP4_m4a
)
610 DEBUGF("Unknown MP4 file type: '%c%c%c%c'\n",
611 (int)(id
>> 24 & 0xff), (int)(id
>> 16 & 0xff),
612 (int)(id
>> 8 & 0xff), (int)(id
& 0xff));
619 lseek(fd
, 4, SEEK_CUR
); /* Skip version */
628 rc
= read_mp4_container(fd
, id3
, size
);
633 /* We need at least a size of 8 to read the next atom. */
634 if (handler
== MP4_mdir
&& size
>8)
636 rc
= read_mp4_tags(fd
, id3
, size
);
642 if (handler
== MP4_soun
)
644 rc
= read_mp4_container(fd
, id3
, size
);
650 lseek(fd
, 8, SEEK_CUR
);
652 rc
= read_mp4_container(fd
, id3
, size
);
657 lseek(fd
, 8, SEEK_CUR
);
658 read_uint32be(fd
, &handler
);
660 /* DEBUGF(" Handler '%c%c%c%c'\n", handler >> 24 & 0xff,
661 handler >> 16 & 0xff, handler >> 8 & 0xff,handler & 0xff); */
669 /* Reset to false. */
670 id3
->needs_upsampling_correction
= false;
672 lseek(fd
, 4, SEEK_CUR
);
673 read_uint32be(fd
, &entries
);
676 for (i
= 0; i
< entries
; i
++)
681 read_uint32be(fd
, &n
);
682 read_uint32be(fd
, &l
);
684 /* Some AAC file use HE profile. In this case the number
685 * of output samples is doubled to a maximum of 2048
686 * samples per frame. This means that files which already
687 * report a frame size of 2048 in their header will not
688 * need any further special handling. */
689 if (id3
->codectype
==AFMT_MP4_AAC_HE
&& l
<=1024)
691 id3
->samples
+= n
* l
* 2;
692 id3
->needs_upsampling_correction
= true;
696 id3
->samples
+= n
* l
;
709 /* Move to the next expected mp4 atom. */
710 lseek(fd
, 28, SEEK_CUR
);
711 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
714 if (subtype
== MP4_esds
)
716 /* Read esds metadata and return if AAC-HE/SBR is used. */
717 if (read_mp4_esds(fd
, id3
, &size
))
718 id3
->codectype
= AFMT_MP4_AAC_HE
;
720 id3
->codectype
= AFMT_MP4_AAC
;
731 /* Move to the next expected mp4 atom. */
732 lseek(fd
, 28, SEEK_CUR
);
733 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
736 /* We might need to parse for the alac metadata atom. */
737 while (!((subsize
==28) && (subtype
==MP4_alac
)) && (size
>0))
739 lseek(fd
, -7, SEEK_CUR
);
740 read_mp4_atom(fd
, &subsize
, &subtype
, size
);
742 errno
= 0; /* will most likely be set while parsing */
745 if (subtype
== MP4_alac
)
747 lseek(fd
, 24, SEEK_CUR
);
748 read_uint32be(fd
, &frequency
);
750 id3
->frequency
= frequency
;
751 id3
->codectype
= AFMT_MP4_ALAC
;
757 /* Some AAC files appear to contain additional empty mdat chunks.
761 id3
->filesize
= size
;
762 if(id3
->samples
> 0) {
763 /* We've already seen the moov chunk. */
770 /* ADDME: add support for real chapters. Right now it's only
771 * used for Nero's gapless hack */
775 lseek(fd
, 8, SEEK_CUR
);
776 read_uint8(fd
, &chapters
);
779 /* the first chapter will be used as the lead_trim */
781 read_uint64be(fd
, ×tamp
);
782 id3
->lead_trim
= (timestamp
* id3
->frequency
) / 10000000;
792 /* Skip final seek. */
795 lseek(fd
, size
, SEEK_CUR
);
797 } while (rc
&& (size_left
> 0) && (errno
== 0) && !done
);
802 bool get_mp4_metadata(int fd
, struct mp3entry
* id3
)
804 id3
->codectype
= AFMT_UNKNOWN
;
808 if (read_mp4_container(fd
, id3
, filesize(fd
)) && (errno
== 0)
809 && (id3
->samples
> 0) && (id3
->frequency
> 0)
810 && (id3
->filesize
> 0))
812 if (id3
->codectype
== AFMT_UNKNOWN
)
814 logf("Not an ALAC or AAC file");
818 id3
->length
= ((int64_t) id3
->samples
* 1000) / id3
->frequency
;
820 id3
->vbr
= true; /* ALAC is native VBR, AAC very unlikely is CBR. */
822 if (id3
->length
<= 0)
824 logf("mp4 length invalid!");
828 id3
->bitrate
= ((int64_t) id3
->filesize
* 8) / id3
->length
;
829 DEBUGF("MP4 bitrate %d, frequency %ld Hz, length %ld ms\n",
830 id3
->bitrate
, id3
->frequency
, id3
->length
);
834 logf("MP4 metadata error");
835 DEBUGF("MP4 metadata error. errno %d, samples %ld, frequency %ld, "
836 "filesize %ld\n", errno
, id3
->samples
, id3
->frequency
,