1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2005 Magnus Holmgren
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
31 /* Type of channel for RVA2 frame. There are more than this defined in the spec
32 but we don't use them. */
33 #define MASTER_CHANNEL 1
35 /* The fixed point math routines (with the exception of fp_atof) are based
36 * on oMathFP by Dan Carter (http://orbisstudios.com).
39 /* 12 bits of precision gives fairly accurate result, but still allows a
40 * compact implementation. The math code supports up to 13...
44 #define FP_MASK ((1 << FP_BITS) - 1)
45 #define FP_ONE (1 << FP_BITS)
46 #define FP_TWO (2 << FP_BITS)
47 #define FP_HALF (1 << (FP_BITS - 1))
48 #define FP_LN2 ( 45426 >> (16 - FP_BITS))
49 #define FP_LN2_INV ( 94548 >> (16 - FP_BITS))
50 #define FP_EXP_ZERO ( 10922 >> (16 - FP_BITS))
51 #define FP_EXP_ONE ( -182 >> (16 - FP_BITS))
52 #define FP_EXP_TWO ( 4 >> (16 - FP_BITS))
53 #define FP_INF (0x7fffffff)
54 #define FP_LN10 (150902 >> (16 - FP_BITS))
56 #define FP_MAX_DIGITS (4)
57 #define FP_MAX_DIGITS_INT (10000)
59 #define FP_FAST_MUL_DIV
61 #ifdef FP_FAST_MUL_DIV
63 /* These macros can easily overflow, but they are good enough for our uses,
64 * and saves some code.
66 #define fp_mul(x, y) (((x) * (y)) >> FP_BITS)
67 #define fp_div(x, y) (((x) << FP_BITS) / (y))
71 static long fp_mul(long x
, long y
)
77 if ((x
== 0) || (y
== 0))
94 rc
= (((x
>> FP_BITS
) * (y
>> FP_BITS
)) << FP_BITS
)
95 + (((x
& FP_MASK
) * (y
& FP_MASK
)) >> FP_BITS
)
96 + ((x
& FP_MASK
) * (y
>> FP_BITS
))
97 + ((x
>> FP_BITS
) * (y
& FP_MASK
));
99 if ((x_neg
^ y_neg
) == 1)
107 static long fp_div(long x
, long y
)
123 return (x
< 0) ? -FP_INF
: FP_INF
;
138 while ((x
& (1 << (30 - msb
))) == 0)
143 while ((y
& (1 << lsb
)) == 0)
148 shifty
= FP_BITS
- (msb
+ lsb
);
149 rc
= ((x
<< msb
) / (y
>> lsb
));
160 if ((x_neg
^ y_neg
) == 1)
168 #endif /* FP_FAST_MUL_DIV */
170 static long fp_exp(long x
)
182 k
= (fp_mul(abs(x
), FP_LN2_INV
) + FP_HALF
) & ~FP_MASK
;
189 x
-= fp_mul(k
, FP_LN2
);
191 R
= FP_TWO
+ fp_mul(z
, FP_EXP_ZERO
+ fp_mul(z
, FP_EXP_ONE
192 + fp_mul(z
, FP_EXP_TWO
)));
193 xp
= FP_ONE
+ fp_div(fp_mul(FP_TWO
, x
), R
- x
);
197 k
= FP_ONE
>> (-k
>> FP_BITS
);
201 k
= FP_ONE
<< (k
>> FP_BITS
);
204 return fp_mul(k
, xp
);
207 static long fp_exp10(long x
)
214 return fp_exp(fp_mul(FP_LN10
, x
));
217 static long fp_atof(const char* s
, int precision
)
220 long int_one
= 1 << precision
;
223 long frac_max
= ((precision
* 4) + 12) / 13;
224 long frac_max_int
= 1;
228 while ((*s
!= '\0') && isspace(*s
))
254 else if (isdigit(*s
))
258 if (frac_count
< frac_max
)
260 frac_part
= frac_part
* 10 + (*s
- '0');
267 int_part
= int_part
* 10 + (*s
- '0');
278 while (frac_count
< frac_max
)
285 return sign
* ((int_part
* int_one
)
286 + (((int64_t) frac_part
* int_one
) / frac_max_int
));
289 static long convert_gain(long gain
)
291 /* Don't allow unreasonably low or high gain changes.
292 * Our math code can't handle it properly anyway. :)
294 if (gain
< (-48 * FP_ONE
))
299 if (gain
> (17 * FP_ONE
))
304 gain
= fp_exp10(gain
/ 20) << (24 - FP_BITS
);
309 long get_replaygain_int(long int_gain
)
311 return convert_gain(int_gain
* FP_ONE
/ 100);
314 long get_replaygain(const char* str
)
320 gain
= fp_atof(str
, FP_BITS
);
321 gain
= convert_gain(gain
);
327 long get_replaypeak(const char* str
)
333 peak
= fp_atof(str
, 24);
339 /* Check for a ReplayGain tag conforming to the "VorbisGain standard". If
340 * found, set the mp3entry accordingly. buffer is where to store the text
341 * contents of the gain tags; up to length bytes (including end nil) can be
342 * written. Returns number of bytes written to the tag text buffer, or zero
343 * if no ReplayGain tag was found (or nothing was copied to the buffer for
346 long parse_replaygain(const char* key
, const char* value
,
347 struct mp3entry
* entry
, char* buffer
, int length
)
351 if (((strcasecmp(key
, "replaygain_track_gain") == 0)
352 || (strcasecmp(key
, "rg_radio") == 0)) && !entry
->track_gain
)
354 entry
->track_gain
= get_replaygain(value
);
355 p
= &(entry
->track_gain_string
);
357 else if (((strcasecmp(key
, "replaygain_album_gain") == 0)
358 || (strcasecmp(key
, "rg_audiophile") == 0)) && !entry
->album_gain
)
360 entry
->album_gain
= get_replaygain(value
);
361 p
= &(entry
->album_gain_string
);
363 else if (((strcasecmp(key
, "replaygain_track_peak") == 0)
364 || (strcasecmp(key
, "rg_peak") == 0)) && !entry
->track_peak
)
366 entry
->track_peak
= get_replaypeak(value
);
368 else if ((strcasecmp(key
, "replaygain_album_peak") == 0)
369 && !entry
->album_peak
)
371 entry
->album_peak
= get_replaypeak(value
);
376 int len
= strlen(value
);
378 len
= MIN(len
, length
- 1);
380 /* A few characters just isn't interesting... */
383 strncpy(buffer
, value
, len
);
393 static long get_rva_values(const char *frame
, long *gain
, long *peak
,
394 char **string
, char *buffer
, int length
)
399 int peakbits
, peakbytes
, shift
;
400 unsigned long peakvalue
= 0;
402 value
= 256 * ((unsigned char)*frame
) + ((unsigned char)*(frame
+ 1));
405 value
= -(value
| ~0xFFFF);
409 len
= snprintf(tmpbuf
, sizeof(tmpbuf
), "%s%d.%02d dB", negative
? "-" : "",
410 value
/ 512, (value
& 0x1FF) * 195 / 1000);
412 *gain
= get_replaygain(tmpbuf
);
414 len
= MIN(len
, length
- 1);
417 strncpy(buffer
, tmpbuf
, len
);
423 peakbits
= *(unsigned char *)frame
++;
424 peakbytes
= MIN(4, (peakbits
+ 7) >> 3);
425 shift
= ((8 - (peakbits
& 7)) & 7) + (4 - peakbytes
) * 8;
427 for (; peakbytes
; peakbytes
--)
430 peakvalue
+= (unsigned long)*frame
++;
436 peakvalue
+= (unsigned long)*frame
>> (8 - shift
);
438 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d.%06d", peakvalue
>> 31,
439 (peakvalue
& ~(1 << 31)) / 2147);
441 *peak
= get_replaypeak(tmpbuf
);
446 long parse_replaygain_rva(const char* key
, const char* value
,
447 struct mp3entry
* entry
, char* buffer
, int length
)
449 /* Values will be overwritten if they already exist. This gives priority to
450 replaygain in RVA2 fields over TXXX fields for ID3v2.4. */
451 if ((strcasecmp(key
, "track") == 0) && *value
== MASTER_CHANNEL
)
453 return get_rva_values(value
+ 1, &(entry
->track_gain
), &(entry
->track_peak
),
454 &(entry
->track_gain_string
), buffer
, length
);
456 else if ((strcasecmp(key
, "album") == 0) && *value
== MASTER_CHANNEL
)
458 return get_rva_values(value
+ 1, &(entry
->album_gain
), &(entry
->album_peak
),
459 &(entry
->album_gain_string
), buffer
, length
);