firmware/replaygain.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Magnus Holmgren
  11  *
  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.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <ctype.h>
  21 #include <inttypes.h>
  22 #include <math.h>
  23 #include <stdbool.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <system.h>
  28 #include "id3.h"
  29 #include "debug.h"
  30
  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
  34
  35 /* The fixed point math routines (with the exception of fp_atof) are based
  36  * on oMathFP by Dan Carter (http://orbisstudios.com).
  37  */
  38
  39 /* 12 bits of precision gives fairly accurate result, but still allows a
  40  * compact implementation. The math code supports up to 13...
  41  */
  42
  43 #define FP_BITS         (12)
  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))
  55
  56 #define FP_MAX_DIGITS       (4)
  57 #define FP_MAX_DIGITS_INT   (10000)
  58
  59 #define FP_FAST_MUL_DIV
  60
  61 #ifdef FP_FAST_MUL_DIV
  62
  63 /* These macros can easily overflow, but they are good enough for our uses,
  64  * and saves some code.
  65  */
  66 #define fp_mul(x, y) (((x) * (y)) >> FP_BITS)
  67 #define fp_div(x, y) (((x) << FP_BITS) / (y))
  68
  69 #else
  70
  71 static long fp_mul(long x, long y)
  72 {
  73     long x_neg = 0;
  74     long y_neg = 0;
  75     long rc;
  76
  77     if ((x == 0) || (y == 0))
  78     {
  79         return 0;
  80     }
  81
  82     if (x < 0)
  83     {
  84         x_neg = 1;
  85         x = -x;
  86     }
  87
  88     if (y < 0)
  89     {
  90         y_neg = 1;
  91         y = -y;
  92     }
  93
  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));
  98
  99     if ((x_neg ^ y_neg) == 1)
 100     {
 101         rc = -rc;
 102     }
 103
 104     return rc;
 105 }
 106
 107 static long fp_div(long x, long y)
 108 {
 109     long x_neg = 0;
 110     long y_neg = 0;
 111     long shifty;
 112     long rc;
 113     int msb = 0;
 114     int lsb = 0;
 115
 116     if (x == 0)
 117     {
 118         return 0;
 119     }
 120
 121     if (y == 0)
 122     {
 123         return (x < 0) ? -FP_INF : FP_INF;
 124     }
 125
 126     if (x < 0)
 127     {
 128         x_neg = 1;
 129         x = -x;
 130     }
 131
 132     if (y < 0)
 133     {
 134         y_neg = 1;
 135         y = -y;
 136     }
 137
 138     while ((x & (1 << (30 - msb))) == 0)
 139     {
 140         msb++;
 141     }
 142
 143     while ((y & (1 << lsb)) == 0)
 144     {
 145         lsb++;
 146     }
 147
 148     shifty = FP_BITS - (msb + lsb);
 149     rc = ((x << msb) / (y >> lsb));
 150
 151     if (shifty > 0)
 152     {
 153         rc <<= shifty;
 154     }
 155     else
 156     {
 157         rc >>= -shifty;
 158     }
 159
 160     if ((x_neg ^ y_neg) == 1)
 161     {
 162         rc = -rc;
 163     }
 164
 165     return rc;
 166 }
 167
 168 #endif /* FP_FAST_MUL_DIV */
 169
 170 static long fp_exp(long x)
 171 {
 172     long k;
 173     long z;
 174     long R;
 175     long xp;
 176
 177     if (x == 0)
 178     {
 179         return FP_ONE;
 180     }
 181
 182     k = (fp_mul(abs(x), FP_LN2_INV) + FP_HALF) & ~FP_MASK;
 183
 184     if (x < 0)
 185     {
 186         k = -k;
 187     }
 188
 189     x -= fp_mul(k, FP_LN2);
 190     z = fp_mul(x, x);
 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);
 194
 195     if (k < 0)
 196     {
 197         k = FP_ONE >> (-k >> FP_BITS);
 198     }
 199     else
 200     {
 201         k = FP_ONE << (k >> FP_BITS);
 202     }
 203
 204     return fp_mul(k, xp);
 205 }
 206
 207 static long fp_exp10(long x)
 208 {
 209     if (x == 0)
 210     {
 211         return FP_ONE;
 212     }
 213
 214     return fp_exp(fp_mul(FP_LN10, x));
 215 }
 216
 217 static long fp_atof(const char* s, int precision)
 218 {
 219     long int_part = 0;
 220     long int_one = 1 << precision;
 221     long frac_part = 0;
 222     long frac_count = 0;
 223     long frac_max = ((precision * 4) + 12) / 13;
 224     long frac_max_int = 1;
 225     long sign = 1;
 226     bool point = false;
 227
 228     while ((*s != '\0') && isspace(*s))
 229     {
 230         s++;
 231     }
 232
 233     if (*s == '-')
 234     {
 235         sign = -1;
 236         s++;
 237     }
 238     else if (*s == '+')
 239     {
 240         s++;
 241     }
 242
 243     while (*s != '\0')
 244     {
 245         if (*s == '.')
 246         {
 247             if (point)
 248             {
 249                 break;
 250             }
 251
 252             point = true;
 253         }
 254         else if (isdigit(*s))
 255         {
 256             if (point)
 257             {
 258                 if (frac_count < frac_max)
 259                 {
 260                     frac_part = frac_part * 10 + (*s - '0');
 261                     frac_count++;
 262                     frac_max_int *= 10;
 263                 }
 264             }
 265             else
 266             {
 267                 int_part = int_part * 10 + (*s - '0');
 268             }
 269         }
 270         else
 271         {
 272             break;
 273         }
 274
 275         s++;
 276     }
 277
 278     while (frac_count < frac_max)
 279     {
 280       frac_part *= 10;
 281       frac_count++;
 282       frac_max_int *= 10;
 283     }
 284
 285     return sign * ((int_part * int_one)
 286         + (((int64_t) frac_part * int_one) / frac_max_int));
 287 }
 288
 289 static long convert_gain(long gain)
 290 {
 291     if (gain != 0)
 292     {
 293         /* Don't allow unreasonably low or high gain changes.
 294          * Our math code can't handle it properly anyway. :)
 295          */
 296         if (gain < (-48 * FP_ONE))
 297         {
 298             gain = -48 * FP_ONE;
 299         }
 300
 301         if (gain > (17 * FP_ONE))
 302         {
 303             gain = 17 * FP_ONE;
 304         }
 305
 306         gain = fp_exp10(gain / 20) << (24 - FP_BITS);
 307     }
 308
 309     return gain;
 310 }
 311
 312 long get_replaygain_int(long int_gain)
 313 {
 314     long gain = 0;
 315
 316     if (int_gain)
 317     {
 318         gain = convert_gain(int_gain * FP_ONE / 100);
 319     }
 320
 321     return gain;
 322 }
 323
 324 long get_replaygain(const char* str)
 325 {
 326     long gain = 0;
 327
 328     if (str)
 329     {
 330         gain = fp_atof(str, FP_BITS);
 331         gain = convert_gain(gain);
 332     }
 333
 334     return gain;
 335 }
 336
 337 long get_replaypeak(const char* str)
 338 {
 339     long peak = 0;
 340
 341     if (str)
 342     {
 343         peak = fp_atof(str, 24);
 344     }
 345
 346     return peak;
 347 }
 348
 349 /* Check for a ReplayGain tag conforming to the "VorbisGain standard". If
 350  * found, set the mp3entry accordingly. buffer is where to store the text
 351  * contents of the gain tags; up to length bytes (including end nil) can be
 352  * written. Returns number of bytes written to the tag text buffer, or zero
 353  * if no ReplayGain tag was found (or nothing was copied to the buffer for
 354  * other reasons).
 355  */
 356 long parse_replaygain(const char* key, const char* value,
 357     struct mp3entry* entry, char* buffer, int length)
 358 {
 359     char **p = NULL;
 360
 361     if (((strcasecmp(key, "replaygain_track_gain") == 0)
 362         || (strcasecmp(key, "rg_radio") == 0)) && !entry->track_gain)
 363     {
 364         entry->track_gain = get_replaygain(value);
 365         p = &(entry->track_gain_string);
 366     }
 367     else if (((strcasecmp(key, "replaygain_album_gain") == 0)
 368         || (strcasecmp(key, "rg_audiophile") == 0)) && !entry->album_gain)
 369     {
 370         entry->album_gain = get_replaygain(value);
 371         p = &(entry->album_gain_string);
 372     }
 373     else if (((strcasecmp(key, "replaygain_track_peak") == 0)
 374         || (strcasecmp(key, "rg_peak") == 0)) && !entry->track_peak)
 375     {
 376         entry->track_peak = get_replaypeak(value);
 377     }
 378     else if ((strcasecmp(key, "replaygain_album_peak") == 0)
 379         && !entry->album_peak)
 380     {
 381         entry->album_peak = get_replaypeak(value);
 382     }
 383
 384     if (p)
 385     {
 386         int len = strlen(value);
 387
 388         len = MIN(len, length - 1);
 389
 390         /* A few characters just isn't interesting... */
 391         if (len > 1)
 392         {
 393             strncpy(buffer, value, len);
 394             buffer[len] = 0;
 395             *p = buffer;
 396             return len + 1;
 397         }
 398     }
 399
 400     return 0;
 401 }
 402
 403 static long get_rva_values(const char *frame, long *gain, long *peak,
 404     char **string, char *buffer, int length)
 405 {
 406     long value, len;
 407     int negative = 0;
 408     char tmpbuf[10];
 409     int peakbits, peakbytes, shift;
 410     unsigned long peakvalue = 0;
 411
 412     value = 256 * ((unsigned char)*frame) + ((unsigned char)*(frame + 1));
 413     if (value & 0x8000)
 414     {
 415         value = -(value | ~0xFFFF);
 416         negative = 1;
 417     }
 418
 419     len = snprintf(tmpbuf, sizeof(tmpbuf), "%s%d.%02d dB", negative ? "-" : "",
 420         value / 512, (value & 0x1FF) * 195 / 1000);
 421
 422     *gain = get_replaygain(tmpbuf);
 423
 424     len = MIN(len, length - 1);
 425     if (len > 1)
 426     {
 427         strncpy(buffer, tmpbuf, len);
 428         buffer[len] = 0;
 429         *string = buffer;
 430     }
 431
 432     frame += 2;
 433     peakbits = *(unsigned char *)frame++;
 434     peakbytes = MIN(4, (peakbits + 7) >> 3);
 435     shift = ((8 - (peakbits & 7)) & 7) + (4 - peakbytes) * 8;
 436
 437     for (; peakbytes; peakbytes--)
 438     {
 439             peakvalue <<= 8;
 440             peakvalue += (unsigned long)*frame++;
 441     }
 442
 443     peakvalue <<= shift;
 444
 445     if (peakbits > 32)
 446         peakvalue += (unsigned long)*frame >> (8 - shift);
 447
 448     snprintf(tmpbuf, sizeof(tmpbuf), "%d.%06d", peakvalue >> 31,
 449         (peakvalue & ~(1 << 31)) / 2147);
 450
 451     *peak = get_replaypeak(tmpbuf);
 452
 453     return len + 1;
 454 }
 455
 456 long parse_replaygain_rva(const char* key, const char* value,
 457     struct mp3entry* entry, char* buffer, int length)
 458 {
 459     /* Values will be overwritten if they already exist. This gives priority to
 460        replaygain in RVA2 fields over TXXX fields for ID3v2.4. */
 461     if ((strcasecmp(key, "track") == 0) && *value == MASTER_CHANNEL)
 462     {
 463         return get_rva_values(value + 1, &(entry->track_gain), &(entry->track_peak),
 464             &(entry->track_gain_string), buffer, length);
 465     }
 466     else if ((strcasecmp(key, "album") == 0) && *value == MASTER_CHANNEL)
 467     {
 468         return get_rva_values(value + 1, &(entry->album_gain), &(entry->album_peak),
 469             &(entry->album_gain_string), buffer, length);
 470     }
 471
 472     return 0;
 473 }