/
mp3utils.c
432 lines (409 loc) · 14.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
SDL_mixer: An audio mixer library based on the SDL library
Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_stdinc.h"
#include "SDL_rwops.h"
#include "mp3utils.h"
27
#if defined(MUSIC_MP3_MAD) || defined(MUSIC_MP3_MPG123)
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*********************** SDL_RW WITH BOOKKEEPING ************************/
size_t MP3_RWread(struct mp3file_t *fil, void *ptr, size_t size, size_t maxnum) {
size_t remaining = (size_t)(fil->length - fil->pos);
size_t ret;
maxnum *= size;
if (maxnum > remaining) maxnum = remaining;
ret = SDL_RWread(fil->src, ptr, 1, maxnum);
fil->pos += (Sint64)ret;
return ret;
}
Sint64 MP3_RWseek(struct mp3file_t *fil, Sint64 offset, int whence) {
Sint64 ret;
43
switch (whence) {
44
45
46
47
case RW_SEEK_CUR:
offset += fil->pos;
break;
case RW_SEEK_END:
48
offset += fil->length;
49
50
51
52
53
54
55
56
57
58
59
60
61
62
break;
}
if (offset < 0) return -1;
if (offset > fil->length)
offset = fil->length;
ret = SDL_RWseek(fil->src, fil->start + offset, RW_SEEK_SET);
if (ret < 0) return ret;
fil->pos = offset;
return (fil->pos - fil->start);
}
/*************************** TAG HANDLING: ******************************/
63
static SDL_INLINE SDL_bool is_id3v1(const unsigned char *data, long length) {
64
/* http://id3.org/ID3v1 : 3 bytes "TAG" identifier and 125 bytes tag data */
65
if (length < 128 || SDL_memcmp(data,"TAG",3) != 0) {
66
67
68
69
return SDL_FALSE;
}
return SDL_TRUE;
}
70
static SDL_bool is_id3v2(const unsigned char *data, size_t length) {
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/* ID3v2 header is 10 bytes: http://id3.org/id3v2.4.0-structure */
/* bytes 0-2: "ID3" identifier */
if (length < 10 || SDL_memcmp(data,"ID3",3) != 0) {
return SDL_FALSE;
}
/* bytes 3-4: version num (major,revision), each byte always less than 0xff. */
if (data[3] == 0xff || data[4] == 0xff) {
return SDL_FALSE;
}
/* bytes 6-9 are the ID3v2 tag size: a 32 bit 'synchsafe' integer, i.e. the
* highest bit 7 in each byte zeroed. i.e.: 7 bit information in each byte ->
* effectively a 28 bit value. */
if (data[6] >= 0x80 || data[7] >= 0x80 || data[8] >= 0x80 || data[9] >= 0x80) {
return SDL_FALSE;
}
return SDL_TRUE;
}
88
static long get_id3v2_len(const unsigned char *data, long length) {
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
/* size is a 'synchsafe' integer (see above) */
long size = (long)((data[6]<<21) + (data[7]<<14) + (data[8]<<7) + data[9]);
size += 10; /* header size */
/* ID3v2 header[5] is flags (bits 4-7 only, 0-3 are zero).
* bit 4 set: footer is present (a copy of the header but
* with "3DI" as ident.) */
if (data[5] & 0x10) {
size += 10; /* footer size */
}
/* optional padding (always zeroes) */
while (size < length && data[size] == 0) {
++size;
}
return size;
}
104
static SDL_bool is_apetag(const unsigned char *data, size_t length) {
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/* http://wiki.hydrogenaud.io/index.php?title=APEv2_specification
* Header/footer is 32 bytes: bytes 0-7 ident, bytes 8-11 version,
* bytes 12-17 size. bytes 24-31 are reserved: must be all zeroes. */
Uint32 v;
if (length < 32 || SDL_memcmp(data,"APETAGEX",8) != 0) {
return SDL_FALSE;
}
v = (Uint32)((data[11]<<24) | (data[10]<<16) | (data[9]<<8) | data[8]); /* version */
if (v != 2000U && v != 1000U) {
return SDL_FALSE;
}
v = 0; /* reserved bits : */
if (SDL_memcmp(&data[24],&v,4) != 0 || SDL_memcmp(&data[28],&v,4) != 0) {
return SDL_FALSE;
}
return SDL_TRUE;
}
123
static long get_ape_len(const unsigned char *data) {
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
Uint32 flags, version;
long size = (long)((data[15]<<24) | (data[14]<<16) | (data[13]<<8) | data[12]);
version = (Uint32)((data[11]<<24) | (data[10]<<16) | (data[9]<<8) | data[8]);
flags = (Uint32)((data[23]<<24) | (data[22]<<16) | (data[21]<<8) | data[20]);
if (version == 2000U && (flags & (1U<<31))) size += 32; /* header present. */
return size;
}
static SDL_INLINE int is_lyrics3tag(const unsigned char *data, long length) {
/* http://id3.org/Lyrics3
* http://id3.org/Lyrics3v2 */
if (length < 15) return 0;
if (SDL_memcmp(data+6,"LYRICS200",9) == 0) return 2; /* v2 */
if (SDL_memcmp(data+6,"LYRICSEND",9) == 0) return 1; /* v1 */
return 0;
}
139
static long get_lyrics3v1_len(struct mp3file_t *m) {
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
const char *p; long i, len;
char buf[5104];
/* needs manual search: http://id3.org/Lyrics3 */
if (m->length < 20) return -1;
len = (m->length > 5109)? 5109 : (long)m->length;
MP3_RWseek(m, -len, RW_SEEK_END);
MP3_RWread(m, buf, 1, (len -= 9)); /* exclude footer */
/* strstr() won't work here. */
for (i = len - 11, p = buf; i >= 0; --i, ++p) {
if (SDL_memcmp(p, "LYRICSBEGIN", 11) == 0)
break;
}
if (i < 0) return -1;
return len - (long)(p - buf) + 9 /* footer */;
}
static SDL_INLINE long get_lyrics3v2_len(const unsigned char *data, long length) {
/* 6 bytes before the end marker is size in decimal format -
* does not include the 9 bytes end marker and size field. */
if (length != 6) return 0;
return SDL_strtol((const char *)data, NULL, 10) + 15;
}
161
static SDL_INLINE SDL_bool verify_lyrics3v2(const unsigned char *data, long length) {
162
163
164
165
if (length < 11) return SDL_FALSE;
if (SDL_memcmp(data,"LYRICSBEGIN",11) == 0) return SDL_TRUE;
return SDL_FALSE;
}
166
#define MMTAG_PARANOID
167
static SDL_bool is_musicmatch(const unsigned char *data, long length) {
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
/* From docs/musicmatch.txt in id3lib: https://sourceforge.net/projects/id3lib/
Overall tag structure:
+-----------------------------+
| Header |
| (256 bytes, OPTIONAL) |
+-----------------------------+
| Image extension (4 bytes) |
+-----------------------------+
| Image binary |
| (var. length >= 4 bytes) |
+-----------------------------+
| Unused (4 bytes) |
+-----------------------------+
| Version info (256 bytes) |
+-----------------------------+
| Audio meta-data |
| (var. length >= 7868 bytes) |
+-----------------------------+
| Data offsets (20 bytes) |
+-----------------------------+
| Footer (48 bytes) |
+-----------------------------+
*/
192
if (length < 48) return SDL_FALSE;
193
194
195
196
197
198
199
200
201
/* sig: 19 bytes company name + 13 bytes space */
if (SDL_memcmp(data,"Brava Software Inc. ",32) != 0) {
return SDL_FALSE;
}
/* 4 bytes version: x.xx */
if (!SDL_isdigit(data[32]) || data[33] != '.' ||
!SDL_isdigit(data[34]) ||!SDL_isdigit(data[35])) {
return SDL_FALSE;
}
202
#ifdef MMTAG_PARANOID
203
/* [36..47]: 12 bytes trailing space */
204
205
206
207
for (length = 36; length < 48; ++length) {
if (data[length] != ' ') return SDL_FALSE;
}
#endif
208
209
return SDL_TRUE;
}
210
static long get_musicmatch_len(struct mp3file_t *m) {
211
212
const Sint32 metasizes[4] = { 7868, 7936, 8004, 8132 };
const unsigned char syncstr[10] = {'1','8','2','7','3','6','4','5',0,0};
213
214
unsigned char buf[256];
Sint32 i, j, imgext_ofs, version_ofs;
215
216
217
218
219
220
long len;
MP3_RWseek(m, -68, RW_SEEK_END);
MP3_RWread(m, buf, 1, 20);
imgext_ofs = (Sint32)((buf[3] <<24) | (buf[2] <<16) | (buf[1] <<8) | buf[0] );
version_ofs = (Sint32)((buf[15]<<24) | (buf[14]<<16) | (buf[13]<<8) | buf[12]);
221
if (version_ofs <= imgext_ofs) return -1;
222
if (version_ofs <= 0 || imgext_ofs <= 0) return -1;
223
224
225
226
227
228
229
230
231
232
/* Try finding the version info section:
* Because metadata section comes after it, and because metadata section
* has different sizes across versions (format ver. <= 3.00: always 7868
* bytes), we can _not_ directly calculate using deltas from the offsets
* section. */
for (i = 0; i < 4; ++i) {
/* 48: footer, 20: offsets, 256: version info */
len = metasizes[i] + 48 + 20 + 256;
if (m->length < len) return -1;
MP3_RWseek(m, -len, RW_SEEK_END);
233
MP3_RWread(m, buf, 1, 256);
234
/* [0..9]: sync string, [30..255]: 0x20 */
235
236
237
238
239
240
#ifdef MMTAG_PARANOID
for (j = 30; j < 256; ++j) {
if (buf[j] != ' ') break;
}
if (j < 256) continue;
#endif
241
242
243
244
245
if (SDL_memcmp(buf, syncstr, 10) == 0) {
break;
}
}
if (i == 4) return -1; /* no luck. */
246
247
248
#ifdef MMTAG_PARANOID
/* unused section: (4 bytes of 0x00) */
MP3_RWseek(m, -(len + 4), RW_SEEK_END);
249
MP3_RWread(m, buf, 1, 4); j = 0;
250
251
if (SDL_memcmp(buf, &j, 4) != 0) return -1;
#endif
252
253
len += (version_ofs - imgext_ofs);
if (m->length < len) return -1;
254
255
256
MP3_RWseek(m, -len, RW_SEEK_END);
MP3_RWread(m, buf, 1, 8);
j = (Sint32)((buf[7] <<24) | (buf[6] <<16) | (buf[5] <<8) | buf[4]);
257
if (j < 0) return -1;
258
/* verify image size: */
259
/* without this, we may land at a wrong place. */
260
if (j + 12 != version_ofs - imgext_ofs) return -1;
261
/* try finding the optional header */
262
if (m->length < len + 256) return len;
263
MP3_RWseek(m, -(len + 256), RW_SEEK_END);
264
MP3_RWread(m, buf, 1, 256);
265
266
267
268
/* [0..9]: sync string, [30..255]: 0x20 */
if (SDL_memcmp(buf, syncstr, 10) != 0) {
return len;
}
269
270
271
272
273
#ifdef MMTAG_PARANOID
for (j = 30; j < 256; ++j) {
if (buf[j] != ' ') return len;
}
#endif
274
275
return len + 256; /* header is present. */
}
276
277
static int probe_id3v1(struct mp3file_t *fil, unsigned char *buf, int atend) {
278
279
if (fil->length >= 128) {
MP3_RWseek(fil, -128, RW_SEEK_END);
280
281
if (MP3_RWread(fil, buf, 1, 128) != 128)
return -1;
282
if (is_id3v1(buf, 128)) {
283
284
285
286
287
288
289
if (!atend) { /* possible false positive? */
if (is_musicmatch(buf + 128 - 48, 48) ||
is_apetag (buf + 128 - 32, 32) ||
is_lyrics3tag(buf + 128 - 15, 15)) {
return 0;
}
}
290
fil->length -= 128;
291
return 1;
292
293
/* FIXME: handle possible double-ID3v1 tags?? */
}
294
}
295
296
297
298
return 0;
}
static int probe_mmtag(struct mp3file_t *fil, unsigned char *buf) {
long len;
299
300
if (fil->length >= 68) {
MP3_RWseek(fil, -48, RW_SEEK_END);
301
302
if (MP3_RWread(fil, buf, 1, 48) != 48)
return -1;
303
304
if (is_musicmatch(buf, 48)) {
len = get_musicmatch_len(fil);
305
306
if (len < 0) return -1;
if (len >= fil->length) return -1;
307
fil->length -= len;
308
return 1;
309
310
}
}
311
312
313
314
return 0;
}
static int probe_apetag(struct mp3file_t *fil, unsigned char *buf) {
long len;
315
316
if (fil->length >= 32) {
MP3_RWseek(fil, -32, RW_SEEK_END);
317
318
if (MP3_RWread(fil, buf, 1, 32) != 32)
return -1;
319
320
if (is_apetag(buf, 32)) {
len = get_ape_len(buf);
321
if (len >= fil->length) return -1;
322
fil->length -= len;
323
return 1;
324
325
}
}
326
327
328
329
return 0;
}
static int probe_lyrics3(struct mp3file_t *fil, unsigned char *buf) {
long len;
330
331
if (fil->length >= 15) {
MP3_RWseek(fil, -15, RW_SEEK_END);
332
333
if (MP3_RWread(fil, buf, 1, 15) != 15)
return -1;
334
335
336
len = is_lyrics3tag(buf, 15);
if (len == 2) {
len = get_lyrics3v2_len(buf, 6);
337
338
if (len >= fil->length) return -1;
if (len < 15) return -1;
339
MP3_RWseek(fil, -len, RW_SEEK_END);
340
if (MP3_RWread(fil, buf, 1, 11) != 11)
341
342
return -1;
if (!verify_lyrics3v2(buf, 11)) return -1;
343
fil->length -= len;
344
return 1;
345
346
347
}
else if (len == 1) {
len = get_lyrics3v1_len(fil);
348
if (len < 0) return -1;
349
fil->length -= len;
350
return 1;
351
352
}
}
353
354
355
356
357
358
359
360
361
362
363
364
365
return 0;
}
int mp3_skiptags(struct mp3file_t *fil, SDL_bool keep_id3v2)
{
unsigned char buf[128];
long len; size_t readsize;
int c_id3, c_ape, c_lyr, c_mm;
int rc = -1;
/* MP3 standard has no metadata format, so everyone invented
* their own thing, even with extensions, until ID3v2 became
* dominant: Hence the impossible mess here.
366
367
368
*
* Note: I don't yet care about freaky broken mp3 files with
* double tags. -- O.S.
369
370
371
372
373
374
375
376
377
*/
readsize = MP3_RWread(fil, buf, 1, 128);
if (!readsize) goto fail;
/* ID3v2 tag is at the start */
if (is_id3v2(buf, readsize)) {
len = get_id3v2_len(buf, (long)readsize);
if (len >= fil->length) goto fail;
378
if (!keep_id3v2) {
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
fil->start += len;
fil->length -= len;
}
}
/* APE tag _might_ be at the start (discouraged
* but not forbidden, either.) read the header. */
else if (is_apetag(buf, readsize)) {
len = get_ape_len(buf);
if (len >= fil->length) goto fail;
fil->start += len;
fil->length -= len;
}
/* it's not impossible that _old_ MusicMatch tag
* placing itself after ID3v1. */
if ((c_mm = probe_mmtag(fil, buf)) < 0) {
goto fail;
}
/* ID3v1 tag is at the end */
398
if ((c_id3 = probe_id3v1(fil, buf, !c_mm)) < 0) {
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
goto fail;
}
/* we do not know the order of ape or lyrics3
* or musicmatch tags, hence the loop here.. */
c_ape = 0;
c_lyr = 0;
for (;;) {
if (!c_lyr) {
/* care about mp3s with double Lyrics3 tags? */
if ((c_lyr = probe_lyrics3(fil, buf)) < 0)
goto fail;
if (c_lyr) continue;
}
if (!c_mm) {
if ((c_mm = probe_mmtag(fil, buf)) < 0)
goto fail;
if (c_mm) continue;
}
if (!c_ape) {
if ((c_ape = probe_apetag(fil, buf)) < 0)
goto fail;
if (c_ape) continue;
}
break;
} /* for (;;) */
424
425
rc = (fil->length > 0)? 0 : -1;
426
427
fail:
MP3_RWseek(fil, 0, RW_SEEK_SET);
428
return rc;
429
}
430
#endif /* MUSIC_MP3_??? */
431
432
/* vi: set ts=4 sw=4 expandtab: */