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 /* The fixed point math routines (with the exception of fp_atof) are based
  32  * on oMathFP by Dan Carter (http://orbisstudios.com).
  33  */
  34
  35 /* 12 bits of precision gives fairly accurate result, but still allows a
  36  * compact implementation. The math code supports up to 13...
  37  */
  38
  39 #define FP_BITS         (12)
  40 #define FP_MASK         ((1 << FP_BITS) - 1)
  41 #define FP_ONE          (1 << FP_BITS)
  42 #define FP_TWO          (2 << FP_BITS)
  43 #define FP_HALF         (1 << (FP_BITS - 1))
  44 #define FP_LN2          ( 45426 >> (16 - FP_BITS))
  45 #define FP_LN2_INV      ( 94548 >> (16 - FP_BITS))
  46 #define FP_EXP_ZERO     ( 10922 >> (16 - FP_BITS))
  47 #define FP_EXP_ONE      (  -182 >> (16 - FP_BITS))
  48 #define FP_EXP_TWO      (     4 >> (16 - FP_BITS))
  49 #define FP_INF          (0x7fffffff)
  50 #define FP_LN10         (150902 >> (16 - FP_BITS))
  51
  52 #define FP_MAX_DIGITS       (4)
  53 #define FP_MAX_DIGITS_INT   (10000)
  54
  55 #define FP_FAST_MUL_DIV
  56
  57 #ifdef FP_FAST_MUL_DIV
  58
  59 /* These macros can easily overflow, but they are good enough for our uses,
  60  * and saves some code.
  61  */
  62 #define fp_mul(x, y) (((x) * (y)) >> FP_BITS)
  63 #define fp_div(x, y) (((x) << FP_BITS) / (y))
  64
  65 #else
  66
  67 static long fp_mul(long x, long y)
  68 {
  69     long x_neg = 0;
  70     long y_neg = 0;
  71     long rc;
  72
  73     if ((x == 0) || (y == 0))
  74     {
  75         return 0;
  76     }
  77
  78     if (x < 0)
  79     {
  80         x_neg = 1;
  81         x = -x;
  82     }
  83
  84     if (y < 0)
  85     {
  86         y_neg = 1;
  87         y = -y;
  88     }
  89
  90     rc = (((x >> FP_BITS) * (y >> FP_BITS)) << FP_BITS)
  91         + (((x & FP_MASK) * (y & FP_MASK)) >> FP_BITS)
  92         + ((x & FP_MASK) * (y >> FP_BITS))
  93         + ((x >> FP_BITS) * (y & FP_MASK));
  94
  95     if ((x_neg ^ y_neg) == 1)
  96     {
  97         rc = -rc;
  98     }
  99
 100     return rc;
 101 }
 102
 103 static long fp_div(long x, long y)
 104 {
 105     long x_neg = 0;
 106     long y_neg = 0;
 107     long shifty;
 108     long rc;
 109     int msb = 0;
 110     int lsb = 0;
 111
 112     if (x == 0)
 113     {
 114         return 0;
 115     }
 116
 117     if (y == 0)
 118     {
 119         return (x < 0) ? -FP_INF : FP_INF;
 120     }
 121
 122     if (x < 0)
 123     {
 124         x_neg = 1;
 125         x = -x;
 126     }
 127
 128     if (y < 0)
 129     {
 130         y_neg = 1;
 131         y = -y;
 132     }
 133
 134     while ((x & (1 << (30 - msb))) == 0)
 135     {
 136         msb++;
 137     }
 138
 139     while ((y & (1 << lsb)) == 0)
 140     {
 141         lsb++;
 142     }
 143
 144     shifty = FP_BITS - (msb + lsb);
 145     rc = ((x << msb) / (y >> lsb));
 146
 147     if (shifty > 0)
 148     {
 149         rc <<= shifty;
 150     }
 151     else
 152     {
 153         rc >>= -shifty;
 154     }
 155
 156     if ((x_neg ^ y_neg) == 1)
 157     {
 158         rc = -rc;
 159     }
 160
 161     return rc;
 162 }
 163
 164 #endif /* FP_FAST_MUL_DIV */
 165
 166 static long fp_exp(long x)
 167 {
 168     long k;
 169     long z;
 170     long R;
 171     long xp;
 172
 173     if (x == 0)
 174     {
 175         return FP_ONE;
 176     }
 177
 178     k = (fp_mul(abs(x), FP_LN2_INV) + FP_HALF) & ~FP_MASK;
 179
 180     if (x < 0)
 181     {
 182         k = -k;
 183     }
 184
 185     x -= fp_mul(k, FP_LN2);
 186     z = fp_mul(x, x);
 187     R = FP_TWO + fp_mul(z, FP_EXP_ZERO + fp_mul(z, FP_EXP_ONE
 188         + fp_mul(z, FP_EXP_TWO)));
 189     xp = FP_ONE + fp_div(fp_mul(FP_TWO, x), R - x);
 190
 191     if (k < 0)
 192     {
 193         k = FP_ONE >> (-k >> FP_BITS);
 194     }
 195     else
 196     {
 197         k = FP_ONE << (k >> FP_BITS);
 198     }
 199
 200     return fp_mul(k, xp);
 201 }
 202
 203 static long fp_exp10(long x)
 204 {
 205     if (x == 0)
 206     {
 207         return FP_ONE;
 208     }
 209
 210     return fp_exp(fp_mul(FP_LN10, x));
 211 }
 212
 213 static long fp_atof(const char* s, int precision)
 214 {
 215     long int_part = 0;
 216     long int_one = 1 << precision;
 217     long frac_part = 0;
 218     long frac_count = 0;
 219     long frac_max = ((precision * 4) + 12) / 13;
 220     long frac_max_int = 1;
 221     long sign = 1;
 222     bool point = false;
 223
 224     while ((*s != '\0') && isspace(*s))
 225     {
 226         s++;
 227     }
 228
 229     if (*s == '-')
 230     {
 231         sign = -1;
 232         s++;
 233     }
 234     else if (*s == '+')
 235     {
 236         s++;
 237     }
 238
 239     while (*s != '\0')
 240     {
 241         if (*s == '.')
 242         {
 243             if (point)
 244             {
 245                 break;
 246             }
 247
 248             point = true;
 249         }
 250         else if (isdigit(*s))
 251         {
 252             if (point)
 253             {
 254                 if (frac_count < frac_max)
 255                 {
 256                     frac_part = frac_part * 10 + (*s - '0');
 257                     frac_count++;
 258                     frac_max_int *= 10;
 259                 }
 260             }
 261             else
 262             {
 263                 int_part = int_part * 10 + (*s - '0');
 264             }
 265         }
 266         else
 267         {
 268             break;
 269         }
 270
 271         s++;
 272     }
 273
 274     while (frac_count < frac_max)
 275     {
 276       frac_part *= 10;
 277       frac_count++;
 278       frac_max_int *= 10;
 279     }
 280
 281     return sign * ((int_part * int_one)
 282         + (((int64_t) frac_part * int_one) / frac_max_int));
 283 }
 284
 285 static long convert_gain(long gain)
 286 {
 287     /* Don't allow unreasonably low or high gain changes.
 288      * Our math code can't handle it properly anyway. :)
 289      */
 290     if (gain < (-48 * FP_ONE))
 291     {
 292         gain = -48 * FP_ONE;
 293     }
 294
 295     if (gain > (17 * FP_ONE))
 296     {
 297         gain = 17 * FP_ONE;
 298     }
 299
 300     gain = fp_exp10(gain / 20) << (24 - FP_BITS);
 301
 302     return gain;
 303 }
 304
 305 /* Get the sample scale factor in Q7.24 format from a gain value. Returns 0
 306  * for no gain.
 307  *
 308  * str  Gain in dB as a string. E.g., "-3.45 dB"; the "dB" part is ignored.
 309  */
 310 static long get_replaygain(const char* str)
 311 {
 312     long gain = 0;
 313
 314     if (str)
 315     {
 316         gain = fp_atof(str, FP_BITS);
 317         gain = convert_gain(gain);
 318     }
 319
 320     return gain;
 321 }
 322
 323 /* Get the peak volume in Q7.24 format.
 324  *
 325  * str  Peak volume. Full scale is specified as "1.0". Returns 0 for no peak.
 326  */
 327 static long get_replaypeak(const char* str)
 328 {
 329     long peak = 0;
 330
 331     if (str)
 332     {
 333         peak = fp_atof(str, 24);
 334     }
 335
 336     return peak;
 337 }
 338
 339 /* Get a sample scale factor in Q7.24 format from a gain value.
 340  *
 341  * int_gain  Gain in dB, multiplied by 100.
 342  */
 343 long get_replaygain_int(long int_gain)
 344 {
 345     return convert_gain(int_gain * FP_ONE / 100);
 346 }
 347
 348 /* Parse a ReplayGain tag conforming to the "VorbisGain standard". If a
 349  * valid tag is found, update mp3entry struct accordingly. Existing values
 350  * are not overwritten. Returns number of bytes written to buffer.
 351  *
 352  * key     Name of the tag.
 353  * value   Value of the tag.
 354  * entry   mp3entry struct to update.
 355  * buffer  Where to store the text for gain values (for later display).
 356  * length  Bytes left in buffer.
 357  */
 358 long parse_replaygain(const char* key, const char* value,
 359     struct mp3entry* entry, char* buffer, int length)
 360 {
 361     char **p = NULL;
 362
 363     if (((strcasecmp(key, "replaygain_track_gain") == 0)
 364         || (strcasecmp(key, "rg_radio") == 0)) && !entry->track_gain)
 365     {
 366         entry->track_gain = get_replaygain(value);
 367         p = &(entry->track_gain_string);
 368     }
 369     else if (((strcasecmp(key, "replaygain_album_gain") == 0)
 370         || (strcasecmp(key, "rg_audiophile") == 0)) && !entry->album_gain)
 371     {
 372         entry->album_gain = get_replaygain(value);
 373         p = &(entry->album_gain_string);
 374     }
 375     else if (((strcasecmp(key, "replaygain_track_peak") == 0)
 376         || (strcasecmp(key, "rg_peak") == 0)) && !entry->track_peak)
 377     {
 378         entry->track_peak = get_replaypeak(value);
 379     }
 380     else if ((strcasecmp(key, "replaygain_album_peak") == 0)
 381         && !entry->album_peak)
 382     {
 383         entry->album_peak = get_replaypeak(value);
 384     }
 385
 386     if (p)
 387     {
 388         int len = strlen(value);
 389
 390         len = MIN(len, length - 1);
 391
 392         /* A few characters just isn't interesting... */
 393         if (len > 1)
 394         {
 395             strncpy(buffer, value, len);
 396             buffer[len] = 0;
 397             *p = buffer;
 398             return len + 1;
 399         }
 400     }
 401
 402     return 0;
 403 }
 404
 405 /* Set ReplayGain values from integers. Existing values are not overwritten.
 406  * Returns number of bytes written to buffer.
 407  *
 408  * album   If true, set album values, otherwise set track values.
 409  * gain    Gain value in dB, multiplied by 512. 0 for no gain.
 410  * peak    Peak volume in Q7.24 format, where 1.0 is full scale. 0 for no
 411  *         peak volume.
 412  * buffer  Where to store the text for gain values (for later display).
 413  * length  Bytes left in buffer.
 414  */
 415 long parse_replaygain_int(bool album, long gain, long peak,
 416     struct mp3entry* entry, char* buffer, int length)
 417 {
 418     long len = 0;
 419
 420     if (buffer != NULL)
 421     {
 422         len = snprintf(buffer, length, "%d.%02d dB", gain / 512,
 423             ((abs(gain) & 0x01ff) * 100 + 256) / 512);
 424         len++;
 425     }
 426
 427     if (gain != 0)
 428     {
 429         gain = convert_gain(gain * FP_ONE / 512);
 430     }
 431
 432     if (album)
 433     {
 434         entry->album_gain = gain;
 435         entry->album_gain_string = buffer;
 436
 437         if (peak)
 438         {
 439             entry->album_peak = peak;
 440         }
 441     }
 442     else
 443     {
 444         entry->track_gain = gain;
 445         entry->track_gain_string = buffer;
 446
 447         if (peak)
 448         {
 449             entry->track_peak = peak;
 450         }
 451     }
 452
 453     return len;
 454 }